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