home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_261 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  3.3 KB  |  108 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4.  
  5. def abstractmethod(funcobj):
  6.     funcobj.__isabstractmethod__ = True
  7.     return funcobj
  8.  
  9.  
  10. class abstractproperty(property):
  11.     __isabstractmethod__ = True
  12.  
  13.  
  14. class ABCMeta(type):
  15.     _abc_invalidation_counter = 0
  16.     
  17.     def __new__(mcls, name, bases, namespace):
  18.         cls = super(ABCMeta, mcls).__new__(mcls, name, bases, namespace)
  19.         abstracts = set((lambda .0: for name, value in .0:
  20. if getattr(value, '__isabstractmethod__', False):
  21. namecontinue)(namespace.items()))
  22.         for base in bases:
  23.             for name in getattr(base, '__abstractmethods__', set()):
  24.                 value = getattr(cls, name, None)
  25.                 if getattr(value, '__isabstractmethod__', False):
  26.                     abstracts.add(name)
  27.                     continue
  28.             
  29.         
  30.         cls.__abstractmethods__ = frozenset(abstracts)
  31.         cls._abc_registry = set()
  32.         cls._abc_cache = set()
  33.         cls._abc_negative_cache = set()
  34.         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
  35.         return cls
  36.  
  37.     
  38.     def register(cls, subclass):
  39.         if not isinstance(cls, type):
  40.             raise TypeError('Can only register classes')
  41.         isinstance(cls, type)
  42.         if issubclass(subclass, cls):
  43.             return None
  44.         if issubclass(cls, subclass):
  45.             raise RuntimeError('Refusing to create an inheritance cycle')
  46.         issubclass(cls, subclass)
  47.         cls._abc_registry.add(subclass)
  48.         ABCMeta._abc_invalidation_counter += 1
  49.  
  50.     
  51.     def _dump_registry(cls, file = None):
  52.         print >>file, 'Class: %s.%s' % (cls.__module__, cls.__name__)
  53.         print >>file, 'Inv.counter: %s' % ABCMeta._abc_invalidation_counter
  54.         for name in sorted(cls.__dict__.keys()):
  55.             if name.startswith('_abc_'):
  56.                 value = getattr(cls, name)
  57.                 print >>file, '%s: %r' % (name, value)
  58.                 continue
  59.         
  60.  
  61.     
  62.     def __instancecheck__(cls, instance):
  63.         subclass = getattr(instance, '__class__', None)
  64.         if subclass in cls._abc_cache:
  65.             return True
  66.         subtype = type(instance)
  67.         if subtype is subclass or subclass is None:
  68.             if cls._abc_negative_cache_version == ABCMeta._abc_invalidation_counter and subtype in cls._abc_negative_cache:
  69.                 return False
  70.             return cls.__subclasscheck__(subtype)
  71.         if not cls.__subclasscheck__(subclass):
  72.             pass
  73.         return cls.__subclasscheck__(subtype)
  74.  
  75.     
  76.     def __subclasscheck__(cls, subclass):
  77.         if subclass in cls._abc_cache:
  78.             return True
  79.         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
  80.             cls._abc_negative_cache = set()
  81.             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
  82.         elif subclass in cls._abc_negative_cache:
  83.             return False
  84.         ok = cls.__subclasshook__(subclass)
  85.         if ok is not NotImplemented:
  86.             if ok:
  87.                 cls._abc_cache.add(subclass)
  88.             else:
  89.                 cls._abc_negative_cache.add(subclass)
  90.             return ok
  91.         if cls in getattr(subclass, '__mro__', ()):
  92.             cls._abc_cache.add(subclass)
  93.             return True
  94.         for rcls in cls._abc_registry:
  95.             if issubclass(subclass, rcls):
  96.                 cls._abc_cache.add(subclass)
  97.                 return True
  98.         
  99.         for scls in cls.__subclasses__():
  100.             if issubclass(subclass, scls):
  101.                 cls._abc_cache.add(subclass)
  102.                 return True
  103.         
  104.         cls._abc_negative_cache.add(subclass)
  105.         return False
  106.  
  107.  
  108.