omlish 0.0.0.dev453__py3-none-any.whl → 0.0.0.dev455__py3-none-any.whl

omlish/marshal/polymorphism/marshal.py

@@ -2,13 +2,13 @@ import abc
 import dataclasses as dc
 import typing as ta
 
-from ... import check
 from ... import lang
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleMarshalerFactory
 from .metadata import FieldTypeTagging
 from .metadata import Impls
 from .metadata import Polymorphism
@@ -53,10 +53,10 @@ class FieldPolymorphismMarshaler(PolymorphismMarshaler):
 def make_polymorphism_marshaler(
         impls: Impls,
         tt: TypeTagging,
-        ctx: MarshalContext,
+        ctx: MarshalFactoryContext,
 ) -> Marshaler:
     m = {
-        i.ty: (i.tag, ctx.make(i.ty))
+        i.ty: (i.tag, ctx.make_marshaler(i.ty))
         for i in impls
     }
     if isinstance(tt, WrapperTypeTagging):
@@ -68,13 +68,11 @@ def make_polymorphism_marshaler(
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismMarshalerFactory(SimpleMarshalerFactory):
+class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return rty is self.p.ty
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        check.is_(rty, self.p.ty)
-        return make_polymorphism_marshaler(self.p.impls, self.tt, ctx)
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if rty is not self.p.ty:
+            return None
+        return lambda: make_polymorphism_marshaler(self.p.impls, self.tt, ctx)

omlish/marshal/polymorphism/unions.py

@@ -1,14 +1,16 @@
+import typing as ta
+
 from ... import cached
 from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from ... import reflect as rfl
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
+from ..base.types import UnmarshalerFactory
 from .marshal import make_polymorphism_marshaler
 from .metadata import Impls
 from .metadata import TypeTagging
@@ -30,7 +32,7 @@ class _BasePolymorphismUnionFactory(lang.Abstract):
     def rtys(self) -> frozenset[rfl.Type]:
         return frozenset(i.ty for i in self.impls)
 
-    def guard(self, ctx: MarshalContext | UnmarshalContext, rty: rfl.Type) -> bool:
+    def _guard(self, rty: rfl.Type) -> bool:
         if not isinstance(rty, rfl.Union):
             return False
         if self.allow_partial:
@@ -44,12 +46,16 @@ class _BasePolymorphismUnionFactory(lang.Abstract):
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnionMarshalerFactory(_BasePolymorphismUnionFactory, SimpleMarshalerFactory):
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return make_polymorphism_marshaler(self.get_impls(rty), self.tt, ctx)
+class PolymorphismUnionMarshalerFactory(_BasePolymorphismUnionFactory, MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not self._guard(rty):
+            return None
+        return lambda: make_polymorphism_marshaler(self.get_impls(rty), self.tt, ctx)
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnionUnmarshalerFactory(_BasePolymorphismUnionFactory, SimpleUnmarshalerFactory):
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return make_polymorphism_unmarshaler(self.get_impls(rty), self.tt, ctx)
+class PolymorphismUnionUnmarshalerFactory(_BasePolymorphismUnionFactory, UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not self._guard(rty):
+            return None
+        return lambda: make_polymorphism_unmarshaler(self.get_impls(rty), self.tt, ctx)

omlish/marshal/polymorphism/unmarshal.py

@@ -7,9 +7,10 @@ from ... import check
 from ... import lang
 from ... import reflect as rfl
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleUnmarshalerFactory
 from .metadata import FieldTypeTagging
 from .metadata import Impls
 from .metadata import Polymorphism
@@ -58,12 +59,12 @@ class FieldPolymorphismUnmarshaler(PolymorphismUnmarshaler):
 def make_polymorphism_unmarshaler(
         impls: Impls,
         tt: TypeTagging,
-        ctx: UnmarshalContext,
+        ctx: UnmarshalFactoryContext,
 ) -> Unmarshaler:
     m = {
         t: u
         for i in impls
-        for u in [ctx.make(i.ty)]
+        for u in [ctx.make_unmarshaler(i.ty)]
         for t in [i.tag, *i.alts]
     }
     if isinstance(tt, WrapperTypeTagging):
@@ -75,13 +76,11 @@ def make_polymorphism_unmarshaler(
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnmarshalerFactory(SimpleUnmarshalerFactory):
+class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return rty is self.p.ty
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        check.is_(rty, self.p.ty)
-        return make_polymorphism_unmarshaler(self.p.impls, self.tt, ctx)
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if rty is not self.p.ty:
+            return None
+        return lambda: make_polymorphism_unmarshaler(self.p.impls, self.tt, ctx)

omlish/marshal/singular/enums.py

@@ -5,12 +5,14 @@ import typing as ta
 from ... import check
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
 
 
 ##
@@ -24,14 +26,11 @@ class EnumMarshaler(Marshaler):
         return o.name
 
 
-class EnumMarshalerFactory(SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, type) and issubclass(rty, enum.Enum)
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        ty = check.isinstance(rty, type)
-        check.state(issubclass(ty, enum.Enum))
-        return EnumMarshaler(ty)  # noqa
+class EnumMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, enum.Enum)):
+            return None
+        return lambda: EnumMarshaler(rty)  # noqa
 
 
 @dc.dataclass(frozen=True)
@@ -42,11 +41,8 @@ class EnumUnmarshaler(Unmarshaler):
         return self.ty[check.isinstance(v, str)]
 
 
-class EnumUnmarshalerFactory(SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, type) and issubclass(rty, enum.Enum)
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        ty = check.isinstance(rty, type)
-        check.state(issubclass(ty, enum.Enum))
-        return EnumUnmarshaler(ty)
+class EnumUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, type) and issubclass(rty, enum.Enum)):
+            return None
+        return lambda: EnumUnmarshaler(rty)  # noqa

