home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / copy_reg.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2004-02-22  |  6KB  |  174 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.3)
  3.  
  4. '''Helper to provide extensibility for pickle/cPickle.
  5.  
  6. This is only useful to add pickle support for extension types defined in
  7. C, not for instances of user-defined classes.
  8. '''
  9. from types import ClassType as _ClassType
  10. __all__ = [
  11.     'pickle',
  12.     'constructor',
  13.     'add_extension',
  14.     'remove_extension',
  15.     'clear_extension_cache']
  16. dispatch_table = { }
  17.  
  18. def pickle(ob_type, pickle_function, constructor_ob = None):
  19.     if type(ob_type) is _ClassType:
  20.         raise TypeError('copy_reg is not intended for use with classes')
  21.     
  22.     if not callable(pickle_function):
  23.         raise TypeError('reduction functions must be callable')
  24.     
  25.     dispatch_table[ob_type] = pickle_function
  26.     if constructor_ob is not None:
  27.         constructor(constructor_ob)
  28.     
  29.  
  30.  
  31. def constructor(object):
  32.     if not callable(object):
  33.         raise TypeError('constructors must be callable')
  34.     
  35.  
  36.  
  37. try:
  38.     complex
  39. except NameError:
  40.     pass
  41.  
  42.  
  43. def pickle_complex(c):
  44.     return (complex, (c.real, c.imag))
  45.  
  46. pickle(complex, pickle_complex, complex)
  47.  
  48. def _reconstructor(cls, base, state):
  49.     if base is object:
  50.         obj = object.__new__(cls)
  51.     else:
  52.         obj = base.__new__(cls, state)
  53.         base.__init__(obj, state)
  54.     return obj
  55.  
  56. _HEAPTYPE = 1 << 9
  57.  
  58. def _reduce_ex(self, proto):
  59.     if not proto < 2:
  60.         raise AssertionError
  61.     for base in self.__class__.__mro__:
  62.         if hasattr(base, '__flags__') and not (base.__flags__ & _HEAPTYPE):
  63.             break
  64.             continue
  65.     else:
  66.         base = object
  67.     if base is object:
  68.         state = None
  69.     elif base is self.__class__:
  70.         raise TypeError, "can't pickle %s objects" % base.__name__
  71.     
  72.     state = base(self)
  73.     args = (self.__class__, base, state)
  74.     
  75.     try:
  76.         getstate = self.__getstate__
  77.     except AttributeError:
  78.         if getattr(self, '__slots__', None):
  79.             raise TypeError('a class that defines __slots__ without defining __getstate__ cannot be pickled')
  80.         
  81.         
  82.         try:
  83.             dict = self.__dict__
  84.         except AttributeError:
  85.             dict = None
  86.         except:
  87.             None<EXCEPTION MATCH>AttributeError
  88.         
  89.  
  90.         None<EXCEPTION MATCH>AttributeError
  91.  
  92.     dict = getstate()
  93.     if dict:
  94.         return (_reconstructor, args, dict)
  95.     else:
  96.         return (_reconstructor, args)
  97.  
  98.  
  99. def __newobj__(cls, *args):
  100.     return cls.__new__(cls, *args)
  101.  
  102.  
  103. def _slotnames(cls):
  104.     """Return a list of slot names for a given class.
  105.  
  106.     This needs to find slots defined by the class and its bases, so we
  107.     can't simply return the __slots__ attribute.  We must walk down
  108.     the Method Resolution Order and concatenate the __slots__ of each
  109.     class found there.  (This assumes classes don't modify their
  110.     __slots__ attribute to misrepresent their slots after the class is
  111.     defined.)
  112.     """
  113.     names = cls.__dict__.get('__slotnames__')
  114.     if names is not None:
  115.         return names
  116.     
  117.     names = []
  118.     if not hasattr(cls, '__slots__'):
  119.         pass
  120.     else:
  121.         for c in cls.__mro__:
  122.             if '__slots__' in c.__dict__:
  123.                 names += []
  124.                 continue
  125.         
  126.     
  127.     try:
  128.         cls.__slotnames__ = names
  129.     except:
  130.         pass
  131.  
  132.     return names
  133.  
  134. _extension_registry = { }
  135. _inverted_registry = { }
  136. _extension_cache = { }
  137.  
  138. def add_extension(module, name, code):
  139.     '''Register an extension code.'''
  140.     code = int(code)
  141.     if not None if code <= code else code <= 2147483647:
  142.         raise ValueError, 'code out of range'
  143.     
  144.     key = (module, name)
  145.     if _extension_registry.get(key) == code and _inverted_registry.get(code) == key:
  146.         return None
  147.     
  148.     if key in _extension_registry:
  149.         raise ValueError('key %s is already registered with code %s' % (key, _extension_registry[key]))
  150.     
  151.     if code in _inverted_registry:
  152.         raise ValueError('code %s is already in use for key %s' % (code, _inverted_registry[code]))
  153.     
  154.     _extension_registry[key] = code
  155.     _inverted_registry[code] = key
  156.  
  157.  
  158. def remove_extension(module, name, code):
  159.     '''Unregister an extension code.  For testing only.'''
  160.     key = (module, name)
  161.     if _extension_registry.get(key) != code or _inverted_registry.get(code) != key:
  162.         raise ValueError('key %s is not registered with code %s' % (key, code))
  163.     
  164.     del _extension_registry[key]
  165.     del _inverted_registry[code]
  166.     if code in _extension_cache:
  167.         del _extension_cache[code]
  168.     
  169.  
  170.  
  171. def clear_extension_cache():
  172.     _extension_cache.clear()
  173.  
  174.