From 59683c433fd4c19f4921e4b44b8a70174e82fc4b Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= <zbyszek@in.waw.pl>

Date: Tue, 10 Sep 2019 08:32:24 +0200

Subject: [PATCH 18/18] Unbundle cloudpickle

---

 joblib/externals/cloudpickle/__init__.py     |   11 -

 joblib/externals/cloudpickle/cloudpickle.py  | 1380 ------------------

 joblib/externals/loky/backend/reduction.py   |    4 +-

 joblib/externals/loky/cloudpickle_wrapper.py |    2 +-

 joblib/parallel.py                           |    2 +-

 setup.py                                     |    2 +-

 6 files changed, 5 insertions(+), 1396 deletions(-)

 delete mode 100644 joblib/externals/cloudpickle/__init__.py

 delete mode 100644 joblib/externals/cloudpickle/cloudpickle.py

diff --git a/joblib/externals/cloudpickle/__init__.py b/joblib/externals/cloudpickle/__init__.py

deleted file mode 100644

index 9806b5c7b2..0000000000

--- a/joblib/externals/cloudpickle/__init__.py

+++ /dev/null

@@ -1,11 +0,0 @@

-from __future__ import absolute_import

-

-import sys

-import pickle

-

-

-from .cloudpickle import *

-if sys.version_info[:2] >= (3, 8):

-    from .cloudpickle_fast import CloudPickler, dumps, dump

-

-__version__ = '1.2.1'

diff --git a/joblib/externals/cloudpickle/cloudpickle.py b/joblib/externals/cloudpickle/cloudpickle.py

deleted file mode 100644

index cc74c642ec..0000000000

--- a/joblib/externals/cloudpickle/cloudpickle.py

+++ /dev/null

@@ -1,1380 +0,0 @@

-"""

-This class is defined to override standard pickle functionality

-

-The goals of it follow:

--Serialize lambdas and nested functions to compiled byte code

--Deal with main module correctly

--Deal with other non-serializable objects

-

-It does not include an unpickler, as standard python unpickling suffices.

-

-This module was extracted from the `cloud` package, developed by `PiCloud, Inc.

-<https://web.archive.org/web/20140626004012/http://www.picloud.com/>`_.

-

-Copyright (c) 2012, Regents of the University of California.

-Copyright (c) 2009 `PiCloud, Inc. <https://web.archive.org/web/20140626004012/http://www.picloud.com/>`_.

-All rights reserved.

-

-Redistribution and use in source and binary forms, with or without

-modification, are permitted provided that the following conditions

-are met:

-    * Redistributions of source code must retain the above copyright

-      notice, this list of conditions and the following disclaimer.

-    * Redistributions in binary form must reproduce the above copyright

-      notice, this list of conditions and the following disclaimer in the

-      documentation and/or other materials provided with the distribution.

-    * Neither the name of the University of California, Berkeley nor the

-      names of its contributors may be used to endorse or promote

-      products derived from this software without specific prior written

-      permission.

-

-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

-TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-"""

-from __future__ import print_function

-

-import dis

-from functools import partial

-import io

-import itertools

-import logging

-import opcode

-import operator

-import pickle

-import platform

-import struct

-import sys

-import traceback

-import types

-import weakref

-import uuid

-import threading

-

-

-try:

-    from enum import Enum

-except ImportError:

-    Enum = None

-

-# cloudpickle is meant for inter process communication: we expect all

-# communicating processes to run the same Python version hence we favor

-# communication speed over compatibility:

-DEFAULT_PROTOCOL = pickle.HIGHEST_PROTOCOL

-

-# Track the provenance of reconstructed dynamic classes to make it possible to

-# recontruct instances from the matching singleton class definition when

-# appropriate and preserve the usual "isinstance" semantics of Python objects.

-_DYNAMIC_CLASS_TRACKER_BY_CLASS = weakref.WeakKeyDictionary()

-_DYNAMIC_CLASS_TRACKER_BY_ID = weakref.WeakValueDictionary()

-_DYNAMIC_CLASS_TRACKER_LOCK = threading.Lock()

-

-PYPY = platform.python_implementation() == "PyPy"

-

-builtin_code_type = None

-if PYPY:

-    # builtin-code objects only exist in pypy

-    builtin_code_type = type(float.__new__.__code__)

-

