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