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