ok
Mini Shell
#!/usr/bin/env python
#
# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
# Copyright (c) 2008-2016 California Institute of Technology.
# Copyright (c) 2016-2023 The Uncertainty Quantification Foundation.
# License: 3-clause BSD. The full license text is available at:
# - https://github.com/uqfoundation/dill/blob/master/LICENSE
import dill
from enum import EnumMeta
import sys
dill.settings['recurse'] = True
# test classdefs
class _class:
def _method(self):
pass
def ok(self):
return True
class _class2:
def __call__(self):
pass
def ok(self):
return True
class _newclass(object):
def _method(self):
pass
def ok(self):
return True
class _newclass2(object):
def __call__(self):
pass
def ok(self):
return True
class _meta(type):
pass
def __call__(self):
pass
def ok(self):
return True
_mclass = _meta("_mclass", (object,), {"__call__": __call__, "ok": ok})
del __call__
del ok
o = _class()
oc = _class2()
n = _newclass()
nc = _newclass2()
m = _mclass()
if sys.hexversion < 0x03090000:
import typing
class customIntList(typing.List[int]):
pass
else:
class customIntList(list[int]):
pass
# test pickles for class instances
def test_class_instances():
assert dill.pickles(o)
assert dill.pickles(oc)
assert dill.pickles(n)
assert dill.pickles(nc)
assert dill.pickles(m)
def test_class_objects():
clslist = [_class,_class2,_newclass,_newclass2,_mclass]
objlist = [o,oc,n,nc,m]
_clslist = [dill.dumps(obj) for obj in clslist]
_objlist = [dill.dumps(obj) for obj in objlist]
for obj in clslist:
globals().pop(obj.__name__)
del clslist
for obj in ['o','oc','n','nc']:
globals().pop(obj)
del objlist
del obj
for obj,cls in zip(_objlist,_clslist):
_cls = dill.loads(cls)
_obj = dill.loads(obj)
assert _obj.ok()
assert _cls.ok(_cls())
if _cls.__name__ == "_mclass":
assert type(_cls).__name__ == "_meta"
# test NoneType
def test_specialtypes():
assert dill.pickles(type(None))
assert dill.pickles(type(NotImplemented))
assert dill.pickles(type(Ellipsis))
assert dill.pickles(type(EnumMeta))
from collections import namedtuple
Z = namedtuple("Z", ['a','b'])
Zi = Z(0,1)
X = namedtuple("Y", ['a','b'])
X.__name__ = "X"
X.__qualname__ = "X" #XXX: name must 'match' or fails to pickle
Xi = X(0,1)
Bad = namedtuple("FakeName", ['a','b'])
Badi = Bad(0,1)
Defaults = namedtuple('Defaults', ['x', 'y'], defaults=[1])
Defaultsi = Defaults(2)
# test namedtuple
def test_namedtuple():
assert Z is dill.loads(dill.dumps(Z))
assert Zi == dill.loads(dill.dumps(Zi))
assert X is dill.loads(dill.dumps(X))
assert Xi == dill.loads(dill.dumps(Xi))
assert Defaults is dill.loads(dill.dumps(Defaults))
assert Defaultsi == dill.loads(dill.dumps(Defaultsi))
assert Bad is not dill.loads(dill.dumps(Bad))
assert Bad._fields == dill.loads(dill.dumps(Bad))._fields
assert tuple(Badi) == tuple(dill.loads(dill.dumps(Badi)))
class A:
class B(namedtuple("C", ["one", "two"])):
'''docstring'''
B.__module__ = 'testing'
a = A()
assert dill.copy(a)
assert dill.copy(A.B).__name__ == 'B'
assert dill.copy(A.B).__qualname__.endswith('.<locals>.A.B')
assert dill.copy(A.B).__doc__ == 'docstring'
assert dill.copy(A.B).__module__ == 'testing'
from typing import NamedTuple
def A():
class B(NamedTuple):
x: int
return B
assert type(dill.copy(A()(8))).__qualname__ == type(A()(8)).__qualname__
def test_dtype():
try:
import numpy as np
dti = np.dtype('int')
assert np.dtype == dill.copy(np.dtype)
assert dti == dill.copy(dti)
except ImportError: pass
def test_array_nested():
try:
import numpy as np
x = np.array([1])
y = (x,)
assert y == dill.copy(y)
except ImportError: pass
def test_array_subclass():
try:
import numpy as np
class TestArray(np.ndarray):
def __new__(cls, input_array, color):
obj = np.asarray(input_array).view(cls)
obj.color = color
return obj
def __array_finalize__(self, obj):
if obj is None:
return
if isinstance(obj, type(self)):
self.color = obj.color
def __getnewargs__(self):
return np.asarray(self), self.color
a1 = TestArray(np.zeros(100), color='green')
if not dill._dill.IS_PYPY:
assert dill.pickles(a1)
assert a1.__dict__ == dill.copy(a1).__dict__
a2 = a1[0:9]
if not dill._dill.IS_PYPY:
assert dill.pickles(a2)
assert a2.__dict__ == dill.copy(a2).__dict__
class TestArray2(np.ndarray):
color = 'blue'
a3 = TestArray2([1,2,3,4,5])
a3.color = 'green'
if not dill._dill.IS_PYPY:
assert dill.pickles(a3)
assert a3.__dict__ == dill.copy(a3).__dict__
except ImportError: pass
def test_method_decorator():
class A(object):
@classmethod
def test(cls):
pass
a = A()
res = dill.dumps(a)
new_obj = dill.loads(res)
new_obj.__class__.test()
# test slots
class Y(object):
__slots__ = ('y', '__weakref__')
def __init__(self, y):
self.y = y
value = 123
y = Y(value)
class Y2(object):
__slots__ = 'y'
def __init__(self, y):
self.y = y
def test_slots():
assert dill.pickles(Y)
assert dill.pickles(y)
assert dill.pickles(Y.y)
assert dill.copy(y).y == value
assert dill.copy(Y2(value)).y == value
def test_origbases():
assert dill.copy(customIntList).__orig_bases__ == customIntList.__orig_bases__
def test_attr():
import attr
@attr.s
class A:
a = attr.ib()
v = A(1)
assert dill.copy(v) == v
def test_metaclass():
class metaclass_with_new(type):
def __new__(mcls, name, bases, ns, **kwds):
cls = super().__new__(mcls, name, bases, ns, **kwds)
assert mcls is not None
assert cls.method(mcls)
return cls
def method(cls, mcls):
return isinstance(cls, mcls)
l = locals()
exec("""class subclass_with_new(metaclass=metaclass_with_new):
def __new__(cls):
self = super().__new__(cls)
return self""", None, l)
subclass_with_new = l['subclass_with_new']
assert dill.copy(subclass_with_new())
def test_enummeta():
from http import HTTPStatus
import enum
assert dill.copy(HTTPStatus.OK) is HTTPStatus.OK
assert dill.copy(enum.EnumMeta) is enum.EnumMeta
if __name__ == '__main__':
test_class_instances()
test_class_objects()
test_specialtypes()
test_namedtuple()
test_dtype()
test_array_nested()
test_array_subclass()
test_method_decorator()
test_slots()
test_origbases()
test_metaclass()
test_enummeta()
Zerion Mini Shell 1.0