omlish 0.0.0.dev106__tar.gz → 0.0.0.dev108__tar.gz

{omlish-0.0.0.dev106/omlish.egg-info → omlish-0.0.0.dev108}/PKG-INFO

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

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev106'
-__revision__ = 'b3a29e6684b70df74a8a994151268bb03c1fbe0d'
+__version__ = '0.0.0.dev108'
+__revision__ = 'cbe1cf56c59d1ba006099e53058ecd40aa4a731d'
 
 
 #

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/dataclasses/impl/reflect.py

@@ -3,7 +3,6 @@ TODO:
  - more cache-recursive reuse - fields, mro, etc
 """
 import dataclasses as dc
-import inspect
 import sys
 import typing as ta
 import weakref
@@ -28,22 +27,9 @@ from .params import get_params_extras
 from .utils import Namespace
 
 
-try:
-    import annotationlib  # noqa
-except ImportError:
-    annotationlib = None
-
-
 MISSING = dc.MISSING
 
 
-def _get_annotations(obj):
-    if annotationlib is not None:
-        return annotationlib.get_annotations(obj, format=annotationlib.Format.FORWARDREF)  # noqa
-    else:
-        return inspect.get_annotations(obj)
-
-
 class ClassInfo:
 
     def __init__(self, cls: type, *, _constructing: bool = False) -> None:
@@ -67,7 +53,10 @@ class ClassInfo:
 
     @cached.property
     def cls_annotations(self) -> ta.Mapping[str, ta.Any]:
-        return _get_annotations(self._cls)
+        # Does not use ta.get_type_hints because that's what std dataclasses do [1]. Might be worth revisiting? A part
+        # of why they don't is to not import typing for efficiency but we don't care about that degree of startup speed.
+        # [1]: https://github.com/python/cpython/blob/54c63a32d06cb5f07a66245c375eac7d7efb964a/Lib/dataclasses.py#L985-L986  # noqa
+        return rfl.get_annotations(self._cls)
 
     ##
 

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/formats/json/__init__.py

@@ -1,3 +1,9 @@
+# ruff: noqa: I001
+import typing as _ta
+
+from ... import lang as _lang
+
+
 from .consts import (  # noqa
     COMPACT_KWARGS,
     COMPACT_SEPARATORS,
@@ -23,6 +29,11 @@ from .json import (  # noqa
     loads,
 )
 
-from .render import (  # noqa
-    JsonRenderer,
-)
+if _ta.TYPE_CHECKING:
+    from .render import (  # noqa
+        JsonRenderer,
+    )
+else:
+    _lang.proxy_init(globals(), '.render', [
+        'JsonRenderer',
+    ])

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/formats/json/cli/cli.py

@@ -5,7 +5,7 @@ TODO:
 
 ==
 
-jq Command options)
+jq Command options:
   -n, --null-input          use `null` as the single input value;
   -R, --raw-input           read each line as string instead of JSON;
   -s, --slurp               read all inputs into an array and use it as the single input value;
@@ -276,11 +276,10 @@ def _main() -> None:
             renderer = EagerRenderer(cfg.rendering)
 
             for buf in yield_input():
-                if buf:
-                    for v in parser.parse(buf):
-                        for e in processor.process(v):
-                            s = renderer.render(e)
-                            print(s, file=out)
+                for v in parser.parse(buf):
+                    for e in processor.process(v):
+                        s = renderer.render(e)
+                        print(s, file=out)
 
         else:
             parser = EagerParser(cfg.format)

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/formats/json/cli/processing.py

@@ -35,8 +35,12 @@ class Processor:
             v = self._jmespath_expr.search(v)
 
         if self._opts.flat:
-            if isinstance(v, str):
-                raise TypeError(f'Flat output must be arrays, got {type(v)}', v)
+            if (
+                    not isinstance(v, ta.Iterable) or  # noqa
+                    isinstance(v, ta.Mapping) or
+                    isinstance(v, lang.BUILTIN_SCALAR_ITERABLE_TYPES)
+            ):
+                raise TypeError(f'Flat output must be flat collections, got {type(v)}', v)
 
             yield from v
 

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/lang/imports.py

@@ -1,12 +1,9 @@
 import contextlib
-import functools
 import importlib.util
 import sys
 import types
 import typing as ta
 
-from .cached import cached_function
-
 
 ##
 
@@ -23,8 +20,40 @@ def can_import(name: str, package: str | None = None) -> bool:
 ##
 
 
-def lazy_import(name: str, package: str | None = None) -> ta.Callable[[], ta.Any]:
-    return cached_function(functools.partial(importlib.import_module, name, package=package))
+def lazy_import(
+        name: str,
+        package: str | None = None,
+        *,
+        optional: bool = False,
+        cache_failure: bool = False,
+) -> ta.Callable[[], ta.Any]:
+    result = not_set = object()
+
+    def inner():
+        nonlocal result
+
+        if result is not not_set:
+            if isinstance(result, Exception):
+                raise result
+            return result
+
+        try:
+            mod = importlib.import_module(name, package=package)
+
+        except Exception as e:
+            if optional:
+                if cache_failure:
+                    result = None
+                return None
+
+            if cache_failure:
+                result = e
+            raise
+
+        result = mod
+        return mod
+
+    return inner
 
 
 def proxy_import(

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/marshal/iterables.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - heterogeneous tuples
+"""
 import collections.abc
 import dataclasses as dc
 import functools

