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

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from abc import ABCMeta, abstractmethod
  5. import sys
  6. __all__ = [
  7.     'Hashable',
  8.     'Iterable',
  9.     'Iterator',
  10.     'Sized',
  11.     'Container',
  12.     'Callable',
  13.     'Set',
  14.     'MutableSet',
  15.     'Mapping',
  16.     'MutableMapping',
  17.     'MappingView',
  18.     'KeysView',
  19.     'ItemsView',
  20.     'ValuesView',
  21.     'Sequence',
  22.     'MutableSequence']
  23.  
  24. class Hashable:
  25.     __metaclass__ = ABCMeta
  26.     
  27.     def __hash__(self):
  28.         return 0
  29.  
  30.     __hash__ = abstractmethod(__hash__)
  31.     
  32.     def __subclasshook__(cls, C):
  33.         if cls is Hashable:
  34.             for B in C.__mro__:
  35.                 if '__hash__' in B.__dict__:
  36.                     if B.__dict__['__hash__']:
  37.                         return True
  38.                     break
  39.                     continue
  40.                 B.__dict__['__hash__']
  41.             
  42.         
  43.         return NotImplemented
  44.  
  45.     __subclasshook__ = classmethod(__subclasshook__)
  46.  
  47.  
  48. class Iterable:
  49.     __metaclass__ = ABCMeta
  50.     
  51.     def __iter__(self):
  52.         while False:
  53.             yield None
  54.  
  55.     __iter__ = abstractmethod(__iter__)
  56.     
  57.     def __subclasshook__(cls, C):
  58.         if cls is Iterable:
  59.             if any((lambda .0: for B in .0:
  60. '__iter__' in B.__dict__)(C.__mro__)):
  61.                 return True
  62.         
  63.         return NotImplemented
  64.  
  65.     __subclasshook__ = classmethod(__subclasshook__)
  66.  
  67. Iterable.register(str)
  68.  
  69. class Iterator(Iterable):
  70.     
  71.     def next(self):
  72.         raise StopIteration
  73.  
  74.     next = abstractmethod(next)
  75.     
  76.     def __iter__(self):
  77.         return self
  78.  
  79.     
  80.     def __subclasshook__(cls, C):
  81.         if cls is Iterator:
  82.             if any((lambda .0: for B in .0:
  83. 'next' in B.__dict__)(C.__mro__)):
  84.                 return True
  85.         
  86.         return NotImplemented
  87.  
  88.     __subclasshook__ = classmethod(__subclasshook__)
  89.  
  90.  
  91. class Sized:
  92.     __metaclass__ = ABCMeta
  93.     
  94.     def __len__(self):
  95.         return 0
  96.  
  97.     __len__ = abstractmethod(__len__)
  98.     
  99.     def __subclasshook__(cls, C):
  100.         if cls is Sized:
  101.             if any((lambda .0: for B in .0:
  102. '__len__' in B.__dict__)(C.__mro__)):
  103.                 return True
  104.         
  105.         return NotImplemented
  106.  
  107.     __subclasshook__ = classmethod(__subclasshook__)
  108.  
  109.  
  110. class Container:
  111.     __metaclass__ = ABCMeta
  112.     
  113.     def __contains__(self, x):
  114.         return False
  115.  
  116.     __contains__ = abstractmethod(__contains__)
  117.     
  118.     def __subclasshook__(cls, C):
  119.         if cls is Container:
  120.             if any((lambda .0: for B in .0:
  121. '__contains__' in B.__dict__)(C.__mro__)):
  122.                 return True
  123.         
  124.         return NotImplemented
  125.  
  126.     __subclasshook__ = classmethod(__subclasshook__)
  127.  
  128.  
  129. class Callable:
  130.     __metaclass__ = ABCMeta
  131.     
  132.     def __call__(self, *args, **kwds):
  133.         return False
  134.  
  135.     __call__ = abstractmethod(__call__)
  136.     
  137.     def __subclasshook__(cls, C):
  138.         if cls is Callable:
  139.             if any((lambda .0: for B in .0:
  140. '__call__' in B.__dict__)(C.__mro__)):
  141.                 return True
  142.         
  143.         return NotImplemented
  144.  
  145.     __subclasshook__ = classmethod(__subclasshook__)
  146.  
  147.  
  148. class Set(Sized, Iterable, Container):
  149.     
  150.     def __le__(self, other):
  151.         if not isinstance(other, Set):
  152.             return NotImplemented
  153.         if len(self) > len(other):
  154.             return False
  155.         for elem in self:
  156.             if elem not in other:
  157.                 return False
  158.         
  159.         return True
  160.  
  161.     
  162.     def __lt__(self, other):
  163.         if not isinstance(other, Set):
  164.             return NotImplemented
  165.         if len(self) < len(other):
  166.             pass
  167.         return self.__le__(other)
  168.  
  169.     
  170.     def __gt__(self, other):
  171.         if not isinstance(other, Set):
  172.             return NotImplemented
  173.         return other < self
  174.  
  175.     
  176.     def __ge__(self, other):
  177.         if not isinstance(other, Set):
  178.             return NotImplemented
  179.         return other <= self
  180.  
  181.     
  182.     def __eq__(self, other):
  183.         if not isinstance(other, Set):
  184.             return NotImplemented
  185.         if len(self) == len(other):
  186.             pass
  187.         return self.__le__(other)
  188.  
  189.     
  190.     def __ne__(self, other):
  191.         return not (self == other)
  192.  
  193.     
  194.     def _from_iterable(cls, it):
  195.         return cls(it)
  196.  
  197.     _from_iterable = classmethod(_from_iterable)
  198.     
  199.     def __and__(self, other):
  200.         if not isinstance(other, Iterable):
  201.             return NotImplemented
  202.         return (self._from_iterable,)((lambda .0: for value in .0:
  203. if value in self:
  204. valuecontinue)(other))
  205.  
  206.     
  207.     def isdisjoint(self, other):
  208.         for value in other:
  209.             if value in self:
  210.                 return False
  211.         
  212.         return True
  213.  
  214.     
  215.     def __or__(self, other):
  216.         if not isinstance(other, Iterable):
  217.             return NotImplemented
  218.         chain = (lambda .0: for s in .0:
  219. for e in s:
  220. e)((self, other))
  221.         return self._from_iterable(chain)
  222.  
  223.     
  224.     def __sub__(self, other):
  225.         if not isinstance(other, Set):
  226.             if not isinstance(other, Iterable):
  227.                 return NotImplemented
  228.             other = self._from_iterable(other)
  229.         
  230.         return (self._from_iterable,)((lambda .0: for value in .0:
  231. if value not in other:
  232. valuecontinue)(self))
  233.  
  234.     
  235.     def __xor__(self, other):
  236.         if not isinstance(other, Set):
  237.             if not isinstance(other, Iterable):
  238.                 return NotImplemented
  239.             other = self._from_iterable(other)
  240.         
  241.         return self - other | other - self
  242.  
  243.     __hash__ = None
  244.     
  245.     def _hash(self):
  246.         MAX = sys.maxint
  247.         MASK = 2 * MAX + 1
  248.         n = len(self)
  249.         h = 1927868237 * (n + 1)
  250.         h &= MASK
  251.         for x in self:
  252.             hx = hash(x)
  253.             h ^= (hx ^ hx << 16 ^ 89869747) * 0xD93F34D7L
  254.             h &= MASK
  255.         
  256.         h = h * 69069 + 907133923
  257.         h &= MASK
  258.         if h > MAX:
  259.             h -= MASK + 1
  260.         
  261.         if h == -1:
  262.             h = 590923713
  263.         
  264.         return h
  265.  
  266.  
  267. Set.register(frozenset)
  268.  
  269. class MutableSet(Set):
  270.     
  271.     def add(self, value):
  272.         raise NotImplementedError
  273.  
  274.     add = abstractmethod(add)
  275.     
  276.     def discard(self, value):
  277.         raise NotImplementedError
  278.  
  279.     discard = abstractmethod(discard)
  280.     
  281.     def remove(self, value):
  282.         if value not in self:
  283.             raise KeyError(value)
  284.         value not in self
  285.         self.discard(value)
  286.  
  287.     
  288.     def pop(self):
  289.         it = iter(self)
  290.         
  291.         try:
  292.             value = next(it)
  293.         except StopIteration:
  294.             raise KeyError
  295.  
  296.         self.discard(value)
  297.         return value
  298.  
  299.     
  300.     def clear(self):
  301.         
  302.         try:
  303.             while True:
  304.                 self.pop()
  305.         except KeyError:
  306.             pass
  307.  
  308.  
  309.     
  310.     def __ior__(self, it):
  311.         for value in it:
  312.             self.add(value)
  313.         
  314.         return self
  315.  
  316.     
  317.     def __iand__(self, it):
  318.         for value in self - it:
  319.             self.discard(value)
  320.         
  321.         return self
  322.  
  323.     
  324.     def __ixor__(self, it):
  325.         if not isinstance(it, Set):
  326.             it = self._from_iterable(it)
  327.         
  328.         for value in it:
  329.             if value in self:
  330.                 self.discard(value)
  331.                 continue
  332.             self.add(value)
  333.         
  334.         return self
  335.  
  336.     
  337.     def __isub__(self, it):
  338.         for value in it:
  339.             self.discard(value)
  340.         
  341.         return self
  342.  
  343.  
  344. MutableSet.register(set)
  345.  
  346. class Mapping(Sized, Iterable, Container):
  347.     
  348.     def __getitem__(self, key):
  349.         raise KeyError
  350.  
  351.     __getitem__ = abstractmethod(__getitem__)
  352.     
  353.     def get(self, key, default = None):
  354.         
  355.         try:
  356.             return self[key]
  357.         except KeyError:
  358.             return default
  359.  
  360.  
  361.     
  362.     def __contains__(self, key):
  363.         
  364.         try:
  365.             self[key]
  366.         except KeyError:
  367.             return False
  368.  
  369.         return True
  370.  
  371.     
  372.     def iterkeys(self):
  373.         return iter(self)
  374.  
  375.     
  376.     def itervalues(self):
  377.         for key in self:
  378.             yield self[key]
  379.         
  380.  
  381.     
  382.     def iteritems(self):
  383.         for key in self:
  384.             yield (key, self[key])
  385.         
  386.  
  387.     
  388.     def keys(self):
  389.         return list(self)
  390.  
  391.     
  392.     def items(self):
  393.         return [ (key, self[key]) for key in self ]
  394.  
  395.     
  396.     def values(self):
  397.         return [ self[key] for key in self ]
  398.  
  399.     __hash__ = None
  400.     
  401.     def __eq__(self, other):
  402.         if isinstance(other, Mapping):
  403.             pass
  404.         return dict(self.items()) == dict(other.items())
  405.  
  406.     
  407.     def __ne__(self, other):
  408.         return not (self == other)
  409.  
  410.  
  411.  
  412. class MappingView(Sized):
  413.     
  414.     def __init__(self, mapping):
  415.         self._mapping = mapping
  416.  
  417.     
  418.     def __len__(self):
  419.         return len(self._mapping)
  420.  
  421.  
  422.  
  423. class KeysView(MappingView, Set):
  424.     
  425.     def __contains__(self, key):
  426.         return key in self._mapping
  427.  
  428.     
  429.     def __iter__(self):
  430.         for key in self._mapping:
  431.             yield key
  432.         
  433.  
  434.  
  435.  
  436. class ItemsView(MappingView, Set):
  437.     
  438.     def __contains__(self, item):
  439.         (key, value) = item
  440.         
  441.         try:
  442.             v = self._mapping[key]
  443.         except KeyError:
  444.             return False
  445.  
  446.         return v == value
  447.  
  448.     
  449.     def __iter__(self):
  450.         for key in self._mapping:
  451.             yield (key, self._mapping[key])
  452.         
  453.  
  454.  
  455.  
  456. class ValuesView(MappingView):
  457.     
  458.     def __contains__(self, value):
  459.         for key in self._mapping:
  460.             if value == self._mapping[key]:
  461.                 return True
  462.         
  463.         return False
  464.  
  465.     
  466.     def __iter__(self):
  467.         for key in self._mapping:
  468.             yield self._mapping[key]
  469.         
  470.  
  471.  
  472.  
  473. class MutableMapping(Mapping):
  474.     
  475.     def __setitem__(self, key, value):
  476.         raise KeyError
  477.  
  478.     __setitem__ = abstractmethod(__setitem__)
  479.     
  480.     def __delitem__(self, key):
  481.         raise KeyError
  482.  
  483.     __delitem__ = abstractmethod(__delitem__)
  484.     __marker = object()
  485.     
  486.     def pop(self, key, default = __marker):
  487.         
  488.         try:
  489.             value = self[key]
  490.         except KeyError:
  491.             if default is self._MutableMapping__marker:
  492.                 raise 
  493.             default is self._MutableMapping__marker
  494.             return default
  495.  
  496.         del self[key]
  497.         return value
  498.  
  499.     
  500.     def popitem(self):
  501.         
  502.         try:
  503.             key = next(iter(self))
  504.         except StopIteration:
  505.             raise KeyError
  506.  
  507.         value = self[key]
  508.         del self[key]
  509.         return (key, value)
  510.  
  511.     
  512.     def clear(self):
  513.         
  514.         try:
  515.             while True:
  516.                 self.popitem()
  517.         except KeyError:
  518.             pass
  519.  
  520.  
  521.     
  522.     def update(self, other = (), **kwds):
  523.         if isinstance(other, Mapping):
  524.             for key in other:
  525.                 self[key] = other[key]
  526.             
  527.         elif hasattr(other, 'keys'):
  528.             for key in other.keys():
  529.                 self[key] = other[key]
  530.             
  531.         else:
  532.             for key, value in other:
  533.                 self[key] = value
  534.             
  535.         for key, value in kwds.items():
  536.             self[key] = value
  537.         
  538.  
  539.     
  540.     def setdefault(self, key, default = None):
  541.         
  542.         try:
  543.             return self[key]
  544.         except KeyError:
  545.             self[key] = default
  546.  
  547.         return default
  548.  
  549.  
  550. MutableMapping.register(dict)
  551.  
  552. class Sequence(Sized, Iterable, Container):
  553.     
  554.     def __getitem__(self, index):
  555.         raise IndexError
  556.  
  557.     __getitem__ = abstractmethod(__getitem__)
  558.     
  559.     def __iter__(self):
  560.         i = 0
  561.         
  562.         try:
  563.             while True:
  564.                 v = self[i]
  565.                 yield v
  566.                 i += 1
  567.         except IndexError:
  568.             return None
  569.  
  570.  
  571.     
  572.     def __contains__(self, value):
  573.         for v in self:
  574.             if v == value:
  575.                 return True
  576.         
  577.         return False
  578.  
  579.     
  580.     def __reversed__(self):
  581.         for i in reversed(range(len(self))):
  582.             yield self[i]
  583.         
  584.  
  585.     
  586.     def index(self, value):
  587.         for i, v in enumerate(self):
  588.             if v == value:
  589.                 return i
  590.         
  591.         raise ValueError
  592.  
  593.     
  594.     def count(self, value):
  595.         return (sum,)((lambda .0: for v in .0:
  596. if v == value:
  597. 1continue)(self))
  598.  
  599.  
  600. Sequence.register(tuple)
  601. Sequence.register(basestring)
  602. Sequence.register(buffer)
  603. Sequence.register(xrange)
  604.  
  605. class MutableSequence(Sequence):
  606.     
  607.     def __setitem__(self, index, value):
  608.         raise IndexError
  609.  
  610.     __setitem__ = abstractmethod(__setitem__)
  611.     
  612.     def __delitem__(self, index):
  613.         raise IndexError
  614.  
  615.     __delitem__ = abstractmethod(__delitem__)
  616.     
  617.     def insert(self, index, value):
  618.         raise IndexError
  619.  
  620.     insert = abstractmethod(insert)
  621.     
  622.     def append(self, value):
  623.         self.insert(len(self), value)
  624.  
  625.     
  626.     def reverse(self):
  627.         n = len(self)
  628.         for i in range(n // 2):
  629.             self[i] = self[n - i - 1]
  630.             self[n - i - 1] = self[i]
  631.         
  632.  
  633.     
  634.     def extend(self, values):
  635.         for v in values:
  636.             self.append(v)
  637.         
  638.  
  639.     
  640.     def pop(self, index = -1):
  641.         v = self[index]
  642.         del self[index]
  643.         return v
  644.  
  645.     
  646.     def remove(self, value):
  647.         del self[self.index(value)]
  648.  
  649.     
  650.     def __iadd__(self, values):
  651.         self.extend(values)
  652.         return self
  653.  
  654.  
  655. MutableSequence.register(list)
  656.