diff -r deb02a2cd24b Lib/copy.py --- a/Lib/copy.py Tue Mar 15 18:37:51 2011 -0400 +++ b/Lib/copy.py Wed Mar 16 12:32:19 2011 -0400 @@ -73,26 +73,23 @@ cls = type(x) copier = _copy_dispatch.get(cls) - if copier: + if copier is not None: return copier(x) copier = getattr(cls, "__copy__", None) - if copier: + if copier is not None: return copier(x) reductor = dispatch_table.get(cls) - if reductor: + if reductor is not None: rv = reductor(x) else: reductor = getattr(x, "__reduce_ex__", None) - if reductor: + if reductor is not None: + # note that object.__reduce_ex__ calls __reduce__ rv = reductor(2) else: - reductor = getattr(x, "__reduce__", None) - if reductor: - rv = reductor() - else: - raise Error("un(shallow)copyable object of type %s" % cls) + raise Error("un(shallow)copyable object of type %s" % cls) return _reconstruct(x, rv, 0) @@ -106,9 +103,7 @@ types.BuiltinFunctionType, type(Ellipsis), types.FunctionType, weakref.ref): d[t] = _copy_immutable -t = getattr(types, "CodeType", None) -if t is not None: - d[t] = _copy_immutable +d[types.CodeType] = _copy_immutable for name in ("complex", "unicode"): t = getattr(builtins, name, None) if t is not None: @@ -119,10 +114,10 @@ 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 +if PyStringMap is not None: # pragma: no cover + def _copy_with_copy_method(x): + return x.copy() + d[PyStringMap] = _copy_with_copy_method # for Jython del d @@ -143,34 +138,26 @@ cls = type(x) copier = _deepcopy_dispatch.get(cls) - if copier: + if copier is not None: 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: + if issubclass(cls, type): y = _deepcopy_atomic(x, memo) else: copier = getattr(x, "__deepcopy__", None) - if copier: + if copier is not None: y = copier(memo) else: reductor = dispatch_table.get(cls) - if reductor: + if reductor is not None: rv = reductor(x) else: reductor = getattr(x, "__reduce_ex__", None) - if reductor: + if reductor is not None: + # note that object.__reduce_ex__ calls __reduce__ rv = reductor(2) else: - reductor = getattr(x, "__reduce__", None) - if reductor: - rv = reductor() - else: - raise Error( - "un(deep)copyable object of type %s" % cls) + raise Error("un(deep)copyable object of type %s" % cls) y = _reconstruct(x, rv, 1, memo) memo[d] = y @@ -186,16 +173,10 @@ d[int] = _deepcopy_atomic d[float] = _deepcopy_atomic d[bool] = _deepcopy_atomic -try: - d[complex] = _deepcopy_atomic -except NameError: - pass +d[complex] = _deepcopy_atomic d[bytes] = _deepcopy_atomic d[str] = _deepcopy_atomic -try: - d[types.CodeType] = _deepcopy_atomic -except AttributeError: - pass +d[types.CodeType] = _deepcopy_atomic d[type] = _deepcopy_atomic d[range] = _deepcopy_atomic d[types.BuiltinFunctionType] = _deepcopy_atomic @@ -211,6 +192,8 @@ d[list] = _deepcopy_list def _deepcopy_tuple(x, memo): + if not x: + return x y = [] for a in x: y.append(deepcopy(a, memo)) @@ -236,7 +219,7 @@ y[deepcopy(key, memo)] = deepcopy(value, memo) return y d[dict] = _deepcopy_dict -if PyStringMap is not None: +if PyStringMap is not None: # pragma: no cover d[PyStringMap] = _deepcopy_dict def _deepcopy_method(x, memo): # Copy instance methods @@ -288,8 +271,9 @@ if state: if deep: state = deepcopy(state, memo) - if hasattr(y, '__setstate__'): - y.__setstate__(state) + setstate = getattr(y, '__setstate__', None) + if setstate is not None: + setstate(state) else: if isinstance(state, tuple) and len(state) == 2: state, slotstate = state @@ -321,68 +305,3 @@ # Helper for instance creation without calling __init__ class _EmptyClass: pass - -def _test(): - l = [None, 1, 2, 3.14, 'xyzzy', (1, 2), [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.items(): - 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 reprlib - print(map(reprlib.repr, l)) - print(map(reprlib.repr, l1)) - print(map(reprlib.repr, l2)) - print(map(reprlib.repr, l3)) - l3 = deepcopy(l) - print(map(reprlib.repr, l)) - print(map(reprlib.repr, l1)) - print(map(reprlib.repr, l2)) - print(map(reprlib.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() diff -r deb02a2cd24b Lib/test/test_copy.py --- a/Lib/test/test_copy.py Tue Mar 15 18:37:51 2011 -0400 +++ b/Lib/test/test_copy.py Wed Mar 16 12:32:19 2011 -0400 @@ -54,20 +54,26 @@ def test_copy_reduce_ex(self): class C(object): def __reduce_ex__(self, proto): + c.append(1) return "" def __reduce__(self): raise support.TestFailed("shouldn't call this") + c = [] x = C() y = copy.copy(x) self.assertTrue(y is x) + self.assertEqual(c, [1]) def test_copy_reduce(self): class C(object): def __reduce__(self): + c.append(1) return "" + c = [] x = C() y = copy.copy(x) self.assertTrue(y is x) + self.assertEqual(c, [1]) def test_copy_cant(self): class C(object): @@ -227,20 +233,26 @@ def test_deepcopy_reduce_ex(self): class C(object): def __reduce_ex__(self, proto): + c.append(1) return "" def __reduce__(self): raise support.TestFailed("shouldn't call this") + c = [] x = C() y = copy.deepcopy(x) self.assertTrue(y is x) + self.assertEqual(c, [1]) def test_deepcopy_reduce(self): class C(object): def __reduce__(self): + c.append(1) return "" + c = [] x = C() y = copy.deepcopy(x) self.assertTrue(y is x) + self.assertEqual(c, [1]) def test_deepcopy_cant(self): class C(object): @@ -283,6 +295,11 @@ self.assertTrue(y[0] is y) self.assertEqual(len(y), 1) + def test_deepcopy_empty_tuple(self): + x = () + y = copy.deepcopy(x) + self.assertTrue(x is y) + def test_deepcopy_tuple(self): x = ([1, 2], 3) y = copy.deepcopy(x) @@ -290,6 +307,11 @@ self.assertTrue(x is not y) self.assertTrue(x[0] is not y[0]) + def test_deepcopy_tuple_of_immutables(self): + x = ((1, 2), 3) + y = copy.deepcopy(x) + self.assertTrue(x is y) + def test_deepcopy_reflexive_tuple(self): x = ([],) x[0].append(x)