-if sys.version_info[0] < 3:  # pragma: no branch

-    from pickle import Pickler

-    try:

-        from cStringIO import StringIO

-    except ImportError:

-        from StringIO import StringIO

-    string_types = (basestring,)  # noqa

-    PY3 = False

-    PY2 = True

-else:

-    types.ClassType = type

-    from pickle import _Pickler as Pickler

-    from io import BytesIO as StringIO

-    string_types = (str,)

-    PY3 = True

-    PY2 = False

-    from importlib._bootstrap import _find_spec

-

-_extract_code_globals_cache = weakref.WeakKeyDictionary()

-

-

-def _ensure_tracking(class_def):

-    with _DYNAMIC_CLASS_TRACKER_LOCK:

-        class_tracker_id = _DYNAMIC_CLASS_TRACKER_BY_CLASS.get(class_def)

-        if class_tracker_id is None:

-            class_tracker_id = uuid.uuid4().hex

-            _DYNAMIC_CLASS_TRACKER_BY_CLASS[class_def] = class_tracker_id

-            _DYNAMIC_CLASS_TRACKER_BY_ID[class_tracker_id] = class_def

-    return class_tracker_id

-

-

-def _lookup_class_or_track(class_tracker_id, class_def):

-    if class_tracker_id is not None:

-        with _DYNAMIC_CLASS_TRACKER_LOCK:

-            class_def = _DYNAMIC_CLASS_TRACKER_BY_ID.setdefault(

-                class_tracker_id, class_def)

-            _DYNAMIC_CLASS_TRACKER_BY_CLASS[class_def] = class_tracker_id

-    return class_def

-

-if sys.version_info[:2] >= (3, 5):

-    from pickle import _getattribute

-elif sys.version_info[:2] >= (3, 4):

-    from pickle import _getattribute as _py34_getattribute

-    #  pickle._getattribute does not return the parent under Python 3.4

-    def _getattribute(obj, name):

-        return _py34_getattribute(obj, name), None

-else:

-    # pickle._getattribute is a python3 addition and enchancement of getattr,

-    # that can handle dotted attribute names. In cloudpickle for python2,

-    # handling dotted names is not needed, so we simply define _getattribute as

-    # a wrapper around getattr.

-    def _getattribute(obj, name):

-        return getattr(obj, name, None), None

-

-

-def _whichmodule(obj, name):

-    """Find the module an object belongs to.

-

-    This function differs from ``pickle.whichmodule`` in two ways:

-    - it does not mangle the cases where obj's module is __main__ and obj was

-      not found in any module.

-    - Errors arising during module introspection are ignored, as those errors

-      are considered unwanted side effects.

-    """

-    module_name = getattr(obj, '__module__', None)

-    if module_name is not None:

-        return module_name

-    # Protect the iteration by using a list copy of sys.modules against dynamic

-    # modules that trigger imports of other modules upon calls to getattr.

-    for module_name, module in list(sys.modules.items()):

-        if module_name == '__main__' or module is None:

-            continue

-        try:

-            if _getattribute(module, name)[0] is obj:

-                return module_name

-        except Exception:

-            pass

-    return None

-

-

-def _is_global(obj, name=None):

-    """Determine if obj can be pickled as attribute of a file-backed module"""

-    if name is None:

-        name = getattr(obj, '__qualname__', None)

-    if name is None:

-        name = getattr(obj, '__name__', None)

-

-    module_name = _whichmodule(obj, name)

-

-    if module_name is None:

-        # In this case, obj.__module__ is None AND obj was not found in any

-        # imported module. obj is thus treated as dynamic.

-        return False

-

-    if module_name == "__main__":

-        return False

-

-    module = sys.modules.get(module_name, None)

-    if module is None:

-        # The main reason why obj's module would not be imported is that this

-        # module has been dynamically created, using for example

-        # types.ModuleType. The other possibility is that module was removed

-        # from sys.modules after obj was created/imported. But this case is not

-        # supported, as the standard pickle does not support it either.

-        return False

-

-    # module has been added to sys.modules, but it can still be dynamic.

-    if _is_dynamic(module):

-        return False

-

-    try:

-        obj2, parent = _getattribute(module, name)

-    except AttributeError:

-        # obj was not found inside the module it points to

-        return False

-    return obj2 is obj

-

-

-def _extract_code_globals(co):

