omlish 0.0.0.dev132__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/lite/marshal.py

@@ -1,7 +1,7 @@
 """
 TODO:
  - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
- - nonstrict toggle
+ - literals
 """
 # ruff: noqa: UP006 UP007
 import abc
@@ -13,17 +13,22 @@ import decimal
 import enum
 import fractions
 import functools
+import inspect
 import threading
 import typing as ta
 import uuid
 import weakref  # noqa
 
-from .check import check_isinstance
-from .check import check_not_none
+from .check import check
 from .reflect import deep_subclasses
+from .reflect import get_literal_type_args
+from .reflect import get_new_type_supertype
 from .reflect import get_optional_alias_arg
 from .reflect import is_generic_alias
+from .reflect import is_literal_type
+from .reflect import is_new_type
 from .reflect import is_union_alias
+from .strings import snake_case
 
 
 T = ta.TypeVar('T')
@@ -32,21 +37,27 @@ T = ta.TypeVar('T')
 ##
 
 
+@dc.dataclass(frozen=True)
+class ObjMarshalOptions:
+    raw_bytes: bool = False
+    non_strict_fields: bool = False
+
+
 class ObjMarshaler(abc.ABC):
     @abc.abstractmethod
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         raise NotImplementedError
 
 
 class NopObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
 
@@ -54,29 +65,29 @@ class NopObjMarshaler(ObjMarshaler):
 class ProxyObjMarshaler(ObjMarshaler):
     m: ta.Optional[ObjMarshaler] = None
 
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return check_not_none(self.m).marshal(o)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check.not_none(self.m).marshal(o, ctx)
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return check_not_none(self.m).unmarshal(o)
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check.not_none(self.m).unmarshal(o, ctx)
 
 
 @dc.dataclass(frozen=True)
 class CastObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return self.ty(o)
 
 
 class DynamicObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return marshal_obj(o)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return ctx.manager.marshal_obj(o, opts=ctx.options)
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
 
@@ -84,21 +95,36 @@ class DynamicObjMarshaler(ObjMarshaler):
 class Base64ObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return base64.b64encode(o).decode('ascii')
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return self.ty(base64.b64decode(o))
 
 
+@dc.dataclass(frozen=True)
+class BytesSwitchedObjMarshaler(ObjMarshaler):
+    m: ObjMarshaler
+
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if ctx.options.raw_bytes:
+            return o
+        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)
+
+
 @dc.dataclass(frozen=True)
 class EnumObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o.name
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return self.ty.__members__[o]  # type: ignore
 
 
@@ -106,15 +132,27 @@ class EnumObjMarshaler(ObjMarshaler):
 class OptionalObjMarshaler(ObjMarshaler):
     item: ObjMarshaler
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         if o is None:
             return None
-        return self.item.marshal(o)
+        return self.item.marshal(o, ctx)
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         if o is None:
             return None
-        return self.item.unmarshal(o)
+        return self.item.unmarshal(o, ctx)
+
+
+@dc.dataclass(frozen=True)
+class LiteralObjMarshaler(ObjMarshaler):
+    item: ObjMarshaler
+    vs: frozenset
+
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        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)
 
 
 @dc.dataclass(frozen=True)
@@ -123,11 +161,11 @@ class MappingObjMarshaler(ObjMarshaler):
     km: ObjMarshaler
     vm: ObjMarshaler
 
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return {self.km.marshal(k): self.vm.marshal(v) for k, v in o.items()}
+    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()}
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty((self.km.unmarshal(k), self.vm.unmarshal(v)) 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())
 
 
 @dc.dataclass(frozen=True)
@@ -135,24 +173,43 @@ class IterableObjMarshaler(ObjMarshaler):
     ty: type
     item: ObjMarshaler
 
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return [self.item.marshal(e) for e in o]
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return [self.item.marshal(e, ctx) for e in o]
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty(self.item.unmarshal(e) 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)
 
 
 @dc.dataclass(frozen=True)
-class DataclassObjMarshaler(ObjMarshaler):
+class FieldsObjMarshaler(ObjMarshaler):
     ty: type
     fs: ta.Mapping[str, ObjMarshaler]
-    nonstrict: bool = False
+    non_strict: bool = False
 
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return {k: m.marshal(getattr(o, k)) for k, m in self.fs.items()}
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return {
+            k: m.marshal(getattr(o, k), ctx)
+            for k, m in self.fs.items()
+        }
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
-        return self.ty(**{k: self.fs[k].unmarshal(v) for k, v in o.items() if not self.nonstrict or k in self.fs})
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(**{
+            k: self.fs[k].unmarshal(v, ctx)
+            for k, v in o.items()
+            if not (self.non_strict or ctx.options.non_strict_fields) or k in self.fs
+        })
+
+
+@dc.dataclass(frozen=True)
+class SingleFieldObjMarshaler(ObjMarshaler):
+    ty: type
+    fld: str
+
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return getattr(o, self.fld)
+
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(**{self.fld: o})
 
 
 @dc.dataclass(frozen=True)
@@ -165,50 +222,57 @@ class PolymorphicObjMarshaler(ObjMarshaler):
     impls_by_ty: ta.Mapping[type, Impl]
     impls_by_tag: ta.Mapping[str, Impl]
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    @classmethod
+    def of(cls, impls: ta.Iterable[Impl]) -> 'PolymorphicObjMarshaler':
+        return cls(
+            {i.ty: i for i in impls},
+            {i.tag: i for i in impls},
+        )
+
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         impl = self.impls_by_ty[type(o)]
-        return {impl.tag: impl.m.marshal(o)}
+        return {impl.tag: impl.m.marshal(o, ctx)}
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         [(t, v)] = o.items()
         impl = self.impls_by_tag[t]
-        return impl.m.unmarshal(v)
+        return impl.m.unmarshal(v, ctx)
 
 
 @dc.dataclass(frozen=True)
 class DatetimeObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o.isoformat()
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return self.ty.fromisoformat(o)  # type: ignore
 
 
 class DecimalObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
-        return str(check_isinstance(o, decimal.Decimal))
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return str(check.isinstance(o, decimal.Decimal))
 
-    def unmarshal(self, v: ta.Any) -> ta.Any:
-        return decimal.Decimal(check_isinstance(v, str))
+    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return decimal.Decimal(check.isinstance(v, str))
 
 
 class FractionObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
-        fr = check_isinstance(o, fractions.Fraction)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        fr = check.isinstance(o, fractions.Fraction)
         return [fr.numerator, fr.denominator]
 
-    def unmarshal(self, v: ta.Any) -> ta.Any:
-        num, denom = check_isinstance(v, list)
+    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        num, denom = check.isinstance(v, list)
         return fractions.Fraction(num, denom)
 
 
 class UuidObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return str(o)
 
-    def unmarshal(self, o: ta.Any) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return uuid.UUID(o)
 
 
@@ -218,11 +282,11 @@ class UuidObjMarshaler(ObjMarshaler):
 _DEFAULT_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = {
     **{t: NopObjMarshaler() for t in (type(None),)},
     **{t: CastObjMarshaler(t) for t in (int, float, str, bool)},
-    **{t: Base64ObjMarshaler(t) for t in (bytes, bytearray)},
+    **{t: BytesSwitchedObjMarshaler(Base64ObjMarshaler(t)) for t in (bytes, bytearray)},
     **{t: IterableObjMarshaler(t, DynamicObjMarshaler()) for t in (list, tuple, set, frozenset)},
     **{t: MappingObjMarshaler(t, DynamicObjMarshaler(), DynamicObjMarshaler()) for t in (dict,)},
 
-    ta.Any: DynamicObjMarshaler(),
+    **{t: DynamicObjMarshaler() for t in (ta.Any, object)},
 
     **{t: DatetimeObjMarshaler(t) for t in (datetime.date, datetime.time, datetime.datetime)},
     decimal.Decimal: DecimalObjMarshaler(),
@@ -244,121 +308,222 @@ _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
 }
 
 
