omlish 0.0.0.dev419__py3-none-any.whl → 0.0.0.dev421__py3-none-any.whl

omlish/lite/marshal.py

@@ -1,9 +1,9 @@
+# ruff: noqa: UP006 UP007 UP045
 """
 TODO:
  - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
  - Options.sequence_cls = list, mapping_cls = dict, ... - def with_mutable_containers() -> Options
 """
-# ruff: noqa: UP006 UP007 UP045
 import abc
 import base64
 import collections.abc
@@ -19,8 +19,9 @@ import typing as ta
 import uuid
 import weakref
 
+from .abstract import Abstract
 from .check import check
-from .reflect import deep_subclasses
+from .objects import deep_subclasses
 from .reflect import get_literal_type_args
 from .reflect import get_new_type_supertype
 from .reflect import is_generic_alias
@@ -42,7 +43,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
@@ -60,26 +61,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):
@@ -90,121 +95,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
@@ -213,31 +248,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
@@ -248,34 +295,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':
@@ -285,24 +344,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):
@@ -410,7 +474,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,
             *,
@@ -437,6 +572,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,
@@ -448,12 +589,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):
@@ -619,49 +760,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)
@@ -673,7 +789,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

omlish/lite/maybes.py

@@ -3,6 +3,8 @@ import abc
 import functools
 import typing as ta
 
+from .abstract import Abstract
+
 
 T = ta.TypeVar('T')
 U = ta.TypeVar('U')
@@ -134,7 +136,7 @@ class Maybe(ta.Generic[T]):
 ##
 
 
-class _Maybe(Maybe[T], abc.ABC):
+class _Maybe(Maybe[T], Abstract):
     def __lt__(self, other):
         if not isinstance(other, _Maybe):
             return NotImplemented

omlish/lite/maysync.py

@@ -45,6 +45,8 @@ import sys
 import threading
 import typing as ta
 
+from .abstract import Abstract
+
 
 T = ta.TypeVar('T')
 O = ta.TypeVar('O')
@@ -58,7 +60,7 @@ _MaysyncRA = ta.TypeVar('_MaysyncRA')
 ##
 
 
-class AnyMaysyncFn(abc.ABC, ta.Generic[_MaysyncRS, _MaysyncRA]):  # noqa
+class AnyMaysyncFn(Abstract, ta.Generic[_MaysyncRS, _MaysyncRA]):
     def __init__(
             self,
             s: ta.Callable[..., _MaysyncRS],
@@ -105,7 +107,7 @@ class MaywaitableAlreadyConsumedError(Exception):
     pass
 
 
-class AnyMaywaitable(abc.ABC, ta.Generic[_MaysyncX]):
+class AnyMaywaitable(Abstract, ta.Generic[_MaysyncX]):
     @ta.final
     def __init__(
             self,

omlish/lite/objects.py

@@ -0,0 +1,81 @@
+# ruff: noqa: UP006 UP036 UP045
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+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)
+    }