omlish/marshal/standard.py

@@ -22,10 +22,10 @@ from .composite.optionals import OptionalMarshalerFactory
 from .composite.optionals import OptionalUnmarshalerFactory
 from .composite.special import SequenceNotStrMarshalerFactory
 from .composite.special import SequenceNotStrUnmarshalerFactory
-from .composite.unions import LiteralUnionMarshalerFactory
-from .composite.unions import LiteralUnionUnmarshalerFactory
-from .composite.unions import PrimitiveUnionMarshalerFactory
-from .composite.unions import PrimitiveUnionUnmarshalerFactory
+from .composite.unions.literals import LiteralUnionMarshalerFactory
+from .composite.unions.literals import LiteralUnionUnmarshalerFactory
+from .composite.unions.primitives import PrimitiveUnionMarshalerFactory
+from .composite.unions.primitives import PrimitiveUnionUnmarshalerFactory
 from .factories.invalidate import InvalidatableMarshalerFactory
 from .factories.invalidate import InvalidatableUnmarshalerFactory
 from .factories.moduleimport.factories import ModuleImportingMarshalerFactory
@@ -119,11 +119,11 @@ def new_standard_marshaler_factory(
         nonlocal gl
         gl = DEFAULT_STANDARD_FACTORIES
 
-        fi: MarshalerFactory = MultiMarshalerFactory([
+        fi: MarshalerFactory = MultiMarshalerFactory(
             *(first if first is not None else []),
             *gl.marshaler_factories,
             *(last if last is not None else []),
-        ])
+        )
 
         fi = RecursiveMarshalerFactory(fi)
 
@@ -152,11 +152,11 @@ def new_standard_unmarshaler_factory(
         nonlocal gl
         gl = DEFAULT_STANDARD_FACTORIES
 
-        fi: UnmarshalerFactory = MultiUnmarshalerFactory([
+        fi: UnmarshalerFactory = MultiUnmarshalerFactory(
             *(first if first is not None else []),
             *gl.unmarshaler_factories,
             *(last if last is not None else []),
-        ])
+        )
 
         fi = RecursiveUnmarshalerFactory(fi)
 

omlish/marshal/trivial/any.py

@@ -15,7 +15,7 @@ from ..factories.typemap import TypeMapUnmarshalerFactory
 
 class AnyMarshalerUnmarshaler(Marshaler, Unmarshaler):
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        return ctx.make(type(o)).marshal(ctx, o)
+        return ctx.marshal_factory_context.make_marshaler(type(o)).marshal(ctx, o)
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
         return v

omlish/marshal/trivial/forbidden.py

@@ -2,45 +2,40 @@ import dataclasses as dc
 import typing as ta
 
 from ... import reflect as rfl
-from ...funcs import match as mfs
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.errors import ForbiddenTypeError
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
-
-
-C = ta.TypeVar('C')
-R = ta.TypeVar('R')
+from ..base.types import UnmarshalerFactory
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class ForbiddenTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
+class ForbiddenTypeMarshalerFactoryUnmarshalerFactory(MarshalerFactory, UnmarshalerFactory):
     rtys: ta.AbstractSet[rfl.Type]
 
-    def guard(self, ctx: C, rty: rfl.Type) -> bool:
-        return rty in self.rtys
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if rty not in self.rtys:
+            return None
 
-    def fn(self, ctx: C, rty: rfl.Type) -> R:
-        raise ForbiddenTypeError(rty)
+        def inner():
+            raise ForbiddenTypeError(rty)
 
+        return inner
 
-@dc.dataclass(frozen=True)
-class ForbiddenTypeMarshalerFactory(
-    ForbiddenTypeFactory[MarshalContext, Marshaler],
-    SimpleMarshalerFactory,
-):
-    pass
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if rty not in self.rtys:
+            return None
 
+        def inner():
+            raise ForbiddenTypeError(rty)
 
-@dc.dataclass(frozen=True)
-class ForbiddenTypeUnmarshalerFactory(
-    ForbiddenTypeFactory[UnmarshalContext, Unmarshaler],
-    SimpleUnmarshalerFactory,
-):
-    pass
+        return inner
+
+
+ForbiddenTypeMarshalerFactory = ForbiddenTypeMarshalerFactoryUnmarshalerFactory
+ForbiddenTypeUnmarshalerFactory = ForbiddenTypeMarshalerFactoryUnmarshalerFactory

omlish/os/forkhooks.py

@@ -1,5 +1,9 @@
 # ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
+"""
+TODO:
+ - https://github.com/python/cpython/issues/50970
+"""
 import os
 import threading
 import typing as ta

omlish/specs/jsonrpc/_marshal.py

@@ -5,7 +5,6 @@ from ... import dataclasses as dc
 from ... import lang
 from ... import marshal as msh
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from .types import NotSpecified
 
 
@@ -25,29 +24,39 @@ class NotSpecifiedUnionMarshaler(msh.Marshaler):
         return self.m.marshal(ctx, o)
 
 
-class NotSpecifiedUnionMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, rfl.Union) and
-        not rty.is_optional and
-        _NOT_SPECIFIED_RTY in rty.args
-    ))
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        args = set(check.isinstance(rty, rfl.Union).args) - {_NOT_SPECIFIED_RTY}
-        nty = rfl.type_(ta.Union[*args])
-        m = ctx.make(nty)
-        return NotSpecifiedUnionMarshaler(m)
-
-
-class NotSpecifiedUnionUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, rfl.Union) and
-        not rty.is_optional and
-        _NOT_SPECIFIED_RTY in rty.args
-    ))
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        args = set(check.isinstance(rty, rfl.Union).args) - {_NOT_SPECIFIED_RTY}
-        nty = rfl.type_(ta.Union[*args])
-        return ctx.make(nty)
+class NotSpecifiedUnionMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (
+            isinstance(rty, rfl.Union) and
+            not rty.is_optional and
+            _NOT_SPECIFIED_RTY in rty.args
+        ):
+            return None
+
+        def inner() -> msh.Marshaler:
+            args = set(check.isinstance(rty, rfl.Union).args) - {_NOT_SPECIFIED_RTY}
+            nty = rfl.type_(ta.Union[*args])
+            m = ctx.make_marshaler(nty)
+            return NotSpecifiedUnionMarshaler(m)
+
+        return inner
+
+
+class NotSpecifiedUnionUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if not (
+            isinstance(rty, rfl.Union) and
+            not rty.is_optional and
+            _NOT_SPECIFIED_RTY in rty.args
+        ):
+            return None
+
+        def inner() -> msh.Unmarshaler:
+            args = set(check.isinstance(rty, rfl.Union).args) - {_NOT_SPECIFIED_RTY}
+            nty = rfl.type_(ta.Union[*args])
+            return ctx.make_unmarshaler(nty)
+
+        return inner
 
 
 @lang.static_init

