omdev 0.0.0.dev416__py3-none-any.whl → 0.0.0.dev500__py3-none-any.whl

omdev/manifests/_dumping.py

@@ -34,11 +34,28 @@ if sys.version_info < (3, 8):
     raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
 
 
+def __omlish_amalg__():  # noqa
+    return dict(
+        src_files=[
+            dict(path='../../omlish/lite/abstract.py', sha1='a2fc3f3697fa8de5247761e9d554e70176f37aac'),
+            dict(path='../../omlish/lite/cached.py', sha1='0c33cf961ac8f0727284303c7a30c5ea98f714f2'),
+            dict(path='../../omlish/lite/check.py', sha1='bb6b6b63333699b84462951a854d99ae83195b94'),
+            dict(path='../../omlish/lite/objects.py', sha1='9566bbf3530fd71fcc56321485216b592fae21e9'),
+            dict(path='../../omlish/lite/reflect.py', sha1='c4fec44bf144e9d93293c996af06f6c65fc5e63d'),
+            dict(path='../../omlish/lite/strings.py', sha1='89831ecbc34ad80e118a865eceb390ed399dc4d6'),
+            dict(path='../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
+            dict(path='dumping.py', sha1='49acd06fdcc3427f4a255fea295d7042bb655a13'),
+        ],
+    )
+
+
 ########################################
 
 
-# ../../omlish/lite/cached.py
+# ../../omlish/lite/abstract.py
 T = ta.TypeVar('T')
+
+# ../../omlish/lite/cached.py
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 # ../../omlish/lite/check.py
@@ -50,6 +67,153 @@ CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
 CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
 
+########################################
+# ../../../omlish/lite/abstract.py
+
+
+##
+
+
+_ABSTRACT_METHODS_ATTR = '__abstractmethods__'
+_IS_ABSTRACT_METHOD_ATTR = '__isabstractmethod__'
+
+
+def is_abstract_method(obj: ta.Any) -> bool:
+    return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
+
+
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
+    if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
+        # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
+        # implementation (especially during testing), and we want to handle both cases.
+        return cls
+
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
+    return cls
+
+
+#
+
+
+class AbstractTypeError(TypeError):
+    pass
+
+
+_FORCE_ABSTRACT_ATTR = '__forceabstract__'
+
+
+class Abstract:
+    """
+    Different from, but interoperable with, abc.ABC / abc.ABCMeta:
+
+     - This raises AbstractTypeError during class creation, not instance instantiation - unless Abstract or abc.ABC are
+       explicitly present in the class's direct bases.
+     - This will forbid instantiation of classes with Abstract in their direct bases even if there are no
+       abstractmethods left on the class.
+     - This is a mixin, not a metaclass.
+     - As it is not an ABCMeta, this does not support virtual base classes. As a result, operations like `isinstance`
+       and `issubclass` are ~7x faster.
+     - It additionally enforces a base class order of (Abstract, abc.ABC) to preemptively prevent common mro conflicts.
+
+    If not mixed-in with an ABCMeta, it will update __abstractmethods__ itself.
+    """
+
+    __slots__ = ()
+
+    __abstractmethods__: ta.ClassVar[ta.FrozenSet[str]] = frozenset()
+
+    #
+
+    def __forceabstract__(self):
+        raise TypeError
+
+    # This is done manually, rather than through @abc.abstractmethod, to mask it from static analysis.
+    setattr(__forceabstract__, _IS_ABSTRACT_METHOD_ATTR, True)
+
+    #
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        setattr(
+            cls,
+            _FORCE_ABSTRACT_ATTR,
+            getattr(Abstract, _FORCE_ABSTRACT_ATTR) if Abstract in cls.__bases__ else False,
+        )
+
+        super().__init_subclass__(**kwargs)
+
+        if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
+
+                raise AbstractTypeError(
+                    f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
+                    ', '.join(sorted([
+                        '.'.join([
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
+                            a,
+                        ])
+                        for a in ams
+                        for c in [amd.get(a)]
+                    ])),
+                )
+
+        xbi = (Abstract, abc.ABC)  # , ta.Generic ?
+        bis = [(cls.__bases__.index(b), b) for b in xbi if b in cls.__bases__]
+        if bis != sorted(bis):
+            raise TypeError(
+                f'Abstract subclass {cls.__name__} must have proper base class order of '
+                f'({", ".join(getattr(b, "__name__") for b in xbi)}), got: '
+                f'({", ".join(getattr(b, "__name__") for _, b in sorted(bis))})',
+            )
+
+        if not isinstance(cls, abc.ABCMeta):
+            update_abstracts(cls, force=True)
+
+
 ########################################
 # ../../../omlish/lite/cached.py
 
@@ -68,7 +232,7 @@ class _AbstractCachedNullary:
     def __call__(self, *args, **kwargs):  # noqa
         raise TypeError
 
-    def __get__(self, instance, owner):  # noqa
+    def __get__(self, instance, owner=None):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 
@@ -107,6 +271,62 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
     return _AsyncCachedNullary(fn)
 
 
+##
+
+
+cached_property = functools.cached_property
+
+
+class _cached_property:  # noqa
+    """Backported to pick up https://github.com/python/cpython/commit/056dfc71dce15f81887f0bd6da09d6099d71f979 ."""
+
+    def __init__(self, func):
+        self.func = func
+        self.attrname = None  # noqa
+        self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
+
+    _NOT_FOUND = object()
+
+    def __set_name__(self, owner, name):
+        if self.attrname is None:
+            self.attrname = name  # noqa
+        elif name != self.attrname:
+            raise TypeError(
+                f'Cannot assign the same cached_property to two different names ({self.attrname!r} and {name!r}).',
+            )
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.attrname is None:
+            raise TypeError('Cannot use cached_property instance without calling __set_name__ on it.')
+
+        try:
+            cache = instance.__dict__
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            raise TypeError(
+                f"No '__dict__' attribute on {type(instance).__name__!r} instance to cache {self.attrname!r} property.",
+            ) from None
+
+        val = cache.get(self.attrname, self._NOT_FOUND)
+
+        if val is self._NOT_FOUND:
+            val = self.func(instance)
+            try:
+                cache[self.attrname] = val
+            except TypeError:
+                raise TypeError(
+                    f"The '__dict__' attribute on {type(instance).__name__!r} instance does not support item "
+                    f"assignment for caching {self.attrname!r} property.",
+                ) from None
+
+        return val
+
+
+globals()['cached_property'] = _cached_property
+
+
 ########################################
 # ../../../omlish/lite/check.py
 """
@@ -598,6 +818,86 @@ class Checks:
 check = Checks()
 
 
+########################################
+# ../../../omlish/lite/objects.py
+
+
+##
+
+
+def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
+    seen = set()
+    todo = list(reversed(cls.__subclasses__()))
+    while todo:
+        cur = todo.pop()
+        if cur in seen:
+            continue
+        seen.add(cur)
+        yield cur
+        todo.extend(reversed(cur.__subclasses__()))
+
+
+##
+
+
+def mro_owner_dict(
+        instance_cls: type,
+        owner_cls: ta.Optional[type] = None,
+        *,
+        bottom_up_key_order: bool = False,
+        sort_keys: bool = False,
+) -> ta.Mapping[str, ta.Tuple[type, ta.Any]]:
+    if owner_cls is None:
+        owner_cls = instance_cls
+
+    mro = instance_cls.__mro__[-2::-1]
+    try:
+        pos = mro.index(owner_cls)
+    except ValueError:
+        raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}') from None
+
+    dct: ta.Dict[str, ta.Tuple[type, ta.Any]] = {}
+    if not bottom_up_key_order:
+        for cur_cls in mro[:pos + 1][::-1]:
+            for k, v in cur_cls.__dict__.items():
+                if k not in dct:
+                    dct[k] = (cur_cls, v)
+
+    else:
+        for cur_cls in mro[:pos + 1]:
+            dct.update({k: (cur_cls, v) for k, v in cur_cls.__dict__.items()})
+
+    if sort_keys:
+        dct = dict(sorted(dct.items(), key=lambda t: t[0]))
+
+    return dct
+
+
+def mro_dict(
+        instance_cls: type,
+        owner_cls: ta.Optional[type] = None,
+        *,
+        bottom_up_key_order: bool = False,
+        sort_keys: bool = False,
+) -> ta.Mapping[str, ta.Any]:
+    return {
+        k: v
+        for k, (o, v) in mro_owner_dict(
+            instance_cls,
+            owner_cls,
+            bottom_up_key_order=bottom_up_key_order,
+            sort_keys=sort_keys,
+        ).items()
+    }
+
+
+def dir_dict(o: ta.Any) -> ta.Dict[str, ta.Any]:
+    return {
+        a: getattr(o, a)
+        for a in dir(o)
+    }
+
+
 ########################################
 # ../../../omlish/lite/reflect.py
 
@@ -687,21 +987,6 @@ def get_literal_type_args(spec: ta.Any) -> ta.Iterable[ta.Any]:
     return spec.__args__
 
 
-##
-
-
-def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
-    seen = set()
-    todo = list(reversed(cls.__subclasses__()))
-    while todo:
-        cur = todo.pop()
-        if cur in seen:
-            continue
-        seen.add(cur)
-        yield cur
-        todo.extend(reversed(cur.__subclasses__()))
-
-
 ########################################
 # ../../../omlish/lite/strings.py
 
@@ -778,13 +1063,6 @@ def split_keep_delimiter(s, d):
 ##
 
 
-def attr_repr(obj: ta.Any, *attrs: str) -> str:
-    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
-
-
-##
-
-
 FORMAT_NUM_BYTES_SUFFIXES: ta.Sequence[str] = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB']
 
 
@@ -818,7 +1096,7 @@ class ObjMarshalOptions:
     non_strict_fields: bool = False
 
 
-class ObjMarshaler(abc.ABC):
+class ObjMarshaler(Abstract):
     @abc.abstractmethod
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         raise NotImplementedError
@@ -836,26 +1114,30 @@ class NopObjMarshaler(ObjMarshaler):
         return o
 
 
-@dc.dataclass()
 class ProxyObjMarshaler(ObjMarshaler):
-    m: ta.Optional[ObjMarshaler] = None
+    def __init__(self, m: ta.Optional[ObjMarshaler] = None) -> None:
+        super().__init__()
+
+        self._m = m
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check.not_none(self.m).marshal(o, ctx)
+        return check.not_none(self._m).marshal(o, ctx)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check.not_none(self.m).unmarshal(o, ctx)
+        return check.not_none(self._m).unmarshal(o, ctx)
 
 
-@dc.dataclass(frozen=True)
 class CastObjMarshaler(ObjMarshaler):
-    ty: type
+    def __init__(self, ty: type) -> None:
+        super().__init__()
+
+        self._ty = ty
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(o)
+        return self._ty(o)
 
 
 class DynamicObjMarshaler(ObjMarshaler):
@@ -866,121 +1148,151 @@ class DynamicObjMarshaler(ObjMarshaler):
         return o
 
 
-@dc.dataclass(frozen=True)
 class Base64ObjMarshaler(ObjMarshaler):
-    ty: type
+    def __init__(self, ty: type) -> None:
+        super().__init__()
+
+        self._ty = ty
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return base64.b64encode(o).decode('ascii')
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(base64.b64decode(o))
+        return self._ty(base64.b64decode(o))
 
 
-@dc.dataclass(frozen=True)
 class BytesSwitchedObjMarshaler(ObjMarshaler):
-    m: ObjMarshaler
+    def __init__(self, m: ObjMarshaler) -> None:
+        super().__init__()
+
+        self._m = m
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         if ctx.options.raw_bytes:
             return o
-        return self.m.marshal(o, ctx)
+        return self._m.marshal(o, ctx)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         if ctx.options.raw_bytes:
             return o
-        return self.m.unmarshal(o, ctx)
+        return self._m.unmarshal(o, ctx)
 
 
-@dc.dataclass(frozen=True)
 class EnumObjMarshaler(ObjMarshaler):
-    ty: type
+    def __init__(self, ty: type) -> None:
+        super().__init__()
+
+        self._ty = ty
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o.name
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty.__members__[o]  # type: ignore
+        return self._ty.__members__[o]  # type: ignore
 
 
-@dc.dataclass(frozen=True)
 class OptionalObjMarshaler(ObjMarshaler):
-    item: ObjMarshaler
+    def __init__(self, item: ObjMarshaler) -> None:
+        super().__init__()
+
+        self._item = item
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         if o is None:
             return None
-        return self.item.marshal(o, ctx)
+        return self._item.marshal(o, ctx)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         if o is None:
             return None
-        return self.item.unmarshal(o, ctx)
+        return self._item.unmarshal(o, ctx)
 
 
-@dc.dataclass(frozen=True)
 class PrimitiveUnionObjMarshaler(ObjMarshaler):
-    pt: ta.Tuple[type, ...]
-    x: ta.Optional[ObjMarshaler] = None
+    def __init__(
+            self,
+            pt: ta.Tuple[type, ...],
+            x: ta.Optional[ObjMarshaler] = None,
+    ) -> None:
+        super().__init__()
+
+        self._pt = pt
+        self._x = x
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if isinstance(o, self.pt):
+        if isinstance(o, self._pt):
             return o
-        elif self.x is not None:
-            return self.x.marshal(o, ctx)
+        elif self._x is not None:
+            return self._x.marshal(o, ctx)
         else:
             raise TypeError(o)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if isinstance(o, self.pt):
+        if isinstance(o, self._pt):
             return o
-        elif self.x is not None:
-            return self.x.unmarshal(o, ctx)
+        elif self._x is not None:
+            return self._x.unmarshal(o, ctx)
         else:
             raise TypeError(o)
 
 
-@dc.dataclass(frozen=True)
 class LiteralObjMarshaler(ObjMarshaler):
-    item: ObjMarshaler
-    vs: frozenset
+    def __init__(
+            self,
+            item: ObjMarshaler,
+            vs: frozenset,
+    ) -> None:
+        super().__init__()
+
+        self._item = item
+        self._vs = vs
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.item.marshal(check.in_(o, self.vs), ctx)
+        return self._item.marshal(check.in_(o, self._vs), ctx)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check.in_(self.item.unmarshal(o, ctx), self.vs)
+        return check.in_(self._item.unmarshal(o, ctx), self._vs)
 
 
-@dc.dataclass(frozen=True)
 class MappingObjMarshaler(ObjMarshaler):
-    ty: type
-    km: ObjMarshaler
-    vm: ObjMarshaler
+    def __init__(
+            self,
+            ty: type,
+            km: ObjMarshaler,
+            vm: ObjMarshaler,
+    ) -> None:
+        super().__init__()
+
+        self._ty = ty
+        self._km = km
+        self._vm = vm
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return {self.km.marshal(k, ctx): self.vm.marshal(v, ctx) for k, v in o.items()}
+        return {self._km.marshal(k, ctx): self._vm.marshal(v, ctx) for k, v in o.items()}
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty((self.km.unmarshal(k, ctx), self.vm.unmarshal(v, ctx)) for k, v in o.items())
+        return self._ty((self._km.unmarshal(k, ctx), self._vm.unmarshal(v, ctx)) for k, v in o.items())
 
 
-@dc.dataclass(frozen=True)
 class IterableObjMarshaler(ObjMarshaler):
-    ty: type
-    item: ObjMarshaler
+    def __init__(
+            self,
+            ty: type,
+            item: ObjMarshaler,
+    ) -> None:
+        super().__init__()
+
+        self._ty = ty
+        self._item = item
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return [self.item.marshal(e, ctx) for e in o]
+        return [self._item.marshal(e, ctx) for e in o]
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(self.item.unmarshal(e, ctx) for e in o)
+        return self._ty(self._item.unmarshal(e, ctx) for e in o)
 
 
-@dc.dataclass(frozen=True)
 class FieldsObjMarshaler(ObjMarshaler):
-    ty: type
-
     @dc.dataclass(frozen=True)
     class Field:
         att: str
@@ -989,31 +1301,43 @@ class FieldsObjMarshaler(ObjMarshaler):
 
         omit_if_none: bool = False
 
-    fs: ta.Sequence[Field]
-
-    non_strict: bool = False
-
-    #
+    def __init__(
+            self,
+            ty: type,
+            fs: ta.Sequence[Field],
+            *,
+            non_strict: bool = False,
+    ) -> None:
+        super().__init__()
 
-    _fs_by_att: ta.ClassVar[ta.Mapping[str, Field]]
-    _fs_by_key: ta.ClassVar[ta.Mapping[str, Field]]
+        self._ty = ty
+        self._fs = fs
+        self._non_strict = non_strict
 
-    def __post_init__(self) -> None:
         fs_by_att: dict = {}
         fs_by_key: dict = {}
-        for f in self.fs:
+        for f in self._fs:
             check.not_in(check.non_empty_str(f.att), fs_by_att)
             check.not_in(check.non_empty_str(f.key), fs_by_key)
             fs_by_att[f.att] = f
             fs_by_key[f.key] = f
-        self.__dict__['_fs_by_att'] = fs_by_att
-        self.__dict__['_fs_by_key'] = fs_by_key
+
+        self._fs_by_att: ta.Mapping[str, FieldsObjMarshaler.Field] = fs_by_att
+        self._fs_by_key: ta.Mapping[str, FieldsObjMarshaler.Field] = fs_by_key
+
+    @property
+    def ty(self) -> type:
+        return self._ty
+
+    @property
+    def fs(self) -> ta.Sequence[Field]:
+        return self._fs
 
     #
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         d = {}
-        for f in self.fs:
+        for f in self._fs:
             mv = f.m.marshal(getattr(o, f.att), ctx)
             if mv is None and f.omit_if_none:
                 continue
@@ -1024,34 +1348,46 @@ class FieldsObjMarshaler(ObjMarshaler):
         kw = {}
         for k, v in o.items():
             if (f := self._fs_by_key.get(k)) is None:
-                if not (self.non_strict or ctx.options.non_strict_fields):
+                if not (self._non_strict or ctx.options.non_strict_fields):
                     raise KeyError(k)
                 continue
             kw[f.att] = f.m.unmarshal(v, ctx)
-        return self.ty(**kw)
+        return self._ty(**kw)
 
 
-@dc.dataclass(frozen=True)
 class SingleFieldObjMarshaler(ObjMarshaler):
-    ty: type
-    fld: str
+    def __init__(
+            self,
+            ty: type,
+            fld: str,
+    ) -> None:
+        super().__init__()
+
+        self._ty = ty
+        self._fld = fld
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return getattr(o, self.fld)
+        return getattr(o, self._fld)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(**{self.fld: o})
+        return self._ty(**{self._fld: o})
 
 
-@dc.dataclass(frozen=True)
 class PolymorphicObjMarshaler(ObjMarshaler):
     class Impl(ta.NamedTuple):
         ty: type
         tag: str
         m: ObjMarshaler
 
-    impls_by_ty: ta.Mapping[type, Impl]
-    impls_by_tag: ta.Mapping[str, Impl]
+    def __init__(
+            self,
+            impls_by_ty: ta.Mapping[type, Impl],
+            impls_by_tag: ta.Mapping[str, Impl],
+    ) -> None:
+        super().__init__()
+
+        self._impls_by_ty = impls_by_ty
+        self._impls_by_tag = impls_by_tag
 
     @classmethod
     def of(cls, impls: ta.Iterable[Impl]) -> 'PolymorphicObjMarshaler':
@@ -1061,24 +1397,29 @@ class PolymorphicObjMarshaler(ObjMarshaler):
         )
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        impl = self.impls_by_ty[type(o)]
+        impl = self._impls_by_ty[type(o)]
         return {impl.tag: impl.m.marshal(o, ctx)}
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         [(t, v)] = o.items()
-        impl = self.impls_by_tag[t]
+        impl = self._impls_by_tag[t]
         return impl.m.unmarshal(v, ctx)
 
 
-@dc.dataclass(frozen=True)
 class DatetimeObjMarshaler(ObjMarshaler):
-    ty: type
+    def __init__(
+            self,
+            ty: type,
+    ) -> None:
+        super().__init__()
+
+        self._ty = ty
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o.isoformat()
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty.fromisoformat(o)  # type: ignore
+        return self._ty.fromisoformat(o)  # type: ignore
 
 
 class DecimalObjMarshaler(ObjMarshaler):
@@ -1186,7 +1527,78 @@ class OBJ_MARSHALER_OMIT_IF_NONE(ObjMarshalerFieldMetadata):  # noqa
 ##
 
 
-class ObjMarshalerManager:
+class ObjMarshalerManager(Abstract):
+    @abc.abstractmethod
+    def make_obj_marshaler(
+            self,
+            ty: ta.Any,
+            rec: ta.Callable[[ta.Any], ObjMarshaler],
+            *,
+            non_strict_fields: bool = False,
+    ) -> ObjMarshaler:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def set_obj_marshaler(
+            self,
+            ty: ta.Any,
+            m: ObjMarshaler,
+            *,
+            override: bool = False,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_obj_marshaler(
+            self,
+            ty: ta.Any,
+            *,
+            no_cache: bool = False,
+            **kwargs: ta.Any,
+    ) -> ObjMarshaler:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
+        raise NotImplementedError
+
+    #
+
+    def marshal_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Any = None,
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> ta.Any:
+        m = self.get_obj_marshaler(ty if ty is not None else type(o))
+        return m.marshal(o, self.make_context(opts))
+
+    def unmarshal_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Union[ta.Type[T], ta.Any],
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> T:
+        m = self.get_obj_marshaler(ty)
+        return m.unmarshal(o, self.make_context(opts))
+
+    def roundtrip_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Any = None,
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> ta.Any:
+        if ty is None:
+            ty = type(o)
+        m: ta.Any = self.marshal_obj(o, ty, opts)
+        u: ta.Any = self.unmarshal_obj(m, ty, opts)
+        return u
+
+
+#
+
+
+class ObjMarshalerManagerImpl(ObjMarshalerManager):
     def __init__(
             self,
             *,
@@ -1213,6 +1625,12 @@ class ObjMarshalerManager:
 
     #
 
+    @classmethod
+    def _is_abstract(cls, ty: type) -> bool:
+        return abc.ABC in ty.__bases__ or Abstract in ty.__bases__
+
+    #
+
     def make_obj_marshaler(
             self,
             ty: ta.Any,
@@ -1224,12 +1642,12 @@ class ObjMarshalerManager:
             if (reg := self._registered_obj_marshalers.get(ty)) is not None:
                 return reg
 
-            if abc.ABC in ty.__bases__:
+            if self._is_abstract(ty):
                 tn = ty.__name__
                 impls: ta.List[ta.Tuple[type, str]] = [  # type: ignore[var-annotated]
                     (ity, ity.__name__)
                     for ity in deep_subclasses(ty)
-                    if abc.ABC not in ity.__bases__
+                    if not self._is_abstract(ity)
                 ]
 
                 if all(itn.endswith(tn) for _, itn in impls):
@@ -1395,49 +1813,24 @@ class ObjMarshalerManager:
                 m = self.make_obj_marshaler(ty, rec, **kwargs)
             finally:
                 del self._proxies[ty]
-            p.m = m
+            p._m = m  # noqa
 
             if not no_cache:
                 self._obj_marshalers[ty] = m
             return m
 
-    #
-
-    def _make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
+    def make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
         return ObjMarshalContext(
             options=opts or self._default_options,
             manager=self,
         )
 
-    def marshal_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Any = None,
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> ta.Any:
-        m = self.get_obj_marshaler(ty if ty is not None else type(o))
-        return m.marshal(o, self._make_context(opts))
 
-    def unmarshal_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Union[ta.Type[T], ta.Any],
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> T:
-        m = self.get_obj_marshaler(ty)
-        return m.unmarshal(o, self._make_context(opts))
+def new_obj_marshaler_manager(**kwargs: ta.Any) -> ObjMarshalerManager:
+    return ObjMarshalerManagerImpl(**kwargs)
 
-    def roundtrip_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Any = None,
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> ta.Any:
-        if ty is None:
-            ty = type(o)
-        m: ta.Any = self.marshal_obj(o, ty, opts)
-        u: ta.Any = self.unmarshal_obj(m, ty, opts)
-        return u
+
+##
 
 
 @dc.dataclass(frozen=True)
@@ -1449,7 +1842,7 @@ class ObjMarshalContext:
 ##
 
 
-OBJ_MARSHALER_MANAGER = ObjMarshalerManager()
+OBJ_MARSHALER_MANAGER = new_obj_marshaler_manager()
 
 set_obj_marshaler = OBJ_MARSHALER_MANAGER.set_obj_marshaler
 get_obj_marshaler = OBJ_MARSHALER_MANAGER.get_obj_marshaler