-    """

-    Find all globals names read or written to by codeblock co

-    """

-    out_names = _extract_code_globals_cache.get(co)

-    if out_names is None:

-        names = co.co_names

-        out_names = {names[oparg] for _, oparg in _walk_global_ops(co)}

-

-        # Declaring a function inside another one using the "def ..."

-        # syntax generates a constant code object corresonding to the one

-        # of the nested function's As the nested function may itself need

-        # global variables, we need to introspect its code, extract its

-        # globals, (look for code object in it's co_consts attribute..) and

-        # add the result to code_globals

-        if co.co_consts:

-            for const in co.co_consts:

-                if isinstance(const, types.CodeType):

-                    out_names |= _extract_code_globals(const)

-

-        _extract_code_globals_cache[co] = out_names

-

-    return out_names

-

-

-def _find_imported_submodules(code, top_level_dependencies):

-    """

-    Find currently imported submodules used by a function.

-

-    Submodules used by a function need to be detected and referenced for the

-    function to work correctly at depickling time. Because submodules can be

-    referenced as attribute of their parent package (``package.submodule``), we

-    need a special introspection technique that does not rely on GLOBAL-related

-    opcodes to find references of them in a code object.

-

-    Example:

-    ```

-    import concurrent.futures

-    import cloudpickle

-    def func():

-        x = concurrent.futures.ThreadPoolExecutor

-    if __name__ == '__main__':

-        cloudpickle.dumps(func)

-    ```

-    The globals extracted by cloudpickle in the function's state include the

-    concurrent package, but not its submodule (here, concurrent.futures), which

-    is the module used by func. Find_imported_submodules will detect the usage

-    of concurrent.futures. Saving this module alongside with func will ensure

-    that calling func once depickled does not fail due to concurrent.futures

-    not being imported

-    """

-

-    subimports = []

-    # check if any known dependency is an imported package

-    for x in top_level_dependencies:

-        if (isinstance(x, types.ModuleType) and

-                hasattr(x, '__package__') and x.__package__):

-            # check if the package has any currently loaded sub-imports

-            prefix = x.__name__ + '.'

-            # A concurrent thread could mutate sys.modules,

-            # make sure we iterate over a copy to avoid exceptions

-            for name in list(sys.modules):

-                # Older versions of pytest will add a "None" module to

-                # sys.modules.

-                if name is not None and name.startswith(prefix):

-                    # check whether the function can address the sub-module

-                    tokens = set(name[len(prefix):].split('.'))

-                    if not tokens - set(code.co_names):

-                        subimports.append(sys.modules[name])

-    return subimports

-

-

-def _make_cell_set_template_code():

-    """Get the Python compiler to emit LOAD_FAST(arg); STORE_DEREF

-

-    Notes

-    -----

-    In Python 3, we could use an easier function:

-

-    .. code-block:: python

-

-       def f():

-           cell = None

-

-           def _stub(value):

-               nonlocal cell

-               cell = value

-

-           return _stub

-

-        _cell_set_template_code = f().__code__

-

-    This function is _only_ a LOAD_FAST(arg); STORE_DEREF, but that is

-    invalid syntax on Python 2. If we use this function we also don't need

-    to do the weird freevars/cellvars swap below

-    """

-    def inner(value):

-        lambda: cell  # make ``cell`` a closure so that we get a STORE_DEREF

-        cell = value

-

-    co = inner.__code__

-

-    # NOTE: we are marking the cell variable as a free variable intentionally

-    # so that we simulate an inner function instead of the outer function. This

-    # is what gives us the ``nonlocal`` behavior in a Python 2 compatible way.

-    if PY2:  # pragma: no branch

-        return types.CodeType(

-            co.co_argcount,

-            co.co_nlocals,

-            co.co_stacksize,

-            co.co_flags,

-            co.co_code,

-            co.co_consts,

-            co.co_names,

-            co.co_varnames,

-            co.co_filename,

-            co.co_name,

-            co.co_firstlineno,

-            co.co_lnotab,

-            co.co_cellvars,  # this is the trickery

-            (),

-        )

-    else:

-        if hasattr(types.CodeType, "co_posonlyargcount"):  # pragma: no branch

