home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / peak / util / addons.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  5.7 KB  |  200 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from peak.util.decorators import decorate_class, enclosing_frame, classy
  5. from weakref import ref
  6. import sys
  7. __all__ = [
  8.     'AddOn',
  9.     'ClassAddOn',
  10.     'Registry',
  11.     'addons_for']
  12. _addons = { }
  13.  
  14. def addons_for(ob):
  15.     
  16.     try:
  17.         d = ob.__dict__
  18.         sd = d.setdefault
  19.         return d
  20.     except (AttributeError, TypeError):
  21.         r = ref(ob)
  22.         
  23.         try:
  24.             return _addons[r]
  25.         except KeyError:
  26.             return _addons.setdefault(ref(ob, _addons.__delitem__), { })
  27.         
  28.  
  29.         None<EXCEPTION MATCH>KeyError
  30.  
  31.  
  32.  
  33. def additional_tests():
  34.     import doctest
  35.     return doctest.DocFileSuite('README.txt', package = '__main__', optionflags = doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
  36.  
  37.  
  38. class AddOn(classy):
  39.     __slots__ = ()
  40.     
  41.     def __class_call__(cls, ob, *data):
  42.         a = addons_for(ob)
  43.         addon_key = cls.addon_key(*data)
  44.         
  45.         try:
  46.             return a[addon_key]
  47.         except KeyError:
  48.             ob = a.setdefault(addon_key, super(AddOn, cls).__class_call__(ob, *data))
  49.             return ob
  50.  
  51.  
  52.     __class_call__ = classmethod(__class_call__)
  53.     
  54.     def addon_key(cls, *args):
  55.         if args:
  56.             return (cls,) + args
  57.         return cls
  58.  
  59.     addon_key = classmethod(addon_key)
  60.     
  61.     def exists_for(cls, ob, *key):
  62.         return cls.addon_key(*key) in addons_for(ob)
  63.  
  64.     exists_for = classmethod(exists_for)
  65.     
  66.     def delete_from(cls, ob, *key):
  67.         a = addons_for(ob)
  68.         
  69.         try:
  70.             del a[cls.addon_key(*key)]
  71.         except KeyError:
  72.             pass
  73.  
  74.  
  75.     delete_from = classmethod(delete_from)
  76.     
  77.     def __init__(self, subject):
  78.         pass
  79.  
  80.  
  81.  
  82. class ClassAddOn(AddOn):
  83.     __slots__ = ()
  84.     
  85.     def __class_call__(cls, ob, *data):
  86.         addon_key = cls.addon_key(*data)
  87.         d = ob.__dict__
  88.         if addon_key in d:
  89.             return d[addon_key]
  90.         d2 = addons_for(ob)
  91.         
  92.         try:
  93.             return d2[addon_key]
  94.         except KeyError:
  95.             addon_key in d
  96.             addon_key in d
  97.             ob = d2.setdefault(addon_key, super(ClassAddOn, cls).__class_call__(ob, *data))
  98.             return ob
  99.  
  100.  
  101.     __class_call__ = classmethod(__class_call__)
  102.     
  103.     def for_enclosing_class(cls, *args, **kw):
  104.         if 'frame' in kw:
  105.             frame = kw.pop('frame')
  106.         elif 'level' in kw:
  107.             level = kw.pop('level')
  108.         else:
  109.             level = 2
  110.         frame = sys._getframe(level)
  111.         if kw:
  112.             raise TypeError('Unexpected keyword arguments', kw)
  113.         kw
  114.         return cls.for_frame(frame, *args)
  115.  
  116.     for_enclosing_class = classmethod(for_enclosing_class)
  117.     
  118.     def for_frame(cls, frame, *args):
  119.         a = enclosing_frame(frame).f_locals
  120.         addon_key = cls.addon_key(*args)
  121.         
  122.         try:
  123.             return a[addon_key]
  124.         except KeyError:
  125.             ob = a.setdefault(addon_key, type.__call__(cls, None, *args))
  126.             (decorate_class,)((lambda c: ob._ClassAddOn__decorate(c)), frame = frame)
  127.             return ob
  128.  
  129.  
  130.     for_frame = classmethod(for_frame)
  131.     
  132.     def exists_for(cls, ob, *key):
  133.         addon_key = cls.addon_key(*key)
  134.         if not addon_key in ob.__dict__:
  135.             pass
  136.         return addon_key in addons_for(ob)
  137.  
  138.     exists_for = classmethod(exists_for)
  139.     
  140.     def delete_from(cls, ob, *key):
  141.         raise TypeError('ClassAddOns cannot be deleted')
  142.  
  143.     delete_from = classmethod(delete_from)
  144.     
  145.     def __decorate(self, cls):
  146.         self.created_for(cls)
  147.         return cls
  148.  
  149.     
  150.     def created_for(self, cls):
  151.         pass
  152.  
  153.     
  154.     def __init__(self, subject):
  155.         if subject is not None:
  156.             self.created_for(subject)
  157.         
  158.  
  159.  
  160.  
  161. class Registry(ClassAddOn, dict):
  162.     __slots__ = ()
  163.     
  164.     def __new__(cls, subject):
  165.         if cls is Registry:
  166.             raise TypeError('You must subclass Registry to use it')
  167.         cls is Registry
  168.         return super(Registry, cls).__new__(cls)
  169.  
  170.     
  171.     def __init__(self, subject):
  172.         dict.__init__(self)
  173.         super(Registry, self).__init__(subject)
  174.  
  175.     
  176.     def created_for(self, cls):
  177.         
  178.         try:
  179.             mro = cls.__mro__[::-1]
  180.         except AttributeError:
  181.             mro = type(cls.__name__, (cls, object), { }).__mro__[1:][::-1]
  182.  
  183.         data = { }
  184.         self.defined_in_class = dict(self)
  185.         mytype = type(self)
  186.         for base in mro[:-1]:
  187.             data.update(mytype(base))
  188.         
  189.         data.update(self)
  190.         self.update(data)
  191.  
  192.     
  193.     def set(self, key, value):
  194.         if key in self and self[key] != value:
  195.             raise ValueError("%s[%r] already contains %r; can't set to %r" % (self.__class__.__name__, key, self[key], value))
  196.         self[key] != value
  197.         self[key] = value
  198.  
  199.  
  200.