File size: 4,227 Bytes
c58af2c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 |
#!/usr/bin/env python
#
# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
# Copyright (c) 2023-2024 The Uncertainty Quantification Foundation.
# License: 3-clause BSD. The full license text is available at:
# - https://github.com/uqfoundation/dill/blob/master/LICENSE
"""
test dill's ability to pickle abstract base class objects
"""
import dill
import abc
from abc import ABC
import warnings
from types import FunctionType
dill.settings['recurse'] = True
class OneTwoThree(ABC):
@abc.abstractmethod
def foo(self):
"""A method"""
pass
@property
@abc.abstractmethod
def bar(self):
"""Property getter"""
pass
@bar.setter
@abc.abstractmethod
def bar(self, value):
"""Property setter"""
pass
@classmethod
@abc.abstractmethod
def cfoo(cls):
"""Class method"""
pass
@staticmethod
@abc.abstractmethod
def sfoo():
"""Static method"""
pass
class EasyAsAbc(OneTwoThree):
def __init__(self):
self._bar = None
def foo(self):
return "Instance Method FOO"
@property
def bar(self):
return self._bar
@bar.setter
def bar(self, value):
self._bar = value
@classmethod
def cfoo(cls):
return "Class Method CFOO"
@staticmethod
def sfoo():
return "Static Method SFOO"
def test_abc_non_local():
assert dill.copy(OneTwoThree) is not OneTwoThree
assert dill.copy(EasyAsAbc) is not EasyAsAbc
with warnings.catch_warnings():
warnings.simplefilter("ignore", dill.PicklingWarning)
assert dill.copy(OneTwoThree, byref=True) is OneTwoThree
assert dill.copy(EasyAsAbc, byref=True) is EasyAsAbc
instance = EasyAsAbc()
# Set a property that StockPickle can't preserve
instance.bar = lambda x: x**2
depickled = dill.copy(instance)
assert type(depickled) is type(instance) #NOTE: issue #612, test_abc_local
#NOTE: dill.copy of local (or non-local) classes should (not) be the same?
assert type(depickled.bar) is FunctionType
assert depickled.bar(3) == 9
assert depickled.sfoo() == "Static Method SFOO"
assert depickled.cfoo() == "Class Method CFOO"
assert depickled.foo() == "Instance Method FOO"
def test_abc_local():
"""
Test using locally scoped ABC class
"""
class LocalABC(ABC):
@abc.abstractmethod
def foo(self):
pass
def baz(self):
return repr(self)
labc = dill.copy(LocalABC)
assert labc is not LocalABC
assert type(labc) is type(LocalABC)
#NOTE: dill.copy of local (or non-local) classes should (not) be the same?
# <class '__main__.LocalABC'>
# <class '__main__.test_abc_local.<locals>.LocalABC'>
class Real(labc):
def foo(self):
return "True!"
def baz(self):
return "My " + super(Real, self).baz()
real = Real()
assert real.foo() == "True!"
try:
labc()
except TypeError as e:
# Expected error
pass
else:
print('Failed to raise type error')
assert False
labc2, pik = dill.copy((labc, Real()))
assert 'Real' == type(pik).__name__
assert '.Real' in type(pik).__qualname__
assert type(pik) is not Real
assert labc2 is not LocalABC
assert labc2 is not labc
assert isinstance(pik, labc2)
assert not isinstance(pik, labc)
assert not isinstance(pik, LocalABC)
assert pik.baz() == "My " + repr(pik)
def test_meta_local_no_cache():
"""
Test calling metaclass and cache registration
"""
LocalMetaABC = abc.ABCMeta('LocalMetaABC', (), {})
class ClassyClass:
pass
class KlassyClass:
pass
LocalMetaABC.register(ClassyClass)
assert not issubclass(KlassyClass, LocalMetaABC)
assert issubclass(ClassyClass, LocalMetaABC)
res = dill.dumps((LocalMetaABC, ClassyClass, KlassyClass))
lmabc, cc, kc = dill.loads(res)
assert type(lmabc) == type(LocalMetaABC)
assert not issubclass(kc, lmabc)
assert issubclass(cc, lmabc)
if __name__ == '__main__':
test_abc_non_local()
test_abc_local()
test_meta_local_no_cache()
|