home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / Bureautique / gImageReader / gimagereader_0.9-1_win32.exe / bin / pprint.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2011-03-24  |  10KB  |  360 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. """Support to pretty-print lists, tuples, & dictionaries recursively.
  5.  
  6. Very simple, but useful, especially in debugging data structures.
  7.  
  8. Classes
  9. -------
  10.  
  11. PrettyPrinter()
  12.     Handle pretty-printing operations onto a stream using a configured
  13.     set of formatting parameters.
  14.  
  15. Functions
  16. ---------
  17.  
  18. pformat()
  19.     Format a Python object into a pretty-printed representation.
  20.  
  21. pprint()
  22.     Pretty-print a Python object to a stream [default is sys.stdout].
  23.  
  24. saferepr()
  25.     Generate a 'standard' repr()-like value, but protect against recursive
  26.     data structures.
  27.  
  28. """
  29. import sys as _sys
  30. import warnings
  31. from cStringIO import StringIO as _StringIO
  32. __all__ = [
  33.     'pprint',
  34.     'pformat',
  35.     'isreadable',
  36.     'isrecursive',
  37.     'saferepr',
  38.     'PrettyPrinter']
  39. _commajoin = ', '.join
  40. _id = id
  41. _len = len
  42. _type = type
  43.  
  44. def pprint(object, stream = None, indent = 1, width = 80, depth = None):
  45.     '''Pretty-print a Python object to a stream [default is sys.stdout].'''
  46.     printer = PrettyPrinter(stream = stream, indent = indent, width = width, depth = depth)
  47.     printer.pprint(object)
  48.  
  49.  
  50. def pformat(object, indent = 1, width = 80, depth = None):
  51.     '''Format a Python object into a pretty-printed representation.'''
  52.     return PrettyPrinter(indent = indent, width = width, depth = depth).pformat(object)
  53.  
  54.  
  55. def saferepr(object):
  56.     '''Version of repr() which can handle recursive data structures.'''
  57.     return _safe_repr(object, { }, None, 0)[0]
  58.  
  59.  
  60. def isreadable(object):
  61.     '''Determine if saferepr(object) is readable by eval().'''
  62.     return _safe_repr(object, { }, None, 0)[1]
  63.  
  64.  
  65. def isrecursive(object):
  66.     '''Determine if object requires a recursive representation.'''
  67.     return _safe_repr(object, { }, None, 0)[2]
  68.  
  69.  
  70. def _sorted(iterable):
  71.     with warnings.catch_warnings():
  72.         if _sys.py3kwarning:
  73.             warnings.filterwarnings('ignore', 'comparing unequal types not supported', DeprecationWarning)
  74.         return sorted(iterable)
  75.  
  76.  
  77. class PrettyPrinter:
  78.     
  79.     def __init__(self, indent = 1, width = 80, depth = None, stream = None):
  80.         '''Handle pretty printing operations onto a stream using a set of
  81.         configured parameters.
  82.  
  83.         indent
  84.             Number of spaces to indent for each level of nesting.
  85.  
  86.         width
  87.             Attempted maximum number of columns in the output.
  88.  
  89.         depth
  90.             The maximum depth to print out nested structures.
  91.  
  92.         stream
  93.             The desired output stream.  If omitted (or false), the standard
  94.             output stream available at construction will be used.
  95.  
  96.         '''
  97.         indent = int(indent)
  98.         width = int(width)
  99.         if not indent >= 0:
  100.             raise AssertionError, 'indent must be >= 0'
  101.         if not None is None and depth > 0:
  102.             raise AssertionError, 'depth must be > 0'
  103.         if not None:
  104.             raise AssertionError, 'width must be != 0'
  105.         self._depth = None
  106.         self._indent_per_level = indent
  107.         self._width = width
  108.         if stream is not None:
  109.             self._stream = stream
  110.         else:
  111.             self._stream = _sys.stdout
  112.  
  113.     
  114.     def pprint(self, object):
  115.         self._format(object, self._stream, 0, 0, { }, 0)
  116.         self._stream.write('\n')
  117.  
  118.     
  119.     def pformat(self, object):
  120.         sio = _StringIO()
  121.         self._format(object, sio, 0, 0, { }, 0)
  122.         return sio.getvalue()
  123.  
  124.     
  125.     def isrecursive(self, object):
  126.         return self.format(object, { }, 0, 0)[2]
  127.  
  128.     
  129.     def isreadable(self, object):
  130.         (s, readable, recursive) = self.format(object, { }, 0, 0)
  131.         if readable:
  132.             pass
  133.         return not recursive
  134.  
  135.     
  136.     def _format(self, object, stream, indent, allowance, context, level):
  137.         level = level + 1
  138.         objid = _id(object)
  139.         if objid in context:
  140.             stream.write(_recursion(object))
  141.             self._recursive = True
  142.             self._readable = False
  143.             return None
  144.         rep = None._repr(object, context, level - 1)
  145.         typ = _type(object)
  146.         sepLines = _len(rep) > self._width - 1 - indent - allowance
  147.         write = stream.write
  148.         if self._depth and level > self._depth:
  149.             write(rep)
  150.             return None
  151.         r = None(typ, '__repr__', None)
  152.         if issubclass(typ, dict) and r is dict.__repr__:
  153.             write('{')
  154.             if self._indent_per_level > 1:
  155.                 write((self._indent_per_level - 1) * ' ')
  156.             length = _len(object)
  157.             if length:
  158.                 context[objid] = 1
  159.                 indent = indent + self._indent_per_level
  160.                 items = _sorted(object.items())
  161.                 (key, ent) = items[0]
  162.                 rep = self._repr(key, context, level)
  163.                 write(rep)
  164.                 write(': ')
  165.                 self._format(ent, stream, indent + _len(rep) + 2, allowance + 1, context, level)
  166.                 if length > 1:
  167.                     for key, ent in items[1:]:
  168.                         rep = self._repr(key, context, level)
  169.                         if sepLines:
  170.                             write(',\n%s%s: ' % (' ' * indent, rep))
  171.                         else:
  172.                             write(', %s: ' % rep)
  173.                         self._format(ent, stream, indent + _len(rep) + 2, allowance + 1, context, level)
  174.                     
  175.                 indent = indent - self._indent_per_level
  176.                 del context[objid]
  177.             write('}')
  178.             return None
  179.         if not None(typ, list) or r is list.__repr__:
  180.             if not issubclass(typ, tuple) or r is tuple.__repr__:
  181.                 if (issubclass(typ, set) or r is set.__repr__ or issubclass(typ, frozenset)) and r is frozenset.__repr__:
  182.                     length = _len(object)
  183.                     if issubclass(typ, list):
  184.                         write('[')
  185.                         endchar = ']'
  186.                     elif issubclass(typ, set):
  187.                         if not length:
  188.                             write('set()')
  189.                             return None
  190.                         None('set([')
  191.                         endchar = '])'
  192.                         object = _sorted(object)
  193.                         indent += 4
  194.                     elif issubclass(typ, frozenset):
  195.                         if not length:
  196.                             write('frozenset()')
  197.                             return None
  198.                         None('frozenset([')
  199.                         endchar = '])'
  200.                         object = _sorted(object)
  201.                         indent += 10
  202.                     else:
  203.                         write('(')
  204.                         endchar = ')'
  205.                     if self._indent_per_level > 1 and sepLines:
  206.                         write((self._indent_per_level - 1) * ' ')
  207.                     if length:
  208.                         context[objid] = 1
  209.                         indent = indent + self._indent_per_level
  210.                         self._format(object[0], stream, indent, allowance + 1, context, level)
  211.                         if length > 1:
  212.                             for ent in object[1:]:
  213.                                 if sepLines:
  214.                                     write(',\n' + ' ' * indent)
  215.                                 else:
  216.                                     write(', ')
  217.                                 self._format(ent, stream, indent, allowance + 1, context, level)
  218.                             
  219.                         indent = indent - self._indent_per_level
  220.                         del context[objid]
  221.                     if issubclass(typ, tuple) and length == 1:
  222.                         write(',')
  223.                     write(endchar)
  224.                     return None
  225.                 None(rep)
  226.                 return None
  227.  
  228.     
  229.     def _repr(self, object, context, level):
  230.         (repr, readable, recursive) = self.format(object, context.copy(), self._depth, level)
  231.         if not readable:
  232.             self._readable = False
  233.         if recursive:
  234.             self._recursive = True
  235.         return repr
  236.  
  237.     
  238.     def format(self, object, context, maxlevels, level):
  239.         """Format object for a specific context, returning a string
  240.         and flags indicating whether the representation is 'readable'
  241.         and whether the object represents a recursive construct.
  242.         """
  243.         return _safe_repr(object, context, maxlevels, level)
  244.  
  245.  
  246.  
  247. def _safe_repr(object, context, maxlevels, level):
  248.     typ = _type(object)
  249.     if typ is str:
  250.         if 'locale' not in _sys.modules:
  251.             return (repr(object), True, False)
  252.         if None in object and '"' not in object:
  253.             closure = '"'
  254.             quotes = {
  255.                 '"': '\\"' }
  256.         else:
  257.             closure = "'"
  258.             quotes = {
  259.                 "'": "\\'" }
  260.         qget = quotes.get
  261.         sio = _StringIO()
  262.         write = sio.write
  263.         for char in object:
  264.             if char.isalpha():
  265.                 write(char)
  266.                 continue
  267.             write(qget(char, repr(char)[1:-1]))
  268.         
  269.         return ('%s%s%s' % (closure, sio.getvalue(), closure), True, False)
  270.     r = None(typ, '__repr__', None)
  271.     if issubclass(typ, dict) and r is dict.__repr__:
  272.         if not object:
  273.             return ('{}', True, False)
  274.         objid = None(object)
  275.         if maxlevels and level >= maxlevels:
  276.             return ('{...}', False, objid in context)
  277.         if None in context:
  278.             return (_recursion(object), False, True)
  279.         context[objid] = None
  280.         readable = True
  281.         recursive = False
  282.         components = []
  283.         append = components.append
  284.         level += 1
  285.         saferepr = _safe_repr
  286.         for k, v in _sorted(object.items()):
  287.             (krepr, kreadable, krecur) = saferepr(k, context, maxlevels, level)
  288.             (vrepr, vreadable, vrecur) = saferepr(v, context, maxlevels, level)
  289.             append('%s: %s' % (krepr, vrepr))
  290.             if readable and kreadable:
  291.                 pass
  292.             readable = vreadable
  293.             if not krecur:
  294.                 if vrecur:
  295.                     recursive = True
  296.                     continue
  297.                 del context[objid]
  298.                 return ('{%s}' % _commajoin(components), readable, recursive)
  299.             if (None(typ, list) or r is list.__repr__ or issubclass(typ, tuple)) and r is tuple.__repr__:
  300.                 if issubclass(typ, list):
  301.                     if not object:
  302.                         return ('[]', True, False)
  303.                     format = None
  304.                 elif _len(object) == 1:
  305.                     format = '(%s,)'
  306.                 elif not object:
  307.                     return ('()', True, False)
  308.                 format = '(%s)'
  309.                 objid = _id(object)
  310.                 if maxlevels and level >= maxlevels:
  311.                     return (format % '...', False, objid in context)
  312.                 if None in context:
  313.                     return (_recursion(object), False, True)
  314.                 context[objid] = None
  315.                 readable = True
  316.                 recursive = False
  317.                 components = []
  318.                 append = components.append
  319.                 level += 1
  320.                 for o in object:
  321.                     (orepr, oreadable, orecur) = _safe_repr(o, context, maxlevels, level)
  322.                     append(orepr)
  323.                     if not oreadable:
  324.                         readable = False
  325.                     if orecur:
  326.                         recursive = True
  327.                         continue
  328.                 del context[objid]
  329.                 return (format % _commajoin(components), readable, recursive)
  330.             rep = None(object)
  331.             if rep:
  332.                 pass
  333.     return (rep, not rep.startswith('<'), False)
  334.  
  335.  
  336. def _recursion(object):
  337.     return '<Recursion on %s with id=%s>' % (_type(object).__name__, _id(object))
  338.  
  339.  
  340. def _perfcheck(object = None):
  341.     import time as time
  342.     if object is None:
  343.         object = [
  344.             ('string', (1, 2), [
  345.                 3,
  346.                 4], {
  347.                 5: 6,
  348.                 7: 8 })] * 100000
  349.     p = PrettyPrinter()
  350.     t1 = time.time()
  351.     _safe_repr(object, { }, None, 0)
  352.     t2 = time.time()
  353.     p.pformat(object)
  354.     t3 = time.time()
  355.     print '_safe_repr:', t2 - t1
  356.     print 'pformat:', t3 - t2
  357.  
  358. if __name__ == '__main__':
  359.     _perfcheck()
  360.