omlish/specs/openapi/_marshal.py

@@ -5,7 +5,6 @@ from ... import dataclasses as dc
 from ... import lang
 from ... import marshal as msh
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from .. import jsonschema as jsch
 from .openapi import Reference
 from .openapi import Schema
@@ -36,10 +35,14 @@ class _ReferenceUnionMarshaler(msh.Marshaler):
             return self.m.marshal(ctx, o)
 
 
-class _ReferenceUnionMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: _reference_union_arg(rty) is not None)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _ReferenceUnionMarshaler(ctx.make(check.not_none(_reference_union_arg(rty))), ctx.make(Reference))
+class _ReferenceUnionMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if (rua := _reference_union_arg(rty)) is None:
+            return None
+        return lambda: _ReferenceUnionMarshaler(
+            ctx.make_marshaler(check.not_none(rua)),
+            ctx.make_marshaler(Reference),
+        )
 
 
 #
@@ -59,10 +62,14 @@ class _ReferenceUnionUnmarshaler(msh.Unmarshaler):
             return self.u.unmarshal(ctx, v)  # noqa
 
 
-class _ReferenceUnionUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: _reference_union_arg(rty) is not None)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _ReferenceUnionUnmarshaler(ctx.make(check.not_none(_reference_union_arg(rty))), ctx.make(Reference))
+class _ReferenceUnionUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if (rua := _reference_union_arg(rty)) is None:
+            return None
+        return lambda: _ReferenceUnionUnmarshaler(
+            ctx.make_unmarshaler(check.not_none(rua)),
+            ctx.make_unmarshaler(Reference),
+        )
 
 
 ##
