home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / collections.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  14.3 KB  |  416 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. __all__ = [
  5.     'Counter',
  6.     'deque',
  7.     'defaultdict',
  8.     'namedtuple',
  9.     'OrderedDict']
  10. from _abcoll import *
  11. import _abcoll
  12. __all__ += _abcoll.__all__
  13. from _collections import deque, defaultdict
  14. from operator import itemgetter as _itemgetter, eq as _eq
  15. from keyword import iskeyword as _iskeyword
  16. import sys as _sys
  17. import heapq as _heapq
  18. from itertools import repeat as _repeat, chain as _chain, starmap as _starmap, ifilter as _ifilter, imap as _imap
  19.  
  20. try:
  21.     from thread import get_ident
  22. except ImportError:
  23.     from dummy_thread import get_ident
  24.  
  25.  
  26. def _recursive_repr(user_function):
  27.     repr_running = set()
  28.     
  29.     def wrapper(self):
  30.         key = (id(self), get_ident())
  31.         if key in repr_running:
  32.             return '...'
  33.         None.add(key)
  34.         
  35.         try:
  36.             result = user_function(self)
  37.         finally:
  38.             repr_running.discard(key)
  39.  
  40.         return result
  41.  
  42.     wrapper.__module__ = getattr(user_function, '__module__')
  43.     wrapper.__doc__ = getattr(user_function, '__doc__')
  44.     wrapper.__name__ = getattr(user_function, '__name__')
  45.     return wrapper
  46.  
  47.  
  48. class OrderedDict(dict, MutableMapping):
  49.     
  50.     def __init__(self, *args, **kwds):
  51.         if len(args) > 1:
  52.             raise TypeError('expected at most 1 arguments, got %d' % len(args))
  53.         
  54.         try:
  55.             self._OrderedDict__root
  56.         except AttributeError:
  57.             self._OrderedDict__root = root = [
  58.                 None,
  59.                 None,
  60.                 None]
  61.             PREV = 0
  62.             NEXT = 1
  63.             root[PREV] = root[NEXT] = root
  64.             self._OrderedDict__map = { }
  65.  
  66.         self.update(*args, **kwds)
  67.  
  68.     
  69.     def __setitem__(self, key, value, PREV = 0, NEXT = 1, dict_setitem = dict.__setitem__):
  70.         if key not in self:
  71.             root = self._OrderedDict__root
  72.             last = root[PREV]
  73.             last[NEXT] = root[PREV] = self._OrderedDict__map[key] = [
  74.                 last,
  75.                 root,
  76.                 key]
  77.         dict_setitem(self, key, value)
  78.  
  79.     
  80.     def __delitem__(self, key, PREV = 0, NEXT = 1, dict_delitem = dict.__delitem__):
  81.         dict_delitem(self, key)
  82.         link = self._OrderedDict__map.pop(key)
  83.         link_prev = link[PREV]
  84.         link_next = link[NEXT]
  85.         link_prev[NEXT] = link_next
  86.         link_next[PREV] = link_prev
  87.  
  88.     
  89.     def __iter__(self, NEXT = 1, KEY = 2):
  90.         root = self._OrderedDict__root
  91.         curr = root[NEXT]
  92.         while curr is not root:
  93.             yield curr[KEY]
  94.             curr = curr[NEXT]
  95.  
  96.     
  97.     def __reversed__(self, PREV = 0, KEY = 2):
  98.         root = self._OrderedDict__root
  99.         curr = root[PREV]
  100.         while curr is not root:
  101.             yield curr[KEY]
  102.             curr = curr[PREV]
  103.  
  104.     
  105.     def __reduce__(self):
  106.         items = [ [
  107.             k,
  108.             self[k]] for k in self ]
  109.         tmp = (self._OrderedDict__map, self._OrderedDict__root)
  110.         del self._OrderedDict__map
  111.         del self._OrderedDict__root
  112.         inst_dict = vars(self).copy()
  113.         (self._OrderedDict__map, self._OrderedDict__root) = tmp
  114.         if inst_dict:
  115.             return (self.__class__, (items,), inst_dict)
  116.         return (None.__class__, (items,))
  117.  
  118.     
  119.     def clear(self):
  120.         
  121.         try:
  122.             for node in self._OrderedDict__map.itervalues():
  123.                 del node[:]
  124.             
  125.             self._OrderedDict__root[:] = [
  126.                 self._OrderedDict__root,
  127.                 self._OrderedDict__root,
  128.                 None]
  129.             self._OrderedDict__map.clear()
  130.         except AttributeError:
  131.             pass
  132.  
  133.         dict.clear(self)
  134.  
  135.     setdefault = MutableMapping.setdefault
  136.     update = MutableMapping.update
  137.     pop = MutableMapping.pop
  138.     keys = MutableMapping.keys
  139.     values = MutableMapping.values
  140.     items = MutableMapping.items
  141.     iterkeys = MutableMapping.iterkeys
  142.     itervalues = MutableMapping.itervalues
  143.     iteritems = MutableMapping.iteritems
  144.     __ne__ = MutableMapping.__ne__
  145.     
  146.     def viewkeys(self):
  147.         return KeysView(self)
  148.  
  149.     
  150.     def viewvalues(self):
  151.         return ValuesView(self)
  152.  
  153.     
  154.     def viewitems(self):
  155.         return ItemsView(self)
  156.  
  157.     
  158.     def popitem(self, last = True):
  159.         if not self:
  160.             raise KeyError('dictionary is empty')
  161.         key = next(reversed(self) if last else iter(self))
  162.         value = self.pop(key)
  163.         return (key, value)
  164.  
  165.     
  166.     def __repr__(self):
  167.         if not self:
  168.             return '%s()' % (self.__class__.__name__,)
  169.         return None % (self.__class__.__name__, self.items())
  170.  
  171.     __repr__ = _recursive_repr(__repr__)
  172.     
  173.     def copy(self):
  174.         return self.__class__(self)
  175.  
  176.     
  177.     def fromkeys(cls, iterable, value = None):
  178.         d = cls()
  179.         for key in iterable:
  180.             d[key] = value
  181.         
  182.         return d
  183.  
  184.     fromkeys = classmethod(fromkeys)
  185.     
  186.     def __eq__(self, other):
  187.         if isinstance(other, OrderedDict):
  188.             if len(self) == len(other):
  189.                 pass
  190.             return all(_imap(_eq, self.iteritems(), other.iteritems()))
  191.         return None.__eq__(self, other)
  192.  
  193.  
  194.  
  195. def namedtuple(typename, field_names, verbose = False, rename = False):
  196.     if isinstance(field_names, basestring):
  197.         field_names = field_names.replace(',', ' ').split()
  198.     field_names = tuple(map(str, field_names))
  199.     if rename:
  200.         names = list(field_names)
  201.         seen = set()
  202.         for i, name in enumerate(names):
  203.             if not all((lambda .0: pass)(name)) and _iskeyword(name) and not name and name[0].isdigit() and name.startswith('_') or name in seen:
  204.                 names[i] = '_%d' % i
  205.             seen.add(name)
  206.         
  207.         field_names = tuple(names)
  208.     for name in (typename,) + field_names:
  209.         if not all((lambda .0: pass)(name)):
  210.             raise ValueError('Type names and field names can only contain alphanumeric characters and underscores: %r' % name)
  211.         if _iskeyword(name):
  212.             raise ValueError('Type names and field names cannot be a keyword: %r' % name)
  213.         if name[0].isdigit():
  214.             raise ValueError('Type names and field names cannot start with a number: %r' % name)
  215.     
  216.     seen_names = set()
  217.     for name in field_names:
  218.         if name.startswith('_') and not rename:
  219.             raise ValueError('Field names cannot start with an underscore: %r' % name)
  220.         if name in seen_names:
  221.             raise ValueError('Encountered duplicate field name: %r' % name)
  222.         seen_names.add(name)
  223.     
  224.     numfields = len(field_names)
  225.     argtxt = repr(field_names).replace("'", '')[1:-1]
  226.     reprtxt = ', '.join((lambda .0: pass)(field_names))
  227.     template = "class %(typename)s(tuple):\n        '%(typename)s(%(argtxt)s)' \n\n        __slots__ = () \n\n        _fields = %(field_names)r \n\n        def __new__(_cls, %(argtxt)s):\n            'Create new instance of %(typename)s(%(argtxt)s)'\n            return _tuple.__new__(_cls, (%(argtxt)s)) \n\n        @classmethod\n        def _make(cls, iterable, new=tuple.__new__, len=len):\n            'Make a new %(typename)s object from a sequence or iterable'\n            result = new(cls, iterable)\n            if len(result) != %(numfields)d:\n                raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result))\n            return result \n\n        def __repr__(self):\n            'Return a nicely formatted representation string'\n            return '%(typename)s(%(reprtxt)s)' %% self \n\n        def _asdict(self):\n            'Return a new OrderedDict which maps field names to their values'\n            return OrderedDict(zip(self._fields, self)) \n\n        def _replace(_self, **kwds):\n            'Return a new %(typename)s object replacing specified fields with new values'\n            result = _self._make(map(kwds.pop, %(field_names)r, _self))\n            if kwds:\n                raise ValueError('Got unexpected field names: %%r' %% kwds.keys())\n            return result \n\n        def __getnewargs__(self):\n            'Return self as a plain tuple.  Used by copy and pickle.'\n            return tuple(self) \n\n" % locals()
  228.     for i, name in enumerate(field_names):
  229.         template += "        %s = _property(_itemgetter(%d), doc='Alias for field number %d')\n" % (name, i, i)
  230.     
  231.     if verbose:
  232.         print template
  233.     namespace = dict(_itemgetter = _itemgetter, __name__ = 'namedtuple_%s' % typename, OrderedDict = OrderedDict, _property = property, _tuple = tuple)
  234.     
  235.     try:
  236.         exec template in namespace
  237.     except SyntaxError:
  238.         e = None
  239.         raise SyntaxError(e.message + ':\n' + template)
  240.  
  241.     result = namespace[typename]
  242.     
  243.     try:
  244.         result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__')
  245.     except (AttributeError, ValueError):
  246.         pass
  247.  
  248.     return result
  249.  
  250.  
  251. class Counter(dict):
  252.     
  253.     def __init__(self, iterable = None, **kwds):
  254.         self.update(iterable, **kwds)
  255.  
  256.     
  257.     def __missing__(self, key):
  258.         return 0
  259.  
  260.     
  261.     def most_common(self, n = None):
  262.         if n is None:
  263.             return sorted(self.iteritems(), key = _itemgetter(1), reverse = True)
  264.         return None.nlargest(n, self.iteritems(), key = _itemgetter(1))
  265.  
  266.     
  267.     def elements(self):
  268.         return _chain.from_iterable(_starmap(_repeat, self.iteritems()))
  269.  
  270.     
  271.     def fromkeys(cls, iterable, v = None):
  272.         raise NotImplementedError('Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')
  273.  
  274.     fromkeys = classmethod(fromkeys)
  275.     
  276.     def update(self, iterable = None, **kwds):
  277.         if iterable is not None:
  278.             if isinstance(iterable, Mapping):
  279.                 if self:
  280.                     self_get = self.get
  281.                     for elem, count in iterable.iteritems():
  282.                         self[elem] = self_get(elem, 0) + count
  283.                     
  284.                 else:
  285.                     dict.update(self, iterable)
  286.             else:
  287.                 self_get = self.get
  288.                 for elem in iterable:
  289.                     self[elem] = self_get(elem, 0) + 1
  290.                 
  291.         if kwds:
  292.             self.update(kwds)
  293.  
  294.     
  295.     def subtract(self, iterable = None, **kwds):
  296.         if iterable is not None:
  297.             self_get = self.get
  298.             if isinstance(iterable, Mapping):
  299.                 for elem, count in iterable.items():
  300.                     self[elem] = self_get(elem, 0) - count
  301.                 
  302.             else:
  303.                 for elem in iterable:
  304.                     self[elem] = self_get(elem, 0) - 1
  305.                 
  306.         if kwds:
  307.             self.subtract(kwds)
  308.  
  309.     
  310.     def copy(self):
  311.         return Counter(self)
  312.  
  313.     
  314.     def __delitem__(self, elem):
  315.         if elem in self:
  316.             dict.__delitem__(self, elem)
  317.  
  318.     
  319.     def __repr__(self):
  320.         if not self:
  321.             return '%s()' % self.__class__.__name__
  322.         items = None.join(map('%r: %r'.__mod__, self.most_common()))
  323.         return '%s({%s})' % (self.__class__.__name__, items)
  324.  
  325.     
  326.     def __add__(self, other):
  327.         if not isinstance(other, Counter):
  328.             return NotImplemented
  329.         result = None()
  330.         for elem in set(self) | set(other):
  331.             newcount = self[elem] + other[elem]
  332.             if newcount > 0:
  333.                 result[elem] = newcount
  334.                 continue
  335.         return result
  336.  
  337.     
  338.     def __sub__(self, other):
  339.         if not isinstance(other, Counter):
  340.             return NotImplemented
  341.         result = None()
  342.         for elem in set(self) | set(other):
  343.             newcount = self[elem] - other[elem]
  344.             if newcount > 0:
  345.                 result[elem] = newcount
  346.                 continue
  347.         return result
  348.  
  349.     
  350.     def __or__(self, other):
  351.         if not isinstance(other, Counter):
  352.             return NotImplemented
  353.         result = None()
  354.         for elem in set(self) | set(other):
  355.             p = self[elem]
  356.             q = other[elem]
  357.             newcount = q if p < q else p
  358.             if newcount > 0:
  359.                 result[elem] = newcount
  360.                 continue
  361.         return result
  362.  
  363.     
  364.     def __and__(self, other):
  365.         if not isinstance(other, Counter):
  366.             return NotImplemented
  367.         result = None()
  368.         if len(self) < len(other):
  369.             self = other
  370.             other = self
  371.         for elem in _ifilter(self.__contains__, other):
  372.             p = self[elem]
  373.             q = other[elem]
  374.             newcount = p if p < q else q
  375.             if newcount > 0:
  376.                 result[elem] = newcount
  377.                 continue
  378.         return result
  379.  
  380.  
  381. if __name__ == '__main__':
  382.     from cPickle import loads, dumps
  383.     Point = namedtuple('Point', 'x, y', True)
  384.     p = Point(x = 10, y = 20)
  385.     
  386.     class Point(namedtuple('Point', 'x y')):
  387.         __slots__ = ()
  388.         
  389.         def hypot(self):
  390.             return (self.x ** 2 + self.y ** 2) ** 0.5
  391.  
  392.         hypot = property(hypot)
  393.         
  394.         def __str__(self):
  395.             return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)
  396.  
  397.  
  398.     for p in (Point(3, 4), Point(14, 5 / 7)):
  399.         print p
  400.     
  401.     
  402.     class Point(namedtuple('Point', 'x y')):
  403.         __slots__ = ()
  404.         _make = classmethod(tuple.__new__)
  405.         
  406.         def _replace(self, _map = map, **kwds):
  407.             return self._make(_map(kwds.get, ('x', 'y'), self))
  408.  
  409.  
  410.     print Point(11, 22)._replace(x = 100)
  411.     Point3D = namedtuple('Point3D', Point._fields + ('z',))
  412.     print Point3D.__doc__
  413.     import doctest
  414.     TestResults = namedtuple('TestResults', 'failed attempted')
  415.     print TestResults(*doctest.testmod())
  416.