-            return types.CodeType(

-                co.co_argcount,

-                co.co_posonlyargcount,  # Python3.8 with PEP570

-                co.co_kwonlyargcount,

-                co.co_nlocals,

-                co.co_stacksize,

-                co.co_flags,

-                co.co_code,

-                co.co_consts,

-                co.co_names,

-                co.co_varnames,

-                co.co_filename,

-                co.co_name,

-                co.co_firstlineno,

-                co.co_lnotab,

-                co.co_cellvars,  # this is the trickery

-                (),

-            )

-        else:

-            return types.CodeType(

-                co.co_argcount,

-                co.co_kwonlyargcount,

-                co.co_nlocals,

-                co.co_stacksize,

-                co.co_flags,

-                co.co_code,

-                co.co_consts,

-                co.co_names,

-                co.co_varnames,

-                co.co_filename,

-                co.co_name,

-                co.co_firstlineno,

-                co.co_lnotab,

-                co.co_cellvars,  # this is the trickery

-                (),

-            )

-

-_cell_set_template_code = _make_cell_set_template_code()

-

-

-def cell_set(cell, value):

-    """Set the value of a closure cell.

-    """

-    return types.FunctionType(

-        _cell_set_template_code,

-        {},

-        '_cell_set_inner',

-        (),

-        (cell,),

-    )(value)

-

-

-# relevant opcodes

-STORE_GLOBAL = opcode.opmap['STORE_GLOBAL']

-DELETE_GLOBAL = opcode.opmap['DELETE_GLOBAL']

-LOAD_GLOBAL = opcode.opmap['LOAD_GLOBAL']

-GLOBAL_OPS = (STORE_GLOBAL, DELETE_GLOBAL, LOAD_GLOBAL)

-HAVE_ARGUMENT = dis.HAVE_ARGUMENT

-EXTENDED_ARG = dis.EXTENDED_ARG

-

-

-_BUILTIN_TYPE_NAMES = {}

-for k, v in types.__dict__.items():

-    if type(v) is type:

-        _BUILTIN_TYPE_NAMES[v] = k

-

-

-def _builtin_type(name):

-    return getattr(types, name)

-

-

-if sys.version_info < (3, 4):  # pragma: no branch

-    def _walk_global_ops(code):

-        """

-        Yield (opcode, argument number) tuples for all

-        global-referencing instructions in *code*.

-        """

-        code = getattr(code, 'co_code', b'')

-        if PY2:  # pragma: no branch

-            code = map(ord, code)

-

-        n = len(code)

-        i = 0

-        extended_arg = 0

-        while i < n:

-            op = code[i]

-            i += 1

-            if op >= HAVE_ARGUMENT:

-                oparg = code[i] + code[i + 1] * 256 + extended_arg

-                extended_arg = 0

-                i += 2

-                if op == EXTENDED_ARG:

-                    extended_arg = oparg * 65536

-                if op in GLOBAL_OPS:

-                    yield op, oparg

-

-else:

-    def _walk_global_ops(code):

-        """

-        Yield (opcode, argument number) tuples for all

-        global-referencing instructions in *code*.

-        """

-        for instr in dis.get_instructions(code):

-            op = instr.opcode

-            if op in GLOBAL_OPS:

-                yield op, instr.arg

-

-

-def _extract_class_dict(cls):

-    """Retrieve a copy of the dict of a class without the inherited methods"""

-    clsdict = dict(cls.__dict__)  # copy dict proxy to a dict

-    if len(cls.__bases__) == 1:

-        inherited_dict = cls.__bases__[0].__dict__

-    else:

-        inherited_dict = {}

-        for base in reversed(cls.__bases__):

-            inherited_dict.update(base.__dict__)

-    to_remove = []

-    for name, value in clsdict.items():

-        try:

-            base_value = inherited_dict[name]

-            if value is base_value:

-                to_remove.append(name)

-        except KeyError:

-            pass

-    for name in to_remove:

-        clsdict.pop(name)

-    return clsdict

-

-

-class CloudPickler(Pickler):

-

-    dispatch = Pickler.dispatch.copy()

-

-    def __init__(self, file, protocol=None):

-        if protocol is None:

-            protocol = DEFAULT_PROTOCOL

-        Pickler.__init__(self, file, protocol=protocol)

-        # map ids to dictionary. used to ensure that functions can share global env

-        self.globals_ref = {}

-

-    def dump(self, obj):

-        self.inject_addons()

-        try:

-            return Pickler.dump(self, obj)