@@ -86,16 +93,17 @@ class _SchemaMarshaler(msh.Marshaler):
         return dct
 
 
-class _SchemaMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is Schema)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _SchemaMarshaler(
+class _SchemaMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not Schema:
+            return None
+        return lambda: _SchemaMarshaler(
             {
-                f: (msh.translate_name(f, msh.Naming.LOW_CAMEL), ctx.make(rfl.type_(a)))
+                f: (msh.translate_name(f, msh.Naming.LOW_CAMEL), ctx.make_marshaler(rfl.type_(a)))
                 for f, a in dc.reflect(Schema).field_annotations.items()
                 if f != 'keywords'
             },
-            ctx.make(jsch.Keywords),
+            ctx.make_marshaler(jsch.Keywords),
         )
 
 
@@ -121,16 +129,17 @@ class _SchemaUnmarshaler(msh.Unmarshaler):
         return Schema(**kw)
 
 
-class _SchemaUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is Schema)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _SchemaUnmarshaler(
+class _SchemaUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if rty is not Schema:
+            return None
+        return lambda: _SchemaUnmarshaler(
             {
-                msh.translate_name(f, msh.Naming.LOW_CAMEL): (f, ctx.make(rfl.type_(a)))
+                msh.translate_name(f, msh.Naming.LOW_CAMEL): (f, ctx.make_unmarshaler(rfl.type_(a)))
                 for f, a in dc.reflect(Schema).field_annotations.items()
                 if f != 'keywords'
             },
-            ctx.make(jsch.Keywords),
+            ctx.make_unmarshaler(jsch.Keywords),
         )