omlish 0.0.0.dev268__py3-none-any.whl → 0.0.0.dev270__py3-none-any.whl

omlish/lang/classes/abstract.py

@@ -5,6 +5,9 @@ import typing as ta
 T = ta.TypeVar('T')
 
 
+##
+
+
 _DISABLE_CHECKS = False
 
 _ABSTRACT_METHODS_ATTR = '__abstractmethods__'

omlish/lang/comparison.py

@@ -1,6 +1,9 @@
 import typing as ta
 
 
+##
+
+
 def cmp(l: ta.Any, r: ta.Any) -> int:
     return int(l > r) - int(l < r)
 

omlish/lang/datetimes.py

@@ -1,6 +1,9 @@
 import datetime
 
 
+##
+
+
 def utcnow() -> datetime.datetime:
     return datetime.datetime.now(tz=datetime.UTC)
 

omlish/lang/generators.py

@@ -203,8 +203,8 @@ class GeneratorMappedIterator(ta.Generic[O, I, R]):
     Like a `map` iterator but takes a generator instead of a function. Provided generator *must* yield outputs 1:1 with
     inputs.
 
-    Generator return value will be captured on `value` property - if present generator stopped, it absent iterator
-    stopped.
+    Generator return value will be captured on `value` property - present if the generator stopped, absent if the
+    iterator stopped.
     """
 
     def __init__(self, g: ta.Generator[O, I, R], it: ta.Iterator[I]) -> None:

omlish/lang/maybes.py

@@ -6,6 +6,9 @@ T = ta.TypeVar('T')
 U = ta.TypeVar('U')
 
 
+##
+
+
 class ValueNotPresentException(BaseException):
     pass
 

omlish/lang/resolving.py

@@ -3,6 +3,9 @@ import string
 import typing as ta
 
 
+##
+
+
 class ResolvableClassNameError(NameError):
     pass
 

omlish/lang/sys.py

@@ -1,6 +1,9 @@
 import sys
 
 
+##
+
+
 REQUIRED_PYTHON_VERSION = (3, 12)
 
 

omlish/marshal/__init__.py

@@ -2,12 +2,24 @@ from .base import (  # noqa
     Marshaler,
     Unmarshaler,
 
+    MarshalerMaker,
+    UnmarshalerMaker,
+
     MarshalerFactory,
     UnmarshalerFactory,
 
+    MarshalerFactory_,
+    UnmarshalerFactory_,
+
+    SimpleMarshalerFactory,
+    SimpleUnmarshalerFactory,
+
     MarshalerFactoryMatchClass,
     UnmarshalerFactoryMatchClass,
 
+    MultiMarshalerFactory,
+    MultiUnmarshalerFactory,
+
     TypeMapMarshalerFactory,
     TypeMapUnmarshalerFactory,
 
@@ -52,6 +64,8 @@ from .global_ import (  # noqa
 
     global_unmarshaler_factory,
     unmarshal,
+
+    register_global,
 )
 
 from .naming import (  # noqa
@@ -138,6 +152,8 @@ from .standard import (  # noqa
 
     STANDARD_UNMARSHALER_FACTORIES,
     new_standard_unmarshaler_factory,
+
+    install_standard_factories,
 )
 
 from .trivial.forbidden import (  # noqa

omlish/marshal/base.py

@@ -117,19 +117,215 @@ class Unmarshaler(lang.Abstract):
         raise NotImplementedError
 
 
-MarshalerFactory: ta.TypeAlias = mfs.MatchFn[['MarshalContext', rfl.Type], Marshaler]
-UnmarshalerFactory: ta.TypeAlias = mfs.MatchFn[['UnmarshalContext', rfl.Type], Unmarshaler]
+##
+
+
+MarshalerMaker: ta.TypeAlias = mfs.MatchFn[['MarshalContext', rfl.Type], Marshaler]
+UnmarshalerMaker: ta.TypeAlias = mfs.MatchFn[['UnmarshalContext', rfl.Type], Unmarshaler]
+
+
+class MarshalerFactory(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def make_marshaler(self) -> MarshalerMaker:
+        raise NotImplementedError
+
+
+class UnmarshalerFactory(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class MarshalerFactory_(MarshalerFactory):  # noqa
+    fn: MarshalerMaker
+
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self.fn
+
+
+@dc.dataclass(frozen=True)
+class UnmarshalerFactory_(UnmarshalerFactory):  # noqa
+    fn: UnmarshalerMaker
+
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self.fn
+
+
+##
+
+
+class SimpleMarshalerFactory(
+    MarshalerFactory,
+    MarshalerMaker,
+    lang.Abstract,
+):
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self
+
+
+class SimpleUnmarshalerFactory(
+    UnmarshalerFactory,
+    UnmarshalerMaker,
+    lang.Abstract,
+):
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self
+
+
+##
+
+
+class MarshalerFactoryMatchClass(
+    MarshalerFactory,
+    mfs.MatchFnClass[['MarshalContext', rfl.Type], Marshaler],
+    lang.Abstract,
+):
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self
+
+
+class UnmarshalerFactoryMatchClass(
+    UnmarshalerFactory,
+    mfs.MatchFnClass[['UnmarshalContext', rfl.Type], Unmarshaler],
+    lang.Abstract,
+):
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self
+
+
+##
+
+
+class MultiMarshalerFactory(MarshalerFactory):
+    def __init__(
+            self,
+            fs: ta.Iterable[MarshalerFactory],
+            *,
+            strict: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._fs = list(fs)
+        self._mmf: mfs.MultiMatchFn[[MarshalContext, rfl.Type], Marshaler] = mfs.MultiMatchFn(
+            [f.make_marshaler for f in self._fs],
+            strict=strict,
+        )
+
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self._mmf
+
+
+class MultiUnmarshalerFactory(UnmarshalerFactory):
+    def __init__(
+            self,
+            fs: ta.Iterable[UnmarshalerFactory],
+            *,
+            strict: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._fs = list(fs)
+        self._mmf: mfs.MultiMatchFn[[UnmarshalContext, rfl.Type], Unmarshaler] = mfs.MultiMatchFn(
+            [f.make_unmarshaler for f in self._fs],
+            strict=strict,
+        )
+
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self._mmf
 
-MarshalerFactoryMatchClass: ta.TypeAlias = mfs.MatchFnClass[['MarshalContext', rfl.Type], Marshaler]
-UnmarshalerFactoryMatchClass: ta.TypeAlias = mfs.MatchFnClass[['UnmarshalContext', rfl.Type], Unmarshaler]
 
+##
+
+
+@dc.dataclass(frozen=True)
+class TypeMapMarshalerFactory(
+    TypeMapFactory['MarshalContext', Marshaler],
+    MarshalerFactory,
+):
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self
+
+
+@dc.dataclass(frozen=True)
+class TypeMapUnmarshalerFactory(
+    TypeMapFactory['UnmarshalContext', Unmarshaler],
+    UnmarshalerFactory,
+):
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self
+
+
+# class TypeMapMarshalerFactory(MarshalerFactory):
+#     def __init__(self, m: ta.Mapping[rfl.Type, MarshalerFactory]) -> None:
+#         super().__init__()
 #
+#         self._m = m
+#         self._tmf: TypeMapFactory['MarshalContext', Marshaler] = TypeMapFactory({
+#             t: f.make_marshaler
+#             for t, f in m.items()
+#         })
+#
+#     @property
+#     def make_marshaler(self) -> MarshalerMaker:
+#         return self._tmf
 
-TypeMapMarshalerFactory: ta.TypeAlias = TypeMapFactory['MarshalContext', Marshaler]
-TypeMapUnmarshalerFactory: ta.TypeAlias = TypeMapFactory['UnmarshalContext', Unmarshaler]
 
-TypeCacheMarshalerFactory: ta.TypeAlias = TypeCacheFactory['MarshalContext', Marshaler]
-TypeCacheUnmarshalerFactory: ta.TypeAlias = TypeCacheFactory['UnmarshalContext', Unmarshaler]
+# class TypeMapUnmarshalerFactory(UnmarshalerFactory):
+#     def __init__(self, m: ta.Mapping[rfl.Type, UnmarshalerFactory]) -> None:
+#         super().__init__()
+#
+#         self._m = m
+#         self._tmf: TypeMapFactory[UnmarshalContext, Unmarshaler] = TypeMapFactory({
+#             t: f.make_unmarshaler
+#             for t, f in m.items()
+#         })
+#
+#     @property
+#     def make_unmarshaler(self) -> UnmarshalerMaker:
+#         return self._tmf
+
+
+##
+
+
+class TypeCacheMarshalerFactory(MarshalerFactory):
+    def __init__(self, f: MarshalerFactory) -> None:
+        super().__init__()
+
+        self._f = f
+        self._tcf: TypeCacheFactory[MarshalContext, Marshaler] = TypeCacheFactory(f.make_marshaler)
+
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self._tcf
+
+
+class TypeCacheUnmarshalerFactory(UnmarshalerFactory):
+    def __init__(self, f: UnmarshalerFactory) -> None:
+        super().__init__()
+
+        self._f = f
+        self._tcf: TypeCacheFactory[UnmarshalContext, Unmarshaler] = TypeCacheFactory(f.make_unmarshaler)
+
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self._tcf
 
 
 ##
@@ -182,7 +378,7 @@ class MarshalContext(BaseContext, lang.Final):
     def make(self, o: ta.Any) -> Marshaler:
         rty = self._reflect(o)
         try:
-            return check.not_none(self.factory)(self, rty)  # type: ignore
+            return check.not_none(self.factory).make_marshaler(self, rty)
         except mfs.MatchGuardError:
             raise UnhandledTypeError(rty)  # noqa
 
@@ -194,7 +390,7 @@ class UnmarshalContext(BaseContext, lang.Final):
     def make(self, o: ta.Any) -> Unmarshaler:
         rty = self._reflect(o)
         try:
-            return check.not_none(self.factory)(self, rty)  # type: ignore
+            return check.not_none(self.factory).make_unmarshaler(self, rty)
         except mfs.MatchGuardError:
             raise UnhandledTypeError(rty)  # noqa
 
@@ -207,9 +403,19 @@ class _ProxyMarshaler(_Proxy[Marshaler], Marshaler):
         return self._obj.marshal(ctx, o)
 
 
-class RecursiveMarshalerFactory(RecursiveTypeFactory[MarshalContext, Marshaler], lang.Final):
+class RecursiveMarshalerFactory(MarshalerFactory, lang.Final):
     def __init__(self, f: MarshalerFactory) -> None:
-        super().__init__(f, _ProxyMarshaler._new)  # noqa
+        super().__init__()
+
+        self._f = f
+        self._rtf: RecursiveTypeFactory[MarshalContext, Marshaler] = RecursiveTypeFactory(
+            self._f.make_marshaler,  # noqa
+            _ProxyMarshaler._new,  # noqa
+        )
+
+    @property
+    def make_marshaler(self) -> MarshalerMaker:
+        return self._rtf
 
 
 class _ProxyUnmarshaler(_Proxy[Unmarshaler], Unmarshaler):
@@ -217,9 +423,19 @@ class _ProxyUnmarshaler(_Proxy[Unmarshaler], Unmarshaler):
         return self._obj.unmarshal(ctx, v)
 
 
-class RecursiveUnmarshalerFactory(RecursiveTypeFactory[UnmarshalContext, Unmarshaler], lang.Final):
+class RecursiveUnmarshalerFactory(UnmarshalerFactory, lang.Final):
     def __init__(self, f: UnmarshalerFactory) -> None:
-        super().__init__(f, _ProxyUnmarshaler._new)  # noqa
+        super().__init__()
+
+        self._f = f
+        self._rtf: RecursiveTypeFactory[UnmarshalContext, Unmarshaler] = RecursiveTypeFactory(
+            self._f.make_unmarshaler,  # noqa
+            _ProxyUnmarshaler._new,  # noqa
+        )
+
+    @property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return self._rtf
 
 
 ##

omlish/marshal/composite/iterables.py

@@ -19,6 +19,9 @@ from ..base import UnmarshalerFactoryMatchClass
 from ..values import Value
 
 
+##
+
+
 DEFAULT_ITERABLE_CONCRETE_TYPES: dict[type[collections.abc.Iterable], type[collections.abc.Iterable]] = {
     collections.abc.Iterable: tuple,  # type: ignore
     collections.abc.Sequence: tuple,  # type: ignore

omlish/marshal/composite/literals.py

@@ -5,13 +5,16 @@ from ... import check
 from ... import reflect as rfl
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
+from ..base import SimpleMarshalerFactory
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 from ..values import Value
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class LiteralMarshaler(Marshaler):
     e: Marshaler
@@ -21,7 +24,7 @@ class LiteralMarshaler(Marshaler):
         return self.e.marshal(ctx, check.in_(o, self.vs))
 
 
-class LiteralMarshalerFactory(MarshalerFactory):
+class LiteralMarshalerFactory(SimpleMarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, rfl.Literal)
 
@@ -40,7 +43,7 @@ class LiteralUnmarshaler(Unmarshaler):
         return check.in_(self.e.unmarshal(ctx, v), self.vs)
 
 
-class LiteralUnmarshalerFactory(UnmarshalerFactory):
+class LiteralUnmarshalerFactory(SimpleUnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, rfl.Literal)
 

omlish/marshal/composite/mappings.py

@@ -14,6 +14,9 @@ from ..base import UnmarshalerFactoryMatchClass
 from ..values import Value
 
 
+##
+
+
 DEFAULT_MAPPING_CONCRETE_TYPES: dict[type[collections.abc.Mapping], type[collections.abc.Mapping]] = {
     collections.abc.Mapping: dict,  # type: ignore
     collections.abc.MutableMapping: dict,  # type: ignore

omlish/marshal/composite/maybes.py

@@ -18,6 +18,9 @@ from ..base import UnmarshalerFactoryMatchClass
 from ..values import Value
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class MaybeMarshaler(Marshaler):
     e: Marshaler

omlish/marshal/composite/newtypes.py

@@ -2,13 +2,16 @@ from ... import check
 from ... import reflect as rfl
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
+from ..base import SimpleMarshalerFactory
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 
 
-class NewtypeMarshalerFactory(MarshalerFactory):
+##
+
+
+class NewtypeMarshalerFactory(SimpleMarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, rfl.NewType)
 
@@ -16,7 +19,7 @@ class NewtypeMarshalerFactory(MarshalerFactory):
         return ctx.make(check.isinstance(rty, rfl.NewType).ty)
 
 
-class NewtypeUnmarshalerFactory(UnmarshalerFactory):
+class NewtypeUnmarshalerFactory(SimpleUnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, rfl.NewType)
 

omlish/marshal/composite/optionals.py

@@ -5,13 +5,16 @@ from ... import check
 from ... import reflect as rfl
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
+from ..base import SimpleMarshalerFactory
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 from ..values import Value
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class OptionalMarshaler(Marshaler):
     e: Marshaler
@@ -22,7 +25,7 @@ class OptionalMarshaler(Marshaler):
         return self.e.marshal(ctx, o)
 
 
-class OptionalMarshalerFactory(MarshalerFactory):
+class OptionalMarshalerFactory(SimpleMarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, rfl.Union) and rty.is_optional
 
@@ -40,7 +43,7 @@ class OptionalUnmarshaler(Unmarshaler):
         return self.e.unmarshal(ctx, v)
 
 
-class OptionalUnmarshalerFactory(UnmarshalerFactory):
+class OptionalUnmarshalerFactory(SimpleUnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, rfl.Union) and rty.is_optional
 

omlish/marshal/composite/wrapped.py

@@ -8,6 +8,9 @@ from ..base import Unmarshaler
 from ..values import Value
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class WrappedMarshaler(Marshaler):
     wrapper: ta.Callable[[MarshalContext, ta.Any], ta.Any]

omlish/marshal/global_.py

@@ -6,6 +6,7 @@ from .base import MarshalerFactory
 from .base import UnmarshalContext
 from .base import UnmarshalerFactory
 from .registries import Registry
+from .registries import RegistryItem
 from .standard import new_standard_marshaler_factory
 from .standard import new_standard_unmarshaler_factory
 from .values import Value
@@ -44,3 +45,18 @@ def global_unmarshaler_factory() -> UnmarshalerFactory:
 def unmarshal(v: Value, ty: type[T], **kwargs: ta.Any) -> T:
     uc = UnmarshalContext(GLOBAL_REGISTRY, factory=global_unmarshaler_factory(), **kwargs)
     return uc.make(ty).unmarshal(uc, v)
+
+
+##
+
+
+def register_global(
+        key: ta.Any,
+        *items: RegistryItem,
+        identity: bool = False,
+) -> None:
+    GLOBAL_REGISTRY.register(
+        key,
+        *items,
+        identity=identity,
+    )

omlish/marshal/objects/dataclasses.py

@@ -12,11 +12,11 @@ from ... import reflect as rfl
 from ...lite import marshal as lm
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
 from ..base import Option
+from ..base import SimpleMarshalerFactory
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 from ..naming import Naming
 from ..naming import translate_name
 from .marshal import ObjectMarshaler
@@ -66,7 +66,7 @@ def get_dataclass_field_infos(
     type_hints = ta.get_type_hints(ty)
 
     ret: list[FieldInfo] = []
-    for field in dc_rf.fields.values():
+    for field in dc_rf.instance_fields:
         if (f_naming := field.metadata.get(Naming, dc_naming)) is not None:
             um_name = translate_name(field.name, f_naming)
         else:
@@ -183,7 +183,7 @@ class AbstractDataclassFactory(lang.Abstract):
 ##
 
 
-class DataclassMarshalerFactory(AbstractDataclassFactory, MarshalerFactory):
+class DataclassMarshalerFactory(AbstractDataclassFactory, SimpleMarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, type) and dc.is_dataclass(rty) and not lang.is_abstract_class(rty)
 
@@ -210,7 +210,7 @@ class DataclassMarshalerFactory(AbstractDataclassFactory, MarshalerFactory):
 ##
 
 
-class DataclassUnmarshalerFactory(AbstractDataclassFactory, UnmarshalerFactory):
+class DataclassUnmarshalerFactory(AbstractDataclassFactory, SimpleUnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, type) and dc.is_dataclass(rty) and not lang.is_abstract_class(rty)
 

omlish/marshal/objects/marshal.py

@@ -6,7 +6,7 @@ from ... import dataclasses as dc
 from ... import reflect as rfl
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
+from ..base import SimpleMarshalerFactory
 from ..values import Value
 from .metadata import FieldInfo
 from .metadata import FieldInfos
@@ -86,7 +86,7 @@ class ObjectMarshaler(Marshaler):
 
 
 @dc.dataclass(frozen=True)
-class SimpleObjectMarshalerFactory(MarshalerFactory):
+class SimpleObjectMarshalerFactory(SimpleMarshalerFactory):
     dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
 
     _: dc.KW_ONLY

omlish/marshal/objects/namedtuples.py

@@ -7,11 +7,11 @@ from ... import lang
 from ... import reflect as rfl
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
 from ..base import Option
+from ..base import SimpleMarshalerFactory
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 from .marshal import ObjectMarshaler
 from .metadata import FieldInfo
 from .metadata import FieldInfos
@@ -55,7 +55,7 @@ def get_namedtuple_field_infos(
 ##
 
 
-class NamedtupleMarshalerFactory(MarshalerFactory):
+class NamedtupleMarshalerFactory(SimpleMarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
         return _is_namedtuple(rty)
 
@@ -79,7 +79,7 @@ class NamedtupleMarshalerFactory(MarshalerFactory):
 ##
 
 
-class NamedtupleUnmarshalerFactory(UnmarshalerFactory):
+class NamedtupleUnmarshalerFactory(SimpleUnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
         return _is_namedtuple(rty)
 

omlish/marshal/objects/unmarshal.py

@@ -4,9 +4,9 @@ import typing as ta
 from ... import check
 from ... import dataclasses as dc
 from ... import reflect as rfl
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 from ..values import Value
 from .metadata import FieldInfo
 from .metadata import FieldInfos
@@ -118,7 +118,7 @@ class ObjectUnmarshaler(Unmarshaler):
 
 
 @dc.dataclass(frozen=True)
-class SimpleObjectUnmarshalerFactory(UnmarshalerFactory):
+class SimpleObjectUnmarshalerFactory(SimpleUnmarshalerFactory):
     dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
 
     _: dc.KW_ONLY