home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / traceback.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  6.9 KB  |  275 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. import linecache
  5. import sys
  6. import types
  7. __all__ = [
  8.     'extract_stack',
  9.     'extract_tb',
  10.     'format_exception',
  11.     'format_exception_only',
  12.     'format_list',
  13.     'format_stack',
  14.     'format_tb',
  15.     'print_exc',
  16.     'format_exc',
  17.     'print_exception',
  18.     'print_last',
  19.     'print_stack',
  20.     'print_tb',
  21.     'tb_lineno']
  22.  
  23. def _print(file, str = '', terminator = '\n'):
  24.     file.write(str + terminator)
  25.  
  26.  
  27. def print_list(extracted_list, file = None):
  28.     if file is None:
  29.         file = sys.stderr
  30.     for filename, lineno, name, line in extracted_list:
  31.         _print(file, '  File "%s", line %d, in %s' % (filename, lineno, name))
  32.         if line:
  33.             _print(file, '    %s' % line.strip())
  34.             continue
  35.  
  36.  
  37. def format_list(extracted_list):
  38.     list = []
  39.     for filename, lineno, name, line in extracted_list:
  40.         item = '  File "%s", line %d, in %s\n' % (filename, lineno, name)
  41.         if line:
  42.             item = item + '    %s\n' % line.strip()
  43.         list.append(item)
  44.     
  45.     return list
  46.  
  47.  
  48. def print_tb(tb, limit = None, file = None):
  49.     if file is None:
  50.         file = sys.stderr
  51.     if limit is None and hasattr(sys, 'tracebacklimit'):
  52.         limit = sys.tracebacklimit
  53.     
  54.     n = 0
  55.     while tb is not None:
  56.         if limit is None or n < limit:
  57.             f = tb.tb_frame
  58.             lineno = tb.tb_lineno
  59.             co = f.f_code
  60.             filename = co.co_filename
  61.             name = co.co_name
  62.             _print(file, '  File "%s", line %d, in %s' % (filename, lineno, name))
  63.             linecache.checkcache(filename)
  64.             line = linecache.getline(filename, lineno, f.f_globals)
  65.             if line:
  66.                 _print(file, '    ' + line.strip())
  67.             tb = tb.tb_next
  68.             n = n + 1
  69.         return None
  70.  
  71.  
  72. def format_tb(tb, limit = None):
  73.     return format_list(extract_tb(tb, limit))
  74.  
  75.  
  76. def extract_tb(tb, limit = None):
  77.     if limit is None and hasattr(sys, 'tracebacklimit'):
  78.         limit = sys.tracebacklimit
  79.     
  80.     list = []
  81.     n = 0
  82.     while tb is not None:
  83.         if limit is None or n < limit:
  84.             f = tb.tb_frame
  85.             lineno = tb.tb_lineno
  86.             co = f.f_code
  87.             filename = co.co_filename
  88.             name = co.co_name
  89.             linecache.checkcache(filename)
  90.             line = linecache.getline(filename, lineno, f.f_globals)
  91.             if line:
  92.                 line = line.strip()
  93.             else:
  94.                 line = None
  95.             list.append((filename, lineno, name, line))
  96.             tb = tb.tb_next
  97.             n = n + 1
  98.         return list
  99.  
  100.  
  101. def print_exception(etype, value, tb, limit = None, file = None):
  102.     if file is None:
  103.         file = sys.stderr
  104.     if tb:
  105.         _print(file, 'Traceback (most recent call last):')
  106.         print_tb(tb, limit, file)
  107.     lines = format_exception_only(etype, value)
  108.     for line in lines:
  109.         _print(file, line, '')
  110.     
  111.  
  112.  
  113. def format_exception(etype, value, tb, limit = None):
  114.     if tb:
  115.         list = [
  116.             'Traceback (most recent call last):\n']
  117.         list = list + format_tb(tb, limit)
  118.     else:
  119.         list = []
  120.     list = list + format_exception_only(etype, value)
  121.     return list
  122.  
  123.  
  124. def format_exception_only(etype, value):
  125.     if isinstance(etype, BaseException) and isinstance(etype, types.InstanceType) and etype is None or type(etype) is str:
  126.         return [
  127.             _format_final_exc_line(etype, value)]
  128.     stype = None.__name__
  129.     if not issubclass(etype, SyntaxError):
  130.         return [
  131.             _format_final_exc_line(stype, value)]
  132.     lines = None
  133.     
  134.     try:
  135.         (filename, lineno, offset, badline) = (msg,)
  136.     except Exception:
  137.         pass
  138.  
  139.     if not filename:
  140.         pass
  141.     filename = '<string>'
  142.     lines.append('  File "%s", line %d\n' % (filename, lineno))
  143.     if badline is not None:
  144.         lines.append('    %s\n' % badline.strip())
  145.         if offset is not None:
  146.             caretspace = badline.rstrip('\n')[:offset].lstrip()
  147.             caretspace = (lambda .0: pass)(caretspace)
  148.             lines.append('   %s^\n' % ''.join(caretspace))
  149.         
  150.     value = msg
  151.     lines.append(_format_final_exc_line(stype, value))
  152.     return lines
  153.  
  154.  
  155. def _format_final_exc_line(etype, value):
  156.     valuestr = _some_str(value)
  157.     if value is None or not valuestr:
  158.         line = '%s\n' % etype
  159.     else:
  160.         line = '%s: %s\n' % (etype, valuestr)
  161.     return line
  162.  
  163.  
  164. def _some_str(value):
  165.     
  166.     try:
  167.         return str(value)
  168.     except Exception:
  169.         pass
  170.  
  171.     
  172.     try:
  173.         value = unicode(value)
  174.         return value.encode('ascii', 'backslashreplace')
  175.     except Exception:
  176.         pass
  177.  
  178.     return '<unprintable %s object>' % type(value).__name__
  179.  
  180.  
  181. def print_exc(limit = None, file = None):
  182.     if file is None:
  183.         file = sys.stderr
  184.     
  185.     try:
  186.         (etype, value, tb) = sys.exc_info()
  187.         print_exception(etype, value, tb, limit, file)
  188.     finally:
  189.         etype = None
  190.         value = None
  191.         tb = None
  192.  
  193.  
  194.  
  195. def format_exc(limit = None):
  196.     
  197.     try:
  198.         (etype, value, tb) = sys.exc_info()
  199.         return ''.join(format_exception(etype, value, tb, limit))
  200.     finally:
  201.         etype = None
  202.         value = None
  203.         tb = None
  204.  
  205.  
  206.  
  207. def print_last(limit = None, file = None):
  208.     if not hasattr(sys, 'last_type'):
  209.         raise ValueError('no last exception')
  210.     if file is None:
  211.         file = sys.stderr
  212.     print_exception(sys.last_type, sys.last_value, sys.last_traceback, limit, file)
  213.  
  214.  
  215. def print_stack(f = None, limit = None, file = None):
  216.     if f is None:
  217.         
  218.         try:
  219.             raise ZeroDivisionError
  220.         except ZeroDivisionError:
  221.             f = sys.exc_info()[2].tb_frame.f_back
  222.         
  223.  
  224.     print_list(extract_stack(f, limit), file)
  225.  
  226.  
  227. def format_stack(f = None, limit = None):
  228.     if f is None:
  229.         
  230.         try:
  231.             raise ZeroDivisionError
  232.         except ZeroDivisionError:
  233.             f = sys.exc_info()[2].tb_frame.f_back
  234.         
  235.  
  236.     return format_list(extract_stack(f, limit))
  237.  
  238.  
  239. def extract_stack(f = None, limit = None):
  240.     if f is None:
  241.         
  242.         try:
  243.             raise ZeroDivisionError
  244.         except ZeroDivisionError:
  245.             f = sys.exc_info()[2].tb_frame.f_back
  246.         
  247.  
  248.     if limit is None and hasattr(sys, 'tracebacklimit'):
  249.         limit = sys.tracebacklimit
  250.     
  251.     list = []
  252.     n = 0
  253.     while f is not None:
  254.         if limit is None or n < limit:
  255.             lineno = f.f_lineno
  256.             co = f.f_code
  257.             filename = co.co_filename
  258.             name = co.co_name
  259.             linecache.checkcache(filename)
  260.             line = linecache.getline(filename, lineno, f.f_globals)
  261.             if line:
  262.                 line = line.strip()
  263.             else:
  264.                 line = None
  265.             list.append((filename, lineno, name, line))
  266.             f = f.f_back
  267.             n = n + 1
  268.         list.reverse()
  269.         return list
  270.  
  271.  
  272. def tb_lineno(tb):
  273.     return tb.tb_lineno
  274.  
  275.