omlish-0.0.0.dev108/omlish/marshal/namedtuples.py

@@ -0,0 +1,111 @@
+import inspect
+import typing as ta
+
+from .. import check
+from .. import collections as col
+from .. import lang
+from .. import reflect as rfl
+from .base import MarshalContext
+from .base import Marshaler
+from .base import MarshalerFactory
+from .base import Option
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .objects import FieldInfo
+from .objects import FieldInfos
+from .objects import FieldMetadata
+from .objects import ObjectMarshaler
+from .objects import ObjectUnmarshaler
+
+
+##
+
+
+def _is_named_tuple(rty: rfl.Type) -> bool:
+    return (
+        isinstance(rty, type) and
+        issubclass(rty, tuple) and
+        ta.NamedTuple in rfl.get_orig_bases(rty)
+    )
+
+
+def get_field_infos(
+        ty: type,
+        opts: col.TypeMap[Option] = col.TypeMap(),
+) -> FieldInfos:
+    check.arg(_is_named_tuple(ty), ty)
+
+    sig = inspect.signature(ty)
+
+    ret: list[FieldInfo] = []
+    for param in sig.parameters.values():
+        ret.append(FieldInfo(
+            name=param.name,
+            type=param.annotation,
+            metadata=FieldMetadata(),
+
+            marshal_name=param.name,
+            unmarshal_names=[param.name],
+        ))
+
+    return FieldInfos(ret)
+
+
+##
+
+
+class NamedtupleMarshalerFactory(MarshalerFactory):
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return _is_named_tuple(rty)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        check.state(_is_named_tuple(rty))
+        ty = check.isinstance(rty, type)
+        check.state(not lang.is_abstract_class(ty))
+
+        fis = get_field_infos(ty, ctx.options)
+
+        fields = [
+            (fi, ctx.make(fi.type))
+            for fi in fis
+        ]
+
+        return ObjectMarshaler(
+            fields,
+        )
+
+
+##
+
+
+class NamedtupleUnmarshalerFactory(UnmarshalerFactory):
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return _is_named_tuple(rty)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        check.state(_is_named_tuple(rty))
+        ty = check.isinstance(rty, type)
+        check.state(not lang.is_abstract_class(ty))
+
+        fis = get_field_infos(ty, ctx.options)
+
+        d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
+        defaults: dict[str, ta.Any] = {}
+
+        for fi in fis:
+            tup = (fi, ctx.make(fi.type))
+
+            for un in fi.unmarshal_names:
+                if un in d:
+                    raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
+                d[un] = tup
+
+            if fi.options.default.present:
+                defaults[fi.name] = fi.options.default.must()
+
+        return ObjectUnmarshaler(
+            ty,
+            d,
+            defaults=defaults,
+        )

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/marshal/standard.py

