KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use deepcopy method in toolium

Best Python code snippet using toolium_python

test_copy.py

Source:test_copy.py

...151            def __eq__(self, other):152                return self.foo == other.foo153        x = C(42)154        self.assertEqual(copy.copy(x), x)155    # The deepcopy() method156    def test_deepcopy_basic(self):157        x = 42158        y = copy.deepcopy(x)159        self.assertEqual(y, x)160    def test_deepcopy_memo(self):161        # Tests of reflexive objects are under type-specific sections below.162        # This tests only repetitions of objects.163        x = []164        x = [x, x]165        y = copy.deepcopy(x)166        self.assertEqual(y, x)167        self.assertIsNot(y, x)168        self.assertIsNot(y[0], x[0])169        self.assertIs(y[0], y[1])170    def test_deepcopy_issubclass(self):171        # XXX Note: there's no way to test the TypeError coming out of172        # issubclass() -- this can only happen when an extension173        # module defines a "type" that doesn't formally inherit from174        # type.175        class Meta(type):176            pass177        class C(metaclass=Meta):178            pass179        self.assertEqual(copy.deepcopy(C), C)180    def test_deepcopy_deepcopy(self):181        class C(object):182            def __init__(self, foo):183                self.foo = foo184            def __deepcopy__(self, memo=None):185                return C(self.foo)186        x = C(42)187        y = copy.deepcopy(x)188        self.assertEqual(y.__class__, x.__class__)189        self.assertEqual(y.foo, x.foo)190    def test_deepcopy_registry(self):191        class C(object):192            def __new__(cls, foo):193                obj = object.__new__(cls)194                obj.foo = foo195                return obj196        def pickle_C(obj):197            return (C, (obj.foo,))198        x = C(42)199        self.assertRaises(TypeError, copy.deepcopy, x)200        copyreg.pickle(C, pickle_C, C)201        y = copy.deepcopy(x)202    def test_deepcopy_reduce_ex(self):203        class C(object):204            def __reduce_ex__(self, proto):205                c.append(1)206                return ""207            def __reduce__(self):208                self.fail("shouldn't call this")209        c = []210        x = C()211        y = copy.deepcopy(x)212        self.assertIs(y, x)213        self.assertEqual(c, [1])214    def test_deepcopy_reduce(self):215        class C(object):216            def __reduce__(self):217                c.append(1)218                return ""219        c = []220        x = C()221        y = copy.deepcopy(x)222        self.assertIs(y, x)223        self.assertEqual(c, [1])224    def test_deepcopy_cant(self):225        class C(object):226            def __getattribute__(self, name):227                if name.startswith("__reduce"):228                    raise AttributeError(name)229                return object.__getattribute__(self, name)230        x = C()231        self.assertRaises(copy.Error, copy.deepcopy, x)232    # Type-specific _deepcopy_xxx() methods233    def test_deepcopy_atomic(self):234        class Classic:235            pass236        class NewStyle(object):237            pass238        def f():239            pass240        tests = [None, 42, 2**100, 3.14, True, False, 1j,241                 "hello", "hello\u1234", f.__code__,242                 NewStyle, range(10), Classic, max]243        for x in tests:244            self.assertIs(copy.deepcopy(x), x)245    def test_deepcopy_list(self):246        x = [[1, 2], 3]247        y = copy.deepcopy(x)248        self.assertEqual(y, x)249        self.assertIsNot(x, y)250        self.assertIsNot(x[0], y[0])251    def test_deepcopy_reflexive_list(self):252        x = []253        x.append(x)254        y = copy.deepcopy(x)255        for op in comparisons:256            self.assertRaises(RuntimeError, op, y, x)257        self.assertIsNot(y, x)258        self.assertIs(y[0], y)259        self.assertEqual(len(y), 1)260    def test_deepcopy_empty_tuple(self):261        x = ()262        y = copy.deepcopy(x)263        self.assertIs(x, y)264    def test_deepcopy_tuple(self):265        x = ([1, 2], 3)266        y = copy.deepcopy(x)267        self.assertEqual(y, x)268        self.assertIsNot(x, y)269        self.assertIsNot(x[0], y[0])270    def test_deepcopy_tuple_of_immutables(self):271        x = ((1, 2), 3)272        y = copy.deepcopy(x)273        self.assertIs(x, y)274    def test_deepcopy_reflexive_tuple(self):275        x = ([],)276        x[0].append(x)277        y = copy.deepcopy(x)278        for op in comparisons:279            self.assertRaises(RuntimeError, op, y, x)280        self.assertIsNot(y, x)281        self.assertIsNot(y[0], x[0])282        self.assertIs(y[0][0], y)283    def test_deepcopy_dict(self):284        x = {"foo": [1, 2], "bar": 3}285        y = copy.deepcopy(x)286        self.assertEqual(y, x)287        self.assertIsNot(x, y)288        self.assertIsNot(x["foo"], y["foo"])289    def test_deepcopy_reflexive_dict(self):290        x = {}291        x['foo'] = x292        y = copy.deepcopy(x)293        for op in order_comparisons:294            self.assertRaises(TypeError, op, y, x)295        for op in equality_comparisons:296            self.assertRaises(RuntimeError, op, y, x)297        self.assertIsNot(y, x)298        self.assertIs(y['foo'], y)299        self.assertEqual(len(y), 1)300    def test_deepcopy_keepalive(self):301        memo = {}302        x = []303        y = copy.deepcopy(x, memo)304        self.assertIs(memo[id(memo)][0], x)305    def test_deepcopy_dont_memo_immutable(self):306        memo = {}307        x = [1, 2, 3, 4]308        y = copy.deepcopy(x, memo)309        self.assertEqual(y, x)310        # There's the entry for the new list, and the keep alive.311        self.assertEqual(len(memo), 2)312        memo = {}313        x = [(1, 2)]314        y = copy.deepcopy(x, memo)315        self.assertEqual(y, x)316        # Tuples with immutable contents are immutable for deepcopy.317        self.assertEqual(len(memo), 2)318    def test_deepcopy_inst_vanilla(self):319        class C:320            def __init__(self, foo):321                self.foo = foo322            def __eq__(self, other):323                return self.foo == other.foo324        x = C([42])325        y = copy.deepcopy(x)326        self.assertEqual(y, x)327        self.assertIsNot(y.foo, x.foo)328    def test_deepcopy_inst_deepcopy(self):329        class C:330            def __init__(self, foo):331                self.foo = foo332            def __deepcopy__(self, memo):333                return C(copy.deepcopy(self.foo, memo))334            def __eq__(self, other):335                return self.foo == other.foo336        x = C([42])337        y = copy.deepcopy(x)338        self.assertEqual(y, x)339        self.assertIsNot(y, x)340        self.assertIsNot(y.foo, x.foo)341    def test_deepcopy_inst_getinitargs(self):342        class C:343            def __init__(self, foo):344                self.foo = foo345            def __getinitargs__(self):346                return (self.foo,)347            def __eq__(self, other):348                return self.foo == other.foo349        x = C([42])350        y = copy.deepcopy(x)351        self.assertEqual(y, x)352        self.assertIsNot(y, x)353        self.assertIsNot(y.foo, x.foo)354    def test_deepcopy_inst_getstate(self):355        class C:356            def __init__(self, foo):357                self.foo = foo358            def __getstate__(self):359                return {"foo": self.foo}360            def __eq__(self, other):361                return self.foo == other.foo362        x = C([42])363        y = copy.deepcopy(x)364        self.assertEqual(y, x)365        self.assertIsNot(y, x)366        self.assertIsNot(y.foo, x.foo)367    def test_deepcopy_inst_setstate(self):368        class C:369            def __init__(self, foo):370                self.foo = foo371            def __setstate__(self, state):372                self.foo = state["foo"]373            def __eq__(self, other):374                return self.foo == other.foo375        x = C([42])376        y = copy.deepcopy(x)377        self.assertEqual(y, x)378        self.assertIsNot(y, x)379        self.assertIsNot(y.foo, x.foo)380    def test_deepcopy_inst_getstate_setstate(self):381        class C:382            def __init__(self, foo):383                self.foo = foo384            def __getstate__(self):385                return self.foo386            def __setstate__(self, state):387                self.foo = state388            def __eq__(self, other):389                return self.foo == other.foo390        x = C([42])391        y = copy.deepcopy(x)392        self.assertEqual(y, x)393        self.assertIsNot(y, x)394        self.assertIsNot(y.foo, x.foo)395    def test_deepcopy_reflexive_inst(self):396        class C:397            pass398        x = C()399        x.foo = x400        y = copy.deepcopy(x)401        self.assertIsNot(y, x)402        self.assertIs(y.foo, y)403    # _reconstruct()404    def test_reconstruct_string(self):405        class C(object):406            def __reduce__(self):407                return ""408        x = C()409        y = copy.copy(x)410        self.assertIs(y, x)411        y = copy.deepcopy(x)412        self.assertIs(y, x)413    def test_reconstruct_nostate(self):414        class C(object):415            def __reduce__(self):416                return (C, ())417        x = C()418        x.foo = 42419        y = copy.copy(x)420        self.assertIs(y.__class__, x.__class__)421        y = copy.deepcopy(x)422        self.assertIs(y.__class__, x.__class__)423    def test_reconstruct_state(self):424        class C(object):425            def __reduce__(self):426                return (C, (), self.__dict__)427            def __eq__(self, other):428                return self.__dict__ == other.__dict__429        x = C()430        x.foo = [42]431        y = copy.copy(x)432        self.assertEqual(y, x)433        y = copy.deepcopy(x)434        self.assertEqual(y, x)435        self.assertIsNot(y.foo, x.foo)436    def test_reconstruct_state_setstate(self):437        class C(object):438            def __reduce__(self):439                return (C, (), self.__dict__)440            def __setstate__(self, state):441                self.__dict__.update(state)442            def __eq__(self, other):443                return self.__dict__ == other.__dict__444        x = C()445        x.foo = [42]446        y = copy.copy(x)447        self.assertEqual(y, x)448        y = copy.deepcopy(x)449        self.assertEqual(y, x)450        self.assertIsNot(y.foo, x.foo)451    def test_reconstruct_reflexive(self):452        class C(object):453            pass454        x = C()455        x.foo = x456        y = copy.deepcopy(x)457        self.assertIsNot(y, x)458        self.assertIs(y.foo, y)459    # Additions for Python 2.3 and pickle protocol 2460    def test_reduce_4tuple(self):461        class C(list):462            def __reduce__(self):463                return (C, (), self.__dict__, iter(self))464            def __eq__(self, other):465                return (list(self) == list(other) and466                        self.__dict__ == other.__dict__)467        x = C([[1, 2], 3])468        y = copy.copy(x)469        self.assertEqual(x, y)470        self.assertIsNot(x, y)471        self.assertIs(x[0], y[0])472        y = copy.deepcopy(x)473        self.assertEqual(x, y)474        self.assertIsNot(x, y)475        self.assertIsNot(x[0], y[0])476    def test_reduce_5tuple(self):477        class C(dict):478            def __reduce__(self):479                return (C, (), self.__dict__, None, self.items())480            def __eq__(self, other):481                return (dict(self) == dict(other) and482                        self.__dict__ == other.__dict__)483        x = C([("foo", [1, 2]), ("bar", 3)])484        y = copy.copy(x)485        self.assertEqual(x, y)486        self.assertIsNot(x, y)487        self.assertIs(x["foo"], y["foo"])488        y = copy.deepcopy(x)489        self.assertEqual(x, y)490        self.assertIsNot(x, y)491        self.assertIsNot(x["foo"], y["foo"])492    def test_copy_slots(self):493        class C(object):494            __slots__ = ["foo"]495        x = C()496        x.foo = [42]497        y = copy.copy(x)498        self.assertIs(x.foo, y.foo)499    def test_deepcopy_slots(self):500        class C(object):501            __slots__ = ["foo"]502        x = C()503        x.foo = [42]504        y = copy.deepcopy(x)505        self.assertEqual(x.foo, y.foo)506        self.assertIsNot(x.foo, y.foo)507    def test_deepcopy_dict_subclass(self):508        class C(dict):509            def __init__(self, d=None):510                if not d:511                    d = {}512                self._keys = list(d.keys())513                super().__init__(d)514            def __setitem__(self, key, item):515                super().__setitem__(key, item)516                if key not in self._keys:517                    self._keys.append(key)518        x = C(d={'foo':0})519        y = copy.deepcopy(x)520        self.assertEqual(x, y)521        self.assertEqual(x._keys, y._keys)522        self.assertIsNot(x, y)523        x['bar'] = 1524        self.assertNotEqual(x, y)525        self.assertNotEqual(x._keys, y._keys)526    def test_copy_list_subclass(self):527        class C(list):528            pass529        x = C([[1, 2], 3])530        x.foo = [4, 5]531        y = copy.copy(x)532        self.assertEqual(list(x), list(y))533        self.assertEqual(x.foo, y.foo)534        self.assertIs(x[0], y[0])535        self.assertIs(x.foo, y.foo)536    def test_deepcopy_list_subclass(self):537        class C(list):538            pass539        x = C([[1, 2], 3])540        x.foo = [4, 5]541        y = copy.deepcopy(x)542        self.assertEqual(list(x), list(y))543        self.assertEqual(x.foo, y.foo)544        self.assertIsNot(x[0], y[0])545        self.assertIsNot(x.foo, y.foo)546    def test_copy_tuple_subclass(self):547        class C(tuple):548            pass549        x = C([1, 2, 3])550        self.assertEqual(tuple(x), (1, 2, 3))551        y = copy.copy(x)552        self.assertEqual(tuple(y), (1, 2, 3))553    def test_deepcopy_tuple_subclass(self):554        class C(tuple):555            pass556        x = C([[1, 2], 3])557        self.assertEqual(tuple(x), ([1, 2], 3))558        y = copy.deepcopy(x)559        self.assertEqual(tuple(y), ([1, 2], 3))560        self.assertIsNot(x, y)561        self.assertIsNot(x[0], y[0])562    def test_getstate_exc(self):563        class EvilState(object):564            def __getstate__(self):565                raise ValueError("ain't got no stickin' state")566        self.assertRaises(ValueError, copy.copy, EvilState())567    def test_copy_function(self):568        self.assertEqual(copy.copy(global_foo), global_foo)569        def foo(x, y): return x+y570        self.assertEqual(copy.copy(foo), foo)571        bar = lambda: None572        self.assertEqual(copy.copy(bar), bar)573    def test_deepcopy_function(self):574        self.assertEqual(copy.deepcopy(global_foo), global_foo)575        def foo(x, y): return x+y576        self.assertEqual(copy.deepcopy(foo), foo)577        bar = lambda: None578        self.assertEqual(copy.deepcopy(bar), bar)579    def _check_weakref(self, _copy):580        class C(object):581            pass582        obj = C()583        x = weakref.ref(obj)584        y = _copy(x)585        self.assertIs(y, x)586        del obj587        y = _copy(x)588        self.assertIs(y, x)589    def test_copy_weakref(self):590        self._check_weakref(copy.copy)591    def test_deepcopy_weakref(self):592        self._check_weakref(copy.deepcopy)593    def _check_copy_weakdict(self, _dicttype):594        class C(object):595            pass596        a, b, c, d = [C() for i in range(4)]597        u = _dicttype()598        u[a] = b599        u[c] = d600        v = copy.copy(u)601        self.assertIsNot(v, u)602        self.assertEqual(v, u)603        self.assertEqual(v[a], b)604        self.assertEqual(v[c], d)605        self.assertEqual(len(v), 2)606        del c, d607        self.assertEqual(len(v), 1)608        x, y = C(), C()609        # The underlying containers are decoupled610        v[x] = y611        self.assertNotIn(x, u)612    def test_copy_weakkeydict(self):613        self._check_copy_weakdict(weakref.WeakKeyDictionary)614    def test_copy_weakvaluedict(self):615        self._check_copy_weakdict(weakref.WeakValueDictionary)616    def test_deepcopy_weakkeydict(self):617        class C(object):618            def __init__(self, i):619                self.i = i620        a, b, c, d = [C(i) for i in range(4)]621        u = weakref.WeakKeyDictionary()622        u[a] = b623        u[c] = d624        # Keys aren't copied, values are625        v = copy.deepcopy(u)626        self.assertNotEqual(v, u)627        self.assertEqual(len(v), 2)628        self.assertIsNot(v[a], b)629        self.assertIsNot(v[c], d)630        self.assertEqual(v[a].i, b.i)631        self.assertEqual(v[c].i, d.i)632        del c633        self.assertEqual(len(v), 1)634    def test_deepcopy_weakvaluedict(self):635        class C(object):636            def __init__(self, i):637                self.i = i638        a, b, c, d = [C(i) for i in range(4)]639        u = weakref.WeakValueDictionary()640        u[a] = b641        u[c] = d642        # Keys are copied, values aren't643        v = copy.deepcopy(u)644        self.assertNotEqual(v, u)645        self.assertEqual(len(v), 2)646        (x, y), (z, t) = sorted(v.items(), key=lambda pair: pair[0].i)647        self.assertIsNot(x, a)648        self.assertEqual(x.i, a.i)649        self.assertIs(y, b)650        self.assertIsNot(z, c)651        self.assertEqual(z.i, c.i)652        self.assertIs(t, d)653        del x, y, z, t654        del d655        self.assertEqual(len(v), 1)656    def test_deepcopy_bound_method(self):657        class Foo(object):658            def m(self):659                pass660        f = Foo()661        f.b = f.m662        g = copy.deepcopy(f)663        self.assertEqual(g.m, g.b)664        self.assertIs(g.b.__self__, g)665        g.b()666def global_foo(x, y): return x+y667def test_main():668    support.run_unittest(TestCopy)669if __name__ == "__main__":...

