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

omlish/marshal/composite/unions.py

@@ -0,0 +1,213 @@
+import typing as ta
+
+from ... import check
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base.contexts import MarshalContext
+from ..base.contexts import UnmarshalContext
+from ..base.types import Marshaler
+from ..base.types import Unmarshaler
+from ..base.values import Value
+from ..factories.simple import SimpleMarshalerFactory
+from ..factories.simple import SimpleUnmarshalerFactory
+
+
+##
+
+
+class MatchUnionMarshaler(Marshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        try:
+            m = self.mmf.match(ctx, o)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(o)  # noqa
+        return m.fn(ctx, o)
+
+
+class MatchUnionUnmarshaler(Unmarshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        try:
+            m = self.mmf.match(ctx, v)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(v)  # noqa
+        return m.fn(ctx, v)
+
+
+##
+
+
+PRIMITIVE_UNION_TYPES: tuple[type, ...] = (
+    float,
+    int,
+    str,
+    bool,
+)
+
+
+class DestructuredPrimitiveUnionType(ta.NamedTuple):
+    prim: ta.Sequence[type]
+    non_prim: ta.Sequence[rfl.Type]
+
+
+def _destructure_primitive_union_type(
+        rty: rfl.Type,
+        prim_tys: ta.Container[type] = PRIMITIVE_UNION_TYPES,
+) -> DestructuredPrimitiveUnionType | None:
+    if not isinstance(rty, rfl.Union):
+        return None
+
+    pr = col.partition(rty.args, lambda a: isinstance(a, type) and a in prim_tys)
+    if not pr.t or len(pr.f) > 1:
+        return None
+
+    return DestructuredPrimitiveUnionType(*pr)  # type: ignore[arg-type]
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshaler(Marshaler):
+    tys: ta.Sequence[type]
+    x: Marshaler | None = None
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        if type(o) not in self.tys:
+            if self.x is not None:
+                return self.x.marshal(ctx, o)
+            raise TypeError(o)
+        return o
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshalerFactory(SimpleMarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return _destructure_primitive_union_type(rty, self.tys) is not None
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        prim, non_prim = check.not_none(_destructure_primitive_union_type(rty, self.tys))
+        return PrimitiveUnionMarshaler(
+            prim,
+            ctx.make(check.single(non_prim)) if non_prim else None,
+        )
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshaler(Unmarshaler):
+    tys: ta.Sequence[type]
+    x: Unmarshaler | None = None
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        if type(v) not in self.tys:
+            if self.x is not None:
+                return self.x.unmarshal(ctx, v)
+            raise TypeError(v)
+        return v
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshalerFactory(SimpleUnmarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return _destructure_primitive_union_type(rty, self.tys) is not None
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        prim, non_prim = check.not_none(_destructure_primitive_union_type(rty, self.tys))
+        return PrimitiveUnionUnmarshaler(
+            prim,
+            ctx.make(check.single(non_prim)) if non_prim else None,
+        )
+
+
+##
+
+
+LITERAL_UNION_TYPES: tuple[type, ...] = (
+    int,
+    str,
+)
+
+
+class DestructuredLiteralUnionType(ta.NamedTuple):
+    v_ty: type
+    lit: rfl.Literal
+    non_lit: rfl.Type
+
+
+def _destructure_literal_union_type(rty: rfl.Type) -> DestructuredLiteralUnionType | None:
+    if not isinstance(rty, rfl.Union):
+        return None
+    lits, non_lits = col.partition(rty.args, lang.isinstance_of(rfl.Literal))  # noqa
+    if len(lits) != 1 or len(non_lits) != 1:
+        return None
+    lit = check.isinstance(check.single(lits), rfl.Literal)
+    v_tys = set(map(type, lit.args))
+    if len(v_tys) != 1:
+        return None
+    [v_ty] = v_tys
+    if v_ty in rty.args or v_ty not in LITERAL_UNION_TYPES:
+        return None
+    return DestructuredLiteralUnionType(v_ty, lit, check.single(non_lits))
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class LiteralUnionMarshaler(Marshaler):
+    v_ty: type
+    l: Marshaler
+    x: Marshaler
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        if isinstance(o, self.v_ty):
+            return self.l.marshal(ctx, o)
+        else:
+            return self.x.marshal(ctx, o)
+
+
+class LiteralUnionMarshalerFactory(SimpleMarshalerFactory):
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return _destructure_literal_union_type(rty) is not None
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        ds = check.not_none(_destructure_literal_union_type(rty))
+        return LiteralUnionMarshaler(ds.v_ty, ctx.make(ds.lit), ctx.make(ds.non_lit))
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class LiteralUnionUnmarshaler(Unmarshaler):
+    v_ty: type
+    l: Unmarshaler
+    x: Unmarshaler
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        if isinstance(v, self.v_ty):
+            return self.l.unmarshal(ctx, v)  # type: ignore[arg-type]
+        else:
+            return self.x.unmarshal(ctx, v)
+
+
+class LiteralUnionUnmarshalerFactory(SimpleUnmarshalerFactory):
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return _destructure_literal_union_type(rty) is not None
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        ds = check.not_none(_destructure_literal_union_type(rty))
+        return LiteralUnionUnmarshaler(ds.v_ty, ctx.make(ds.lit), ctx.make(ds.non_lit))

omlish/marshal/factories/moduleimport/factories.py

@@ -43,11 +43,11 @@ class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
         self._callback = callback
 
         self._lock = threading.RLock()
-        self._has_imported = False
+        self._last_mis: ta.Any = None
 
-    def _do_import(self, ctx: ContextT) -> None:
+    def _do_import(self, ctx: ContextT, mis: ta.Sequence[ModuleImport]) -> None:
         c = 0
-        for mi in ctx.config_registry.get_of(None, ModuleImport):
+        for mi in mis:
             if mi.import_if_necessary():
                 c += 1
 
@@ -56,13 +56,11 @@ class _ModuleImportingFactory(mfs.MatchFn[[ContextT, rfl.Type], R]):
                 self._callback()
 
     def _import_if_necessary(self, ctx: ContextT) -> None:
-        # FIXME:
-        # if not self._has_imported:
-        #     with self._lock:
-        #         if not self._has_imported:
-        #             self._do_import(ctx)
-        #             self._has_imported = True
-        self._do_import(ctx)
+        if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
+            with self._lock:
+                if (mis := ctx.config_registry.get_of(None, ModuleImport)) and mis is not self._last_mis:
+                    self._do_import(ctx, mis)
+                    self._last_mis = mis
 
     def guard(self, ctx: ContextT, rty: rfl.Type) -> bool:
         self._import_if_necessary(ctx)

omlish/marshal/polymorphism/metadata.py

@@ -107,23 +107,34 @@ class Polymorphism:
         return self._impls
 
 
+class AutoStripSuffix(lang.Marker):
+    pass
+
+
 def polymorphism_from_impls(
         ty: type,
         impls: ta.Iterable[type],
         *,
         naming: Naming | None = None,
-        strip_suffix: bool | ta.Literal['auto'] = False,
+        strip_suffix: bool | type[AutoStripSuffix] | str = False,
 ) -> Polymorphism:
     impls = set(impls)
 
-    if strip_suffix == 'auto':
+    ssx: str | None
+    if strip_suffix is AutoStripSuffix:
         strip_suffix = all(c.__name__.endswith(ty.__name__) for c in impls)
+    if isinstance(strip_suffix, bool):
+        ssx = ty.__name__ if strip_suffix else None
+    elif isinstance(strip_suffix, str):
+        ssx = strip_suffix
+    else:
+        raise TypeError(strip_suffix)
 
     dct: dict[str, Impl] = {}
     for cur in impls:
         name = cur.__name__
-        if strip_suffix:
-            name = lang.strip_suffix(name, ty.__name__)
+        if ssx is not None:
+            name = lang.strip_suffix(name, ssx)
         if naming is not None:
             name = translate_name(name, naming)
         if name in dct:
@@ -141,7 +152,7 @@ def polymorphism_from_subclasses(
         ty: type,
         *,
         naming: Naming | None = None,
-        strip_suffix: bool | ta.Literal['auto'] = False,
+        strip_suffix: bool | type[AutoStripSuffix] | str = False,
 ) -> Polymorphism:
     return polymorphism_from_impls(
         ty,

omlish/marshal/polymorphism/standard.py

@@ -1,9 +1,13 @@
+import typing as ta
+
 from ..base.types import MarshalerFactory
 from ..base.types import UnmarshalerFactory
 from .marshal import PolymorphismMarshalerFactory
 from .metadata import Polymorphism
 from .metadata import TypeTagging
 from .metadata import WrapperTypeTagging
+from .unions import PolymorphismUnionMarshalerFactory
+from .unions import PolymorphismUnionUnmarshalerFactory
 from .unmarshal import PolymorphismUnmarshalerFactory
 
 
@@ -13,8 +17,18 @@ from .unmarshal import PolymorphismUnmarshalerFactory
 def standard_polymorphism_factories(
         poly: Polymorphism,
         tt: TypeTagging = WrapperTypeTagging(),
-) -> tuple[MarshalerFactory, UnmarshalerFactory]:
-    return (
+        *,
+        unions: bool | ta.Literal['partial'] = False,
+) -> ta.Sequence[MarshalerFactory | UnmarshalerFactory]:
+    out: list[MarshalerFactory | UnmarshalerFactory] = [
         PolymorphismMarshalerFactory(poly, tt),
         PolymorphismUnmarshalerFactory(poly, tt),
-    )
+    ]
+
+    if unions:
+        out.extend([
+            PolymorphismUnionMarshalerFactory(poly.impls, tt, allow_partial=unions == 'partial'),
+            PolymorphismUnionUnmarshalerFactory(poly.impls, tt, allow_partial=unions == 'partial'),
+        ])
+
+    return out

omlish/marshal/polymorphism/unions.py

@@ -1,17 +1,12 @@
-import typing as ta
-
 from ... import cached
 from ... import check
-from ... import collections as col
 from ... import dataclasses as dc
 from ... import lang
 from ... import reflect as rfl
-from ...funcs import match as mfs
 from ..base.contexts import MarshalContext
 from ..base.contexts import UnmarshalContext
 from ..base.types import Marshaler
 from ..base.types import Unmarshaler
-from ..base.values import Value
 from ..factories.simple import SimpleMarshalerFactory
 from ..factories.simple import SimpleUnmarshalerFactory
 from .marshal import make_polymorphism_marshaler
@@ -24,130 +19,6 @@ from .unmarshal import make_polymorphism_unmarshaler
 ##
 
 
-class MatchUnionMarshaler(Marshaler):
-    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
-
-    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        try:
-            m = self.mmf.match(ctx, o)
-        except mfs.AmbiguousMatchesError:
-            raise ValueError(o)  # noqa
-        return m.fn(ctx, o)
-
-
-class MatchUnionUnmarshaler(Unmarshaler):
-    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
-
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
-        try:
-            m = self.mmf.match(ctx, v)
-        except mfs.AmbiguousMatchesError:
-            raise ValueError(v)  # noqa
-        return m.fn(ctx, v)
-
-
-##
-
-
-PRIMITIVE_UNION_TYPES: tuple[type, ...] = (
-    float,
-    int,
-    str,
-    bool,
-)
-
-
-class DestructuredPrimitiveUnionType(ta.NamedTuple):
-    prim: ta.Sequence[type]
-    non_prim: ta.Sequence[rfl.Type]
-
-
-def _destructure_primitive_union_type(
-        rty: rfl.Type,
-        prim_tys: ta.Container[type] = PRIMITIVE_UNION_TYPES,
-) -> DestructuredPrimitiveUnionType | None:
-    if not isinstance(rty, rfl.Union):
-        return None
-
-    pr = col.partition(rty.args, lambda a: isinstance(a, type) and a in prim_tys)
-    if not pr.t or len(pr.f) > 1:
-        return None
-
-    return DestructuredPrimitiveUnionType(*pr)  # type: ignore[arg-type]
-
-
-#
-
-
-@dc.dataclass(frozen=True)
-class PrimitiveUnionMarshaler(Marshaler):
-    tys: ta.Sequence[type]
-    x: Marshaler | None = None
-
-    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        if type(o) not in self.tys:
-            if self.x is not None:
-                return self.x.marshal(ctx, o)
-            raise TypeError(o)
-        return o
-
-
-@dc.dataclass(frozen=True)
-class PrimitiveUnionMarshalerFactory(SimpleMarshalerFactory):
-    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
-
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return _destructure_primitive_union_type(rty, self.tys) is not None
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        prim, non_prim = check.not_none(_destructure_primitive_union_type(rty, self.tys))
-        return PrimitiveUnionMarshaler(
-            prim,
-            ctx.make(check.single(non_prim)) if non_prim else None,
-        )
-
-
-#
-
-
-@dc.dataclass(frozen=True)
-class PrimitiveUnionUnmarshaler(Unmarshaler):
-    tys: ta.Sequence[type]
-    x: Unmarshaler | None = None
-
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
-        if type(v) not in self.tys:
-            if self.x is not None:
-                return self.x.unmarshal(ctx, v)
-            raise TypeError(v)
-        return v
-
-
-@dc.dataclass(frozen=True)
-class PrimitiveUnionUnmarshalerFactory(SimpleUnmarshalerFactory):
-    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
-
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return _destructure_primitive_union_type(rty, self.tys) is not None
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        prim, non_prim = check.not_none(_destructure_primitive_union_type(rty, self.tys))
-        return PrimitiveUnionUnmarshaler(
-            prim,
-            ctx.make(check.single(non_prim)) if non_prim else None,
-        )
-
-
-#
-
-
-PRIMITIVE_UNION_MARSHALER_FACTORY = PrimitiveUnionMarshalerFactory()
-PRIMITIVE_UNION_UNMARSHALER_FACTORY = PrimitiveUnionUnmarshalerFactory()
-
-
-##
-
-
 @dc.dataclass(frozen=True)
 class _BasePolymorphismUnionFactory(lang.Abstract):
     impls: Impls

omlish/marshal/standard.py

@@ -22,6 +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 .factories.invalidate import InvalidatableMarshalerFactory
 from .factories.invalidate import InvalidatableUnmarshalerFactory
 from .factories.moduleimport.factories import ModuleImportingMarshalerFactory
@@ -36,8 +40,6 @@ from .objects.dataclasses import DataclassMarshalerFactory
 from .objects.dataclasses import DataclassUnmarshalerFactory
 from .objects.namedtuples import NamedtupleMarshalerFactory
 from .objects.namedtuples import NamedtupleUnmarshalerFactory
-from .polymorphism.unions import PrimitiveUnionMarshalerFactory
-from .polymorphism.unions import PrimitiveUnionUnmarshalerFactory
 from .singular.datetimes import DATETIME_MARSHALER_FACTORY
 from .singular.datetimes import DATETIME_UNMARSHALER_FACTORY
 from .singular.enums import EnumMarshalerFactory
@@ -65,6 +67,7 @@ DEFAULT_STANDARD_FACTORIES = StandardFactories(
         PRIMITIVE_MARSHALER_FACTORY,
         NewtypeMarshalerFactory(),
         OptionalMarshalerFactory(),
+        LiteralUnionMarshalerFactory(),
         PrimitiveUnionMarshalerFactory(),
         DataclassMarshalerFactory(),
         NamedtupleMarshalerFactory(),
@@ -84,6 +87,7 @@ DEFAULT_STANDARD_FACTORIES = StandardFactories(
         PRIMITIVE_UNMARSHALER_FACTORY,
         NewtypeUnmarshalerFactory(),
         OptionalUnmarshalerFactory(),
+        LiteralUnionUnmarshalerFactory(),
         PrimitiveUnionUnmarshalerFactory(),
         DataclassUnmarshalerFactory(),
         NamedtupleUnmarshalerFactory(),

omlish/sql/queries/_marshal.py

@@ -92,7 +92,7 @@ def _install_standard_marshaling() -> None:
         p = msh.polymorphism_from_subclasses(
             cls,
             naming=msh.Naming.SNAKE,
-            strip_suffix='auto',
+            strip_suffix=msh.AutoStripSuffix,
         )
         msh.install_standard_factories(
             msh.PolymorphismMarshalerFactory(p),

omlish/sql/queries/rendering.py

@@ -81,7 +81,7 @@ class Renderer(lang.Abstract):
     def args(self) -> lang.Args:
         return self._params_preparer.prepare()
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def render(self, o: ta.Any) -> tp.Part:
         raise TypeError(o)
 

omlish/text/parts.py

@@ -75,7 +75,7 @@ class PartTransform:
     def __call__(self, part: Part | None) -> Part:
         return self._transform(part)
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def _transform(self, part: Part | None) -> Part:
         raise TypeError(part)
 
@@ -214,7 +214,7 @@ class PartRenderer:
     def __call__(self, part: Part | None) -> None:
         return self._render(part)
 
-    @dispatch.method
+    @dispatch.method()
     def _render(self, part: Part | None) -> None:
         raise TypeError(part)
 

omlish/typedvalues/marshal.py

@@ -19,7 +19,7 @@ def _build_typed_value_poly(rty: rfl.Type) -> msh.Polymorphism:
     return msh.polymorphism_from_subclasses(
         ty,
         naming=msh.Naming.SNAKE,
-        strip_suffix='auto',
+        strip_suffix=msh.AutoStripSuffix,
     )
 
 

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

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