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

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/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.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: MarshalContext, 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: UnmarshalContext, 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.MarshalContext, 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(nty)
+            return NotSpecifiedUnionMarshaler(m)
+
+        return inner
+
+
+class NotSpecifiedUnionUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        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(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,11 @@ 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.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if (rua := _reference_union_arg(rty)) is None:
+            return None
+        return lambda: _ReferenceUnionMarshaler(ctx.make(check.not_none(rua)), ctx.make(Reference))
 
 
 #
@@ -59,10 +59,11 @@ 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.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if (rua := _reference_union_arg(rty)) is None:
+            return None
+        return lambda: _ReferenceUnionUnmarshaler(ctx.make(check.not_none(rua)), ctx.make(Reference))
 
 
 ##
@@ -86,10 +87,11 @@ 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.MarshalContext, 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)))
                 for f, a in dc.reflect(Schema).field_annotations.items()
@@ -121,10 +123,11 @@ 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.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if rty is not Schema:
+            return None
+        return lambda: _SchemaUnmarshaler(
             {
                 msh.translate_name(f, msh.Naming.LOW_CAMEL): (f, ctx.make(rfl.type_(a)))
                 for f, a in dc.reflect(Schema).field_annotations.items()

omlish/typedvalues/marshal.py

@@ -1,9 +1,10 @@
+import typing as ta
+
 from .. import check
 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 .collection import TypedValues
 from .reflect import reflect_typed_values_impls
 from .values import ScalarTypedValue
@@ -14,7 +15,7 @@ from .values import TypedValue
 
 
 def _build_typed_value_poly(rty: rfl.Type) -> msh.Polymorphism:
-    ty: type[TypedValue] = check.issubclass(check.isinstance(rty, type), TypedValue)
+    ty: type[TypedValue] = check.issubclass(check.isinstance(rty, type), TypedValue)  # noqa
     check.state(lang.is_abstract_class(ty))
     return msh.polymorphism_from_subclasses(
         ty,
@@ -23,51 +24,68 @@ def _build_typed_value_poly(rty: rfl.Type) -> msh.Polymorphism:
     )
 
 
-class TypedValueMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, type) and
-        issubclass(rty, ScalarTypedValue) and
-        not lang.is_abstract_class(rty)
-    ))
-    def _build_scalar(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        dc_rfl = dc.reflect(check.isinstance(rty, type))
-        v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
-        v_m = ctx.make(v_rty)
-        return msh.WrappedMarshaler(lambda _, o: o.v, v_m)
-
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, type) and
-        issubclass(rty, TypedValue) and
-        lang.is_abstract_class(rty)
-    ))
-    def _build_abstract(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return msh.make_polymorphism_marshaler(
+class TypedValueMarshalerFactory(msh.MarshalerFactoryMethodClass):
+    @msh.MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_scalar(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (
+            isinstance(rty, type) and
+            issubclass(rty, ScalarTypedValue) and
+            not lang.is_abstract_class(rty)
+        ):
+            return None
+
+        def inner() -> msh.Marshaler:
+            dc_rfl = dc.reflect(check.isinstance(rty, type))
+            v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
+            v_m = ctx.make(v_rty)
+            return msh.WrappedMarshaler(lambda _, o: o.v, v_m)
+
+        return inner
+
+    @msh.MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_abstract(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (
+            isinstance(rty, type) and
+            issubclass(rty, TypedValue) and
+            lang.is_abstract_class(rty)
+        ):
+            return None
+
+        return lambda: msh.make_polymorphism_marshaler(
             _build_typed_value_poly(rty).impls,
             msh.WrapperTypeTagging(),
             ctx,
         )
 
 
-class TypedValueUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, type) and
-        issubclass(rty, ScalarTypedValue) and
-        not lang.is_abstract_class(rty)
-    ))
-    def _build_scalar(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        rty = check.isinstance(rty, type)
-        dc_rfl = dc.reflect(rty)
-        v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
-        v_u = ctx.make(v_rty)
-        return msh.WrappedUnmarshaler(lambda _, v: rty(v), v_u)
-
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, type) and
-        issubclass(rty, TypedValue) and
-        lang.is_abstract_class(rty)
-    ))
-    def _build_abstract(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return msh.make_polymorphism_unmarshaler(
+class TypedValueUnmarshalerFactory(msh.UnmarshalerFactoryMethodClass):
+    @msh.UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _make_scalar(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if not (
+            isinstance(rty, type) and
+            issubclass(rty, ScalarTypedValue) and
+            not lang.is_abstract_class(rty)
+        ):
+            return None
+
+        def inner() -> msh.Unmarshaler:
+            dc_rfl = dc.reflect(rty)
+            v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
+            v_u = ctx.make(v_rty)
+            return msh.WrappedUnmarshaler(lambda _, v: rty(v), v_u)
+
+        return inner
+
+    @msh.UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _make_abstract(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if not (
+            isinstance(rty, type) and
+            issubclass(rty, TypedValue) and
+            lang.is_abstract_class(rty)
+        ):
+            return None
+
+        return lambda: msh.make_polymorphism_unmarshaler(
             _build_typed_value_poly(rty).impls,
             msh.WrapperTypeTagging(),
             ctx,
@@ -108,14 +126,18 @@ def build_typed_values_marshaler(ctx: msh.MarshalContext, rty: rfl.Type) -> msh.
     return msh.IterableMarshaler(tv_m)
 
 
-class TypedValuesMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and rty.cls is TypedValues)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return build_typed_values_marshaler(ctx, rty)
+class TypedValuesMarshalerFactory(msh.MarshalerFactoryMethodClass):
+    @msh.MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_generic(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and rty.cls is TypedValues):
+            return None
+        return lambda: build_typed_values_marshaler(ctx, rty)
 
-    @mfs.simple(lambda _, ctx, rty: rty is TypedValues)
-    def _build_concrete(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        raise NotImplementedError
+    @msh.MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_concrete(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not TypedValues:
+            return None
+        return lambda: lang.raise_(NotImplementedError())
 
 
 #
@@ -130,14 +152,18 @@ def build_typed_values_unmarshaler(ctx: msh.UnmarshalContext, rty: rfl.Type) ->
     return msh.IterableUnmarshaler(lambda it: TypedValues(*it), tv_u)  # noqa
 
 
-class TypedValuesUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and rty.cls is TypedValues)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return build_typed_values_unmarshaler(ctx, rty)
+class TypedValuesUnmarshalerFactory(msh.UnmarshalerFactoryMethodClass):
+    @msh.UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and rty.cls is TypedValues):
+            return None
+        return lambda: build_typed_values_unmarshaler(ctx, rty)
 
-    @mfs.simple(lambda _, ctx, rty: rty is TypedValues)
-    def _build_concrete(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        raise NotImplementedError
+    @msh.UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _build_concrete(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if rty is not TypedValues:
+            return None
+        return lambda: lang.raise_(NotImplementedError())
 
 
 ##

{omlish-0.0.0.dev453.dist-info → omlish-0.0.0.dev454.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev453
+Version: 0.0.0.dev454
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause