omlish 0.0.0.dev423__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/math/fixed.py

@@ -70,8 +70,8 @@ class FixedWidthInt(int, lang.Abstract):
 
     #
 
-    def __init_subclass__(cls) -> None:
-        super().__init_subclass__()
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
 
         if lang.is_abstract_class(cls):
             return

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/atomics.py

@@ -7,11 +7,11 @@ import tempfile
 import typing as ta
 
 from ..lite.abstract import Abstract
+from ..lite.attrops import attr_repr
 from ..lite.check import check
-from ..lite.strings import attr_repr
 
 
-AtomicPathSwapKind = ta.Literal['dir', 'file']
+AtomicPathSwapKind = ta.Literal['dir', 'file']  # ta.TypeAlias
 AtomicPathSwapState = ta.Literal['open', 'committed', 'aborted']  # ta.TypeAlias
 
 

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/journald.py

@@ -79,7 +79,7 @@ SD_LOG_LEVEL_MAP: ta.Mapping[int, int] = {
 }
 
 
-class JournaldLogHandler(logging.Handler):
+class JournaldLoggingHandler(logging.Handler):
     """
     TODO:
      - fallback handler for when this barfs
@@ -148,7 +148,7 @@ class JournaldLogHandler(logging.Handler):
             self.handleError(record)
 
 
-def journald_log_handler_factory(
+def journald_logging_handler_factory(
         *,
         no_tty_check: bool = False,
         no_fallback: bool = False,
@@ -158,6 +158,6 @@ def journald_log_handler_factory(
             (no_tty_check or not sys.stderr.isatty()) and
             (no_fallback or sd_try_libsystemd() is not None)
     ):
-        return JournaldLogHandler()
+        return JournaldLoggingHandler()
 
     return logging.StreamHandler()

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/ops.py

@@ -1,3 +1,12 @@
+"""
+TODO:
+ - visitor / transformer
+  - gson had an ObjectNavigator:
+   - https://github.com/google/gson/blob/f291c4d33ea5fcc52afcfa5713e519e663378bda/gson/src/main/java/com/google/gson/ObjectNavigator.java
+   - removed in 25c6ae177b1ca56db7f3c29eb574bdd032a06165
+ - uniform collection isinstance - items() for mappings, iter() for other
+ - also check instance type in isinstance not just items lol
+"""  # noqa
 import dataclasses as dc
 import typing as ta
 

omlish/reflect/types.py

@@ -9,12 +9,9 @@ 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:
- - visitor / transformer
- - uniform collection isinstance - items() for mappings, iter() for other
- - also check instance type in isinstance not just items lol
- - ta.Generic in mro causing trouble - omit? no longer 1:1
- - cache this shit, esp generic_mro shit
-  - cache __hash__ in Generic/Union
+ - !!! refactor like a GuardFn - no check_only, return a closure to continue computation !!!
+ - !! cache this shit !!
+  - especially generic_mro shit
 """
 import dataclasses as dc
 import threading
@@ -22,6 +19,7 @@ import types
 import typing as ta
 
 from ..lite.abstract import Abstract
+from ..lite.dataclasses import dataclass_cache_hash
 
 
 _NoneType = types.NoneType  # type: ignore
@@ -51,6 +49,7 @@ if not isinstance(_Protocol, type) or not issubclass(_Protocol, _Generic):
 ##
 
 
+@dataclass_cache_hash()
 @dc.dataclass(frozen=True)
 class _Special:
     name: str
@@ -68,6 +67,7 @@ class _Special:
         )
 
 
+@dataclass_cache_hash()
 @dc.dataclass(frozen=True)
 class _LazySpecial:
     name: str
@@ -226,7 +226,7 @@ def is_simple_generic_alias_type(oty: type) -> bool:
 
 def get_params(obj: ta.Any) -> tuple[ta.TypeVar, ...]:
     if isinstance(obj, type):
-        if issubclass(obj, ta.Generic):  # type: ignore
+        if issubclass(obj, ta.Generic):
             return obj.__dict__.get('__parameters__', ())  # noqa
 
         if (ks := _KNOWN_SPECIALS.get_by_origin(obj)) is not None:
@@ -297,6 +297,7 @@ TYPES: tuple[type, ...] = (
 ##
 
 
+@dataclass_cache_hash()
 @dc.dataclass(frozen=True)
 class Union(TypeInfo):
     args: frozenset[Type]
@@ -320,6 +321,7 @@ class Union(TypeInfo):
 GenericLikeCls = ta.TypeVar('GenericLikeCls')
 
 
+@dataclass_cache_hash()
 @dc.dataclass(frozen=True)
 class GenericLike(TypeInfo, Abstract, ta.Generic[GenericLikeCls]):
     cls: GenericLikeCls
@@ -363,6 +365,7 @@ class Protocol(GenericLike[ta.Any]):
 #
 
 
+@dataclass_cache_hash()
 @dc.dataclass(frozen=True)
 class NewType(TypeInfo):
     obj: ta.Any
@@ -372,6 +375,7 @@ class NewType(TypeInfo):
 #
 
 
+@dataclass_cache_hash()
 @dc.dataclass(frozen=True)
 class Annotated(TypeInfo):
     ty: Type
@@ -383,6 +387,7 @@ class Annotated(TypeInfo):
 #
 
 
+@dataclass_cache_hash()
 @dc.dataclass(frozen=True)
 class Literal(TypeInfo):
     args: tuple[ta.Any, ...]
@@ -407,6 +412,25 @@ class ReflectTypeError(TypeError):
     pass
 
 
+_TRIVIAL_TYPES: set[ta.Any] = {
+    bool,
+    int,
+    str,
+    float,
+    object,
+    type(None),
+}
+
+
+# TODO: speed up is_type: `if obj.__class__ in _NOT_SUBCLASSED_SPECIAL_TYPES: return True`
+# _NOT_SUBCLASSED_SPECIAL_TYPES: set[type] = {
+#     type(ta.Any),
+#     _UnionGenericAlias,
+#     ta.NewType,
+# }
+# TODO: static_init(for t in _NOT_SUBCLASSED_SPECIAL_TYPES: if (sts := t.__subclasses__()): raise TypeError)
+
+
 class Reflector:
     def __init__(
             self,
@@ -448,12 +472,24 @@ class Reflector:
         if obj is ta.Any:
             return ANY
 
+        ##
+        # Trivial
+
+        try:
+            if obj in _TRIVIAL_TYPES:
+                return obj
+        except TypeError:
+            pass
+
         ##
         # Already a Type?
 
         if isinstance(obj, (ta.TypeVar, TypeInfo)):  # noqa
             return obj
 
+        ##
+        # It's a type
+
         oty = type(obj)
 
         ##
@@ -556,7 +592,7 @@ class Reflector:
                     obj,
                 )
 
-            if issubclass(obj, ta.Generic):  # type: ignore
+            if issubclass(obj, ta.Generic):
                 params = get_params(obj)
                 if params:
                     return Generic(

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}),