Viewing file: test_abc.py (3.75 KB) -rw-r--r-- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
#!/usr/bin/env python """ 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 not type(instance) 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) # TODO should work like it does for non local classes # <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()
|