copy.py

Source:copy.py

1"""Generic (shallow and deep) copying operations.2Interface summary:3        import copy4        x = copy.copy(y)        # make a shallow copy of y5        x = copy.deepcopy(y)    # make a deep copy of y6For module specific errors, copy.Error is raised.7The difference between shallow and deep copying is only relevant for8compound objects (objects that contain other objects, like lists or9class instances).10- A shallow copy constructs a new compound object and then (to the11  extent possible) inserts *the same objects* into it that the12  original contains.13- A deep copy constructs a new compound object and then, recursively,14  inserts *copies* into it of the objects found in the original.15Two problems often exist with deep copy operations that don't exist16with shallow copy operations:17 a) recursive objects (compound objects that, directly or indirectly,18    contain a reference to themselves) may cause a recursive loop19 b) because deep copy copies *everything* it may copy too much, e.g.20    administrative data structures that should be shared even between21    copies22Python's deep copy operation avoids these problems by:23 a) keeping a table of objects already copied during the current24    copying pass25 b) letting user-defined classes override the copying operation or the26    set of components copied27This version does not copy types like module, class, function, method,28nor stack trace, stack frame, nor file, socket, window, nor array, nor29any similar types.30Classes can use the same interfaces to control copying that they use31to control pickling: they can define methods called __getinitargs__(),32__getstate__() and __setstate__().  See the documentation for module33"pickle" for information on these methods.34"""35import types36import weakref37from copy_reg import dispatch_table38class Error(Exception):39    pass40error = Error   # backward compatibility41try:42    from org.python.core import PyStringMap43except ImportError:44    PyStringMap = None45__all__ = ["Error", "copy", "deepcopy"]46def copy(x):47    """Shallow copy operation on arbitrary Python objects.48    See the module's __doc__ string for more info.49    """50    cls = type(x)51    copier = _copy_dispatch.get(cls)52    if copier:53        return copier(x)54    copier = getattr(cls, "__copy__", None)55    if copier:56        return copier(x)57    reductor = dispatch_table.get(cls)58    if reductor:59        rv = reductor(x)60    else:61        reductor = getattr(x, "__reduce_ex__", None)62        if reductor:63            rv = reductor(2)64        else:65            reductor = getattr(x, "__reduce__", None)66            if reductor:67                rv = reductor()68            else:69                raise Error("un(shallow)copyable object of type %s" % cls)70    return _reconstruct(x, rv, 0)71_copy_dispatch = d = {}72def _copy_immutable(x):73    return x74for t in (type(None), int, long, float, bool, str, tuple,75          frozenset, type, xrange, types.ClassType,76          types.BuiltinFunctionType, type(Ellipsis),77          types.FunctionType, weakref.ref):78    d[t] = _copy_immutable79for name in ("ComplexType", "UnicodeType", "CodeType"):80    t = getattr(types, name, None)81    if t is not None:82        d[t] = _copy_immutable83def _copy_with_constructor(x):84    return type(x)(x)85for t in (list, dict, set):86    d[t] = _copy_with_constructor87def _copy_with_copy_method(x):88    return x.copy()89if PyStringMap is not None:90    d[PyStringMap] = _copy_with_copy_method91def _copy_inst(x):92    if hasattr(x, '__copy__'):93        return x.__copy__()94    if hasattr(x, '__getinitargs__'):95        args = x.__getinitargs__()96        y = x.__class__(*args)97    else:98        y = _EmptyClass()99        y.__class__ = x.__class__100    if hasattr(x, '__getstate__'):101        state = x.__getstate__()102    else:103        state = x.__dict__104    if hasattr(y, '__setstate__'):105        y.__setstate__(state)106    else:107        y.__dict__.update(state)108    return y109d[types.InstanceType] = _copy_inst110del d111def deepcopy(x, memo=None, _nil=[]):112    """Deep copy operation on arbitrary Python objects.113    See the module's __doc__ string for more info.114    """115    if memo is None:116        memo = {}117    d = id(x)118    y = memo.get(d, _nil)119    if y is not _nil:120        return y121    cls = type(x)122    copier = _deepcopy_dispatch.get(cls)123    if copier:124        y = copier(x, memo)125    else:126        try:127            issc = issubclass(cls, type)128        except TypeError: # cls is not a class (old Boost; see SF #502085)129            issc = 0130        if issc:131            y = _deepcopy_atomic(x, memo)132        else:133            copier = getattr(x, "__deepcopy__", None)134            if copier:135                y = copier(memo)136            else:137                reductor = dispatch_table.get(cls)138                if reductor:139                    rv = reductor(x)140                else:141                    reductor = getattr(x, "__reduce_ex__", None)142                    if reductor:143                        rv = reductor(2)144                    else:145                        reductor = getattr(x, "__reduce__", None)146                        if reductor:147                            rv = reductor()148                        else:149                            raise Error(150                                "un(deep)copyable object of type %s" % cls)151                y = _reconstruct(x, rv, 1, memo)152    memo[d] = y153    _keep_alive(x, memo) # Make sure x lives at least as long as d154    return y155_deepcopy_dispatch = d = {}156def _deepcopy_atomic(x, memo):157    return x158d[type(None)] = _deepcopy_atomic159d[type(Ellipsis)] = _deepcopy_atomic160d[int] = _deepcopy_atomic161d[long] = _deepcopy_atomic162d[float] = _deepcopy_atomic163d[bool] = _deepcopy_atomic164try:165    d[complex] = _deepcopy_atomic166except NameError:167    pass168d[str] = _deepcopy_atomic169try:170    d[unicode] = _deepcopy_atomic171except NameError:172    pass173try:174    d[types.CodeType] = _deepcopy_atomic175except AttributeError:176    pass177d[type] = _deepcopy_atomic178d[xrange] = _deepcopy_atomic179d[types.ClassType] = _deepcopy_atomic180d[types.BuiltinFunctionType] = _deepcopy_atomic181d[types.FunctionType] = _deepcopy_atomic182d[weakref.ref] = _deepcopy_atomic183def _deepcopy_list(x, memo):184    y = []185    memo[id(x)] = y186    for a in x:187        y.append(deepcopy(a, memo))188    return y189d[list] = _deepcopy_list190def _deepcopy_tuple(x, memo):191    y = []192    for a in x:193        y.append(deepcopy(a, memo))194    d = id(x)195    try:196        return memo[d]197    except KeyError:198        pass199    for i in range(len(x)):200        if x[i] is not y[i]:201            y = tuple(y)202            break203    else:204        y = x205    memo[d] = y206    return y207d[tuple] = _deepcopy_tuple208def _deepcopy_dict(x, memo):209    y = {}210    memo[id(x)] = y211    for key, value in x.iteritems():212        y[deepcopy(key, memo)] = deepcopy(value, memo)213    return y214d[dict] = _deepcopy_dict215if PyStringMap is not None:216    d[PyStringMap] = _deepcopy_dict217def _deepcopy_method(x, memo): # Copy instance methods218    return type(x)(x.im_func, deepcopy(x.im_self, memo), x.im_class)219_deepcopy_dispatch[types.MethodType] = _deepcopy_method220def _keep_alive(x, memo):221    """Keeps a reference to the object x in the memo.222    Because we remember objects by their id, we have223    to assure that possibly temporary objects are kept224    alive by referencing them.225    We store a reference at the id of the memo, which should226    normally not be used unless someone tries to deepcopy227    the memo itself...228    """229    try:230        memo[id(memo)].append(x)231    except KeyError:232        # aha, this is the first one :-)233        memo[id(memo)]=[x]234def _deepcopy_inst(x, memo):235    if hasattr(x, '__deepcopy__'):236        return x.__deepcopy__(memo)237    if hasattr(x, '__getinitargs__'):238        args = x.__getinitargs__()239        args = deepcopy(args, memo)240        y = x.__class__(*args)241    else:242        y = _EmptyClass()243        y.__class__ = x.__class__244    memo[id(x)] = y245    if hasattr(x, '__getstate__'):246        state = x.__getstate__()247    else:248        state = x.__dict__249    state = deepcopy(state, memo)250    if hasattr(y, '__setstate__'):251        y.__setstate__(state)252    else:253        y.__dict__.update(state)254    return y255d[types.InstanceType] = _deepcopy_inst256def _reconstruct(x, info, deep, memo=None):257    if isinstance(info, str):258        return x259    assert isinstance(info, tuple)260    if memo is None:261        memo = {}262    n = len(info)263    assert n in (2, 3, 4, 5)264    callable, args = info[:2]265    if n > 2:266        state = info[2]267    else:268        state = {}269    if n > 3:270        listiter = info[3]271    else:272        listiter = None273    if n > 4:274        dictiter = info[4]275    else:276        dictiter = None277    if deep:278        args = deepcopy(args, memo)279    y = callable(*args)280    memo[id(x)] = y281    if state:282        if deep:283            state = deepcopy(state, memo)284        if hasattr(y, '__setstate__'):285            y.__setstate__(state)286        else:287            if isinstance(state, tuple) and len(state) == 2:288                state, slotstate = state289            else:290                slotstate = None291            if state is not None:292                y.__dict__.update(state)293            if slotstate is not None:294                for key, value in slotstate.iteritems():295                    setattr(y, key, value)296    if listiter is not None:297        for item in listiter:298            if deep:299                item = deepcopy(item, memo)300            y.append(item)301    if dictiter is not None:302        for key, value in dictiter:303            if deep:304                key = deepcopy(key, memo)305                value = deepcopy(value, memo)306            y[key] = value307    return y308del d309del types310# Helper for instance creation without calling __init__311class _EmptyClass:312    pass313def _test():314    l = [None, 1, 2L, 3.14, 'xyzzy', (1, 2L), [3.14, 'abc'],315         {'abc': 'ABC'}, (), [], {}]316    l1 = copy(l)317    print l1==l318    l1 = map(copy, l)319    print l1==l320    l1 = deepcopy(l)321    print l1==l322    class C:323        def __init__(self, arg=None):324            self.a = 1325            self.arg = arg326            if __name__ == '__main__':327                import sys328                file = sys.argv[0]329            else:330                file = __file__331            self.fp = open(file)332            self.fp.close()333        def __getstate__(self):334            return {'a': self.a, 'arg': self.arg}335        def __setstate__(self, state):336            for key, value in state.iteritems():337                setattr(self, key, value)338        def __deepcopy__(self, memo=None):339            new = self.__class__(deepcopy(self.arg, memo))340            new.a = self.a341            return new342    c = C('argument sketch')343    l.append(c)344    l2 = copy(l)345    print l == l2346    print l347    print l2348    l2 = deepcopy(l)349    print l == l2350    print l351    print l2352    l.append({l[1]: l, 'xyz': l[2]})353    l3 = copy(l)354    import repr355    print map(repr.repr, l)356    print map(repr.repr, l1)357    print map(repr.repr, l2)358    print map(repr.repr, l3)359    l3 = deepcopy(l)360    import repr361    print map(repr.repr, l)362    print map(repr.repr, l1)363    print map(repr.repr, l2)364    print map(repr.repr, l3)365    class odict(dict):366        def __init__(self, d = {}):367            self.a = 99368            dict.__init__(self, d)369        def __setitem__(self, k, i):370            dict.__setitem__(self, k, i)371            self.a372    o = odict({"A" : "B"})373    x = deepcopy(o)374    print(o, x)375if __name__ == '__main__':...

