home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2842 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  9.5 KB  |  376 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import UserDict
  5. from _weakref import getweakrefcount, getweakrefs, ref, proxy, CallableProxyType, ProxyType, ReferenceType
  6. from exceptions import ReferenceError
  7. ProxyTypes = (ProxyType, CallableProxyType)
  8. __all__ = [
  9.     'ref',
  10.     'proxy',
  11.     'getweakrefcount',
  12.     'getweakrefs',
  13.     'WeakKeyDictionary',
  14.     'ReferenceError',
  15.     'ReferenceType',
  16.     'ProxyType',
  17.     'CallableProxyType',
  18.     'ProxyTypes',
  19.     'WeakValueDictionary']
  20.  
  21. class WeakValueDictionary(UserDict.UserDict):
  22.     
  23.     def __init__(self, *args, **kw):
  24.         
  25.         def remove(wr, selfref = ref(self)):
  26.             self = selfref()
  27.             if self is not None:
  28.                 del self.data[wr.key]
  29.             
  30.  
  31.         self._remove = remove
  32.         UserDict.UserDict.__init__(self, *args, **kw)
  33.  
  34.     
  35.     def __getitem__(self, key):
  36.         o = self.data[key]()
  37.         if o is None:
  38.             raise KeyError, key
  39.         o is None
  40.         return o
  41.  
  42.     
  43.     def __contains__(self, key):
  44.         
  45.         try:
  46.             o = self.data[key]()
  47.         except KeyError:
  48.             return False
  49.  
  50.         return o is not None
  51.  
  52.     
  53.     def has_key(self, key):
  54.         
  55.         try:
  56.             o = self.data[key]()
  57.         except KeyError:
  58.             return False
  59.  
  60.         return o is not None
  61.  
  62.     
  63.     def __repr__(self):
  64.         return '<WeakValueDictionary at %s>' % id(self)
  65.  
  66.     
  67.     def __setitem__(self, key, value):
  68.         self.data[key] = KeyedRef(value, self._remove, key)
  69.  
  70.     
  71.     def copy(self):
  72.         new = WeakValueDictionary()
  73.         for key, wr in self.data.items():
  74.             o = wr()
  75.             if o is not None:
  76.                 new[key] = o
  77.                 continue
  78.         
  79.         return new
  80.  
  81.     
  82.     def get(self, key, default = None):
  83.         
  84.         try:
  85.             wr = self.data[key]
  86.         except KeyError:
  87.             return default
  88.  
  89.         o = wr()
  90.         if o is None:
  91.             return default
  92.         return o
  93.  
  94.     
  95.     def items(self):
  96.         L = []
  97.         for key, wr in self.data.items():
  98.             o = wr()
  99.             if o is not None:
  100.                 L.append((key, o))
  101.                 continue
  102.         
  103.         return L
  104.  
  105.     
  106.     def iteritems(self):
  107.         for wr in self.data.itervalues():
  108.             value = wr()
  109.             if value is not None:
  110.                 yield (wr.key, value)
  111.                 continue
  112.         
  113.  
  114.     
  115.     def iterkeys(self):
  116.         return self.data.iterkeys()
  117.  
  118.     
  119.     def __iter__(self):
  120.         return self.data.iterkeys()
  121.  
  122.     
  123.     def itervaluerefs(self):
  124.         return self.data.itervalues()
  125.  
  126.     
  127.     def itervalues(self):
  128.         for wr in self.data.itervalues():
  129.             obj = wr()
  130.             if obj is not None:
  131.                 yield obj
  132.                 continue
  133.         
  134.  
  135.     
  136.     def popitem(self):
  137.         while None:
  138.             (key, wr) = self.data.popitem()
  139.             o = wr()
  140.             if o is not None:
  141.                 return (key, o)
  142.             continue
  143.             return None
  144.  
  145.     
  146.     def pop(self, key, *args):
  147.         
  148.         try:
  149.             o = self.data.pop(key)()
  150.         except KeyError:
  151.             if args:
  152.                 return args[0]
  153.             raise 
  154.         except:
  155.             args
  156.  
  157.         if o is None:
  158.             raise KeyError, key
  159.         o is None
  160.         return o
  161.  
  162.     
  163.     def setdefault(self, key, default = None):
  164.         
  165.         try:
  166.             wr = self.data[key]
  167.         except KeyError:
  168.             self.data[key] = KeyedRef(default, self._remove, key)
  169.             return default
  170.  
  171.         return wr()
  172.  
  173.     
  174.     def update(self, dict = None, **kwargs):
  175.         d = self.data
  176.         if dict is not None:
  177.             if not hasattr(dict, 'items'):
  178.                 dict = type({ })(dict)
  179.             
  180.             for key, o in dict.items():
  181.                 d[key] = KeyedRef(o, self._remove, key)
  182.             
  183.         
  184.         if len(kwargs):
  185.             self.update(kwargs)
  186.         
  187.  
  188.     
  189.     def valuerefs(self):
  190.         return self.data.values()
  191.  
  192.     
  193.     def values(self):
  194.         L = []
  195.         for wr in self.data.values():
  196.             o = wr()
  197.             if o is not None:
  198.                 L.append(o)
  199.                 continue
  200.         
  201.         return L
  202.  
  203.  
  204.  
  205. class KeyedRef(ref):
  206.     __slots__ = ('key',)
  207.     
  208.     def __new__(type, ob, callback, key):
  209.         self = ref.__new__(type, ob, callback)
  210.         self.key = key
  211.         return self
  212.  
  213.     
  214.     def __init__(self, ob, callback, key):
  215.         super(KeyedRef, self).__init__(ob, callback)
  216.  
  217.  
  218.  
  219. class WeakKeyDictionary(UserDict.UserDict):
  220.     
  221.     def __init__(self, dict = None):
  222.         self.data = { }
  223.         
  224.         def remove(k, selfref = ref(self)):
  225.             self = selfref()
  226.             if self is not None:
  227.                 del self.data[k]
  228.             
  229.  
  230.         self._remove = remove
  231.         if dict is not None:
  232.             self.update(dict)
  233.         
  234.  
  235.     
  236.     def __delitem__(self, key):
  237.         del self.data[ref(key)]
  238.  
  239.     
  240.     def __getitem__(self, key):
  241.         return self.data[ref(key)]
  242.  
  243.     
  244.     def __repr__(self):
  245.         return '<WeakKeyDictionary at %s>' % id(self)
  246.  
  247.     
  248.     def __setitem__(self, key, value):
  249.         self.data[ref(key, self._remove)] = value
  250.  
  251.     
  252.     def copy(self):
  253.         new = WeakKeyDictionary()
  254.         for key, value in self.data.items():
  255.             o = key()
  256.             if o is not None:
  257.                 new[o] = value
  258.                 continue
  259.         
  260.         return new
  261.  
  262.     
  263.     def get(self, key, default = None):
  264.         return self.data.get(ref(key), default)
  265.  
  266.     
  267.     def has_key(self, key):
  268.         
  269.         try:
  270.             wr = ref(key)
  271.         except TypeError:
  272.             return 0
  273.  
  274.         return wr in self.data
  275.  
  276.     
  277.     def __contains__(self, key):
  278.         
  279.         try:
  280.             wr = ref(key)
  281.         except TypeError:
  282.             return 0
  283.  
  284.         return wr in self.data
  285.  
  286.     
  287.     def items(self):
  288.         L = []
  289.         for key, value in self.data.items():
  290.             o = key()
  291.             if o is not None:
  292.                 L.append((o, value))
  293.                 continue
  294.         
  295.         return L
  296.  
  297.     
  298.     def iteritems(self):
  299.         for wr, value in self.data.iteritems():
  300.             key = wr()
  301.             if key is not None:
  302.                 yield (key, value)
  303.                 continue
  304.         
  305.  
  306.     
  307.     def iterkeyrefs(self):
  308.         return self.data.iterkeys()
  309.  
  310.     
  311.     def iterkeys(self):
  312.         for wr in self.data.iterkeys():
  313.             obj = wr()
  314.             if obj is not None:
  315.                 yield obj
  316.                 continue
  317.         
  318.  
  319.     
  320.     def __iter__(self):
  321.         return self.iterkeys()
  322.  
  323.     
  324.     def itervalues(self):
  325.         return self.data.itervalues()
  326.  
  327.     
  328.     def keyrefs(self):
  329.         return self.data.keys()
  330.  
  331.     
  332.     def keys(self):
  333.         L = []
  334.         for wr in self.data.keys():
  335.             o = wr()
  336.             if o is not None:
  337.                 L.append(o)
  338.                 continue
  339.         
  340.         return L
  341.  
  342.     
  343.     def popitem(self):
  344.         while None:
  345.             (key, value) = self.data.popitem()
  346.             o = key()
  347.             if o is not None:
  348.                 return (o, value)
  349.             continue
  350.             return None
  351.  
  352.     
  353.     def pop(self, key, *args):
  354.         return self.data.pop(ref(key), *args)
  355.  
  356.     
  357.     def setdefault(self, key, default = None):
  358.         return self.data.setdefault(ref(key, self._remove), default)
  359.  
  360.     
  361.     def update(self, dict = None, **kwargs):
  362.         d = self.data
  363.         if dict is not None:
  364.             if not hasattr(dict, 'items'):
  365.                 dict = type({ })(dict)
  366.             
  367.             for key, value in dict.items():
  368.                 d[ref(key, self._remove)] = value
  369.             
  370.         
  371.         if len(kwargs):
  372.             self.update(kwargs)
  373.         
  374.  
  375.  
  376.