-def _make_obj_marshaler(
-        ty: ta.Any,
-        rec: ta.Callable[[ta.Any], ObjMarshaler],
-        *,
-        nonstrict_dataclasses: bool = False,
-) -> ObjMarshaler:
-    if isinstance(ty, type):
-        if abc.ABC in ty.__bases__:
-            impls = [  # type: ignore
-                PolymorphicObjMarshaler.Impl(
-                    ity,
-                    ity.__qualname__,
-                    rec(ity),
-                )
-                for ity in deep_subclasses(ty)
-                if abc.ABC not in ity.__bases__
-            ]
-            return PolymorphicObjMarshaler(
-                {i.ty: i for i in impls},
-                {i.tag: i for i in impls},
-            )
-
-        if issubclass(ty, enum.Enum):
-            return EnumObjMarshaler(ty)
-
-        if dc.is_dataclass(ty):
-            return DataclassObjMarshaler(
-                ty,
-                {f.name: rec(f.type) for f in dc.fields(ty)},
-                nonstrict=nonstrict_dataclasses,
-            )
+##
 
-    if is_generic_alias(ty):
-        try:
-            mt = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES[ta.get_origin(ty)]
-        except KeyError:
-            pass
-        else:
-            k, v = ta.get_args(ty)
-            return MappingObjMarshaler(mt, rec(k), rec(v))
 
-        try:
-            st = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES[ta.get_origin(ty)]
-        except KeyError:
-            pass
-        else:
-            [e] = ta.get_args(ty)
-            return IterableObjMarshaler(st, rec(e))
+_REGISTERED_OBJ_MARSHALERS_BY_TYPE: ta.MutableMapping[type, ObjMarshaler] = weakref.WeakKeyDictionary()
 
-        if is_union_alias(ty):
-            return OptionalObjMarshaler(rec(get_optional_alias_arg(ty)))
 
-    raise TypeError(ty)
+def register_type_obj_marshaler(ty: type, om: ObjMarshaler) -> None:
+    _REGISTERED_OBJ_MARSHALERS_BY_TYPE[ty] = om
 
 
 ##
 
 
-_OBJ_MARSHALERS_LOCK = threading.RLock()
+class ObjMarshalerManager:
+    def __init__(
+            self,
+            *,
+            default_options: ObjMarshalOptions = ObjMarshalOptions(),
+
+            default_obj_marshalers: ta.Dict[ta.Any, ObjMarshaler] = _DEFAULT_OBJ_MARSHALERS,  # noqa
+            generic_mapping_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES,  # noqa
+            generic_iterable_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES,  # noqa
+
+            registered_obj_marshalers: ta.Mapping[type, ObjMarshaler] = _REGISTERED_OBJ_MARSHALERS_BY_TYPE,
+    ) -> None:
+        super().__init__()
+
+        self._default_options = default_options
+
+        self._obj_marshalers = dict(default_obj_marshalers)
+        self._generic_mapping_types = generic_mapping_types
+        self._generic_iterable_types = generic_iterable_types
+        self._registered_obj_marshalers = registered_obj_marshalers
+
+        self._lock = threading.RLock()
+        self._marshalers: ta.Dict[ta.Any, ObjMarshaler] = dict(_DEFAULT_OBJ_MARSHALERS)
+        self._proxies: ta.Dict[ta.Any, ProxyObjMarshaler] = {}
+
+    #
+
+    def make_obj_marshaler(
+            self,
+            ty: ta.Any,
+            rec: ta.Callable[[ta.Any], ObjMarshaler],
+            *,
+            non_strict_fields: bool = False,
+    ) -> ObjMarshaler:
+        if isinstance(ty, type):
+            if (reg := self._registered_obj_marshalers.get(ty)) is not None:
+                return reg
+
+            if abc.ABC in ty.__bases__:
+                impls = [ity for ity in deep_subclasses(ty) if abc.ABC not in ity.__bases__]  # type: ignore
+                if all(ity.__qualname__.endswith(ty.__name__) for ity in impls):
+                    ins = {ity: snake_case(ity.__qualname__[:-len(ty.__name__)]) for ity in impls}
+                else:
+                    ins = {ity: ity.__qualname__ for ity in impls}
+                return PolymorphicObjMarshaler.of([
+                    PolymorphicObjMarshaler.Impl(
+                        ity,
+                        itn,
+                        rec(ity),
+                    )
+                    for ity, itn in ins.items()
+                ])
+
+            if issubclass(ty, enum.Enum):
+                return EnumObjMarshaler(ty)
+
+            if dc.is_dataclass(ty):
+                return FieldsObjMarshaler(
+                    ty,
+                    {f.name: rec(f.type) for f in dc.fields(ty)},
+                    non_strict=non_strict_fields,
+                )
 