oagis.js

Source:oagis.js

1require('./modules/utils').init(Object)2var BOD = exports.BOD = {3	ApplicationArea: {Sender: null, Receiver: null, CreationDateTime: null, BODID: null},4	DataArea: null5}6var AddressType = exports.AddressType = {7	ID: [],8	AttentionOfName: null,9	AddressLine: [],10	CityName: null,11	CountryCode: null12}13var LocationType = exports.LocationType = {14	ID: null,15	Address: {16		ID: [],17		AttentionOfName: null,18		AddressLine: [],19		CityName: null,20		CountryCode: null,21		PostalCode: null22	}23}24var ContactType = exports.ContactType = {25	Name: null,26	Communication: {27		UserArea: {28			Phone: "",29			Fax: "",30			Email: ""31		}32	}33}34var PartyType = exports.PartyType = {35	PartyIDs: {ID: []},36	AccountID: null,37	Name: null,38	Location: LocationType.deepCopy(),39	Contact: ContactType.deepCopy()40}41var CustomerPartyType = exports.CustomerPartyType = {42	PartyIDs: {ID: []},43	AccountID: null,44	Name: undefined,45	Location: LocationType.deepCopy(),46	Contact: ContactType.deepCopy(),47	CustomerAccountID: null48}49var SupplierPartyType = exports.SupplierPartyType = {50	PartyIDs: {ID: []},51	AccountID: null,52	Name: undefined,53	Location: LocationType.deepCopy(),54	Contact: ContactType.deepCopy(),55}56var HeaderType = exports.HeaderType = {57	DocumentID: {ID: null},58	DocumentReference: {DocumentID: {ID: null}},59	LastModificationDateTime: null,60	DocumentDateTime: null61}62var RequestHeaderType = exports.RequestHeaderType = HeaderType.deepCopy().extend({63	CustomerParty: CustomerPartyType.deepCopy(),64	SupplierParty: SupplierPartyType.deepCopy(),65	Description: [],66	Note: [],67	DocumentDateTime: null,68})69var RFQLineType = exports.RFQLineType = {70	LineNumber: null,71	DocumentReference: {72		SalesOrderReference: {LineNumber: null}73	},74	Description: null,75	Quantity: null,76	Quantity_unitCode: null77}78var RFQ = exports.RFQ = {79	RFQHeader: RequestHeaderType.deepCopy(),80	RFQLine: []81}82var SalesOrder = exports.SalesOrder = {83	SalesOrderHeader: RequestHeaderType.deepCopy(),84	SalesOrderLine: []85}86var QuoteLineType = exports.QuoteLineType = {87	LineNumber: null,88	DocumentReference: {89		SalesOrderReference: {LineNumber: null}90	},91	Description: null,92	Quantity: null,93	Quantity_unitCode: null,94	UnitPrice: {95		Amount: null,96		Amount_currencyID: null,97		PerQuantity: null,98		PerQuantity_unitCode: null99	},100	ExtendedAmount: null,101	ExtendedAmount_currencyID: null,102	TotalAmount: null,103	TotalAmount_currencyID: null104}105var Quote = exports.Quote = {106	QuoteHeader: RequestHeaderType.deepCopy().extend({107		DocumentReference: {108			SalesOrderReference: {DocumentID: {ID: null}}109		},110		RFQReference: {DocumentID: {ID: null}}111	}),112	QuoteLine: []113}114var PurchaseOrder = exports.PurchaseOrder = {115	PurchaseOrderHeader: RequestHeaderType.deepCopy(),116	PurchaseOrderLine: []117}118exports.ProcessRFQ = {119	name: "ProcessRFQ",120	ApplicationArea: {Sender: null, Receiver: null},121	DataArea: {122		RFQ: RFQ.deepCopy(),123		Process: null124	}125}126exports.ProcessQuote = {127	name: "ProcessQuote",128	ApplicationArea: {Sender: null, Receiver: null},129	DataArea: {130		Quote: Quote.deepCopy(),131		Process: null132	}133}134exports.ProcessSalesOrder = BOD.deepCopy().extend({135	name: "ProcessSalesOrder",136	DataArea: {137		Process: null,138		SalesOrder: SalesOrder.deepCopy()139	}140})141exports.SyncSalesOrder = BOD.deepCopy().extend({142	name: "SyncSalesOrder",143	DataArea: {144		Sync: null,145		SalesOrder: SalesOrder.deepCopy()146	}147})148exports.ProcessPurchaseOrder = BOD.deepCopy().extend({149	name: "ProcessPurchaseOrder",150	DataArea: {151		Process: null,152		PurchaseOrder: PurchaseOrder.deepCopy()153	}...

deepcopy_vx.x.x.js

Source:deepcopy_vx.x.x.js

1// flow-typed signature: 55fcd3edf9374214993f2d6b8478b1302// flow-typed version: <<STUB>>/deepcopy_v^0.6.3/flow_v0.68.03/**4 * This is an autogenerated libdef stub for:5 *6 *   'deepcopy'7 *8 * Fill this stub out by replacing all the `any` types.9 *10 * Once filled out, we encourage you to share your work with the11 * community by sending a pull request to:12 * https://github.com/flowtype/flow-typed13 */14declare module 'deepcopy' {15  declare module.exports: any;16}17/**18 * We include stubs for each file inside this npm package in case you need to19 * require those files directly. Feel free to delete any files that aren't20 * needed.21 */22declare module 'deepcopy/build/deepcopy' {23  declare module.exports: any;24}25declare module 'deepcopy/build/deepcopy.min' {26  declare module.exports: any;27}28declare module 'deepcopy/lib/copy' {29  declare module.exports: any;30}31declare module 'deepcopy/lib/index' {32  declare module.exports: any;33}34declare module 'deepcopy/lib/polyfill' {35  declare module.exports: any;36}37declare module 'deepcopy/src/copy' {38  declare module.exports: any;39}40declare module 'deepcopy/src/index' {41  declare module.exports: any;42}43declare module 'deepcopy/src/polyfill' {44  declare module.exports: any;45}46// Filename aliases47declare module 'deepcopy/build/deepcopy.js' {48  declare module.exports: $Exports<'deepcopy/build/deepcopy'>;49}50declare module 'deepcopy/build/deepcopy.min.js' {51  declare module.exports: $Exports<'deepcopy/build/deepcopy.min'>;52}53declare module 'deepcopy/index' {54  declare module.exports: $Exports<'deepcopy'>;55}56declare module 'deepcopy/index.js' {57  declare module.exports: $Exports<'deepcopy'>;58}59declare module 'deepcopy/lib/copy.js' {60  declare module.exports: $Exports<'deepcopy/lib/copy'>;61}62declare module 'deepcopy/lib/index.js' {63  declare module.exports: $Exports<'deepcopy/lib/index'>;64}65declare module 'deepcopy/lib/polyfill.js' {66  declare module.exports: $Exports<'deepcopy/lib/polyfill'>;67}68declare module 'deepcopy/src/copy.js' {69  declare module.exports: $Exports<'deepcopy/src/copy'>;70}71declare module 'deepcopy/src/index.js' {72  declare module.exports: $Exports<'deepcopy/src/index'>;73}74declare module 'deepcopy/src/polyfill.js' {75  declare module.exports: $Exports<'deepcopy/src/polyfill'>;...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.