-        except RuntimeError as e:

-            if 'recursion' in e.args[0]:

-                msg = """Could not pickle object as excessively deep recursion required."""

-                raise pickle.PicklingError(msg)

-            else:

-                raise

-

-    def save_memoryview(self, obj):

-        self.save(obj.tobytes())

-

-    dispatch[memoryview] = save_memoryview

-

-    if PY2:  # pragma: no branch

-        def save_buffer(self, obj):

-            self.save(str(obj))

-

-        dispatch[buffer] = save_buffer  # noqa: F821 'buffer' was removed in Python 3

-

-    def save_module(self, obj):

-        """

-        Save a module as an import

-        """

-        if _is_dynamic(obj):

-            self.save_reduce(dynamic_subimport, (obj.__name__, vars(obj)),

-                             obj=obj)

-        else:

-            self.save_reduce(subimport, (obj.__name__,), obj=obj)

-

-    dispatch[types.ModuleType] = save_module

-

-    def save_codeobject(self, obj):

-        """

-        Save a code object

-        """

-        if PY3:  # pragma: no branch

-            if hasattr(obj, "co_posonlyargcount"):  # pragma: no branch

-                args = (

-                    obj.co_argcount, obj.co_posonlyargcount,

-                    obj.co_kwonlyargcount, obj.co_nlocals, obj.co_stacksize,

-                    obj.co_flags, obj.co_code, obj.co_consts, obj.co_names,

-                    obj.co_varnames, obj.co_filename, obj.co_name,

-                    obj.co_firstlineno, obj.co_lnotab, obj.co_freevars,

-                    obj.co_cellvars

-                )

-            else:

-                args = (

-                    obj.co_argcount, obj.co_kwonlyargcount, obj.co_nlocals,

-                    obj.co_stacksize, obj.co_flags, obj.co_code, obj.co_consts,

-                    obj.co_names, obj.co_varnames, obj.co_filename,

-                    obj.co_name, obj.co_firstlineno, obj.co_lnotab,

-                    obj.co_freevars, obj.co_cellvars

-                )

-        else:

-            args = (

-                obj.co_argcount, obj.co_nlocals, obj.co_stacksize, obj.co_flags, obj.co_code,

-                obj.co_consts, obj.co_names, obj.co_varnames, obj.co_filename, obj.co_name,

-                obj.co_firstlineno, obj.co_lnotab, obj.co_freevars, obj.co_cellvars

-            )

-        self.save_reduce(types.CodeType, args, obj=obj)

-

-    dispatch[types.CodeType] = save_codeobject

-

-    def save_function(self, obj, name=None):

-        """ Registered with the dispatch to handle all function types.

-

-        Determines what kind of function obj is (e.g. lambda, defined at

-        interactive prompt, etc) and handles the pickling appropriately.

-        """

-        if _is_global(obj, name=name):

-            return Pickler.save_global(self, obj, name=name)

-        elif PYPY and isinstance(obj.__code__, builtin_code_type):

-            return self.save_pypy_builtin_func(obj)

-        else:

-            return self.save_function_tuple(obj)

-

-    dispatch[types.FunctionType] = save_function

-

-    def save_pypy_builtin_func(self, obj):

-        """Save pypy equivalent of builtin functions.

-

-        PyPy does not have the concept of builtin-functions. Instead,

-        builtin-functions are simple function instances, but with a

-        builtin-code attribute.

-        Most of the time, builtin functions should be pickled by attribute. But

-        PyPy has flaky support for __qualname__, so some builtin functions such

-        as float.__new__ will be classified as dynamic. For this reason only,

-        we created this special routine. Because builtin-functions are not

-        expected to have closure or globals, there is no additional hack

-        (compared the one already implemented in pickle) to protect ourselves

-        from reference cycles. A simple (reconstructor, newargs, obj.__dict__)

-        tuple is save_reduced.

-

-        Note also that PyPy improved their support for __qualname__ in v3.6, so

-        this routing should be removed when cloudpickle supports only PyPy 3.6

-        and later.

-        """

-        rv = (types.FunctionType, (obj.__code__, {}, obj.__name__,

-                                   obj.__defaults__, obj.__closure__),

-              obj.__dict__)

-        self.save_reduce(*rv, obj=obj)

-

-    def _save_dynamic_enum(self, obj, clsdict):

