omlish 0.0.0.dev172__tar.gz → 0.0.0.dev174__tar.gz

{omlish-0.0.0.dev172/omlish.egg-info → omlish-0.0.0.dev174}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev172
+Version: 0.0.0.dev174
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev172'
-__revision__ = 'e37ff8d8de7971241ac3ad5a24d9b2fdc38f56c9'
+__version__ = '0.0.0.dev174'
+__revision__ = '4f993faa76d18f69b14ecdaef0be0291704815e2'
 
 
 #

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish/lite/dataclasses.py

@@ -1,5 +1,6 @@
 # ruff: noqa: UP006 UP007
 import dataclasses as dc
+import typing as ta
 
 
 def dataclass_cache_hash(
@@ -30,3 +31,12 @@ def dataclass_cache_hash(
         return cls
 
     return inner
+
+
+def dataclass_maybe_post_init(sup: ta.Any) -> bool:
+    try:
+        fn = sup.__post_init__
+    except AttributeError:
+        return False
+    fn()
+    return True

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish/lite/marshal.py

@@ -21,9 +21,11 @@ import weakref  # noqa
 
 from .check import check
 from .reflect import deep_subclasses
+from .reflect import get_literal_type_args
 from .reflect import get_new_type_supertype
 from .reflect import get_optional_alias_arg
 from .reflect import is_generic_alias
+from .reflect import is_literal_type
 from .reflect import is_new_type
 from .reflect import is_union_alias
 from .strings import snake_case
@@ -141,6 +143,18 @@ class OptionalObjMarshaler(ObjMarshaler):
         return self.item.unmarshal(o, ctx)
 
 
+@dc.dataclass(frozen=True)
+class LiteralObjMarshaler(ObjMarshaler):
+    item: ObjMarshaler
+    vs: frozenset
+
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.item.marshal(check.in_(o, self.vs), ctx)
+
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check.in_(self.item.unmarshal(o, ctx), self.vs)
+
+
 @dc.dataclass(frozen=True)
 class MappingObjMarshaler(ObjMarshaler):
     ty: type
@@ -352,6 +366,11 @@ class ObjMarshalerManager:
         if is_new_type(ty):
             return rec(get_new_type_supertype(ty))
 
+        if is_literal_type(ty):
+            lvs = frozenset(get_literal_type_args(ty))
+            lty = check.single(set(map(type, lvs)))
+            return LiteralObjMarshaler(rec(lty), lvs)
+
         if is_generic_alias(ty):
             try:
                 mt = self._generic_mapping_types[ta.get_origin(ty)]

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish/lite/reflect.py

@@ -7,6 +7,9 @@ import typing as ta
 T = ta.TypeVar('T')
 
 
+##
+
+
 _GENERIC_ALIAS_TYPES = (
     ta._GenericAlias,  # type: ignore  # noqa
     *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
@@ -24,6 +27,9 @@ is_union_alias = functools.partial(is_generic_alias, origin=ta.Union)
 is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
 
 
+##
+
+
 def is_optional_alias(spec: ta.Any) -> bool:
     return (
         isinstance(spec, _GENERIC_ALIAS_TYPES) and  # noqa
@@ -38,6 +44,9 @@ def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
     return it
 
 
+##
+
+
 def is_new_type(spec: ta.Any) -> bool:
     if isinstance(ta.NewType, type):
         return isinstance(spec, ta.NewType)
@@ -50,6 +59,26 @@ def get_new_type_supertype(spec: ta.Any) -> ta.Any:
     return spec.__supertype__
 
 
+##
+
+
+def is_literal_type(spec: ta.Any) -> bool:
+    if hasattr(ta, '_LiteralGenericAlias'):
+        return isinstance(spec, ta._LiteralGenericAlias)  # noqa
+    else:
+        return (
+            isinstance(spec, ta._GenericAlias) and  # type: ignore  # noqa
+            spec.__origin__ is ta.Literal
+        )
+
+
+def get_literal_type_args(spec: ta.Any) -> ta.Iterable[ta.Any]:
+    return spec.__args__
+
+
+##
+
+
 def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
     seen = set()
     todo = list(reversed(cls.__subclasses__()))

omlish-0.0.0.dev174/omlish/marshal/literals.py

@@ -0,0 +1,50 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import check
+from .. import reflect as rfl
+from .base import MarshalContext
+from .base import Marshaler
+from .base import MarshalerFactory
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .values import Value
+
+
+@dc.dataclass(frozen=True)
+class LiteralMarshaler(Marshaler):
+    e: Marshaler
+    vs: frozenset
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        return self.e.marshal(ctx, check.in_(o, self.vs))
+
+
+class LiteralMarshalerFactory(MarshalerFactory):
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Literal)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        lty = check.isinstance(rty, rfl.Literal)
+        ety = check.single(set(map(type, lty.args)))
+        return LiteralMarshaler(ctx.make(ety), frozenset(lty.args))
+
+
+@dc.dataclass(frozen=True)
+class LiteralUnmarshaler(Unmarshaler):
+    e: Unmarshaler
+    vs: frozenset
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        return check.in_(self.e.unmarshal(ctx, v), self.vs)
+
+
+class LiteralUnmarshalerFactory(UnmarshalerFactory):
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Literal)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        lty = check.isinstance(rty, rfl.Literal)
+        ety = check.single(set(map(type, lty.args)))
+        return LiteralUnmarshaler(ctx.make(ety), frozenset(lty.args))

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish/marshal/standard.py

@@ -17,6 +17,8 @@ from .enums import EnumMarshalerFactory
 from .enums import EnumUnmarshalerFactory
 from .iterables import IterableMarshalerFactory
 from .iterables import IterableUnmarshalerFactory
+from .literals import LiteralMarshalerFactory
+from .literals import LiteralUnmarshalerFactory
 from .mappings import MappingMarshalerFactory
 from .mappings import MappingUnmarshalerFactory
 from .maybes import MaybeMarshalerFactory
@@ -48,6 +50,7 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     DataclassMarshalerFactory(),
     NamedtupleMarshalerFactory(),
     EnumMarshalerFactory(),
+    LiteralMarshalerFactory(),
     NUMBERS_MARSHALER_FACTORY,
     UUID_MARSHALER_FACTORY,
     BASE64_MARSHALER_FACTORY,
@@ -80,6 +83,7 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     DataclassUnmarshalerFactory(),
     NamedtupleUnmarshalerFactory(),
     EnumUnmarshalerFactory(),
+    LiteralUnmarshalerFactory(),
     NUMBERS_UNMARSHALER_FACTORY,
     UUID_UNMARSHALER_FACTORY,
     BASE64_UNMARSHALER_FACTORY,

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish/reflect/__init__.py

@@ -27,10 +27,13 @@ from .types import (  # noqa
     Any,
     DEFAULT_REFLECTOR,
     Generic,
+    Literal,
     NewType,
+    ReflectTypeError,
     Reflector,
     TYPES,
     Type,
+    TypeInfo,
     Union,
     get_newtype_supertype,
     get_orig_bases,

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish/reflect/subst.py

@@ -8,6 +8,7 @@ from .ops import get_concrete_type
 from .ops import to_annotation
 from .types import Any
 from .types import Generic
+from .types import Literal
 from .types import NewType
 from .types import Type
 from .types import Union
@@ -35,7 +36,7 @@ def replace_type_vars(
         update_aliases: bool = False,
 ) -> Type:
     def rec(cur):
-        if isinstance(cur, (type, NewType, Any)):
+        if isinstance(cur, (type, NewType, Any, Literal)):
             return cur
 
         if isinstance(cur, Generic):

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish/reflect/types.py

@@ -7,6 +7,7 @@ TODO:
  - cache this shit, esp generic_mro shit
   - cache __hash__ in Generic/Union
 """
+import abc
 import dataclasses as dc
 import types
 import typing as ta
@@ -17,11 +18,12 @@ _NoneType = types.NoneType  # type: ignore
 _NONE_TYPE_FROZENSET: frozenset['Type'] = frozenset([_NoneType])
 
 
-_GenericAlias = ta._GenericAlias  # type: ignore  # noqa
+_AnnotatedAlias = ta._AnnotatedAlias  # type: ignore  # noqa
 _CallableGenericAlias = ta._CallableGenericAlias  # type: ignore  # noqa
+_GenericAlias = ta._GenericAlias  # type: ignore  # noqa
+_LiteralGenericAlias = ta._LiteralGenericAlias  # type: ignore  # noqa
 _SpecialGenericAlias = ta._SpecialGenericAlias  # type: ignore  # noqa
 _UnionGenericAlias = ta._UnionGenericAlias   # type: ignore  # noqa
-_AnnotatedAlias = ta._AnnotatedAlias  # type: ignore  # noqa
 
 
 ##
@@ -116,19 +118,29 @@ def get_newtype_supertype(obj: ta.Any) -> ta.Any:
 ##
 
 
-Type: ta.TypeAlias = ta.Union[
+class TypeInfo(abc.ABC):  # noqa
+    pass
+
+
+Type: ta.TypeAlias = ta.Union[  # noqa
     type,
     ta.TypeVar,
-    'Union',
-    'Generic',
-    'NewType',
-    'Annotated',
-    'Any',
+    TypeInfo,
 ]
 
 
+TYPES: tuple[type, ...] = (
+    type,
+    ta.TypeVar,
+    TypeInfo,
+)
+
+
+##
+
+
 @dc.dataclass(frozen=True)
-class Union:
+class Union(TypeInfo):
     args: frozenset[Type]
 
     @property
@@ -144,8 +156,11 @@ class Union:
         return Union(rem)
 
 
+#
+
+
 @dc.dataclass(frozen=True)
-class Generic:
+class Generic(TypeInfo):
     cls: type
     args: tuple[Type, ...]                                                # map[int, V] = (int, V) | map[T, T] = (T, T)
 
@@ -167,39 +182,51 @@ class Generic:
         )
 
 
+#
+
+
 @dc.dataclass(frozen=True)
-class NewType:
+class NewType(TypeInfo):
     obj: ta.Any
     ty: Type
 
 
+#
+
+
 @dc.dataclass(frozen=True)
-class Annotated:
+class Annotated(TypeInfo):
     ty: Type
     md: ta.Sequence[ta.Any]
 
     obj: ta.Any = dc.field(compare=False, repr=False)
 
 
-class Any:
+#
+
+
+@dc.dataclass(frozen=True)
+class Literal(TypeInfo):
+    args: tuple[ta.Any, ...]
+
+    obj: ta.Any = dc.field(compare=False, repr=False)
+
+
+#
+
+
+class Any(TypeInfo):
     pass
 
 
 ANY = Any()
 
 
-TYPES: tuple[type, ...] = (
-    type,
-    ta.TypeVar,
-    Union,
-    Generic,
-    NewType,
-    Annotated,
-    Any,
-)
+##
 
 
-##
+class ReflectTypeError(TypeError):
+    pass
 
 
 class Reflector:
@@ -212,57 +239,80 @@ class Reflector:
 
         self._override = override
 
+    #
+
     def is_type(self, obj: ta.Any) -> bool:
-        if isinstance(obj, (Union, Generic, ta.TypeVar, NewType, Any)):  # noqa
+        try:
+            self._type(obj, check_only=True)
+        except ReflectTypeError:
+            return False
+        else:
             return True
 
-        oty = type(obj)
-
-        return (
-                oty is _UnionGenericAlias or oty is types.UnionType or  # noqa
-
-                isinstance(obj, ta.NewType) or  # noqa
-
-                (
-                    is_simple_generic_alias_type(oty) or
-                    oty is _CallableGenericAlias
-                ) or
+    def type(self, obj: ta.Any) -> Type:
+        if (ty := self._type(obj, check_only=False)) is None:
+            raise RuntimeError(obj)
+        return ty
 
-                isinstance(obj, type) or
+    #
 
-                isinstance(obj, _SpecialGenericAlias)
-        )
+    def _type(self, obj: ta.Any, *, check_only: bool) -> Type | None:
+        ##
+        # Overrides beat everything
 
-    def type(self, obj: ta.Any) -> Type:
         if self._override is not None:
             if (ovr := self._override(obj)) is not None:
                 return ovr
 
+        ##
+        # Any
+
         if obj is ta.Any:
             return ANY
 
-        if isinstance(obj, (Union, Generic, ta.TypeVar, NewType, Any)):  # noqa
+        ##
+        # Already a Type?
+
+        if isinstance(obj, (ta.TypeVar, TypeInfo)):  # noqa
             return obj
 
         oty = type(obj)
 
+        ##
+        # Union
+
         if oty is _UnionGenericAlias or oty is types.UnionType:
+            if check_only:
+                return None
+
             return Union(frozenset(self.type(a) for a in ta.get_args(obj)))
 
+        ##
+        # NewType
+
         if isinstance(obj, ta.NewType):  # noqa
+            if check_only:
+                return None
+
             return NewType(obj, get_newtype_supertype(obj))
 
+        ##
+        # Simple Generic
+
         if (
                 is_simple_generic_alias_type(oty) or
                 oty is _CallableGenericAlias
         ):
+            if check_only:
+                return None
+
             origin = ta.get_origin(obj)
             args = ta.get_args(obj)
 
             if oty is _CallableGenericAlias:
                 p, r = args
                 if p is Ellipsis or isinstance(p, ta.ParamSpec):
-                    raise TypeError(f'Callable argument not yet supported for {obj=}')
+                    raise ReflectTypeError(f'Callable argument not yet supported for {obj=}')
                 args = (*p, r)
                 params = _KNOWN_SPECIAL_TYPE_VARS[:len(args)]
 
@@ -276,7 +326,7 @@ class Reflector:
                 params = get_params(origin)
 
             if len(args) != len(params):
-                raise TypeError(f'Mismatched {args=} and {params=} for {obj=}')
+                raise ReflectTypeError(f'Mismatched {args=} and {params=} for {obj=}')
 
             return Generic(
                 origin,
@@ -285,7 +335,13 @@ class Reflector:
                 obj,
             )
 
+        ##
+        # Full Generic
+
         if isinstance(obj, type):
+            if check_only:
+                return None
+
             if issubclass(obj, ta.Generic):  # type: ignore
                 params = get_params(obj)
                 if params:
@@ -295,12 +351,20 @@ class Reflector:
                         params,
                         obj,
                     )
+
             return obj
 
+        ##
+        # Special Generic
+
         if isinstance(obj, _SpecialGenericAlias):
             if (ks := _KNOWN_SPECIALS_BY_ALIAS.get(obj)) is not None:
+                if check_only:
+                    return None
+
                 if (np := ks.nparams) < 0:
-                    raise TypeError(obj)
+                    raise ReflectTypeError(obj)
+
                 params = _KNOWN_SPECIAL_TYPE_VARS[:np]
                 return Generic(
                     ks.origin,
@@ -309,11 +373,29 @@ class Reflector:
                     obj,
                 )
 
+        ##
+        # Annotated
+
         if isinstance(obj, _AnnotatedAlias):
+            if check_only:
+                return None
+
             o = ta.get_args(obj)[0]
             return Annotated(self.type(o), md=obj.__metadata__, obj=obj)
 
-        raise TypeError(obj)
+        ##
+        # Literal
+
+        if isinstance(obj, _LiteralGenericAlias):
+            if check_only:
+                return None
+
+            return Literal(ta.get_args(obj), obj=obj)
+
+        ##
+        # Failure
+
+        raise ReflectTypeError(obj)
 
 
 DEFAULT_REFLECTOR = Reflector()

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev172
+Version: 0.0.0.dev174
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/omlish.egg-info/SOURCES.txt

@@ -432,6 +432,7 @@ omlish/marshal/forbidden.py
 omlish/marshal/global_.py
 omlish/marshal/helpers.py
 omlish/marshal/iterables.py
+omlish/marshal/literals.py
 omlish/marshal/mappings.py
 omlish/marshal/maybes.py
 omlish/marshal/namedtuples.py

{omlish-0.0.0.dev172 → omlish-0.0.0.dev174}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev172'
+version = '0.0.0.dev174'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',