home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1731 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  71.8 KB  |  2,159 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. skip_doctest = True
  5. import sys
  6. import os
  7. import os.path as os
  8. import stat
  9. import glob
  10. import new
  11. import csv
  12. import datetime
  13. import types
  14. import itertools
  15. import mimetypes
  16. import StringIO
  17.  
  18. try:
  19.     import collections
  20. except ImportError:
  21.     deque = list
  22.  
  23. deque = collections.deque
  24.  
  25. try:
  26.     set
  27. except NameError:
  28.     import sets
  29.     set = sets.Set
  30.  
  31.  
  32. try:
  33.     sorted
  34. except NameError:
  35.     
  36.     def sorted(iterator, key = None, reverse = False):
  37.         items = list(iterator)
  38.         if key is not None:
  39.             (items.sort,)((lambda i1, i2: cmp(key(i1), key(i2))))
  40.         else:
  41.             items.sort()
  42.         if reverse:
  43.             items.reverse()
  44.         
  45.         return items
  46.  
  47.  
  48.  
  49. try:
  50.     GeneratorExit
  51. except NameError:
  52.     GeneratorExit = SystemExit
  53.  
  54.  
  55. try:
  56.     import pwd
  57. except ImportError:
  58.     pwd = None
  59.  
  60.  
  61. try:
  62.     import grp
  63. except ImportError:
  64.     grp = None
  65.  
  66. from IPython.external import simplegeneric
  67. from IPython.external import path
  68.  
  69. try:
  70.     from IPython import genutils, generics
  71. except ImportError:
  72.     genutils = None
  73.     generics = None
  74.  
  75. from IPython import ipapi
  76. __all__ = [
  77.     'ifile',
  78.     'ils',
  79.     'iglob',
  80.     'iwalk',
  81.     'ipwdentry',
  82.     'ipwd',
  83.     'igrpentry',
  84.     'igrp',
  85.     'icsv',
  86.     'ix',
  87.     'ichain',
  88.     'isort',
  89.     'ifilter',
  90.     'ieval',
  91.     'ienum',
  92.     'ienv',
  93.     'ihist',
  94.     'ialias',
  95.     'icap',
  96.     'idump',
  97.     'iless']
  98. os.stat_float_times(True)
  99.  
  100. class AttrNamespace(object):
  101.     
  102.     def __init__(self, wrapped):
  103.         self.wrapped = wrapped
  104.  
  105.     
  106.     def __getitem__(self, name):
  107.         if name == '_':
  108.             return self.wrapped
  109.         
  110.         try:
  111.             return getattr(self.wrapped, name)
  112.         except AttributeError:
  113.             name == '_'
  114.             name == '_'
  115.             raise KeyError(name)
  116.         except:
  117.             name == '_'
  118.  
  119.  
  120.  
  121.  
  122. try:
  123.     eval('_', None, AttrNamespace(None))
  124. except TypeError:
  125.     real_eval = eval
  126.     
  127.     def eval(codestring, _globals, _locals):
  128.         if isinstance(codestring, basestring):
  129.             code = compile(codestring, '_eval', 'eval')
  130.         else:
  131.             code = codestring
  132.         newlocals = { }
  133.         for name in code.co_names:
  134.             
  135.             try:
  136.                 newlocals[name] = _locals[name]
  137.             continue
  138.             except KeyError:
  139.                 continue
  140.             
  141.  
  142.         
  143.         return real_eval(code, _globals, newlocals)
  144.  
  145.  
  146. noitem = object()
  147.  
  148. def item(iterator, index, default = noitem):
  149.     i = index
  150.     if default is noitem:
  151.         raise IndexError(index)
  152.     default is noitem
  153.     return default
  154.  
  155.  
  156. def getglobals(g):
  157.     if g is None:
  158.         if ipapi is not None:
  159.             api = ipapi.get()
  160.             if api is not None:
  161.                 return api.user_ns
  162.         
  163.         return globals()
  164.     return g
  165.  
  166.  
  167. class Descriptor(object):
  168.     
  169.     def __hash__(self):
  170.         return hash(self.__class__) ^ hash(self.key())
  171.  
  172.     
  173.     def __eq__(self, other):
  174.         if self.__class__ is other.__class__:
  175.             pass
  176.         return self.key() == other.key()
  177.  
  178.     
  179.     def __ne__(self, other):
  180.         if not self.__class__ is not other.__class__:
  181.             pass
  182.         return self.key() != other.key()
  183.  
  184.     
  185.     def key(self):
  186.         pass
  187.  
  188.     
  189.     def name(self):
  190.         key = self.key()
  191.         if key is None:
  192.             return '_'
  193.         return str(key)
  194.  
  195.     
  196.     def attrtype(self, obj):
  197.         pass
  198.  
  199.     
  200.     def valuetype(self, obj):
  201.         pass
  202.  
  203.     
  204.     def value(self, obj):
  205.         pass
  206.  
  207.     
  208.     def doc(self, obj):
  209.         pass
  210.  
  211.     
  212.     def shortdoc(self, obj):
  213.         doc = self.doc(obj)
  214.         if doc is not None:
  215.             doc = doc.strip().splitlines()[0].strip()
  216.         
  217.         return doc
  218.  
  219.     
  220.     def iter(self, obj):
  221.         return xiter(self.value(obj))
  222.  
  223.  
  224.  
  225. class SelfDescriptor(Descriptor):
  226.     
  227.     def key(self):
  228.         pass
  229.  
  230.     
  231.     def attrtype(self, obj):
  232.         return 'self'
  233.  
  234.     
  235.     def valuetype(self, obj):
  236.         return type(obj)
  237.  
  238.     
  239.     def value(self, obj):
  240.         return obj
  241.  
  242.     
  243.     def __repr__(self):
  244.         return 'Self'
  245.  
  246.  
  247. selfdescriptor = SelfDescriptor()
  248.  
  249. class AttributeDescriptor(Descriptor):
  250.     __slots__ = ('_name', '_doc')
  251.     
  252.     def __init__(self, name, doc = None):
  253.         self._name = name
  254.         self._doc = doc
  255.  
  256.     
  257.     def key(self):
  258.         return self._name
  259.  
  260.     
  261.     def doc(self, obj):
  262.         return self._doc
  263.  
  264.     
  265.     def attrtype(self, obj):
  266.         return 'attr'
  267.  
  268.     
  269.     def valuetype(self, obj):
  270.         return type(getattr(obj, self._name))
  271.  
  272.     
  273.     def value(self, obj):
  274.         return getattr(obj, self._name)
  275.  
  276.     
  277.     def __repr__(self):
  278.         if self._doc is None:
  279.             return 'Attribute(%r)' % self._name
  280.         return 'Attribute(%r, %r)' % (self._name, self._doc)
  281.  
  282.  
  283.  
  284. class IndexDescriptor(Descriptor):
  285.     __slots__ = ('_index',)
  286.     
  287.     def __init__(self, index):
  288.         self._index = index
  289.  
  290.     
  291.     def key(self):
  292.         return self._index
  293.  
  294.     
  295.     def attrtype(self, obj):
  296.         return 'item'
  297.  
  298.     
  299.     def valuetype(self, obj):
  300.         return type(obj[self._index])
  301.  
  302.     
  303.     def value(self, obj):
  304.         return obj[self._index]
  305.  
  306.     
  307.     def __repr__(self):
  308.         return 'Index(%r)' % self._index
  309.  
  310.  
  311.  
  312. class MethodDescriptor(Descriptor):
  313.     __slots__ = ('_name', '_doc')
  314.     
  315.     def __init__(self, name, doc = None):
  316.         self._name = name
  317.         self._doc = doc
  318.  
  319.     
  320.     def key(self):
  321.         return self._name
  322.  
  323.     
  324.     def doc(self, obj):
  325.         if self._doc is None:
  326.             return getattr(obj, self._name).__doc__
  327.         return self._doc
  328.  
  329.     
  330.     def attrtype(self, obj):
  331.         return 'method'
  332.  
  333.     
  334.     def valuetype(self, obj):
  335.         return type(self.value(obj))
  336.  
  337.     
  338.     def value(self, obj):
  339.         return getattr(obj, self._name)()
  340.  
  341.     
  342.     def __repr__(self):
  343.         if self._doc is None:
  344.             return 'Method(%r)' % self._name
  345.         return 'Method(%r, %r)' % (self._name, self._doc)
  346.  
  347.  
  348.  
  349. class IterAttributeDescriptor(Descriptor):
  350.     __slots__ = ('_name', '_doc')
  351.     
  352.     def __init__(self, name, doc = None):
  353.         self._name = name
  354.         self._doc = doc
  355.  
  356.     
  357.     def key(self):
  358.         return self._name
  359.  
  360.     
  361.     def doc(self, obj):
  362.         return self._doc
  363.  
  364.     
  365.     def attrtype(self, obj):
  366.         return 'iter'
  367.  
  368.     
  369.     def valuetype(self, obj):
  370.         return noitem
  371.  
  372.     
  373.     def value(self, obj):
  374.         return noitem
  375.  
  376.     
  377.     def iter(self, obj):
  378.         return xiter(getattr(obj, self._name))
  379.  
  380.     
  381.     def __repr__(self):
  382.         if self._doc is None:
  383.             return 'IterAttribute(%r)' % self._name
  384.         return 'IterAttribute(%r, %r)' % (self._name, self._doc)
  385.  
  386.  
  387.  
  388. class IterMethodDescriptor(Descriptor):
  389.     __slots__ = ('_name', '_doc')
  390.     
  391.     def __init__(self, name, doc = None):
  392.         self._name = name
  393.         self._doc = doc
  394.  
  395.     
  396.     def key(self):
  397.         return self._name
  398.  
  399.     
  400.     def doc(self, obj):
  401.         if self._doc is None:
  402.             return getattr(obj, self._name).__doc__
  403.         return self._doc
  404.  
  405.     
  406.     def attrtype(self, obj):
  407.         return 'itermethod'
  408.  
  409.     
  410.     def valuetype(self, obj):
  411.         return noitem
  412.  
  413.     
  414.     def value(self, obj):
  415.         return noitem
  416.  
  417.     
  418.     def iter(self, obj):
  419.         return xiter(getattr(obj, self._name)())
  420.  
  421.     
  422.     def __repr__(self):
  423.         if self._doc is None:
  424.             return 'IterMethod(%r)' % self._name
  425.         return 'IterMethod(%r, %r)' % (self._name, self._doc)
  426.  
  427.  
  428.  
  429. class FunctionDescriptor(Descriptor):
  430.     __slots__ = ('_function', '_name', '_doc')
  431.     
  432.     def __init__(self, function, name = None, doc = None):
  433.         self._function = function
  434.         self._name = name
  435.         self._doc = doc
  436.  
  437.     
  438.     def key(self):
  439.         return self._function
  440.  
  441.     
  442.     def name(self):
  443.         if self._name is not None:
  444.             return self._name
  445.         return getattr(self._function, '__xname__', self._function.__name__)
  446.  
  447.     
  448.     def doc(self, obj):
  449.         if self._doc is None:
  450.             return self._function.__doc__
  451.         return self._doc
  452.  
  453.     
  454.     def attrtype(self, obj):
  455.         return 'function'
  456.  
  457.     
  458.     def valuetype(self, obj):
  459.         return type(self._function(obj))
  460.  
  461.     
  462.     def value(self, obj):
  463.         return self._function(obj)
  464.  
  465.     
  466.     def __repr__(self):
  467.         if self._doc is None:
  468.             return 'Function(%r)' % self._name
  469.         return 'Function(%r, %r)' % (self._name, self._doc)
  470.  
  471.  
  472.  
  473. class Table(object):
  474.     
  475.     class __metaclass__(type):
  476.         
  477.         def __iter__(self):
  478.             return iter(self())
  479.  
  480.         
  481.         def __or__(self, other):
  482.             return self() | other
  483.  
  484.         
  485.         def __add__(self, other):
  486.             return self() + other
  487.  
  488.         
  489.         def __radd__(self, other):
  490.             return other + self()
  491.  
  492.         
  493.         def __getitem__(self, index):
  494.             return self()[index]
  495.  
  496.  
  497.     
  498.     def __getitem__(self, index):
  499.         return item(self, index)
  500.  
  501.     
  502.     def __contains__(self, item):
  503.         for haveitem in self:
  504.             if item == haveitem:
  505.                 return True
  506.         
  507.         return False
  508.  
  509.     
  510.     def __or__(self, other):
  511.         if isinstance(other, type) and issubclass(other, (Table, Display)):
  512.             other = other()
  513.         elif not isinstance(other, Display) and not isinstance(other, Table):
  514.             other = ieval(other)
  515.         
  516.         return other.__ror__(self)
  517.  
  518.     
  519.     def __add__(self, other):
  520.         if isinstance(other, type) and issubclass(other, Table):
  521.             other = other()
  522.         
  523.         return ichain(self, other)
  524.  
  525.     
  526.     def __radd__(self, other):
  527.         if isinstance(other, type) and issubclass(other, Table):
  528.             other = other()
  529.         
  530.         return ichain(other, self)
  531.  
  532.  
  533.  
  534. class Pipe(Table):
  535.     
  536.     class __metaclass__(Table.__metaclass__):
  537.         
  538.         def __ror__(self, input):
  539.             return input | self()
  540.  
  541.  
  542.     
  543.     def __ror__(self, input):
  544.         if isinstance(input, type) and issubclass(input, Table):
  545.             input = input()
  546.         
  547.         self.input = input
  548.         return self
  549.  
  550.  
  551.  
  552. def xrepr(item, mode = 'default'):
  553.     
  554.     try:
  555.         func = item.__xrepr__
  556.     except AttributeError:
  557.         yield (astyle.style_default, repr(item))
  558.  
  559.     
  560.     try:
  561.         for x in func(mode):
  562.             yield x
  563.     except (KeyboardInterrupt, SystemExit, GeneratorExit):
  564.         raise 
  565.     except Exception:
  566.         yield (astyle.style_default, repr(item))
  567.  
  568.  
  569. xrepr = simplegeneric.generic(xrepr)
  570.  
  571. def xrepr_none(self, mode = 'default'):
  572.     yield (astyle.style_type_none, repr(self))
  573.  
  574. xrepr.when_object(None)(xrepr_none)
  575.  
  576. def xrepr_noitem(self, mode = 'default'):
  577.     yield (2, True)
  578.     yield (astyle.style_nodata, '<?>')
  579.  
  580. xrepr.when_object(noitem)(xrepr_noitem)
  581.  
  582. def xrepr_bool(self, mode = 'default'):
  583.     yield (astyle.style_type_bool, repr(self))
  584.  
  585. xrepr.when_type(bool)(xrepr_bool)
  586.  
  587. def xrepr_str(self, mode = 'default'):
  588.     if mode == 'cell':
  589.         yield (astyle.style_default, repr(self.expandtabs(tab))[1:-1])
  590.     else:
  591.         yield (astyle.style_default, repr(self))
  592.  
  593. xrepr.when_type(str)(xrepr_str)
  594.  
  595. def xrepr_unicode(self, mode = 'default'):
  596.     if mode == 'cell':
  597.         yield (astyle.style_default, repr(self.expandtabs(tab))[2:-1])
  598.     else:
  599.         yield (astyle.style_default, repr(self))
  600.  
  601. xrepr.when_type(unicode)(xrepr_unicode)
  602.  
  603. def xrepr_number(self, mode = 'default'):
  604.     yield (1, True)
  605.     yield (astyle.style_type_number, repr(self))
  606.  
  607. xrepr.when_type(int)(xrepr_number)
  608. xrepr.when_type(long)(xrepr_number)
  609. xrepr.when_type(float)(xrepr_number)
  610.  
  611. def xrepr_complex(self, mode = 'default'):
  612.     yield (astyle.style_type_number, repr(self))
  613.  
  614. xrepr.when_type(complex)(xrepr_number)
  615.  
  616. def xrepr_datetime(self, mode = 'default'):
  617.     if mode == 'cell':
  618.         yield (astyle.style_type_datetime, '%04d-%02d-%02d %02d:%02d:%02d.%06d' % (self.year, self.month, self.day, self.hour, self.minute, self.second, self.microsecond))
  619.     else:
  620.         yield (astyle.style_type_datetime, repr(self))
  621.  
  622. xrepr.when_type(datetime.datetime)(xrepr_datetime)
  623.  
  624. def xrepr_date(self, mode = 'default'):
  625.     if mode == 'cell':
  626.         yield (astyle.style_type_datetime, '%04d-%02d-%02d' % (self.year, self.month, self.day))
  627.     else:
  628.         yield (astyle.style_type_datetime, repr(self))
  629.  
  630. xrepr.when_type(datetime.date)(xrepr_date)
  631.  
  632. def xrepr_time(self, mode = 'default'):
  633.     if mode == 'cell':
  634.         yield (astyle.style_type_datetime, '%02d:%02d:%02d.%06d' % (self.hour, self.minute, self.second, self.microsecond))
  635.     else:
  636.         yield (astyle.style_type_datetime, repr(self))
  637.  
  638. xrepr.when_type(datetime.time)(xrepr_time)
  639.  
  640. def xrepr_timedelta(self, mode = 'default'):
  641.     yield (astyle.style_type_datetime, repr(self))
  642.  
  643. xrepr.when_type(datetime.timedelta)(xrepr_timedelta)
  644.  
  645. def xrepr_type(self, mode = 'default'):
  646.     if self.__module__ == '__builtin__':
  647.         yield (astyle.style_type_type, self.__name__)
  648.     else:
  649.         yield (astyle.style_type_type, '%s.%s' % (self.__module__, self.__name__))
  650.  
  651. xrepr.when_type(type)(xrepr_type)
  652.  
  653. def xrepr_exception(self, mode = 'default'):
  654.     if self.__class__.__module__ == 'exceptions':
  655.         classname = self.__class__.__name__
  656.     else:
  657.         classname = '%s.%s' % (self.__class__.__module__, self.__class__.__name__)
  658.     if mode == 'header' or mode == 'footer':
  659.         yield (astyle.style_error, '%s: %s' % (classname, self))
  660.     else:
  661.         yield (astyle.style_error, classname)
  662.  
  663. xrepr.when_type(Exception)(xrepr_exception)
  664.  
  665. def xrepr_listtuple(self, mode = 'default'):
  666.     if mode == 'header' or mode == 'footer':
  667.         if self.__class__.__module__ == '__builtin__':
  668.             classname = self.__class__.__name__
  669.         else:
  670.             classname = '%s.%s' % (self.__class__.__module__, self.__class__.__name__)
  671.         yield (astyle.style_default, '<%s object with %d items at 0x%x>' % (classname, len(self), id(self)))
  672.     else:
  673.         yield (-1, False)
  674.         if isinstance(self, list):
  675.             yield (astyle.style_default, '[')
  676.             end = ']'
  677.         else:
  678.             yield (astyle.style_default, '(')
  679.             end = ')'
  680.         for i, subself in enumerate(self):
  681.             if i:
  682.                 yield (astyle.style_default, ', ')
  683.             
  684.             for part in xrepr(subself, 'default'):
  685.                 yield part
  686.             
  687.         
  688.         yield (astyle.style_default, end)
  689.  
  690. xrepr.when_type(list)(xrepr_listtuple)
  691. xrepr.when_type(tuple)(xrepr_listtuple)
  692.  
  693. def xrepr_dict(self, mode = 'default'):
  694.     if mode == 'header' or mode == 'footer':
  695.         if self.__class__.__module__ == '__builtin__':
  696.             classname = self.__class__.__name__
  697.         else:
  698.             classname = '%s.%s' % (self.__class__.__module__, self.__class__.__name__)
  699.         yield (astyle.style_default, '<%s object with %d items at 0x%x>' % (classname, len(self), id(self)))
  700.     else:
  701.         yield (-1, False)
  702.         if isinstance(self, dict):
  703.             yield (astyle.style_default, '{')
  704.             end = '}'
  705.         else:
  706.             yield (astyle.style_default, 'dictproxy((')
  707.             end = '})'
  708.         for key, value in enumerate(self.iteritems()):
  709.             for part in xrepr(key, 'default'):
  710.                 yield part
  711.                 None if i else None
  712.             
  713.             yield (astyle.style_default, ': ')
  714.             for part in xrepr(value, 'default'):
  715.                 yield part
  716.             
  717.         
  718.         yield (astyle.style_default, end)
  719.  
  720. xrepr.when_type(dict)(xrepr_dict)
  721. xrepr.when_type(types.DictProxyType)(xrepr_dict)
  722.  
  723. def upgradexattr(attr):
  724.     if attr is None:
  725.         return selfdescriptor
  726.     if isinstance(attr, Descriptor):
  727.         return attr
  728.     if isinstance(attr, basestring):
  729.         if attr.endswith('()'):
  730.             if attr.startswith('-'):
  731.                 return IterMethodDescriptor(attr[1:-2])
  732.             return MethodDescriptor(attr[:-2])
  733.         attr.endswith('()')
  734.         if attr.startswith('-'):
  735.             return IterAttributeDescriptor(attr[1:])
  736.         return AttributeDescriptor(attr)
  737.     isinstance(attr, basestring)
  738.     if isinstance(attr, (int, long)):
  739.         return IndexDescriptor(attr)
  740.     if callable(attr):
  741.         return FunctionDescriptor(attr)
  742.     raise TypeError("can't handle descriptor %r" % attr)
  743.  
  744.  
  745. def xattrs(item, mode = 'default'):
  746.     
  747.     try:
  748.         func = item.__xattrs__
  749.     except AttributeError:
  750.         if mode == 'detail':
  751.             for attrname in dir(item):
  752.                 yield AttributeDescriptor(attrname)
  753.             
  754.         else:
  755.             yield selfdescriptor
  756.     except:
  757.         mode == 'detail'
  758.  
  759.     for attr in func(mode):
  760.         yield upgradexattr(attr)
  761.     
  762.  
  763. xattrs = simplegeneric.generic(xattrs)
  764.  
  765. def xattrs_complex(self, mode = 'default'):
  766.     if mode == 'detail':
  767.         return (AttributeDescriptor('real'), AttributeDescriptor('imag'))
  768.     return (selfdescriptor,)
  769.  
  770. xattrs.when_type(complex)(xattrs_complex)
  771.  
  772. def _isdict(item):
  773.     
  774.     try:
  775.         itermeth = item.__class__.__iter__
  776.     except (AttributeError, TypeError):
  777.         return False
  778.  
  779.     if not itermeth is dict.__iter__:
  780.         pass
  781.     return itermeth is types.DictProxyType.__iter__
  782.  
  783.  
  784. def _isstr(item):
  785.     if not isinstance(item, basestring):
  786.         return False
  787.     
  788.     try:
  789.         itermeth = item.__class__.__iter__
  790.     except AttributeError:
  791.         isinstance(item, basestring)
  792.         isinstance(item, basestring)
  793.         return True
  794.  
  795.     return False
  796.  
  797.  
  798. def xiter(item):
  799.     
  800.     try:
  801.         func = item.__xiter__
  802.     except AttributeError:
  803.         if _isdict(item):
  804.             
  805.             def items(item):
  806.                 fields = ('key', 'value')
  807.                 for key, value in item.iteritems():
  808.                     yield Fields(fields, key = key, value = value)
  809.                 
  810.  
  811.             return items(item)
  812.         if isinstance(item, new.module):
  813.             
  814.             def items(item):
  815.                 fields = ('key', 'value')
  816.                 for key in sorted(item.__dict__):
  817.                     yield Fields(fields, key = key, value = getattr(item, key))
  818.                 
  819.  
  820.             return items(item)
  821.         if _isstr(item):
  822.             if not item:
  823.                 raise ValueError("can't enter empty string")
  824.             item
  825.             lines = item.splitlines()
  826.             if len(lines) == 1:
  827.                 
  828.                 def iterone(item):
  829.                     yield item
  830.  
  831.                 return iterone(item)
  832.             return iter(lines)
  833.         _isstr(item)
  834.         return iter(item)
  835.         isinstance(item, new.module)
  836.  
  837.     return iter(func())
  838.  
  839. xiter = simplegeneric.generic(xiter)
  840.  
  841. class ichain(Pipe):
  842.     
  843.     def __init__(self, *iters):
  844.         self.iters = iters
  845.  
  846.     
  847.     def __iter__(self):
  848.         return itertools.chain(*self.iters)
  849.  
  850.     
  851.     def __xrepr__(self, mode = 'default'):
  852.         if mode == 'header' or mode == 'footer':
  853.             for i, item in enumerate(self.iters):
  854.                 if i:
  855.                     yield (astyle.style_default, '+')
  856.                 
  857.                 if isinstance(item, Pipe):
  858.                     yield (astyle.style_default, '(')
  859.                 
  860.                 for part in xrepr(item, mode):
  861.                     yield part
  862.                 
  863.                 if isinstance(item, Pipe):
  864.                     yield (astyle.style_default, ')')
  865.                     continue
  866.             
  867.         else:
  868.             yield (astyle.style_default, repr(self))
  869.  
  870.     
  871.     def __repr__(self):
  872.         args = []([ repr(it) for it in self.iters ])
  873.         return '%s.%s(%s)' % (self.__class__.__module__, self.__class__.__name__, args)
  874.  
  875.  
  876.  
  877. class ifile(path.path):
  878.     
  879.     def getmode(self):
  880.         return self.stat().st_mode
  881.  
  882.     mode = property(getmode, None, None, 'Access mode')
  883.     
  884.     def gettype(self):
  885.         data = [
  886.             (stat.S_ISREG, 'file'),
  887.             (stat.S_ISDIR, 'dir'),
  888.             (stat.S_ISCHR, 'chardev'),
  889.             (stat.S_ISBLK, 'blockdev'),
  890.             (stat.S_ISFIFO, 'fifo'),
  891.             (stat.S_ISLNK, 'symlink'),
  892.             (stat.S_ISSOCK, 'socket')]
  893.         lstat = self.lstat()
  894.         m = self.mode
  895.         [](_[2])
  896.         return ', '.join(types)
  897.  
  898.     type = property(gettype, None, None, 'file type (file, directory, link, etc.)')
  899.     
  900.     def getmodestr(self):
  901.         m = self.mode
  902.         data = [
  903.             (stat.S_IRUSR, '-r'),
  904.             (stat.S_IWUSR, '-w'),
  905.             (stat.S_IXUSR, '-x'),
  906.             (stat.S_IRGRP, '-r'),
  907.             (stat.S_IWGRP, '-w'),
  908.             (stat.S_IXGRP, '-x'),
  909.             (stat.S_IROTH, '-r'),
  910.             (stat.S_IWOTH, '-w'),
  911.             (stat.S_IXOTH, '-x')]
  912.         return []([ text[bool(m & bit)] for bit, text in data ])
  913.  
  914.     modestr = property(getmodestr, None, None, 'Access mode as string')
  915.     
  916.     def getblocks(self):
  917.         return self.stat().st_blocks
  918.  
  919.     blocks = property(getblocks, None, None, 'File size in blocks')
  920.     
  921.     def getblksize(self):
  922.         return self.stat().st_blksize
  923.  
  924.     blksize = property(getblksize, None, None, 'Filesystem block size')
  925.     
  926.     def getdev(self):
  927.         return self.stat().st_dev
  928.  
  929.     dev = property(getdev)
  930.     
  931.     def getnlink(self):
  932.         return self.stat().st_nlink
  933.  
  934.     nlink = property(getnlink, None, None, 'Number of links')
  935.     
  936.     def getuid(self):
  937.         return self.stat().st_uid
  938.  
  939.     uid = property(getuid, None, None, 'User id of file owner')
  940.     
  941.     def getgid(self):
  942.         return self.stat().st_gid
  943.  
  944.     gid = property(getgid, None, None, 'Group id of file owner')
  945.     
  946.     def getowner(self):
  947.         stat = self.stat()
  948.         
  949.         try:
  950.             return pwd.getpwuid(stat.st_uid).pw_name
  951.         except KeyError:
  952.             return stat.st_uid
  953.  
  954.  
  955.     owner = property(getowner, None, None, 'Owner name (or id)')
  956.     
  957.     def getgroup(self):
  958.         stat = self.stat()
  959.         
  960.         try:
  961.             return grp.getgrgid(stat.st_gid).gr_name
  962.         except KeyError:
  963.             return stat.st_gid
  964.  
  965.  
  966.     group = property(getgroup, None, None, 'Group name (or id)')
  967.     
  968.     def getadate(self):
  969.         return datetime.datetime.utcfromtimestamp(self.atime)
  970.  
  971.     adate = property(getadate, None, None, 'Access date')
  972.     
  973.     def getcdate(self):
  974.         return datetime.datetime.utcfromtimestamp(self.ctime)
  975.  
  976.     cdate = property(getcdate, None, None, 'Creation date')
  977.     
  978.     def getmdate(self):
  979.         return datetime.datetime.utcfromtimestamp(self.mtime)
  980.  
  981.     mdate = property(getmdate, None, None, 'Modification date')
  982.     
  983.     def mimetype(self):
  984.         return mimetypes.guess_type(self.basename())[0]
  985.  
  986.     
  987.     def encoding(self):
  988.         return mimetypes.guess_type(self.basename())[1]
  989.  
  990.     
  991.     def __repr__(self):
  992.         return 'ifile(%s)' % path._base.__repr__(self)
  993.  
  994.     if sys.platform == 'win32':
  995.         defaultattrs = (None, 'type', 'size', 'modestr', 'mdate')
  996.     else:
  997.         defaultattrs = (None, 'type', 'size', 'modestr', 'owner', 'group', 'mdate')
  998.     
  999.     def __xattrs__(self, mode = 'default'):
  1000.         if mode == 'detail':
  1001.             return ('name', 'basename()', 'abspath()', 'realpath()', 'type', 'mode', 'modestr', 'stat()', 'lstat()', 'uid', 'gid', 'owner', 'group', 'dev', 'nlink', 'ctime', 'mtime', 'atime', 'cdate', 'mdate', 'adate', 'size', 'blocks', 'blksize', 'isdir()', 'islink()', 'mimetype()', 'encoding()', '-listdir()', '-dirs()', '-files()', '-walk()', '-walkdirs()', '-walkfiles()')
  1002.         return self.defaultattrs
  1003.  
  1004.  
  1005.  
  1006. def xiter_ifile(self):
  1007.     if self.isdir():
  1008.         yield (self / os.pardir).abspath()
  1009.         for child in sorted(self.listdir()):
  1010.             yield child
  1011.         
  1012.     else:
  1013.         f = self.open('rb')
  1014.         for line in f:
  1015.             yield line
  1016.         
  1017.         f.close()
  1018.  
  1019. xiter.when_type(ifile)(xiter_ifile)
  1020.  
  1021. def xrepr_ifile(self, mode = 'default'):
  1022.     
  1023.     try:
  1024.         if self.isdir():
  1025.             name = 'idir'
  1026.             style = astyle.style_dir
  1027.         else:
  1028.             name = 'ifile'
  1029.             style = astyle.style_file
  1030.     except IOError:
  1031.         name = 'ifile'
  1032.         style = astyle.style_default
  1033.  
  1034.     if mode in ('cell', 'header', 'footer'):
  1035.         abspath = repr(path._base(self.normpath()))
  1036.         if abspath.startswith('u'):
  1037.             abspath = abspath[2:-1]
  1038.         else:
  1039.             abspath = abspath[1:-1]
  1040.         if mode == 'cell':
  1041.             yield (style, abspath)
  1042.         else:
  1043.             yield (style, '%s(%s)' % (name, abspath))
  1044.     else:
  1045.         yield (style, repr(self))
  1046.  
  1047. xrepr.when_type(ifile)(xrepr_ifile)
  1048.  
  1049. class ils(Table):
  1050.     
  1051.     def __init__(self, base = os.curdir, dirs = True, files = True):
  1052.         self.base = os.path.expanduser(base)
  1053.         self.dirs = dirs
  1054.         self.files = files
  1055.  
  1056.     
  1057.     def __iter__(self):
  1058.         base = ifile(self.base)
  1059.         yield (base / os.pardir).abspath()
  1060.         for child in sorted(base.listdir()):
  1061.             if self.dirs:
  1062.                 if self.files:
  1063.                     yield child
  1064.                 elif child.isdir():
  1065.                     yield child
  1066.                 
  1067.             self.files
  1068.             if self.files:
  1069.                 if not child.isdir():
  1070.                     yield child
  1071.                 
  1072.             child.isdir()
  1073.         
  1074.  
  1075.     
  1076.     def __xrepr__(self, mode = 'default'):
  1077.         return xrepr(ifile(self.base), mode)
  1078.  
  1079.     
  1080.     def __repr__(self):
  1081.         return '%s.%s(%r)' % (self.__class__.__module__, self.__class__.__name__, self.base)
  1082.  
  1083.  
  1084.  
  1085. class iglob(Table):
  1086.     
  1087.     def __init__(self, glob):
  1088.         self.glob = glob
  1089.  
  1090.     
  1091.     def __iter__(self):
  1092.         for name in glob.glob(self.glob):
  1093.             yield ifile(name)
  1094.         
  1095.  
  1096.     
  1097.     def __xrepr__(self, mode = 'default'):
  1098.         if mode == 'header' and mode == 'footer' or mode == 'cell':
  1099.             yield (astyle.style_default, '%s(%r)' % (self.__class__.__name__, self.glob))
  1100.         else:
  1101.             yield (astyle.style_default, repr(self))
  1102.  
  1103.     
  1104.     def __repr__(self):
  1105.         return '%s.%s(%r)' % (self.__class__.__module__, self.__class__.__name__, self.glob)
  1106.  
  1107.  
  1108.  
  1109. class iwalk(Table):
  1110.     
  1111.     def __init__(self, base = os.curdir, dirs = True, files = True):
  1112.         self.base = os.path.expanduser(base)
  1113.         self.dirs = dirs
  1114.         self.files = files
  1115.  
  1116.     
  1117.     def __iter__(self):
  1118.         for dirpath, dirnames, filenames in os.walk(self.base):
  1119.             if self.dirs:
  1120.                 for name in sorted(dirnames):
  1121.                     yield ifile(os.path.join(dirpath, name))
  1122.                 
  1123.             
  1124.             if self.files:
  1125.                 for name in sorted(filenames):
  1126.                     yield ifile(os.path.join(dirpath, name))
  1127.                 
  1128.         
  1129.  
  1130.     
  1131.     def __xrepr__(self, mode = 'default'):
  1132.         if mode == 'header' and mode == 'footer' or mode == 'cell':
  1133.             yield (astyle.style_default, '%s(%r)' % (self.__class__.__name__, self.base))
  1134.         else:
  1135.             yield (astyle.style_default, repr(self))
  1136.  
  1137.     
  1138.     def __repr__(self):
  1139.         return '%s.%s(%r)' % (self.__class__.__module__, self.__class__.__name__, self.base)
  1140.  
  1141.  
  1142.  
  1143. class ipwdentry(object):
  1144.     
  1145.     def __init__(self, id):
  1146.         self._id = id
  1147.         self._entry = None
  1148.  
  1149.     
  1150.     def __eq__(self, other):
  1151.         if self.__class__ is other.__class__:
  1152.             pass
  1153.         return self._id == other._id
  1154.  
  1155.     
  1156.     def __ne__(self, other):
  1157.         if not self.__class__ is not other.__class__:
  1158.             pass
  1159.         return self._id != other._id
  1160.  
  1161.     
  1162.     def _getentry(self):
  1163.         if self._entry is None:
  1164.             if isinstance(self._id, basestring):
  1165.                 self._entry = pwd.getpwnam(self._id)
  1166.             else:
  1167.                 self._entry = pwd.getpwuid(self._id)
  1168.         
  1169.         return self._entry
  1170.  
  1171.     
  1172.     def getname(self):
  1173.         if isinstance(self._id, basestring):
  1174.             return self._id
  1175.         return self._getentry().pw_name
  1176.  
  1177.     name = property(getname, None, None, 'User name')
  1178.     
  1179.     def getpasswd(self):
  1180.         return self._getentry().pw_passwd
  1181.  
  1182.     passwd = property(getpasswd, None, None, 'Password')
  1183.     
  1184.     def getuid(self):
  1185.         if isinstance(self._id, basestring):
  1186.             return self._getentry().pw_uid
  1187.         return self._id
  1188.  
  1189.     uid = property(getuid, None, None, 'User id')
  1190.     
  1191.     def getgid(self):
  1192.         return self._getentry().pw_gid
  1193.  
  1194.     gid = property(getgid, None, None, 'Primary group id')
  1195.     
  1196.     def getgroup(self):
  1197.         return igrpentry(self.gid)
  1198.  
  1199.     group = property(getgroup, None, None, 'Group')
  1200.     
  1201.     def getgecos(self):
  1202.         return self._getentry().pw_gecos
  1203.  
  1204.     gecos = property(getgecos, None, None, 'Information (e.g. full user name)')
  1205.     
  1206.     def getdir(self):
  1207.         return self._getentry().pw_dir
  1208.  
  1209.     dir = property(getdir, None, None, '$HOME directory')
  1210.     
  1211.     def getshell(self):
  1212.         return self._getentry().pw_shell
  1213.  
  1214.     shell = property(getshell, None, None, 'Login shell')
  1215.     
  1216.     def __xattrs__(self, mode = 'default'):
  1217.         return ('name', 'passwd', 'uid', 'gid', 'gecos', 'dir', 'shell')
  1218.  
  1219.     
  1220.     def __repr__(self):
  1221.         return '%s.%s(%r)' % (self.__class__.__module__, self.__class__.__name__, self._id)
  1222.  
  1223.  
  1224.  
  1225. class ipwd(Table):
  1226.     
  1227.     def __iter__(self):
  1228.         for entry in pwd.getpwall():
  1229.             yield ipwdentry(entry.pw_name)
  1230.         
  1231.  
  1232.     
  1233.     def __xrepr__(self, mode = 'default'):
  1234.         if mode == 'header' and mode == 'footer' or mode == 'cell':
  1235.             yield (astyle.style_default, '%s()' % self.__class__.__name__)
  1236.         else:
  1237.             yield (astyle.style_default, repr(self))
  1238.  
  1239.  
  1240.  
  1241. class igrpentry(object):
  1242.     
  1243.     def __init__(self, id):
  1244.         self._id = id
  1245.         self._entry = None
  1246.  
  1247.     
  1248.     def __eq__(self, other):
  1249.         if self.__class__ is other.__class__:
  1250.             pass
  1251.         return self._id == other._id
  1252.  
  1253.     
  1254.     def __ne__(self, other):
  1255.         if not self.__class__ is not other.__class__:
  1256.             pass
  1257.         return self._id != other._id
  1258.  
  1259.     
  1260.     def _getentry(self):
  1261.         if self._entry is None:
  1262.             if isinstance(self._id, basestring):
  1263.                 self._entry = grp.getgrnam(self._id)
  1264.             else:
  1265.                 self._entry = grp.getgrgid(self._id)
  1266.         
  1267.         return self._entry
  1268.  
  1269.     
  1270.     def getname(self):
  1271.         if isinstance(self._id, basestring):
  1272.             return self._id
  1273.         return self._getentry().gr_name
  1274.  
  1275.     name = property(getname, None, None, 'Group name')
  1276.     
  1277.     def getpasswd(self):
  1278.         return self._getentry().gr_passwd
  1279.  
  1280.     passwd = property(getpasswd, None, None, 'Password')
  1281.     
  1282.     def getgid(self):
  1283.         if isinstance(self._id, basestring):
  1284.             return self._getentry().gr_gid
  1285.         return self._id
  1286.  
  1287.     gid = property(getgid, None, None, 'Group id')
  1288.     
  1289.     def getmem(self):
  1290.         return self._getentry().gr_mem
  1291.  
  1292.     mem = property(getmem, None, None, 'Members')
  1293.     
  1294.     def __xattrs__(self, mode = 'default'):
  1295.         return ('name', 'passwd', 'gid', 'mem')
  1296.  
  1297.     
  1298.     def __xrepr__(self, mode = 'default'):
  1299.         if mode == 'header' and mode == 'footer' or mode == 'cell':
  1300.             yield (astyle.style_default, 'group ')
  1301.             
  1302.             try:
  1303.                 yield (astyle.style_default, self.name)
  1304.             except KeyError:
  1305.                 if isinstance(self._id, basestring):
  1306.                     yield (astyle.style_default, self.name_id)
  1307.                 else:
  1308.                     yield (astyle.style_type_number, str(self._id))
  1309.             except:
  1310.                 isinstance(self._id, basestring)
  1311.             
  1312.  
  1313.         None<EXCEPTION MATCH>KeyError
  1314.         yield (astyle.style_default, repr(self))
  1315.  
  1316.     
  1317.     def __iter__(self):
  1318.         for member in self.mem:
  1319.             yield ipwdentry(member)
  1320.         
  1321.  
  1322.     
  1323.     def __repr__(self):
  1324.         return '%s.%s(%r)' % (self.__class__.__module__, self.__class__.__name__, self._id)
  1325.  
  1326.  
  1327.  
  1328. class igrp(Table):
  1329.     
  1330.     def __iter__(self):
  1331.         for entry in grp.getgrall():
  1332.             yield igrpentry(entry.gr_name)
  1333.         
  1334.  
  1335.     
  1336.     def __xrepr__(self, mode = 'default'):
  1337.         if mode == 'header' or mode == 'footer':
  1338.             yield (astyle.style_default, '%s()' % self.__class__.__name__)
  1339.         else:
  1340.             yield (astyle.style_default, repr(self))
  1341.  
  1342.  
  1343.  
  1344. class Fields(object):
  1345.     
  1346.     def __init__(self, fieldnames, **fields):
  1347.         self._Fields__fieldnames = [ upgradexattr(fieldname) for fieldname in fieldnames ]
  1348.         for key, value in fields.iteritems():
  1349.             setattr(self, key, value)
  1350.         
  1351.  
  1352.     
  1353.     def __xattrs__(self, mode = 'default'):
  1354.         return self._Fields__fieldnames
  1355.  
  1356.     
  1357.     def __xrepr__(self, mode = 'default'):
  1358.         yield (-1, False)
  1359.         if mode == 'header' or mode == 'cell':
  1360.             yield (astyle.style_default, self.__class__.__name__)
  1361.             yield (astyle.style_default, '(')
  1362.             for i, f in enumerate(self._Fields__fieldnames):
  1363.                 if i:
  1364.                     yield (astyle.style_default, ', ')
  1365.                 
  1366.                 yield (astyle.style_default, f.name())
  1367.                 yield (astyle.style_default, '=')
  1368.                 for part in xrepr(getattr(self, f), 'default'):
  1369.                     yield part
  1370.                 
  1371.             
  1372.             yield (astyle.style_default, ')')
  1373.         elif mode == 'footer':
  1374.             yield (astyle.style_default, self.__class__.__name__)
  1375.             yield (astyle.style_default, '(')
  1376.             for i, f in enumerate(self._Fields__fieldnames):
  1377.                 if i:
  1378.                     yield (astyle.style_default, ', ')
  1379.                 
  1380.                 yield (astyle.style_default, f.name())
  1381.             
  1382.             yield (astyle.style_default, ')')
  1383.         else:
  1384.             yield (astyle.style_default, repr(self))
  1385.  
  1386.  
  1387.  
  1388. class FieldTable(Table, list):
  1389.     
  1390.     def __init__(self, *fields):
  1391.         Table.__init__(self)
  1392.         list.__init__(self)
  1393.         self.fields = fields
  1394.  
  1395.     
  1396.     def add(self, **fields):
  1397.         self.append(Fields(self.fields, **fields))
  1398.  
  1399.     
  1400.     def __xrepr__(self, mode = 'default'):
  1401.         yield (-1, False)
  1402.         if mode == 'header' or mode == 'footer':
  1403.             yield (astyle.style_default, self.__class__.__name__)
  1404.             yield (astyle.style_default, '(')
  1405.             for i, f in enumerate(self._FieldTable__fieldnames):
  1406.                 if i:
  1407.                     yield (astyle.style_default, ', ')
  1408.                 
  1409.                 yield (astyle.style_default, f)
  1410.             
  1411.             yield (astyle.style_default, ')')
  1412.         else:
  1413.             yield (astyle.style_default, repr(self))
  1414.  
  1415.     
  1416.     def __repr__(self):
  1417.         return '<%s.%s object with fields=%r at 0x%x>' % (self.__class__.__module__, self.__class__.__name__, ', '.join(map(repr, self.fields)), id(self))
  1418.  
  1419.  
  1420.  
  1421. class List(list):
  1422.     
  1423.     def __xattrs__(self, mode = 'default'):
  1424.         return xrange(len(self))
  1425.  
  1426.     
  1427.     def __xrepr__(self, mode = 'default'):
  1428.         yield (-1, False)
  1429.         if mode == 'header' and mode == 'cell' and mode == 'footer' or mode == 'default':
  1430.             yield (astyle.style_default, self.__class__.__name__)
  1431.             yield (astyle.style_default, '(')
  1432.             for i, item in enumerate(self):
  1433.                 if i:
  1434.                     yield (astyle.style_default, ', ')
  1435.                 
  1436.                 for part in xrepr(item, 'default'):
  1437.                     yield part
  1438.                 
  1439.             
  1440.             yield (astyle.style_default, ')')
  1441.         else:
  1442.             yield (astyle.style_default, repr(self))
  1443.  
  1444.  
  1445.  
  1446. class ienv(Table):
  1447.     
  1448.     def __iter__(self):
  1449.         fields = ('key', 'value')
  1450.         for key, value in os.environ.iteritems():
  1451.             yield Fields(fields, key = key, value = value)
  1452.         
  1453.  
  1454.     
  1455.     def __xrepr__(self, mode = 'default'):
  1456.         if mode == 'header' or mode == 'cell':
  1457.             yield (astyle.style_default, '%s()' % self.__class__.__name__)
  1458.         else:
  1459.             yield (astyle.style_default, repr(self))
  1460.  
  1461.  
  1462.  
  1463. class ihist(Table):
  1464.     
  1465.     def __init__(self, raw = True):
  1466.         self.raw = raw
  1467.  
  1468.     
  1469.     def __iter__(self):
  1470.         api = ipapi.get()
  1471.         if self.raw:
  1472.             for line in api.IP.input_hist_raw:
  1473.                 yield line.rstrip('\n')
  1474.             
  1475.         else:
  1476.             for line in api.IP.input_hist:
  1477.                 yield line.rstrip('\n')
  1478.             
  1479.  
  1480.  
  1481.  
  1482. class Alias(object):
  1483.     
  1484.     def __init__(self, name, args, command):
  1485.         self.name = name
  1486.         self.args = args
  1487.         self.command = command
  1488.  
  1489.     
  1490.     def __xattrs__(self, mode = 'default'):
  1491.         return ('name', 'args', 'command')
  1492.  
  1493.  
  1494.  
  1495. class ialias(Table):
  1496.     
  1497.     def __iter__(self):
  1498.         api = ipapi.get()
  1499.         for args, command in api.IP.alias_table.iteritems():
  1500.             yield Alias(name, args, command)
  1501.         
  1502.  
  1503.  
  1504.  
  1505. class icsv(Pipe):
  1506.     
  1507.     def __init__(self, **csvargs):
  1508.         self.csvargs = csvargs
  1509.  
  1510.     
  1511.     def __iter__(self):
  1512.         input = self.input
  1513.         if isinstance(input, ifile):
  1514.             input = input.open('rb')
  1515.         
  1516.         reader = csv.reader(input, **self.csvargs)
  1517.         for line in reader:
  1518.             yield List(line)
  1519.         
  1520.  
  1521.     
  1522.     def __xrepr__(self, mode = 'default'):
  1523.         yield (-1, False)
  1524.         if mode == 'header' or mode == 'footer':
  1525.             input = getattr(self, 'input', None)
  1526.             if input is not None:
  1527.                 for part in xrepr(input, mode):
  1528.                     yield part
  1529.                 
  1530.                 yield (astyle.style_default, ' | ')
  1531.             
  1532.             yield (astyle.style_default, '%s(' % self.__class__.__name__)
  1533.             for name, value in enumerate(self.csvargs.iteritems()):
  1534.                 yield (astyle.style_default, name)
  1535.                 None if i else None
  1536.                 yield (astyle.style_default, '=')
  1537.                 for part in xrepr(value, 'default'):
  1538.                     yield part
  1539.                 
  1540.             
  1541.             yield (astyle.style_default, ')')
  1542.         else:
  1543.             yield (astyle.style_default, repr(self))
  1544.  
  1545.     
  1546.     def __repr__(self):
  1547.         args = []([ '%s=%r' % item for item in self.csvargs.iteritems() ])
  1548.         return '<%s.%s %s at 0x%x>' % (self.__class__.__module__, self.__class__.__name__, args, id(self))
  1549.  
  1550.  
  1551.  
  1552. class ix(Table):
  1553.     
  1554.     def __init__(self, cmd):
  1555.         self.cmd = cmd
  1556.         self._pipeout = None
  1557.  
  1558.     
  1559.     def __iter__(self):
  1560.         (_pipein, self._pipeout) = os.popen4(self.cmd)
  1561.         _pipein.close()
  1562.         for l in self._pipeout:
  1563.             yield l.rstrip('\r\n')
  1564.         
  1565.         self._pipeout.close()
  1566.         self._pipeout = None
  1567.  
  1568.     
  1569.     def __del__(self):
  1570.         if self._pipeout is not None and not (self._pipeout.closed):
  1571.             self._pipeout.close()
  1572.         
  1573.         self._pipeout = None
  1574.  
  1575.     
  1576.     def __xrepr__(self, mode = 'default'):
  1577.         if mode == 'header' or mode == 'footer':
  1578.             yield (astyle.style_default, '%s(%r)' % (self.__class__.__name__, self.cmd))
  1579.         else:
  1580.             yield (astyle.style_default, repr(self))
  1581.  
  1582.     
  1583.     def __repr__(self):
  1584.         return '%s.%s(%r)' % (self.__class__.__module__, self.__class__.__name__, self.cmd)
  1585.  
  1586.  
  1587.  
  1588. class ifilter(Pipe):
  1589.     
  1590.     def __init__(self, expr, globals = None, errors = 'raiseifallfail'):
  1591.         self.expr = expr
  1592.         self.globals = globals
  1593.         self.errors = errors
  1594.  
  1595.     
  1596.     def __iter__(self):
  1597.         ok = 0
  1598.         exc_info = None
  1599.         for item in xiter(self.input):
  1600.             
  1601.             try:
  1602.                 ok += 1
  1603.             continue
  1604.             except (KeyboardInterrupt, SystemExit):
  1605.                 None if callable(self.expr) else (None, None)
  1606.                 None if callable(self.expr) else (None, None)
  1607.                 raise 
  1608.                 continue
  1609.                 except Exception:
  1610.                     exc = None
  1611.                     if self.errors == 'drop':
  1612.                         pass
  1613.                     elif self.errors == 'keep':
  1614.                         yield item
  1615.                     elif self.errors == 'keeperror':
  1616.                         yield exc
  1617.                     elif self.errors == 'raise':
  1618.                         raise 
  1619.                     elif self.errors == 'raiseifallfail':
  1620.                         if exc_info is None:
  1621.                             exc_info = sys.exc_info()
  1622.                         
  1623.                     
  1624.                     self.errors == 'drop'
  1625.                 
  1626.             if not ok and exc_info is not None:
  1627.                 raise exc_info[0], exc_info[1], exc_info[2]
  1628.             return None
  1629.  
  1630.  
  1631.     
  1632.     def __xrepr__(self, mode = 'default'):
  1633.         if mode == 'header' or mode == 'footer':
  1634.             input = getattr(self, 'input', None)
  1635.             if input is not None:
  1636.                 for part in xrepr(input, mode):
  1637.                     yield part
  1638.                 
  1639.                 yield (astyle.style_default, ' | ')
  1640.             
  1641.             yield (astyle.style_default, '%s(' % self.__class__.__name__)
  1642.             for part in xrepr(self.expr, 'default'):
  1643.                 yield part
  1644.             
  1645.             yield (astyle.style_default, ')')
  1646.         else:
  1647.             yield (astyle.style_default, repr(self))
  1648.  
  1649.     
  1650.     def __repr__(self):
  1651.         return '<%s.%s expr=%r at 0x%x>' % (self.__class__.__module__, self.__class__.__name__, self.expr, id(self))
  1652.  
  1653.  
  1654.  
  1655. class ieval(Pipe):
  1656.     
  1657.     def __init__(self, expr, globals = None, errors = 'raiseifallfail'):
  1658.         self.expr = expr
  1659.         self.globals = globals
  1660.         self.errors = errors
  1661.  
  1662.     
  1663.     def __iter__(self):
  1664.         ok = 0
  1665.         exc_info = None
  1666.         for item in xiter(self.input):
  1667.             
  1668.             try:
  1669.                 yield do(item)
  1670.                 None if callable(self.expr) else (None, None)
  1671.             continue
  1672.             except (KeyboardInterrupt, SystemExit):
  1673.                 None if callable(self.expr) else (None, None)
  1674.                 None if callable(self.expr) else (None, None)
  1675.                 raise 
  1676.                 continue
  1677.                 except Exception:
  1678.                     exc = None
  1679.                     if self.errors == 'drop':
  1680.                         pass
  1681.                     elif self.errors == 'keep':
  1682.                         yield item
  1683.                     elif self.errors == 'keeperror':
  1684.                         yield exc
  1685.                     elif self.errors == 'raise':
  1686.                         raise 
  1687.                     elif self.errors == 'raiseifallfail':
  1688.                         if exc_info is None:
  1689.                             exc_info = sys.exc_info()
  1690.                         
  1691.                     
  1692.                     self.errors == 'drop'
  1693.                 
  1694.             if not ok and exc_info is not None:
  1695.                 raise exc_info[0], exc_info[1], exc_info[2]
  1696.             return None
  1697.  
  1698.  
  1699.     
  1700.     def __xrepr__(self, mode = 'default'):
  1701.         if mode == 'header' or mode == 'footer':
  1702.             input = getattr(self, 'input', None)
  1703.             if input is not None:
  1704.                 for part in xrepr(input, mode):
  1705.                     yield part
  1706.                 
  1707.                 yield (astyle.style_default, ' | ')
  1708.             
  1709.             yield (astyle.style_default, '%s(' % self.__class__.__name__)
  1710.             for part in xrepr(self.expr, 'default'):
  1711.                 yield part
  1712.             
  1713.             yield (astyle.style_default, ')')
  1714.         else:
  1715.             yield (astyle.style_default, repr(self))
  1716.  
  1717.     
  1718.     def __repr__(self):
  1719.         return '<%s.%s expr=%r at 0x%x>' % (self.__class__.__module__, self.__class__.__name__, self.expr, id(self))
  1720.  
  1721.  
  1722.  
  1723. class ienum(Pipe):
  1724.     skip_doctest = True
  1725.     
  1726.     def __iter__(self):
  1727.         fields = ('index', 'object')
  1728.         for index, object in enumerate(xiter(self.input)):
  1729.             yield Fields(fields, index = index, object = object)
  1730.         
  1731.  
  1732.  
  1733.  
  1734. class isort(Pipe):
  1735.     
  1736.     def __init__(self, key = None, globals = None, reverse = False):
  1737.         self.key = key
  1738.         self.globals = globals
  1739.         self.reverse = reverse
  1740.  
  1741.     
  1742.     def __iter__(self):
  1743.         if self.key is None:
  1744.             items = sorted(xiter(self.input), reverse = self.reverse)
  1745.         elif callable(self.key):
  1746.             items = sorted(xiter(self.input), key = self.key, reverse = self.reverse)
  1747.         else:
  1748.             g = getglobals(self.globals)
  1749.             key = compile(self.key, 'ipipe-expression', 'eval')
  1750.             
  1751.             def realkey(item):
  1752.                 return eval(key, g, AttrNamespace(item))
  1753.  
  1754.             items = sorted(xiter(self.input), key = realkey, reverse = self.reverse)
  1755.         for item in items:
  1756.             yield item
  1757.             (None, None)
  1758.         
  1759.  
  1760.     
  1761.     def __xrepr__(self, mode = 'default'):
  1762.         if mode == 'header' or mode == 'footer':
  1763.             input = getattr(self, 'input', None)
  1764.             if input is not None:
  1765.                 for part in xrepr(input, mode):
  1766.                     yield part
  1767.                 
  1768.                 yield (astyle.style_default, ' | ')
  1769.             
  1770.             yield (astyle.style_default, '%s(' % self.__class__.__name__)
  1771.             for part in xrepr(self.key, 'default'):
  1772.                 yield part
  1773.             
  1774.             if self.reverse:
  1775.                 yield (astyle.style_default, ', ')
  1776.                 for part in xrepr(True, 'default'):
  1777.                     yield part
  1778.                 
  1779.             
  1780.             yield (astyle.style_default, ')')
  1781.         else:
  1782.             yield (astyle.style_default, repr(self))
  1783.  
  1784.     
  1785.     def __repr__(self):
  1786.         return '<%s.%s key=%r reverse=%r at 0x%x>' % (self.__class__.__module__, self.__class__.__name__, self.key, self.reverse, id(self))
  1787.  
  1788.  
  1789. tab = 3
  1790.  
  1791. def _format(field):
  1792.     if isinstance(field, str):
  1793.         text = repr(field.expandtabs(tab))[1:-1]
  1794.     elif isinstance(field, unicode):
  1795.         text = repr(field.expandtabs(tab))[2:-1]
  1796.     elif isinstance(field, datetime.datetime):
  1797.         text = '%04d-%02d-%02d %02d:%02d:%02d.%06d' % (field.year, field.month, field.day, field.hour, field.minute, field.second, field.microsecond)
  1798.     elif isinstance(field, datetime.date):
  1799.         text = '%04d-%02d-%02d' % (field.year, field.month, field.day)
  1800.     else:
  1801.         text = repr(field)
  1802.     return text
  1803.  
  1804.  
  1805. class Display(object):
  1806.     
  1807.     class __metaclass__(type):
  1808.         
  1809.         def __ror__(self, input):
  1810.             return input | self()
  1811.  
  1812.  
  1813.     
  1814.     def __init__(self, input = None):
  1815.         self.input = input
  1816.  
  1817.     
  1818.     def __ror__(self, input):
  1819.         self.input = input
  1820.         return self
  1821.  
  1822.     
  1823.     def display(self):
  1824.         pass
  1825.  
  1826.  
  1827.  
  1828. class iless(Display):
  1829.     cmd = 'less --quit-if-one-screen --LONG-PROMPT --LINE-NUMBERS --chop-long-lines --shift=8 --RAW-CONTROL-CHARS'
  1830.     
  1831.     def display(self):
  1832.         
  1833.         try:
  1834.             pager = os.popen(self.cmd, 'w')
  1835.             
  1836.             try:
  1837.                 for item in xiter(self.input):
  1838.                     first = False
  1839.                     for attr in xattrs(item, 'default'):
  1840.                         if first:
  1841.                             first = False
  1842.                         else:
  1843.                             pager.write(' ')
  1844.                         attr = upgradexattr(attr)
  1845.                         if not isinstance(attr, SelfDescriptor):
  1846.                             pager.write(attr.name())
  1847.                             pager.write('=')
  1848.                         
  1849.                         pager.write(str(attr.value(item)))
  1850.                     
  1851.                     pager.write('\n')
  1852.             finally:
  1853.                 pager.close()
  1854.  
  1855.         except Exception:
  1856.             exc = None
  1857.             print '%s: %s' % (exc.__class__.__name__, str(exc))
  1858.  
  1859.  
  1860.  
  1861.  
  1862. class _RedirectIO(object):
  1863.     
  1864.     def __init__(self, *args, **kwargs):
  1865.         self.stream = StringIO.StringIO()
  1866.         self.stdout = sys.stdout
  1867.         sys.stdout = self
  1868.         self.stderr = sys.stderr
  1869.         sys.stderr = self
  1870.  
  1871.     
  1872.     def write(self, text):
  1873.         self.stream.write(text)
  1874.         self.stdout.write(text)
  1875.         if '\n' in text:
  1876.             self.stdout.flush()
  1877.         
  1878.  
  1879.     
  1880.     def writelines(self, lines):
  1881.         self.stream.writelines(lines)
  1882.         self.stdout.writelines(lines)
  1883.         self.stdout.flush()
  1884.  
  1885.     
  1886.     def restore(self):
  1887.         self.stdout.flush()
  1888.         self.stderr.flush()
  1889.         sys.stdout = self.stdout
  1890.         sys.stderr = self.stderr
  1891.  
  1892.  
  1893.  
  1894. class icap(Table):
  1895.     skip_doctest = True
  1896.     
  1897.     def __init__(self, expr, globals = None):
  1898.         self.expr = expr
  1899.         self.globals = globals
  1900.         log = _RedirectIO()
  1901.         
  1902.         try:
  1903.             exec (expr, getglobals(globals))
  1904.         finally:
  1905.             log.restore()
  1906.  
  1907.         self.stream = log.stream
  1908.  
  1909.     
  1910.     def __iter__(self):
  1911.         self.stream.seek(0)
  1912.         for line in self.stream:
  1913.             yield line.rstrip('\r\n')
  1914.         
  1915.  
  1916.     
  1917.     def __xrepr__(self, mode = 'default'):
  1918.         if mode == 'header' or mode == 'footer':
  1919.             yield (astyle.style_default, '%s(%r)' % (self.__class__.__name__, self.expr))
  1920.         else:
  1921.             yield (astyle.style_default, repr(self))
  1922.  
  1923.     
  1924.     def __repr__(self):
  1925.         return '%s.%s(%r)' % (self.__class__.__module__, self.__class__.__name__, self.expr)
  1926.  
  1927.  
  1928.  
  1929. def xformat(value, mode, maxlength):
  1930.     align = None
  1931.     full = True
  1932.     width = 0
  1933.     text = astyle.Text()
  1934.     for style, part in xrepr(value, mode):
  1935.         if align is None:
  1936.             if isinstance(style, int):
  1937.                 align = style
  1938.                 full = part
  1939.                 continue
  1940.             else:
  1941.                 align = -1
  1942.                 full = True
  1943.         
  1944.         if not isinstance(style, int):
  1945.             text.append((style, part))
  1946.             width += len(part)
  1947.             if width >= maxlength and not full:
  1948.                 text.append((astyle.style_ellisis, '...'))
  1949.                 width += 3
  1950.                 break
  1951.             
  1952.         not full
  1953.     
  1954.     if align is None:
  1955.         align = -1
  1956.     
  1957.     return (align, width, text)
  1958.  
  1959. import astyle
  1960.  
  1961. class idump(Display):
  1962.     maxattrlength = 200
  1963.     style_header = astyle.Style.fromstr('white:black:bold')
  1964.     
  1965.     def __init__(self, input = None, *attrs):
  1966.         Display.__init__(self, input)
  1967.         self.attrs = [ upgradexattr(attr) for attr in attrs ]
  1968.         self.headerpadchar = ' '
  1969.         self.headersepchar = '|'
  1970.         self.datapadchar = ' '
  1971.         self.datasepchar = '|'
  1972.  
  1973.     
  1974.     def display(self):
  1975.         stream = genutils.Term.cout
  1976.         allattrs = []
  1977.         attrset = set()
  1978.         colwidths = { }
  1979.         rows = []
  1980.         for item in xiter(self.input):
  1981.             row = { }
  1982.             attrs = self.attrs
  1983.             if not attrs:
  1984.                 attrs = xattrs(item, 'default')
  1985.             
  1986.             for attr in attrs:
  1987.                 if attr not in attrset:
  1988.                     allattrs.append(attr)
  1989.                     attrset.add(attr)
  1990.                     colwidths[attr] = len(attr.name())
  1991.                 
  1992.                 
  1993.                 try:
  1994.                     value = attr.value(item)
  1995.                 except (KeyboardInterrupt, SystemExit):
  1996.                     raise 
  1997.                 except Exception:
  1998.                     exc = None
  1999.                     value = exc
  2000.  
  2001.                 (align, width, text) = xformat(value, 'cell', self.maxattrlength)
  2002.                 colwidths[attr] = max(colwidths[attr], width)
  2003.                 row[attr] = (align, width, text)
  2004.             
  2005.             rows.append(row)
  2006.         
  2007.         stream.write('\n')
  2008.         for i, attr in enumerate(allattrs):
  2009.             attrname = attr.name()
  2010.             self.style_header(attrname).write(stream)
  2011.             spc = colwidths[attr] - len(attrname)
  2012.             if i < len(colwidths) - 1:
  2013.                 stream.write(self.headerpadchar * spc)
  2014.                 stream.write(self.headersepchar)
  2015.                 continue
  2016.         
  2017.         stream.write('\n')
  2018.         for row in rows:
  2019.             for i, attr in enumerate(allattrs):
  2020.                 (align, width, text) = row[attr]
  2021.                 spc = colwidths[attr] - width
  2022.                 if align == -1:
  2023.                     text.write(stream)
  2024.                     if i < len(colwidths) - 1:
  2025.                         stream.write(self.datapadchar * spc)
  2026.                     
  2027.                 elif align == 0:
  2028.                     spc = colwidths[attr] - width
  2029.                     spc1 = spc // 2
  2030.                     spc2 = spc - spc1
  2031.                     stream.write(self.datapadchar * spc1)
  2032.                     text.write(stream)
  2033.                     if i < len(colwidths) - 1:
  2034.                         stream.write(self.datapadchar * spc2)
  2035.                     
  2036.                 else:
  2037.                     stream.write(self.datapadchar * spc)
  2038.                     text.write(stream)
  2039.                 if i < len(colwidths) - 1:
  2040.                     stream.write(self.datasepchar)
  2041.                     continue
  2042.             
  2043.             stream.write('\n')
  2044.         
  2045.  
  2046.  
  2047.  
  2048. class AttributeDetail(Table):
  2049.     
  2050.     def __init__(self, object, descriptor):
  2051.         self.object = object
  2052.         self.descriptor = descriptor
  2053.  
  2054.     
  2055.     def __iter__(self):
  2056.         return self.descriptor.iter(self.object)
  2057.  
  2058.     
  2059.     def name(self):
  2060.         return self.descriptor.name()
  2061.  
  2062.     
  2063.     def attrtype(self):
  2064.         return self.descriptor.attrtype(self.object)
  2065.  
  2066.     
  2067.     def valuetype(self):
  2068.         return self.descriptor.valuetype(self.object)
  2069.  
  2070.     
  2071.     def doc(self):
  2072.         return self.descriptor.doc(self.object)
  2073.  
  2074.     
  2075.     def shortdoc(self):
  2076.         return self.descriptor.shortdoc(self.object)
  2077.  
  2078.     
  2079.     def value(self):
  2080.         return self.descriptor.value(self.object)
  2081.  
  2082.     
  2083.     def __xattrs__(self, mode = 'default'):
  2084.         attrs = ('name()', 'attrtype()', 'valuetype()', 'value()', 'shortdoc()')
  2085.         if mode == 'detail':
  2086.             attrs += ('doc()',)
  2087.         
  2088.         return attrs
  2089.  
  2090.     
  2091.     def __xrepr__(self, mode = 'default'):
  2092.         yield (-1, True)
  2093.         valuetype = self.valuetype()
  2094.         if valuetype is not noitem:
  2095.             for part in xrepr(valuetype):
  2096.                 yield part
  2097.             
  2098.             yield (astyle.style_default, ' ')
  2099.         
  2100.         yield (astyle.style_default, self.attrtype())
  2101.         yield (astyle.style_default, ' ')
  2102.         yield (astyle.style_default, self.name())
  2103.         yield (astyle.style_default, ' of ')
  2104.         for part in xrepr(self.object):
  2105.             yield part
  2106.         
  2107.  
  2108.  
  2109.  
  2110. try:
  2111.     from ibrowse import ibrowse
  2112. except ImportError:
  2113.     
  2114.     try:
  2115.         from igrid import igrid
  2116.     except ImportError:
  2117.         defaultdisplay = idump
  2118.  
  2119.     defaultdisplay = igrid
  2120.     __all__.append('igrid')
  2121.  
  2122. defaultdisplay = ibrowse
  2123. __all__.append('ibrowse')
  2124. if generics is not None:
  2125.     
  2126.     def display_display(obj):
  2127.         return obj.display()
  2128.  
  2129.     generics.result_display.when_type(Display)(display_display)
  2130.     
  2131.     def display_tableobject(obj):
  2132.         return display_display(defaultdisplay(obj))
  2133.  
  2134.     generics.result_display.when_type(Table)(display_tableobject)
  2135.     
  2136.     def display_tableclass(obj):
  2137.         return display_tableobject(obj())
  2138.  
  2139.     generics.result_display.when_type(Table.__metaclass__)(display_tableclass)
  2140. else:
  2141.     
  2142.     def installdisplayhook():
  2143.         _originalhook = sys.displayhook
  2144.         
  2145.         def displayhook(obj):
  2146.             if isinstance(obj, type) and issubclass(obj, Table):
  2147.                 obj = obj()
  2148.             
  2149.             if isinstance(obj, Table):
  2150.                 obj = defaultdisplay(obj)
  2151.             
  2152.             if isinstance(obj, Display):
  2153.                 return obj.display()
  2154.             _originalhook(obj)
  2155.  
  2156.         sys.displayhook = displayhook
  2157.  
  2158.     installdisplayhook()
  2159.