@@ -21,6 +21,8 @@ from .mappings import MappingMarshalerFactory
 from .mappings import MappingUnmarshalerFactory
 from .maybes import MaybeMarshalerFactory
 from .maybes import MaybeUnmarshalerFactory
+from .namedtuples import NamedtupleMarshalerFactory
+from .namedtuples import NamedtupleUnmarshalerFactory
 from .newtypes import NewtypeMarshalerFactory
 from .newtypes import NewtypeUnmarshalerFactory
 from .numbers import NUMBERS_MARSHALER_FACTORY
@@ -44,6 +46,7 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     OptionalMarshalerFactory(),
     PrimitiveUnionMarshalerFactory(),
     DataclassMarshalerFactory(),
+    NamedtupleMarshalerFactory(),
     EnumMarshalerFactory(),
     NUMBERS_MARSHALER_FACTORY,
     UUID_MARSHALER_FACTORY,
@@ -75,6 +78,7 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     OptionalUnmarshalerFactory(),
     PrimitiveUnionUnmarshalerFactory(),
     DataclassUnmarshalerFactory(),
+    NamedtupleUnmarshalerFactory(),
     EnumUnmarshalerFactory(),
     NUMBERS_UNMARSHALER_FACTORY,
     UUID_UNMARSHALER_FACTORY,

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/marshal/unions.py

@@ -3,6 +3,7 @@ import typing as ta
 from .. import cached
 from .. import check
 from .. import dataclasses as dc
+from .. import lang
 from .. import matchfns as mfs
 from .. import reflect as rfl
 from .base import MarshalContext
@@ -115,34 +116,36 @@ PRIMITIVE_UNION_UNMARSHALER_FACTORY = PrimitiveUnionUnmarshalerFactory()
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnionMarshalerFactory(MarshalerFactory):
+class _BasePolymorphismUnionFactory(lang.Abstract):
     impls: Impls
     tt: TypeTagging = WrapperTypeTagging()
+    allow_partial: bool = dc.field(default=False, kw_only=True)
 
     @cached.property
     @dc.init
-    def rty(self) -> rfl.Union:
-        return rfl.type_(ta.Union[*tuple(i.ty for i in self.impls)])  # type: ignore
+    def rtys(self) -> frozenset[rfl.Type]:
+        return frozenset(i.ty for i in self.impls)
 
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Union) and rty == self.rty
+    def guard(self, ctx: MarshalContext | UnmarshalContext, rty: rfl.Type) -> bool:
+        if not isinstance(rty, rfl.Union):
+            return False
+        if self.allow_partial:
+            return not (rty.args - self.rtys)
+        else:
+            return rty.args == self.rtys
 
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        return make_polymorphism_marshaler(self.impls, self.tt, ctx)
+    def get_impls(self, rty: rfl.Type) -> Impls:
+        uty = check.isinstance(rty, rfl.Union)
+        return Impls([self.impls.by_ty[check.isinstance(a, type)] for a in uty.args])
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnionUnmarshalerFactory(UnmarshalerFactory):
-    impls: Impls
-    tt: TypeTagging = WrapperTypeTagging()
-
-    @cached.property
-    @dc.init
-    def rty(self) -> rfl.Union:
-        return rfl.type_(ta.Union[*tuple(i.ty for i in self.impls)])  # type: ignore
+class PolymorphismUnionMarshalerFactory(_BasePolymorphismUnionFactory, MarshalerFactory):
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        return make_polymorphism_marshaler(self.get_impls(rty), self.tt, ctx)
 
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, rfl.Union) and rty == self.rty
 
+@dc.dataclass(frozen=True)
+class PolymorphismUnionUnmarshalerFactory(_BasePolymorphismUnionFactory, UnmarshalerFactory):
     def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        return make_polymorphism_unmarshaler(self.impls, self.tt, ctx)
