Guido van Rossum | 4b8c6ea | 2000-02-04 15:39:30 +0000 | [diff] [blame] | 1 | """Generic (shallow and deep) copying operations. |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 2 | |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 3 | Interface summary: |
| 4 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 5 | import copy |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 6 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 7 | x = copy.copy(y) # make a shallow copy of y |
| 8 | x = copy.deepcopy(y) # make a deep copy of y |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 9 | |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 10 | For module specific errors, copy.Error is raised. |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 11 | |
| 12 | The difference between shallow and deep copying is only relevant for |
| 13 | compound objects (objects that contain other objects, like lists or |
| 14 | class instances). |
| 15 | |
| 16 | - A shallow copy constructs a new compound object and then (to the |
Raymond Hettinger | f9d88ab | 2005-06-13 01:10:15 +0000 | [diff] [blame] | 17 | extent possible) inserts *the same objects* into it that the |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 18 | original contains. |
| 19 | |
| 20 | - A deep copy constructs a new compound object and then, recursively, |
| 21 | inserts *copies* into it of the objects found in the original. |
| 22 | |
| 23 | Two problems often exist with deep copy operations that don't exist |
| 24 | with shallow copy operations: |
| 25 | |
Guido van Rossum | f7cea10 | 1997-05-28 19:31:14 +0000 | [diff] [blame] | 26 | a) recursive objects (compound objects that, directly or indirectly, |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 27 | contain a reference to themselves) may cause a recursive loop |
| 28 | |
Guido van Rossum | f7cea10 | 1997-05-28 19:31:14 +0000 | [diff] [blame] | 29 | b) because deep copy copies *everything* it may copy too much, e.g. |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 30 | administrative data structures that should be shared even between |
| 31 | copies |
| 32 | |
| 33 | Python's deep copy operation avoids these problems by: |
| 34 | |
Guido van Rossum | f7cea10 | 1997-05-28 19:31:14 +0000 | [diff] [blame] | 35 | a) keeping a table of objects already copied during the current |
| 36 | copying pass |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 37 | |
Guido van Rossum | f7cea10 | 1997-05-28 19:31:14 +0000 | [diff] [blame] | 38 | b) letting user-defined classes override the copying operation or the |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 39 | set of components copied |
| 40 | |
| 41 | This version does not copy types like module, class, function, method, |
| 42 | nor stack trace, stack frame, nor file, socket, window, nor array, nor |
| 43 | any similar types. |
| 44 | |
| 45 | Classes can use the same interfaces to control copying that they use |
| 46 | to control pickling: they can define methods called __getinitargs__(), |
Guido van Rossum | c5d2d51 | 1997-12-07 16:18:22 +0000 | [diff] [blame] | 47 | __getstate__() and __setstate__(). See the documentation for module |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 48 | "pickle" for information on these methods. |
| 49 | """ |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 50 | |
| 51 | import types |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 52 | import weakref |
Alexandre Vassalotti | f7fa63d | 2008-05-11 08:55:36 +0000 | [diff] [blame] | 53 | from copyreg import dispatch_table |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 54 | |
Fred Drake | 227b120 | 2000-08-17 05:06:49 +0000 | [diff] [blame] | 55 | class Error(Exception): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 56 | pass |
| 57 | error = Error # backward compatibility |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 58 | |
Guido van Rossum | f8baad0 | 2000-11-27 21:53:14 +0000 | [diff] [blame] | 59 | try: |
| 60 | from org.python.core import PyStringMap |
| 61 | except ImportError: |
| 62 | PyStringMap = None |
| 63 | |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 64 | __all__ = ["Error", "copy", "deepcopy"] |
Skip Montanaro | e99d5ea | 2001-01-20 19:54:20 +0000 | [diff] [blame] | 65 | |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 66 | def copy(x): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 67 | """Shallow copy operation on arbitrary Python objects. |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 68 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 69 | See the module's __doc__ string for more info. |
| 70 | """ |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 71 | |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 72 | cls = type(x) |
| 73 | |
| 74 | copier = _copy_dispatch.get(cls) |
| 75 | if copier: |
| 76 | return copier(x) |
| 77 | |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 78 | if issubclass(cls, type): |
Alexandre Vassalotti | 5c1c3b4 | 2013-12-01 13:25:26 -0800 | [diff] [blame] | 79 | # treat it as a regular class: |
| 80 | return _copy_immutable(x) |
| 81 | |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 82 | copier = getattr(cls, "__copy__", None) |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 83 | if copier is not None: |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 84 | return copier(x) |
| 85 | |
| 86 | reductor = dispatch_table.get(cls) |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 87 | if reductor is not None: |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 88 | rv = reductor(x) |
| 89 | else: |
| 90 | reductor = getattr(x, "__reduce_ex__", None) |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 91 | if reductor is not None: |
Serhiy Storchaka | 32af754 | 2015-03-24 18:06:42 +0200 | [diff] [blame] | 92 | rv = reductor(4) |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 93 | else: |
| 94 | reductor = getattr(x, "__reduce__", None) |
| 95 | if reductor: |
| 96 | rv = reductor() |
| 97 | else: |
| 98 | raise Error("un(shallow)copyable object of type %s" % cls) |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 99 | |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 100 | if isinstance(rv, str): |
| 101 | return x |
| 102 | return _reconstruct(x, None, *rv) |
Tim Peters | f2715e0 | 2003-02-19 02:35:07 +0000 | [diff] [blame] | 103 | |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 104 | |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 105 | _copy_dispatch = d = {} |
| 106 | |
Raymond Hettinger | f0e3569 | 2004-03-08 05:59:33 +0000 | [diff] [blame] | 107 | def _copy_immutable(x): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 108 | return x |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 109 | for t in (type(None), int, float, bool, complex, str, tuple, |
| 110 | bytes, frozenset, type, range, slice, |
| 111 | types.BuiltinFunctionType, type(Ellipsis), type(NotImplemented), |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 112 | types.FunctionType, weakref.ref): |
Raymond Hettinger | f0e3569 | 2004-03-08 05:59:33 +0000 | [diff] [blame] | 113 | d[t] = _copy_immutable |
Guido van Rossum | 1325790 | 2007-06-07 23:15:56 +0000 | [diff] [blame] | 114 | t = getattr(types, "CodeType", None) |
| 115 | if t is not None: |
| 116 | d[t] = _copy_immutable |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 117 | |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 118 | d[list] = list.copy |
| 119 | d[dict] = dict.copy |
| 120 | d[set] = set.copy |
| 121 | d[bytearray] = bytearray.copy |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 122 | |
Guido van Rossum | f8baad0 | 2000-11-27 21:53:14 +0000 | [diff] [blame] | 123 | if PyStringMap is not None: |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 124 | d[PyStringMap] = PyStringMap.copy |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 125 | |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 126 | del d, t |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 127 | |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 128 | def deepcopy(x, memo=None, _nil=[]): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 129 | """Deep copy operation on arbitrary Python objects. |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 130 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 131 | See the module's __doc__ string for more info. |
| 132 | """ |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 133 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 134 | if memo is None: |
| 135 | memo = {} |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 136 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 137 | d = id(x) |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 138 | y = memo.get(d, _nil) |
| 139 | if y is not _nil: |
| 140 | return y |
| 141 | |
| 142 | cls = type(x) |
| 143 | |
| 144 | copier = _deepcopy_dispatch.get(cls) |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 145 | if copier is not None: |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 146 | y = copier(x, memo) |
| 147 | else: |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 148 | if issubclass(cls, type): |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 149 | y = _deepcopy_atomic(x, memo) |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 150 | else: |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 151 | copier = getattr(x, "__deepcopy__", None) |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 152 | if copier is not None: |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 153 | y = copier(memo) |
| 154 | else: |
| 155 | reductor = dispatch_table.get(cls) |
| 156 | if reductor: |
| 157 | rv = reductor(x) |
| 158 | else: |
| 159 | reductor = getattr(x, "__reduce_ex__", None) |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 160 | if reductor is not None: |
Serhiy Storchaka | 32af754 | 2015-03-24 18:06:42 +0200 | [diff] [blame] | 161 | rv = reductor(4) |
Guido van Rossum | e690883 | 2003-02-19 01:19:28 +0000 | [diff] [blame] | 162 | else: |
| 163 | reductor = getattr(x, "__reduce__", None) |
| 164 | if reductor: |
| 165 | rv = reductor() |
| 166 | else: |
| 167 | raise Error( |
| 168 | "un(deep)copyable object of type %s" % cls) |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 169 | if isinstance(rv, str): |
| 170 | y = x |
| 171 | else: |
| 172 | y = _reconstruct(x, memo, *rv) |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 173 | |
Benjamin Peterson | e90ec36 | 2011-06-27 16:22:46 -0500 | [diff] [blame] | 174 | # If is its own copy, don't memoize. |
| 175 | if y is not x: |
| 176 | memo[d] = y |
| 177 | _keep_alive(x, memo) # Make sure x lives at least as long as d |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 178 | return y |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 179 | |
| 180 | _deepcopy_dispatch = d = {} |
| 181 | |
| 182 | def _deepcopy_atomic(x, memo): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 183 | return x |
Raymond Hettinger | f715366 | 2005-02-07 14:16:21 +0000 | [diff] [blame] | 184 | d[type(None)] = _deepcopy_atomic |
Christian Heimes | cc47b05 | 2008-03-25 14:56:36 +0000 | [diff] [blame] | 185 | d[type(Ellipsis)] = _deepcopy_atomic |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 186 | d[type(NotImplemented)] = _deepcopy_atomic |
Raymond Hettinger | f715366 | 2005-02-07 14:16:21 +0000 | [diff] [blame] | 187 | d[int] = _deepcopy_atomic |
Raymond Hettinger | f715366 | 2005-02-07 14:16:21 +0000 | [diff] [blame] | 188 | d[float] = _deepcopy_atomic |
| 189 | d[bool] = _deepcopy_atomic |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 190 | d[complex] = _deepcopy_atomic |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 191 | d[bytes] = _deepcopy_atomic |
Raymond Hettinger | f715366 | 2005-02-07 14:16:21 +0000 | [diff] [blame] | 192 | d[str] = _deepcopy_atomic |
Berker Peksag | 2708578 | 2018-07-09 23:14:54 +0300 | [diff] [blame] | 193 | d[types.CodeType] = _deepcopy_atomic |
Raymond Hettinger | f715366 | 2005-02-07 14:16:21 +0000 | [diff] [blame] | 194 | d[type] = _deepcopy_atomic |
Martin v. Löwis | ba8f5ff | 2003-06-14 07:10:06 +0000 | [diff] [blame] | 195 | d[types.BuiltinFunctionType] = _deepcopy_atomic |
Guido van Rossum | 1968ad3 | 2006-02-25 22:38:04 +0000 | [diff] [blame] | 196 | d[types.FunctionType] = _deepcopy_atomic |
Antoine Pitrou | 6e61006 | 2009-05-15 17:04:50 +0000 | [diff] [blame] | 197 | d[weakref.ref] = _deepcopy_atomic |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 198 | |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 199 | def _deepcopy_list(x, memo, deepcopy=deepcopy): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 200 | y = [] |
| 201 | memo[id(x)] = y |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 202 | append = y.append |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 203 | for a in x: |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 204 | append(deepcopy(a, memo)) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 205 | return y |
Raymond Hettinger | f715366 | 2005-02-07 14:16:21 +0000 | [diff] [blame] | 206 | d[list] = _deepcopy_list |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 207 | |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 208 | def _deepcopy_tuple(x, memo, deepcopy=deepcopy): |
Benjamin Peterson | 4ce5f3f | 2014-05-03 20:22:00 -0400 | [diff] [blame] | 209 | y = [deepcopy(a, memo) for a in x] |
Benjamin Peterson | e90ec36 | 2011-06-27 16:22:46 -0500 | [diff] [blame] | 210 | # We're not going to put the tuple in the memo, but it's still important we |
| 211 | # check for it, in case the tuple contains recursive mutable structures. |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 212 | try: |
Benjamin Peterson | e90ec36 | 2011-06-27 16:22:46 -0500 | [diff] [blame] | 213 | return memo[id(x)] |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 214 | except KeyError: |
| 215 | pass |
Benjamin Peterson | 4ce5f3f | 2014-05-03 20:22:00 -0400 | [diff] [blame] | 216 | for k, j in zip(x, y): |
| 217 | if k is not j: |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 218 | y = tuple(y) |
| 219 | break |
| 220 | else: |
| 221 | y = x |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 222 | return y |
Raymond Hettinger | f715366 | 2005-02-07 14:16:21 +0000 | [diff] [blame] | 223 | d[tuple] = _deepcopy_tuple |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 224 | |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 225 | def _deepcopy_dict(x, memo, deepcopy=deepcopy): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 226 | y = {} |
| 227 | memo[id(x)] = y |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 228 | for key, value in x.items(): |
Raymond Hettinger | e0d4972 | 2002-06-02 18:55:56 +0000 | [diff] [blame] | 229 | y[deepcopy(key, memo)] = deepcopy(value, memo) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 230 | return y |
Raymond Hettinger | f715366 | 2005-02-07 14:16:21 +0000 | [diff] [blame] | 231 | d[dict] = _deepcopy_dict |
Guido van Rossum | f8baad0 | 2000-11-27 21:53:14 +0000 | [diff] [blame] | 232 | if PyStringMap is not None: |
| 233 | d[PyStringMap] = _deepcopy_dict |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 234 | |
Antoine Pitrou | 1fc0d2b | 2009-11-28 15:58:27 +0000 | [diff] [blame] | 235 | def _deepcopy_method(x, memo): # Copy instance methods |
| 236 | return type(x)(x.__func__, deepcopy(x.__self__, memo)) |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 237 | d[types.MethodType] = _deepcopy_method |
| 238 | |
| 239 | del d |
Antoine Pitrou | 1fc0d2b | 2009-11-28 15:58:27 +0000 | [diff] [blame] | 240 | |
Guido van Rossum | 558be28 | 1997-08-20 22:26:19 +0000 | [diff] [blame] | 241 | def _keep_alive(x, memo): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 242 | """Keeps a reference to the object x in the memo. |
Guido van Rossum | 558be28 | 1997-08-20 22:26:19 +0000 | [diff] [blame] | 243 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 244 | Because we remember objects by their id, we have |
| 245 | to assure that possibly temporary objects are kept |
| 246 | alive by referencing them. |
| 247 | We store a reference at the id of the memo, which should |
| 248 | normally not be used unless someone tries to deepcopy |
| 249 | the memo itself... |
| 250 | """ |
| 251 | try: |
| 252 | memo[id(memo)].append(x) |
| 253 | except KeyError: |
| 254 | # aha, this is the first one :-) |
| 255 | memo[id(memo)]=[x] |
Guido van Rossum | 558be28 | 1997-08-20 22:26:19 +0000 | [diff] [blame] | 256 | |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 257 | def _reconstruct(x, memo, func, args, |
| 258 | state=None, listiter=None, dictiter=None, |
| 259 | deepcopy=deepcopy): |
| 260 | deep = memo is not None |
| 261 | if deep and args: |
| 262 | args = (deepcopy(arg, memo) for arg in args) |
| 263 | y = func(*args) |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 264 | if deep: |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 265 | memo[id(x)] = y |
Antoine Pitrou | 3941a8f | 2010-09-04 17:40:21 +0000 | [diff] [blame] | 266 | |
Serhiy Storchaka | cbbec1c | 2015-11-30 17:20:02 +0200 | [diff] [blame] | 267 | if state is not None: |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 268 | if deep: |
Guido van Rossum | 1e91c14 | 2001-12-28 21:33:22 +0000 | [diff] [blame] | 269 | state = deepcopy(state, memo) |
Guido van Rossum | 3e3583c | 2002-06-06 17:41:20 +0000 | [diff] [blame] | 270 | if hasattr(y, '__setstate__'): |
| 271 | y.__setstate__(state) |
| 272 | else: |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 273 | if isinstance(state, tuple) and len(state) == 2: |
| 274 | state, slotstate = state |
| 275 | else: |
| 276 | slotstate = None |
| 277 | if state is not None: |
| 278 | y.__dict__.update(state) |
| 279 | if slotstate is not None: |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 280 | for key, value in slotstate.items(): |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 281 | setattr(y, key, value) |
Antoine Pitrou | 3941a8f | 2010-09-04 17:40:21 +0000 | [diff] [blame] | 282 | |
| 283 | if listiter is not None: |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 284 | if deep: |
| 285 | for item in listiter: |
Antoine Pitrou | 3941a8f | 2010-09-04 17:40:21 +0000 | [diff] [blame] | 286 | item = deepcopy(item, memo) |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 287 | y.append(item) |
| 288 | else: |
| 289 | for item in listiter: |
| 290 | y.append(item) |
Antoine Pitrou | 3941a8f | 2010-09-04 17:40:21 +0000 | [diff] [blame] | 291 | if dictiter is not None: |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 292 | if deep: |
| 293 | for key, value in dictiter: |
Antoine Pitrou | 3941a8f | 2010-09-04 17:40:21 +0000 | [diff] [blame] | 294 | key = deepcopy(key, memo) |
| 295 | value = deepcopy(value, memo) |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 296 | y[key] = value |
| 297 | else: |
| 298 | for key, value in dictiter: |
| 299 | y[key] = value |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 300 | return y |
| 301 | |
Serhiy Storchaka | 818e18d | 2016-03-06 14:56:57 +0200 | [diff] [blame] | 302 | del types, weakref, PyStringMap |