copyreg.py

"""Helper to provide extensibility for pickle.

This is only useful to add pickle support for extension types defined in
C, not for instances of user-defined classes.
"""

__all__= ["pickle", "constructor",
"add_extension", "remove_extension", "clear_extension_cache"]

dispatch_table= {}

defpickle(ob_type, pickle_function, constructor_ob=None):
ifnotcallable(pickle_function):
raiseTypeError("reduction functions must be callable")
dispatch_table[ob_type] =pickle_function

# The constructor_ob function is a vestige of safe for unpickling.
# There is no reason for the caller to pass it anymore.
ifconstructor_obisnotNone:
constructor(constructor_ob)

defconstructor(object):
ifnotcallable(object):
raiseTypeError("constructors must be callable")

# Example: provide pickling support for complex numbers.

defpickle_complex(c):
returncomplex, (c.real, c.imag)

pickle(complex, pickle_complex, complex)

defpickle_union(obj):
importfunctools, operator
returnfunctools.reduce, (operator.or_, obj.__args__)

pickle(type(int|str), pickle_union)

# Support for pickling new-style objects

def_reconstructor(cls, base, state):
ifbaseisobject:
obj=object.__new__(cls)
else:
obj=base.__new__(cls, state)
ifbase.__init__!=object.__init__:
base.__init__(obj, state)
returnobj

_HEAPTYPE=1<<9
_new_type=type(int.__new__)

# Python code for object.__reduce_ex__ for protocols 0 and 1

def_reduce_ex(self, proto):
assertproto<2
cls=self.__class__
forbaseincls.__mro__:
ifhasattr(base, '__flags__') andnotbase.__flags__&_HEAPTYPE:
break
new=base.__new__
ifisinstance(new, _new_type) andnew.__self__isbase:
break
else:
base=object# not really reachable
ifbaseisobject:
state=None
else:
ifbaseiscls:
raiseTypeError(f"cannot pickle {cls.__name__!r} object")
state=base(self)
args= (cls, base, state)
try:
getstate=self.__getstate__
exceptAttributeError:
ifgetattr(self, "__slots__", None):
raiseTypeError(f"cannot pickle {cls.__name__!r} object: "
f"a class that defines __slots__ without "
f"defining __getstate__ cannot be pickled "
f"with protocol {proto}") fromNone
try:
dict=self.__dict__
exceptAttributeError:
dict=None
else:
if (type(self).__getstate__isobject.__getstate__and
getattr(self, "__slots__", None)):
raiseTypeError("a class that defines __slots__ without "
"defining __getstate__ cannot be pickled")
dict=getstate()
ifdict:
return_reconstructor, args, dict
else:
return_reconstructor, args

# Helper for __reduce_ex__ protocol 2

def__newobj__(cls, *args):
returncls.__new__(cls, *args)

def__newobj_ex__(cls, args, kwargs):
"""Used by pickle protocol 4, instead of __newobj__ to allow classes with
 keyword-only arguments to be pickled correctly.
 """
returncls.__new__(cls, *args, **kwargs)

def_slotnames(cls):
"""Return a list of slot names for a given class.

 This needs to find slots defined by the class and its bases, so we
 can't simply return the __slots__ attribute. We must walk down
 the Method Resolution Order and concatenate the __slots__ of each
 class found there. (This assumes classes don't modify their
 __slots__ attribute to misrepresent their slots after the class is
 defined.)
 """

# Get the value from a cache in the class if possible
names=cls.__dict__.get("__slotnames__")
ifnamesisnotNone:
returnnames

# Not cached -- calculate the value
names= []
ifnothasattr(cls, "__slots__"):
# This class has no slots
pass
else:
# Slots found -- gather slot names from all base classes
forcincls.__mro__:
if"__slots__"inc.__dict__:
slots=c.__dict__['__slots__']
# if class has a single slot, it can be given as a string
ifisinstance(slots, str):
slots= (slots,)
fornameinslots:
# special descriptors
ifnamein ("__dict__", "__weakref__"):
continue
# mangled names
elifname.startswith('__') andnotname.endswith('__'):
stripped=c.__name__.lstrip('_')
ifstripped:
names.append('_%s%s'% (stripped, name))
else:
names.append(name)
else:
names.append(name)

# Cache the outcome in the class if at all possible
try:
cls.__slotnames__=names
except:
pass# But don't die if we can't

returnnames

# A registry of extension codes. This is an ad-hoc compression
# mechanism. Whenever a global reference to <module>, <name> is about
# to be pickled, the (<module>, <name>) tuple is looked up here to see
# if it is a registered extension code for it. Extension codes are
# universal, so that the meaning of a pickle does not depend on
# context. (There are also some codes reserved for local use that
# don't have this restriction.) Codes are positive ints; 0 is
# reserved.

_extension_registry= {} # key -> code
_inverted_registry= {} # code -> key
_extension_cache= {} # code -> object
# Don't ever rebind those names: pickling grabs a reference to them when
# it's initialized, and won't see a rebinding.

defadd_extension(module, name, code):
"""Register an extension code."""
code=int(code)
ifnot1<=code<=0x7fffffff:
raiseValueError("code out of range")
key= (module, name)
if (_extension_registry.get(key) ==codeand
_inverted_registry.get(code) ==key):
return# Redundant registrations are benign
ifkeyin_extension_registry:
raiseValueError("key %s is already registered with code %s"%
 (key, _extension_registry[key]))
ifcodein_inverted_registry:
raiseValueError("code %s is already in use for key %s"%
 (code, _inverted_registry[code]))
_extension_registry[key] =code
_inverted_registry[code] =key

defremove_extension(module, name, code):
"""Unregister an extension code. For testing only."""
key= (module, name)
if (_extension_registry.get(key) !=codeor
_inverted_registry.get(code) !=key):
raiseValueError("key %s is not registered with code %s"%
 (key, code))
del_extension_registry[key]
del_inverted_registry[code]
ifcodein_extension_cache:
del_extension_cache[code]

defclear_extension_cache():
_extension_cache.clear()

# Standard extension code assignments

# Reserved ranges

# First Last Count Purpose
# 1 127 127 Reserved for Python standard library
# 128 191 64 Reserved for Zope
# 192 239 48 Reserved for 3rd parties
# 240 255 16 Reserved for private use (will never be assigned)
# 256 Inf Inf Reserved for future assignment

# Extension codes are assigned by the Python Software Foundation.