+        return make_polymorphism_unmarshaler(self.get_impls(rty), self.tt, ctx)

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/reflect/__init__.py

@@ -1,3 +1,7 @@
+from .inspect import (  # noqa
+    get_annotations,
+)
+
 from .isinstance import (  # noqa
     KNOWN_ISINSTANCE_GENERICS,
     isinstance_of,

omlish-0.0.0.dev108/omlish/reflect/inspect.py

@@ -0,0 +1,23 @@
+"""
+TODO:
+ - vs ta.get_type_hints?
+"""
+import typing as ta
+
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import inspect
+else:
+    inspect = lang.proxy_import('inspect')
+
+
+annotationlib = lang.lazy_import('annotationlib', optional=True, cache_failure=True)
+
+
+def get_annotations(obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+    if (al := annotationlib()) is not None:
+        return al.get_annotations(obj, format=al.Format.FORWARDREF)  # noqa
+    else:
+        return inspect.get_annotations(obj)

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish/reflect/types.py

@@ -42,7 +42,7 @@ _KNOWN_SPECIALS = [
         v.__origin__,
         v._nparams,  # noqa
     )
-    for v in ta.__dict__.values()
+    for v in ta.__dict__.values()  # noqa
     if isinstance(v, _SpecialGenericAlias)
 ]
 
@@ -78,7 +78,9 @@ def get_params(obj: ta.Any) -> tuple[ta.TypeVar, ...]:
             return obj.__dict__.get('__parameters__', ())  # noqa
 
         if (ks := _KNOWN_SPECIALS_BY_ORIGIN.get(obj)) is not None:
-            return _KNOWN_SPECIAL_TYPE_VARS[:ks.nparams]
+            if (np := ks.nparams) < 0:
+                raise TypeError(obj)
+            return _KNOWN_SPECIAL_TYPE_VARS[:np]
 
     oty = type(obj)
 
@@ -256,18 +258,26 @@ class Reflector:
         ):
             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=}')
                 args = (*p, r)
                 params = _KNOWN_SPECIAL_TYPE_VARS[:len(args)]
+
+            elif origin is tuple:
+                params = _KNOWN_SPECIAL_TYPE_VARS[:len(args)]
+
             elif origin is ta.Generic:
                 params = args
+
             else:
                 params = get_params(origin)
+
             if len(args) != len(params):
                 raise TypeError(f'Mismatched {args=} and {params=} for {obj=}')
+
             return Generic(
                 origin,
                 tuple(self.type(a) for a in args),
@@ -289,7 +299,9 @@ class Reflector:
 
         if isinstance(obj, _SpecialGenericAlias):
             if (ks := _KNOWN_SPECIALS_BY_ALIAS.get(obj)) is not None:
-                params = _KNOWN_SPECIAL_TYPE_VARS[:ks.nparams]
+                if (np := ks.nparams) < 0:
+                    raise TypeError(obj)
+                params = _KNOWN_SPECIAL_TYPE_VARS[:np]
                 return Generic(
                     ks.origin,
                     params,

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/omlish.egg-info/SOURCES.txt

@@ -343,6 +343,7 @@ omlish/marshal/helpers.py
 omlish/marshal/iterables.py
 omlish/marshal/mappings.py
 omlish/marshal/maybes.py
+omlish/marshal/namedtuples.py
 omlish/marshal/naming.py
 omlish/marshal/newtypes.py
 omlish/marshal/nop.py
@@ -362,6 +363,7 @@ omlish/math/bits.py
 omlish/math/floats.py
 omlish/math/stats.py
 omlish/reflect/__init__.py
+omlish/reflect/inspect.py
 omlish/reflect/isinstance.py
 omlish/reflect/ops.py
 omlish/reflect/subst.py

{omlish-0.0.0.dev106 → omlish-0.0.0.dev108}/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.dev106'
+version = '0.0.0.dev108'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',