+++ /dev/null
-"""Helper to provide extensibility for pickle/cPickle.\r
-\r
-This is only useful to add pickle support for extension types defined in\r
-C, not for instances of user-defined classes.\r
-"""\r
-\r
-from types import ClassType as _ClassType\r
-\r
-__all__ = ["pickle", "constructor",\r
- "add_extension", "remove_extension", "clear_extension_cache"]\r
-\r
-dispatch_table = {}\r
-\r
-def pickle(ob_type, pickle_function, constructor_ob=None):\r
- if type(ob_type) is _ClassType:\r
- raise TypeError("copy_reg is not intended for use with classes")\r
-\r
- if not hasattr(pickle_function, '__call__'):\r
- raise TypeError("reduction functions must be callable")\r
- dispatch_table[ob_type] = pickle_function\r
-\r
- # The constructor_ob function is a vestige of safe for unpickling.\r
- # There is no reason for the caller to pass it anymore.\r
- if constructor_ob is not None:\r
- constructor(constructor_ob)\r
-\r
-def constructor(object):\r
- if not hasattr(object, '__call__'):\r
- raise TypeError("constructors must be callable")\r
-\r
-# Example: provide pickling support for complex numbers.\r
-\r
-try:\r
- complex\r
-except NameError:\r
- pass\r
-else:\r
-\r
- def pickle_complex(c):\r
- return complex, (c.real, c.imag)\r
-\r
- pickle(complex, pickle_complex, complex)\r
-\r
-# Support for pickling new-style objects\r
-\r
-def _reconstructor(cls, base, state):\r
- if base is object:\r
- obj = object.__new__(cls)\r
- else:\r
- obj = base.__new__(cls, state)\r
- if base.__init__ != object.__init__:\r
- base.__init__(obj, state)\r
- return obj\r
-\r
-_HEAPTYPE = 1<<9\r
-\r
-# Python code for object.__reduce_ex__ for protocols 0 and 1\r
-\r
-def _reduce_ex(self, proto):\r
- assert proto < 2\r
- for base in self.__class__.__mro__:\r
- if hasattr(base, '__flags__') and not base.__flags__ & _HEAPTYPE:\r
- break\r
- else:\r
- base = object # not really reachable\r
- if base is object:\r
- state = None\r
- else:\r
- if base is self.__class__:\r
- raise TypeError, "can't pickle %s objects" % base.__name__\r
- state = base(self)\r
- args = (self.__class__, base, state)\r
- try:\r
- getstate = self.__getstate__\r
- except AttributeError:\r
- if getattr(self, "__slots__", None):\r
- raise TypeError("a class that defines __slots__ without "\r
- "defining __getstate__ cannot be pickled")\r
- try:\r
- dict = self.__dict__\r
- except AttributeError:\r
- dict = None\r
- else:\r
- dict = getstate()\r
- if dict:\r
- return _reconstructor, args, dict\r
- else:\r
- return _reconstructor, args\r
-\r
-# Helper for __reduce_ex__ protocol 2\r
-\r
-def __newobj__(cls, *args):\r
- return cls.__new__(cls, *args)\r
-\r
-def _slotnames(cls):\r
- """Return a list of slot names for a given class.\r
-\r
- This needs to find slots defined by the class and its bases, so we\r
- can't simply return the __slots__ attribute. We must walk down\r
- the Method Resolution Order and concatenate the __slots__ of each\r
- class found there. (This assumes classes don't modify their\r
- __slots__ attribute to misrepresent their slots after the class is\r
- defined.)\r
- """\r
-\r
- # Get the value from a cache in the class if possible\r
- names = cls.__dict__.get("__slotnames__")\r
- if names is not None:\r
- return names\r
-\r
- # Not cached -- calculate the value\r
- names = []\r
- if not hasattr(cls, "__slots__"):\r
- # This class has no slots\r
- pass\r
- else:\r
- # Slots found -- gather slot names from all base classes\r
- for c in cls.__mro__:\r
- if "__slots__" in c.__dict__:\r
- slots = c.__dict__['__slots__']\r
- # if class has a single slot, it can be given as a string\r
- if isinstance(slots, basestring):\r
- slots = (slots,)\r
- for name in slots:\r
- # special descriptors\r
- if name in ("__dict__", "__weakref__"):\r
- continue\r
- # mangled names\r
- elif name.startswith('__') and not name.endswith('__'):\r
- names.append('_%s%s' % (c.__name__, name))\r
- else:\r
- names.append(name)\r
-\r
- # Cache the outcome in the class if at all possible\r
- try:\r
- cls.__slotnames__ = names\r
- except:\r
- pass # But don't die if we can't\r
-\r
- return names\r
-\r
-# A registry of extension codes. This is an ad-hoc compression\r
-# mechanism. Whenever a global reference to <module>, <name> is about\r
-# to be pickled, the (<module>, <name>) tuple is looked up here to see\r
-# if it is a registered extension code for it. Extension codes are\r
-# universal, so that the meaning of a pickle does not depend on\r
-# context. (There are also some codes reserved for local use that\r
-# don't have this restriction.) Codes are positive ints; 0 is\r
-# reserved.\r
-\r
-_extension_registry = {} # key -> code\r
-_inverted_registry = {} # code -> key\r
-_extension_cache = {} # code -> object\r
-# Don't ever rebind those names: cPickle grabs a reference to them when\r
-# it's initialized, and won't see a rebinding.\r
-\r
-def add_extension(module, name, code):\r
- """Register an extension code."""\r
- code = int(code)\r
- if not 1 <= code <= 0x7fffffff:\r
- raise ValueError, "code out of range"\r
- key = (module, name)\r
- if (_extension_registry.get(key) == code and\r
- _inverted_registry.get(code) == key):\r
- return # Redundant registrations are benign\r
- if key in _extension_registry:\r
- raise ValueError("key %s is already registered with code %s" %\r
- (key, _extension_registry[key]))\r
- if code in _inverted_registry:\r
- raise ValueError("code %s is already in use for key %s" %\r
- (code, _inverted_registry[code]))\r
- _extension_registry[key] = code\r
- _inverted_registry[code] = key\r
-\r
-def remove_extension(module, name, code):\r
- """Unregister an extension code. For testing only."""\r
- key = (module, name)\r
- if (_extension_registry.get(key) != code or\r
- _inverted_registry.get(code) != key):\r
- raise ValueError("key %s is not registered with code %s" %\r
- (key, code))\r
- del _extension_registry[key]\r
- del _inverted_registry[code]\r
- if code in _extension_cache:\r
- del _extension_cache[code]\r
-\r
-def clear_extension_cache():\r
- _extension_cache.clear()\r
-\r
-# Standard extension code assignments\r
-\r
-# Reserved ranges\r
-\r
-# First Last Count Purpose\r
-# 1 127 127 Reserved for Python standard library\r
-# 128 191 64 Reserved for Zope\r
-# 192 239 48 Reserved for 3rd parties\r
-# 240 255 16 Reserved for private use (will never be assigned)\r
-# 256 Inf Inf Reserved for future assignment\r
-\r
-# Extension codes are assigned by the Python Software Foundation.\r
projects / mirror_edk2.git / blobdiff