-        """Special handling for dynamic Enum subclasses

-

-        Use a dedicated Enum constructor (inspired by EnumMeta.__call__) as the

-        EnumMeta metaclass has complex initialization that makes the Enum

-        subclasses hold references to their own instances.

-        """

-        members = dict((e.name, e.value) for e in obj)

-

-        # Python 2.7 with enum34 can have no qualname:

-        qualname = getattr(obj, "__qualname__", None)

-

-        self.save_reduce(_make_skeleton_enum,

-                         (obj.__bases__, obj.__name__, qualname, members,

-                          obj.__module__, _ensure_tracking(obj), None),

-                         obj=obj)

-

-        # Cleanup the clsdict that will be passed to _rehydrate_skeleton_class:

-        # Those attributes are already handled by the metaclass.

-        for attrname in ["_generate_next_value_", "_member_names_",

-                         "_member_map_", "_member_type_",

-                         "_value2member_map_"]:

-            clsdict.pop(attrname, None)

-        for member in members:

-            clsdict.pop(member)

-

-    def save_dynamic_class(self, obj):

-        """Save a class that can't be stored as module global.

-

-        This method is used to serialize classes that are defined inside

-        functions, or that otherwise can't be serialized as attribute lookups

-        from global modules.

-        """

-        clsdict = _extract_class_dict(obj)

-        clsdict.pop('__weakref__', None)

-

-        # For ABCMeta in python3.7+, remove _abc_impl as it is not picklable.

-        # This is a fix which breaks the cache but this only makes the first

-        # calls to issubclass slower.

-        if "_abc_impl" in clsdict:

-            import abc

-            (registry, _, _, _) = abc._get_dump(obj)

-            clsdict["_abc_impl"] = [subclass_weakref()

-                                    for subclass_weakref in registry]

-

-        # On PyPy, __doc__ is a readonly attribute, so we need to include it in

-        # the initial skeleton class.  This is safe because we know that the

-        # doc can't participate in a cycle with the original class.

-        type_kwargs = {'__doc__': clsdict.pop('__doc__', None)}

-

-        if hasattr(obj, "__slots__"):

-            type_kwargs['__slots__'] = obj.__slots__

-            # pickle string length optimization: member descriptors of obj are

-            # created automatically from obj's __slots__ attribute, no need to

-            # save them in obj's state

-            if isinstance(obj.__slots__, string_types):

-                clsdict.pop(obj.__slots__)

-            else:

-                for k in obj.__slots__:

-                    clsdict.pop(k, None)

-

-        # If type overrides __dict__ as a property, include it in the type

-        # kwargs. In Python 2, we can't set this attribute after construction.

-        __dict__ = clsdict.pop('__dict__', None)

-        if isinstance(__dict__, property):

-            type_kwargs['__dict__'] = __dict__

-

-        save = self.save

-        write = self.write

-

-        # We write pickle instructions explicitly here to handle the

-        # possibility that the type object participates in a cycle with its own

-        # __dict__. We first write an empty "skeleton" version of the class and

-        # memoize it before writing the class' __dict__ itself. We then write

-        # instructions to "rehydrate" the skeleton class by restoring the

-        # attributes from the __dict__.

-        #

-        # A type can appear in a cycle with its __dict__ if an instance of the

-        # type appears in the type's __dict__ (which happens for the stdlib

-        # Enum class), or if the type defines methods that close over the name

-        # of the type, (which is common for Python 2-style super() calls).

-

-        # Push the rehydration function.

-        save(_rehydrate_skeleton_class)

-

-        # Mark the start of the args tuple for the rehydration function.

-        write(pickle.MARK)

-

-        # Create and memoize an skeleton class with obj's name and bases.

-        if Enum is not None and issubclass(obj, Enum):

-            # Special handling of Enum subclasses

-            self._save_dynamic_enum(obj, clsdict)

-        else:

-            # "Regular" class definition:

-            tp = type(obj)

-            self.save_reduce(_make_skeleton_class,

-                             (tp, obj.__name__, obj.__bases__, type_kwargs,

-                              _ensure_tracking(obj), None),

-                             obj=obj)

-

-        # Now save the rest of obj's __dict__. Any references to obj

-        # encountered while saving will point to the skeleton class.

-        save(clsdict)

-

-        # Write a tuple of (skeleton_class, clsdict).