omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/marshal/polymorphism/unions.py

@@ -5,14 +5,12 @@ from ... import check
 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.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
-from ..base.values import Value
-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
@@ -23,98 +21,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,
-)
-
-
-#
-
-
-@dc.dataclass(frozen=True)
-class PrimitiveUnionMarshaler(Marshaler):
-    tys: ta.Sequence[type]
-
-    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        if type(o) not in self.tys:
-            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 isinstance(rty, rfl.Union) and all(a in self.tys for a in rty.args)
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        args = check.isinstance(rty, rfl.Union).args
-        return PrimitiveUnionMarshaler([t for t in self.tys if t in args])
-
-
-#
-
-
-@dc.dataclass(frozen=True)
-class PrimitiveUnionUnmarshaler(Unmarshaler):
-    tys: ta.Sequence[type]
-
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
-        if type(v) not in self.tys:
-            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 isinstance(rty, rfl.Union) and all(a in self.tys for a in rty.args)
-
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        args = check.isinstance(rty, rfl.Union).args
-        return PrimitiveUnionUnmarshaler([t for t in self.tys if t in args])
-
-
-#
-
-
-PRIMITIVE_UNION_MARSHALER_FACTORY = PrimitiveUnionMarshalerFactory()
-PRIMITIVE_UNION_UNMARSHALER_FACTORY = PrimitiveUnionUnmarshalerFactory()
-
-
-##
-
-
 @dc.dataclass(frozen=True)
 class _BasePolymorphismUnionFactory(lang.Abstract):
     impls: Impls
@@ -126,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:
@@ -140,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,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.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
@@ -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(),
@@ -115,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)
 
@@ -148,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/metadata.py

@@ -19,6 +19,8 @@ from . import lang
 
 T = ta.TypeVar('T')
 
+ObjectMetadataT = ta.TypeVar('ObjectMetadataT', bound='ObjectMetadata')
+
 
 ##
 
@@ -94,12 +96,32 @@ def append_object_metadata(obj: T, *mds: ObjectMetadata) -> T:
 _type = type
 
 
+@ta.overload
+def get_object_metadata(
+        obj: ta.Any,
+        *,
+        strict: bool = False,
+        type: ta.Type[ObjectMetadataT],  # noqa
+) -> ta.Sequence[ObjectMetadataT]:
+    ...
+
+
+@ta.overload
 def get_object_metadata(
         obj: ta.Any,
         *,
         strict: bool = False,
         type: ta.Type | tuple[ta.Type, ...] | None = None,  # noqa
-) -> ta.Sequence[ObjectMetadata]:
+) -> ta.Sequence[ta.Any]:
+    ...
+
+
+def get_object_metadata(
+        obj,
+        *,
+        strict=False,
+        type=None,  # noqa
+):
     try:
         tgt = _unwrap_object_metadata_target(obj)
     except ObjectMetadataTargetTypeError:

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/os/pidfiles/pinning.py

@@ -25,8 +25,8 @@ import sys
 import time
 import typing as ta
 
-from ...diag.lslocks import LslocksCommand
-from ...diag.lsof import LsofCommand
+from ...diag.cmds.lslocks import LslocksCommand
+from ...diag.cmds.lsof import LsofCommand
 from ...lite.abstract import Abstract
 from ...lite.check import check
 from ...lite.timeouts import Timeout

omlish/reflect/types.py

@@ -9,6 +9,7 @@ give it some guiding North Star to make all of its decisions for it, and to add
 meet, join, solve, ...), but it's quite a bit of work and not a priority at the moment.
 
 TODO:
+ - !!! refactor like a GuardFn - no check_only, return a closure to continue computation !!!
  - !! cache this shit !!
   - especially generic_mro shit
 """

omlish/secrets/marshal.py

@@ -54,7 +54,7 @@ def marshal_secret_field(f: dc.Field) -> dc.Field:
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     msh.install_standard_factories(
         msh.ForbiddenTypeMarshalerFactory({Secret}),
         msh.ForbiddenTypeUnmarshalerFactory({Secret}),

omlish/specs/jmespath/__init__.py

@@ -28,6 +28,18 @@ See:
  - https://github.com/jmespath-community/jmespath.spec/discussions?discussions_q=label%3Ajep-candidate
  - https://github.com/jmespath-community/jmespath.spec/discussions/97
 """  # noqa
+from ... import dataclasses as _dc  # noqa
+
+
+_dc.init_package(
+    globals(),
+    codegen=True,
+)
+
+
+##
+
+
 from . import errors  # noqa
 from . import functions  # noqa
 from . import lexer  # noqa
@@ -41,6 +53,3 @@ from .parser import (  # noqa
 from .visitor import (  # noqa
     Options,
 )
-
-
-__version__ = '1.0.1'