-_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = dict(_DEFAULT_OBJ_MARSHALERS)
+            if issubclass(ty, tuple) and hasattr(ty, '_fields'):
+                return FieldsObjMarshaler(
+                    ty,
+                    {p.name: rec(p.annotation) for p in inspect.signature(ty).parameters.values()},
+                    non_strict=non_strict_fields,
+                )
 
-_OBJ_MARSHALER_PROXIES: ta.Dict[ta.Any, ProxyObjMarshaler] = {}
+        if is_new_type(ty):
+            return rec(get_new_type_supertype(ty))
 
+        if is_literal_type(ty):
+            lvs = frozenset(get_literal_type_args(ty))
+            lty = check.single(set(map(type, lvs)))
+            return LiteralObjMarshaler(rec(lty), lvs)
 
-def register_opj_marshaler(ty: ta.Any, m: ObjMarshaler) -> None:
-    with _OBJ_MARSHALERS_LOCK:
-        if ty in _OBJ_MARSHALERS:
-            raise KeyError(ty)
-        _OBJ_MARSHALERS[ty] = m
+        if is_generic_alias(ty):
+            try:
+                mt = self._generic_mapping_types[ta.get_origin(ty)]
+            except KeyError:
+                pass
+            else:
+                k, v = ta.get_args(ty)
+                return MappingObjMarshaler(mt, rec(k), rec(v))
 
+            try:
+                st = self._generic_iterable_types[ta.get_origin(ty)]
+            except KeyError:
+                pass
+            else:
+                [e] = ta.get_args(ty)
+                return IterableObjMarshaler(st, rec(e))
+
+            if is_union_alias(ty):
+                return OptionalObjMarshaler(rec(get_optional_alias_arg(ty)))
+
+        raise TypeError(ty)
+
+    #
+
+    def set_obj_marshaler(
+            self,
+            ty: ta.Any,
+            m: ObjMarshaler,
+            *,
+            override: bool = False,
+    ) -> None:
+        with self._lock:
+            if not override and ty in self._obj_marshalers:
+                raise KeyError(ty)
+            self._obj_marshalers[ty] = m
+
+    def get_obj_marshaler(
+            self,
+            ty: ta.Any,
+            *,
+            no_cache: bool = False,
+            **kwargs: ta.Any,
+    ) -> ObjMarshaler:
+        with self._lock:
+            if not no_cache:
+                try:
+                    return self._obj_marshalers[ty]
+                except KeyError:
+                    pass
 
-def get_obj_marshaler(
-        ty: ta.Any,
-        *,
-        no_cache: bool = False,
-        **kwargs: ta.Any,
-) -> ObjMarshaler:
-    with _OBJ_MARSHALERS_LOCK:
-        if not no_cache:
             try:
-                return _OBJ_MARSHALERS[ty]
+                return self._proxies[ty]
             except KeyError:
                 pass
 
-        try:
-            return _OBJ_MARSHALER_PROXIES[ty]
-        except KeyError:
-            pass
+            rec = functools.partial(
+                self.get_obj_marshaler,
+                no_cache=no_cache,
+                **kwargs,
+            )
+
+            p = ProxyObjMarshaler()
+            self._proxies[ty] = p
+            try:
+                m = self.make_obj_marshaler(ty, rec, **kwargs)
+            finally:
+                del self._proxies[ty]
+            p.m = m
+
+            if not no_cache:
+                self._obj_marshalers[ty] = m
+            return m
+
+    #
 
-        rec = functools.partial(
-            get_obj_marshaler,
-            no_cache=no_cache,
-            **kwargs,
+    def _make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
+        return ObjMarshalContext(
+            options=opts or self._default_options,
+            manager=self,
         )
 
-        p = ProxyObjMarshaler()
-        _OBJ_MARSHALER_PROXIES[ty] = p
-        try:
-            m = _make_obj_marshaler(ty, rec, **kwargs)
-        finally:
-            del _OBJ_MARSHALER_PROXIES[ty]
-        p.m = m
+    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
 
-        if not no_cache:
-            _OBJ_MARSHALERS[ty] = m
-        return m
+
+@dc.dataclass(frozen=True)
+class ObjMarshalContext:
+    options: ObjMarshalOptions
+    manager: ObjMarshalerManager
 
 
 ##
 
 
-def marshal_obj(o: ta.Any, ty: ta.Any = None) -> ta.Any:
-    return get_obj_marshaler(ty if ty is not None else type(o)).marshal(o)
+OBJ_MARSHALER_MANAGER = ObjMarshalerManager()
 
+set_obj_marshaler = OBJ_MARSHALER_MANAGER.set_obj_marshaler
+get_obj_marshaler = OBJ_MARSHALER_MANAGER.get_obj_marshaler
 
-def unmarshal_obj(o: ta.Any, ty: ta.Union[ta.Type[T], ta.Any]) -> T:
-    return get_obj_marshaler(ty).unmarshal(o)
+marshal_obj = OBJ_MARSHALER_MANAGER.marshal_obj
+unmarshal_obj = OBJ_MARSHALER_MANAGER.unmarshal_obj

omlish/lite/pycharm.py

@@ -0,0 +1,47 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import typing as ta
+
+
+DEFAULT_PYCHARM_VERSION = '242.23726.102'
+
+
+@dc.dataclass(frozen=True)
+class PycharmRemoteDebug:
+    port: int
+    host: ta.Optional[str] = 'localhost'
+    install_version: ta.Optional[str] = DEFAULT_PYCHARM_VERSION
+
+
+def pycharm_debug_connect(prd: PycharmRemoteDebug) -> None:
+    if prd.install_version is not None:
+        import subprocess
+        import sys
+        subprocess.check_call([
+            sys.executable,
+            '-mpip',
+            'install',
+            f'pydevd-pycharm~={prd.install_version}',
+        ])
+
+    pydevd_pycharm = __import__('pydevd_pycharm')  # noqa
+    pydevd_pycharm.settrace(
+        prd.host,
+        port=prd.port,
+        stdoutToServer=True,
+        stderrToServer=True,
+    )
+
+
+def pycharm_debug_preamble(prd: PycharmRemoteDebug) -> str:
+    import inspect
+    import textwrap
+    return textwrap.dedent(f"""
+        {inspect.getsource(pycharm_debug_connect)}
+
+        pycharm_debug_connect(PycharmRemoteDebug(
+            {prd.port!r},
+            host={prd.host!r},
+            install_version={prd.install_version!r},
+        ))
+    """)