home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / pprint.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  7.9 KB  |  303 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. import sys as _sys
  5. import warnings
  6. from cStringIO import StringIO as _StringIO
  7. __all__ = [
  8.     'pprint',
  9.     'pformat',
  10.     'isreadable',
  11.     'isrecursive',
  12.     'saferepr',
  13.     'PrettyPrinter']
  14. _commajoin = ', '.join
  15. _id = id
  16. _len = len
  17. _type = type
  18.  
  19. def pprint(object, stream = None, indent = 1, width = 80, depth = None):
  20.     printer = PrettyPrinter(stream = stream, indent = indent, width = width, depth = depth)
  21.     printer.pprint(object)
  22.  
  23.  
  24. def pformat(object, indent = 1, width = 80, depth = None):
  25.     return PrettyPrinter(indent = indent, width = width, depth = depth).pformat(object)
  26.  
  27.  
  28. def saferepr(object):
  29.     return _safe_repr(object, { }, None, 0)[0]
  30.  
  31.  
  32. def isreadable(object):
  33.     return _safe_repr(object, { }, None, 0)[1]
  34.  
  35.  
  36. def isrecursive(object):
  37.     return _safe_repr(object, { }, None, 0)[2]
  38.  
  39.  
  40. def _sorted(iterable):
  41.     with warnings.catch_warnings():
  42.         if _sys.py3kwarning:
  43.             warnings.filterwarnings('ignore', 'comparing unequal types not supported', DeprecationWarning)
  44.         return sorted(iterable)
  45.  
  46.  
  47. class PrettyPrinter:
  48.     
  49.     def __init__(self, indent = 1, width = 80, depth = None, stream = None):
  50.         indent = int(indent)
  51.         width = int(width)
  52.         self._depth = depth
  53.         self._indent_per_level = indent
  54.         self._width = width
  55.         if stream is not None:
  56.             self._stream = stream
  57.         else:
  58.             self._stream = _sys.stdout
  59.  
  60.     
  61.     def pprint(self, object):
  62.         self._format(object, self._stream, 0, 0, { }, 0)
  63.         self._stream.write('\n')
  64.  
  65.     
  66.     def pformat(self, object):
  67.         sio = _StringIO()
  68.         self._format(object, sio, 0, 0, { }, 0)
  69.         return sio.getvalue()
  70.  
  71.     
  72.     def isrecursive(self, object):
  73.         return self.format(object, { }, 0, 0)[2]
  74.  
  75.     
  76.     def isreadable(self, object):
  77.         (s, readable, recursive) = self.format(object, { }, 0, 0)
  78.         if readable:
  79.             pass
  80.         return not recursive
  81.  
  82.     
  83.     def _format(self, object, stream, indent, allowance, context, level):
  84.         level = level + 1
  85.         objid = _id(object)
  86.         if objid in context:
  87.             stream.write(_recursion(object))
  88.             self._recursive = True
  89.             self._readable = False
  90.             return None
  91.         rep = None._repr(object, context, level - 1)
  92.         typ = _type(object)
  93.         sepLines = _len(rep) > self._width - 1 - indent - allowance
  94.         write = stream.write
  95.         if self._depth and level > self._depth:
  96.             write(rep)
  97.             return None
  98.         r = None(typ, '__repr__', None)
  99.         if issubclass(typ, dict) and r is dict.__repr__:
  100.             write('{')
  101.             if self._indent_per_level > 1:
  102.                 write((self._indent_per_level - 1) * ' ')
  103.             length = _len(object)
  104.             if length:
  105.                 context[objid] = 1
  106.                 indent = indent + self._indent_per_level
  107.                 items = _sorted(object.items())
  108.                 (key, ent) = items[0]
  109.                 rep = self._repr(key, context, level)
  110.                 write(rep)
  111.                 write(': ')
  112.                 self._format(ent, stream, indent + _len(rep) + 2, allowance + 1, context, level)
  113.                 if length > 1:
  114.                     for key, ent in items[1:]:
  115.                         rep = self._repr(key, context, level)
  116.                         if sepLines:
  117.                             write(',\n%s%s: ' % (' ' * indent, rep))
  118.                         else:
  119.                             write(', %s: ' % rep)
  120.                         self._format(ent, stream, indent + _len(rep) + 2, allowance + 1, context, level)
  121.                     
  122.                 indent = indent - self._indent_per_level
  123.                 del context[objid]
  124.             write('}')
  125.             return None
  126.         if not None(typ, list) or r is list.__repr__:
  127.             if not issubclass(typ, tuple) or r is tuple.__repr__:
  128.                 if (issubclass(typ, set) or r is set.__repr__ or issubclass(typ, frozenset)) and r is frozenset.__repr__:
  129.                     length = _len(object)
  130.                     if issubclass(typ, list):
  131.                         write('[')
  132.                         endchar = ']'
  133.                     elif issubclass(typ, set):
  134.                         if not length:
  135.                             write('set()')
  136.                             return None
  137.                         None('set([')
  138.                         endchar = '])'
  139.                         object = _sorted(object)
  140.                         indent += 4
  141.                     elif issubclass(typ, frozenset):
  142.                         if not length:
  143.                             write('frozenset()')
  144.                             return None
  145.                         None('frozenset([')
  146.                         endchar = '])'
  147.                         object = _sorted(object)
  148.                         indent += 10
  149.                     else:
  150.                         write('(')
  151.                         endchar = ')'
  152.                     if self._indent_per_level > 1 and sepLines:
  153.                         write((self._indent_per_level - 1) * ' ')
  154.                     if length:
  155.                         context[objid] = 1
  156.                         indent = indent + self._indent_per_level
  157.                         self._format(object[0], stream, indent, allowance + 1, context, level)
  158.                         if length > 1:
  159.                             for ent in object[1:]:
  160.                                 if sepLines:
  161.                                     write(',\n' + ' ' * indent)
  162.                                 else:
  163.                                     write(', ')
  164.                                 self._format(ent, stream, indent, allowance + 1, context, level)
  165.                             
  166.                         indent = indent - self._indent_per_level
  167.                         del context[objid]
  168.                     if issubclass(typ, tuple) and length == 1:
  169.                         write(',')
  170.                     write(endchar)
  171.                     return None
  172.                 None(rep)
  173.                 return None
  174.  
  175.     
  176.     def _repr(self, object, context, level):
  177.         (repr, readable, recursive) = self.format(object, context.copy(), self._depth, level)
  178.         if not readable:
  179.             self._readable = False
  180.         if recursive:
  181.             self._recursive = True
  182.         return repr
  183.  
  184.     
  185.     def format(self, object, context, maxlevels, level):
  186.         return _safe_repr(object, context, maxlevels, level)
  187.  
  188.  
  189.  
  190. def _safe_repr(object, context, maxlevels, level):
  191.     typ = _type(object)
  192.     if typ is str:
  193.         if 'locale' not in _sys.modules:
  194.             return (repr(object), True, False)
  195.         if None in object and '"' not in object:
  196.             closure = '"'
  197.             quotes = {
  198.                 '"': '\\"' }
  199.         else:
  200.             closure = "'"
  201.             quotes = {
  202.                 "'": "\\'" }
  203.         qget = quotes.get
  204.         sio = _StringIO()
  205.         write = sio.write
  206.         for char in object:
  207.             if char.isalpha():
  208.                 write(char)
  209.                 continue
  210.             write(qget(char, repr(char)[1:-1]))
  211.         
  212.         return ('%s%s%s' % (closure, sio.getvalue(), closure), True, False)
  213.     r = None(typ, '__repr__', None)
  214.     if issubclass(typ, dict) and r is dict.__repr__:
  215.         if not object:
  216.             return ('{}', True, False)
  217.         objid = None(object)
  218.         if maxlevels and level >= maxlevels:
  219.             return ('{...}', False, objid in context)
  220.         if None in context:
  221.             return (_recursion(object), False, True)
  222.         context[objid] = None
  223.         readable = True
  224.         recursive = False
  225.         components = []
  226.         append = components.append
  227.         level += 1
  228.         saferepr = _safe_repr
  229.         for k, v in _sorted(object.items()):
  230.             (krepr, kreadable, krecur) = saferepr(k, context, maxlevels, level)
  231.             (vrepr, vreadable, vrecur) = saferepr(v, context, maxlevels, level)
  232.             append('%s: %s' % (krepr, vrepr))
  233.             if readable and kreadable:
  234.                 pass
  235.             readable = vreadable
  236.             if not krecur:
  237.                 if vrecur:
  238.                     recursive = True
  239.                     continue
  240.                 del context[objid]
  241.                 return ('{%s}' % _commajoin(components), readable, recursive)
  242.             if (None(typ, list) or r is list.__repr__ or issubclass(typ, tuple)) and r is tuple.__repr__:
  243.                 if issubclass(typ, list):
  244.                     if not object:
  245.                         return ('[]', True, False)
  246.                     format = None
  247.                 elif _len(object) == 1:
  248.                     format = '(%s,)'
  249.                 elif not object:
  250.                     return ('()', True, False)
  251.                 format = '(%s)'
  252.                 objid = _id(object)
  253.                 if maxlevels and level >= maxlevels:
  254.                     return (format % '...', False, objid in context)
  255.                 if None in context:
  256.                     return (_recursion(object), False, True)
  257.                 context[objid] = None
  258.                 readable = True
  259.                 recursive = False
  260.                 components = []
  261.                 append = components.append
  262.                 level += 1
  263.                 for o in object:
  264.                     (orepr, oreadable, orecur) = _safe_repr(o, context, maxlevels, level)
  265.                     append(orepr)
  266.                     if not oreadable:
  267.                         readable = False
  268.                     if orecur:
  269.                         recursive = True
  270.                         continue
  271.                 del context[objid]
  272.                 return (format % _commajoin(components), readable, recursive)
  273.             rep = None(object)
  274.             if rep:
  275.                 pass
  276.     return (rep, not rep.startswith('<'), False)
  277.  
  278.  
  279. def _recursion(object):
  280.     return '<Recursion on %s with id=%s>' % (_type(object).__name__, _id(object))
  281.  
  282.  
  283. def _perfcheck(object = None):
  284.     import time
  285.     if object is None:
  286.         object = [
  287.             ('string', (1, 2), [
  288.                 3,
  289.                 4], {
  290.                 5: 6,
  291.                 7: 8 })] * 100000
  292.     p = PrettyPrinter()
  293.     t1 = time.time()
  294.     _safe_repr(object, { }, None, 0)
  295.     t2 = time.time()
  296.     p.pformat(object)
  297.     t3 = time.time()
  298.     print '_safe_repr:', t2 - t1
  299.     print 'pformat:', t3 - t2
  300.  
  301. if __name__ == '__main__':
  302.     _perfcheck()
  303.