--- /dev/null
+"""Generic (shallow and deep) copying operations.\r
+\r
+Interface summary:\r
+\r
+ import copy\r
+\r
+ x = copy.copy(y) # make a shallow copy of y\r
+ x = copy.deepcopy(y) # make a deep copy of y\r
+\r
+For module specific errors, copy.Error is raised.\r
+\r
+The difference between shallow and deep copying is only relevant for\r
+compound objects (objects that contain other objects, like lists or\r
+class instances).\r
+\r
+- A shallow copy constructs a new compound object and then (to the\r
+ extent possible) inserts *the same objects* into it that the\r
+ original contains.\r
+\r
+- A deep copy constructs a new compound object and then, recursively,\r
+ inserts *copies* into it of the objects found in the original.\r
+\r
+Two problems often exist with deep copy operations that don't exist\r
+with shallow copy operations:\r
+\r
+ a) recursive objects (compound objects that, directly or indirectly,\r
+ contain a reference to themselves) may cause a recursive loop\r
+\r
+ b) because deep copy copies *everything* it may copy too much, e.g.\r
+ administrative data structures that should be shared even between\r
+ copies\r
+\r
+Python's deep copy operation avoids these problems by:\r
+\r
+ a) keeping a table of objects already copied during the current\r
+ copying pass\r
+\r
+ b) letting user-defined classes override the copying operation or the\r
+ set of components copied\r
+\r
+This version does not copy types like module, class, function, method,\r
+nor stack trace, stack frame, nor file, socket, window, nor array, nor\r
+any similar types.\r
+\r
+Classes can use the same interfaces to control copying that they use\r
+to control pickling: they can define methods called __getinitargs__(),\r
+__getstate__() and __setstate__(). See the documentation for module\r
+"pickle" for information on these methods.\r
+"""\r
+\r
+import types\r
+import weakref\r
+from copy_reg import dispatch_table\r
+\r
+class Error(Exception):\r
+ pass\r
+error = Error # backward compatibility\r
+\r
+try:\r
+ from org.python.core import PyStringMap\r
+except ImportError:\r
+ PyStringMap = None\r
+\r
+__all__ = ["Error", "copy", "deepcopy"]\r
+\r
+def copy(x):\r
+ """Shallow copy operation on arbitrary Python objects.\r
+\r
+ See the module's __doc__ string for more info.\r
+ """\r
+\r
+ cls = type(x)\r
+\r
+ copier = _copy_dispatch.get(cls)\r
+ if copier:\r
+ return copier(x)\r
+\r
+ copier = getattr(cls, "__copy__", None)\r
+ if copier:\r
+ return copier(x)\r
+\r
+ reductor = dispatch_table.get(cls)\r
+ if reductor:\r
+ rv = reductor(x)\r
+ else:\r
+ reductor = getattr(x, "__reduce_ex__", None)\r
+ if reductor:\r
+ rv = reductor(2)\r
+ else:\r
+ reductor = getattr(x, "__reduce__", None)\r
+ if reductor:\r
+ rv = reductor()\r
+ else:\r
+ raise Error("un(shallow)copyable object of type %s" % cls)\r
+\r
+ return _reconstruct(x, rv, 0)\r
+\r
+\r
+_copy_dispatch = d = {}\r
+\r
+def _copy_immutable(x):\r
+ return x\r
+for t in (type(None), int, long, float, bool, str, tuple,\r
+ frozenset, type, xrange, types.ClassType,\r
+ types.BuiltinFunctionType, type(Ellipsis),\r
+ types.FunctionType, weakref.ref):\r
+ d[t] = _copy_immutable\r
+for name in ("ComplexType", "UnicodeType", "CodeType"):\r
+ t = getattr(types, name, None)\r
+ if t is not None:\r
+ d[t] = _copy_immutable\r
+\r
+def _copy_with_constructor(x):\r
+ return type(x)(x)\r
+for t in (list, dict, set):\r
+ d[t] = _copy_with_constructor\r
+\r
+def _copy_with_copy_method(x):\r
+ return x.copy()\r
+if PyStringMap is not None:\r
+ d[PyStringMap] = _copy_with_copy_method\r
+\r
+def _copy_inst(x):\r
+ if hasattr(x, '__copy__'):\r
+ return x.__copy__()\r
+ if hasattr(x, '__getinitargs__'):\r
+ args = x.__getinitargs__()\r
+ y = x.__class__(*args)\r
+ else:\r
+ y = _EmptyClass()\r
+ y.__class__ = x.__class__\r
+ if hasattr(x, '__getstate__'):\r
+ state = x.__getstate__()\r
+ else:\r
+ state = x.__dict__\r
+ if hasattr(y, '__setstate__'):\r
+ y.__setstate__(state)\r
+ else:\r
+ y.__dict__.update(state)\r
+ return y\r
+d[types.InstanceType] = _copy_inst\r
+\r
+del d\r
+\r
+def deepcopy(x, memo=None, _nil=[]):\r
+ """Deep copy operation on arbitrary Python objects.\r
+\r
+ See the module's __doc__ string for more info.\r
+ """\r
+\r
+ if memo is None:\r
+ memo = {}\r
+\r
+ d = id(x)\r
+ y = memo.get(d, _nil)\r
+ if y is not _nil:\r
+ return y\r
+\r
+ cls = type(x)\r
+\r
+ copier = _deepcopy_dispatch.get(cls)\r
+ if copier:\r
+ y = copier(x, memo)\r
+ else:\r
+ try:\r
+ issc = issubclass(cls, type)\r
+ except TypeError: # cls is not a class (old Boost; see SF #502085)\r
+ issc = 0\r
+ if issc:\r
+ y = _deepcopy_atomic(x, memo)\r
+ else:\r
+ copier = getattr(x, "__deepcopy__", None)\r
+ if copier:\r
+ y = copier(memo)\r
+ else:\r
+ reductor = dispatch_table.get(cls)\r
+ if reductor:\r
+ rv = reductor(x)\r
+ else:\r
+ reductor = getattr(x, "__reduce_ex__", None)\r
+ if reductor:\r
+ rv = reductor(2)\r
+ else:\r
+ reductor = getattr(x, "__reduce__", None)\r
+ if reductor:\r
+ rv = reductor()\r
+ else:\r
+ raise Error(\r
+ "un(deep)copyable object of type %s" % cls)\r
+ y = _reconstruct(x, rv, 1, memo)\r
+\r
+ memo[d] = y\r
+ _keep_alive(x, memo) # Make sure x lives at least as long as d\r
+ return y\r
+\r
+_deepcopy_dispatch = d = {}\r
+\r
+def _deepcopy_atomic(x, memo):\r
+ return x\r
+d[type(None)] = _deepcopy_atomic\r
+d[type(Ellipsis)] = _deepcopy_atomic\r
+d[int] = _deepcopy_atomic\r
+d[long] = _deepcopy_atomic\r
+d[float] = _deepcopy_atomic\r
+d[bool] = _deepcopy_atomic\r
+try:\r
+ d[complex] = _deepcopy_atomic\r
+except NameError:\r
+ pass\r
+d[str] = _deepcopy_atomic\r
+try:\r
+ d[unicode] = _deepcopy_atomic\r
+except NameError:\r
+ pass\r
+try:\r
+ d[types.CodeType] = _deepcopy_atomic\r
+except AttributeError:\r
+ pass\r
+d[type] = _deepcopy_atomic\r
+d[xrange] = _deepcopy_atomic\r
+d[types.ClassType] = _deepcopy_atomic\r
+d[types.BuiltinFunctionType] = _deepcopy_atomic\r
+d[types.FunctionType] = _deepcopy_atomic\r
+d[weakref.ref] = _deepcopy_atomic\r
+\r
+def _deepcopy_list(x, memo):\r
+ y = []\r
+ memo[id(x)] = y\r
+ for a in x:\r
+ y.append(deepcopy(a, memo))\r
+ return y\r
+d[list] = _deepcopy_list\r
+\r
+def _deepcopy_tuple(x, memo):\r
+ y = []\r
+ for a in x:\r
+ y.append(deepcopy(a, memo))\r
+ d = id(x)\r
+ try:\r
+ return memo[d]\r
+ except KeyError:\r
+ pass\r
+ for i in range(len(x)):\r
+ if x[i] is not y[i]:\r
+ y = tuple(y)\r
+ break\r
+ else:\r
+ y = x\r
+ memo[d] = y\r
+ return y\r
+d[tuple] = _deepcopy_tuple\r
+\r
+def _deepcopy_dict(x, memo):\r
+ y = {}\r
+ memo[id(x)] = y\r
+ for key, value in x.iteritems():\r
+ y[deepcopy(key, memo)] = deepcopy(value, memo)\r
+ return y\r
+d[dict] = _deepcopy_dict\r
+if PyStringMap is not None:\r
+ d[PyStringMap] = _deepcopy_dict\r
+\r
+def _deepcopy_method(x, memo): # Copy instance methods\r
+ return type(x)(x.im_func, deepcopy(x.im_self, memo), x.im_class)\r
+_deepcopy_dispatch[types.MethodType] = _deepcopy_method\r
+\r
+def _keep_alive(x, memo):\r
+ """Keeps a reference to the object x in the memo.\r
+\r
+ Because we remember objects by their id, we have\r
+ to assure that possibly temporary objects are kept\r
+ alive by referencing them.\r
+ We store a reference at the id of the memo, which should\r
+ normally not be used unless someone tries to deepcopy\r
+ the memo itself...\r
+ """\r
+ try:\r
+ memo[id(memo)].append(x)\r
+ except KeyError:\r
+ # aha, this is the first one :-)\r
+ memo[id(memo)]=[x]\r
+\r
+def _deepcopy_inst(x, memo):\r
+ if hasattr(x, '__deepcopy__'):\r
+ return x.__deepcopy__(memo)\r
+ if hasattr(x, '__getinitargs__'):\r
+ args = x.__getinitargs__()\r
+ args = deepcopy(args, memo)\r
+ y = x.__class__(*args)\r
+ else:\r
+ y = _EmptyClass()\r
+ y.__class__ = x.__class__\r
+ memo[id(x)] = y\r
+ if hasattr(x, '__getstate__'):\r
+ state = x.__getstate__()\r
+ else:\r
+ state = x.__dict__\r
+ state = deepcopy(state, memo)\r
+ if hasattr(y, '__setstate__'):\r
+ y.__setstate__(state)\r
+ else:\r
+ y.__dict__.update(state)\r
+ return y\r
+d[types.InstanceType] = _deepcopy_inst\r
+\r
+def _reconstruct(x, info, deep, memo=None):\r
+ if isinstance(info, str):\r
+ return x\r
+ assert isinstance(info, tuple)\r
+ if memo is None:\r
+ memo = {}\r
+ n = len(info)\r
+ assert n in (2, 3, 4, 5)\r
+ callable, args = info[:2]\r
+ if n > 2:\r
+ state = info[2]\r
+ else:\r
+ state = {}\r
+ if n > 3:\r
+ listiter = info[3]\r
+ else:\r
+ listiter = None\r
+ if n > 4:\r
+ dictiter = info[4]\r
+ else:\r
+ dictiter = None\r
+ if deep:\r
+ args = deepcopy(args, memo)\r
+ y = callable(*args)\r
+ memo[id(x)] = y\r
+\r
+ if state:\r
+ if deep:\r
+ state = deepcopy(state, memo)\r
+ if hasattr(y, '__setstate__'):\r
+ y.__setstate__(state)\r
+ else:\r
+ if isinstance(state, tuple) and len(state) == 2:\r
+ state, slotstate = state\r
+ else:\r
+ slotstate = None\r
+ if state is not None:\r
+ y.__dict__.update(state)\r
+ if slotstate is not None:\r
+ for key, value in slotstate.iteritems():\r
+ setattr(y, key, value)\r
+\r
+ if listiter is not None:\r
+ for item in listiter:\r
+ if deep:\r
+ item = deepcopy(item, memo)\r
+ y.append(item)\r
+ if dictiter is not None:\r
+ for key, value in dictiter:\r
+ if deep:\r
+ key = deepcopy(key, memo)\r
+ value = deepcopy(value, memo)\r
+ y[key] = value\r
+ return y\r
+\r
+del d\r
+\r
+del types\r
+\r
+# Helper for instance creation without calling __init__\r
+class _EmptyClass:\r
+ pass\r
+\r
+def _test():\r
+ l = [None, 1, 2L, 3.14, 'xyzzy', (1, 2L), [3.14, 'abc'],\r
+ {'abc': 'ABC'}, (), [], {}]\r
+ l1 = copy(l)\r
+ print l1==l\r
+ l1 = map(copy, l)\r
+ print l1==l\r
+ l1 = deepcopy(l)\r
+ print l1==l\r
+ class C:\r
+ def __init__(self, arg=None):\r
+ self.a = 1\r
+ self.arg = arg\r
+ if __name__ == '__main__':\r
+ import sys\r
+ file = sys.argv[0]\r
+ else:\r
+ file = __file__\r
+ self.fp = open(file)\r
+ self.fp.close()\r
+ def __getstate__(self):\r
+ return {'a': self.a, 'arg': self.arg}\r
+ def __setstate__(self, state):\r
+ for key, value in state.iteritems():\r
+ setattr(self, key, value)\r
+ def __deepcopy__(self, memo=None):\r
+ new = self.__class__(deepcopy(self.arg, memo))\r
+ new.a = self.a\r
+ return new\r
+ c = C('argument sketch')\r
+ l.append(c)\r
+ l2 = copy(l)\r
+ print l == l2\r
+ print l\r
+ print l2\r
+ l2 = deepcopy(l)\r
+ print l == l2\r
+ print l\r
+ print l2\r
+ l.append({l[1]: l, 'xyz': l[2]})\r
+ l3 = copy(l)\r
+ import repr\r
+ print map(repr.repr, l)\r
+ print map(repr.repr, l1)\r
+ print map(repr.repr, l2)\r
+ print map(repr.repr, l3)\r
+ l3 = deepcopy(l)\r
+ import repr\r
+ print map(repr.repr, l)\r
+ print map(repr.repr, l1)\r
+ print map(repr.repr, l2)\r
+ print map(repr.repr, l3)\r
+ class odict(dict):\r
+ def __init__(self, d = {}):\r
+ self.a = 99\r
+ dict.__init__(self, d)\r
+ def __setitem__(self, k, i):\r
+ dict.__setitem__(self, k, i)\r
+ self.a\r
+ o = odict({"A" : "B"})\r
+ x = deepcopy(o)\r
+ print(o, x)\r
+\r
+if __name__ == '__main__':\r
+ _test()\r
projects / mirror_edk2.git / blobdiff