omlish 0.0.0.dev413__tar.gz → 0.0.0.dev415__tar.gz

{omlish-0.0.0.dev413/omlish.egg-info → omlish-0.0.0.dev415}/PKG-INFO

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

{omlish-0.0.0.dev413 → omlish-0.0.0.dev415}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev413'
-__revision__ = '3a75442fb3c6056a588c83a888a2f2792d35a3ab'
+__version__ = '0.0.0.dev415'
+__revision__ = '79bb2b1f7af2d9c344f8471cd6e785914768a72f'
 
 
 #
@@ -175,7 +175,6 @@ class SetuptoolsBase:
             '*.g4',
             '*.h',
 
-            '.dataclasses.json',
             '.manifests.json',
 
             'LICENSE',

{omlish-0.0.0.dev413 → omlish-0.0.0.dev415}/omlish/codecs/registry.py

@@ -77,7 +77,7 @@ class CodecRegistry:
             codec_or_lazy = self._by_name[name]
 
             if isinstance(codec_or_lazy, LazyLoadedCodec):
-                codec = check.isinstance(codec_or_lazy.load(), Codec)
+                codec = check.isinstance(codec_or_lazy.resolve(), Codec)
                 self._by_name[name] = codec
                 self._post_load(codec)
             else:

omlish-0.0.0.dev415/omlish/dataclasses/__init__.py

@@ -0,0 +1,180 @@
+# ruff: noqa: I001
+import sys as _sys
+
+from .. import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    ##
+    # stdlib interface
+
+    from dataclasses import (  # noqa
+        FrozenInstanceError,
+
+        MISSING,
+        KW_ONLY,
+
+        InitVar,
+        Field,
+
+        field,
+
+        dataclass,
+        make_dataclass,
+
+        fields,
+
+        is_dataclass,
+
+        replace,
+    )
+
+    from .impl.api import (  # noqa
+        dataclass as xdataclass,
+
+        make_dataclass as xmake_dataclass,
+
+        field as xfield,
+    )
+
+    from .impl.concerns.replace import (  # noqa
+        replace as xreplace,
+    )
+
+    from .tools.as_ import (  # noqa
+        asdict,
+        astuple,
+    )
+
+    ##
+    # additional interface
+
+    from .impl.api import (  # noqa
+        append_class_metadata,
+        extra_class_params,
+        init,
+        metadata,
+        validate,
+
+        extra_field_params,
+        set_field_metadata,
+        update_extra_field_params,
+        with_extra_field_params,
+    )
+
+    from .errors import (  # noqa
+        FieldFnValidationError,
+        FieldTypeValidationError,
+        FieldValidationError,
+        FnValidationError,
+        TypeValidationError,
+        ValidationError,
+    )
+
+    from .metaclass.bases import (  # noqa
+        Box,
+        Case,
+        Data,
+        Frozen,
+    )
+
+    from .metaclass.meta import (  # noqa
+        DataMeta,
+    )
+
+    from .metaclass.specs import (  # noqa
+        get_metaclass_spec,
+    )
+
+    from .reflection import (  # noqa
+        reflect,
+    )
+
+    from .specs import (  # noqa
+        CoerceFn,
+        ValidateFn,
+        ReprFn,
+
+        InitFn,
+        ClassValidateFn,
+
+        DefaultFactory,
+
+        FieldType,
+
+        FieldSpec,
+
+        ClassSpec,
+    )
+
+    from .tools.as_ import (  # noqa
+        shallow_asdict,
+        shallow_astuple,
+    )
+
+    from .tools.iter import (  # noqa
+        fields_dict,
+
+        iter_items,
+        iter_keys,
+        iter_values,
+    )
+
+    from .tools.modifiers import (  # noqa
+        field_modifier,
+        update_fields,
+    )
+
+    from .tools.only_ import (  # noqa
+        only,
+    )
+
+    from .tools.replace import (  # noqa
+        deep_replace,
+    )
+
+    from .tools.repr import (  # noqa
+        opt_repr,
+        truthy_repr,
+    )
+
+    from .tools.static import (  # noqa
+        Static,
+    )
+
+    ##
+    # lite imports
+
+    from ..lite.dataclasses import (  # noqa
+        is_immediate_dataclass,
+
+        dataclass_maybe_post_init as maybe_post_init,
+    )
+
+
+##
+# globals hack
+
+def _self_patching_global_proxy(l, r, ak_fn=None):
+    def inner(*args, **kwargs):
+        fn = getattr(_sys.modules[__name__], r)
+        globals()[l] = fn
+        if ak_fn:
+            args, kwargs = ak_fn(*args, **kwargs)
+        return fn(*args, **kwargs)
+    return inner
+
+
+globals()['field'] = _self_patching_global_proxy('field', 'xfield')
+
+globals()['dataclass'] = _self_patching_global_proxy('dataclass', 'xdataclass')
+
+globals()['make_dataclass'] = _self_patching_global_proxy(
+    'make_dataclass',
+    'xmake_dataclass',
+    lambda *args, _frame_offset=1, **kwargs: (args, dict(_frame_offset=_frame_offset + 1, **kwargs)),
+)
+
+globals()['replace'] = _self_patching_global_proxy('replace', 'xreplace')

{omlish-0.0.0.dev413 → omlish-0.0.0.dev415}/omlish/dataclasses/impl/api/classes/make.py

@@ -55,6 +55,8 @@ def make_dataclass(  # noqa
         terse_repr: bool | None = None,
 
         allow_redundant_decorator: bool | None = None,
+
+        _frame_offset: int = 1,
 ):
     if decorator is not dataclass:
         raise TypeError(
@@ -136,14 +138,14 @@ def make_dataclass(  # noqa
 
     if _IS_PY_3_14:
         # For now, set annotations including the _ANY_MARKER.
-        cls.__annotate__ = annotate_method  # type: ignore
+        cls.__annotate__ = annotate_method  # type: ignore  # noqa
 
     if module is None:
         try:
-            module = sys._getframemodulename(1) or '__main__'  # type: ignore  # noqa
+            module = sys._getframemodulename(_frame_offset) or '__main__'  # type: ignore  # noqa
         except AttributeError:
             with contextlib.suppress(AttributeError, ValueError):
-                module = sys._getframe(1).f_globals.get('__name__', '__main__')  # noqa
+                module = sys._getframe(_frame_offset).f_globals.get('__name__', '__main__')  # noqa
     if module is not None:
         cls.__module__ = module
 

omlish-0.0.0.dev415/omlish/dataclasses/impl/configs.py

@@ -0,0 +1,69 @@
+import dataclasses as dc
+import typing as ta
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class PackageConfig:
+    codegen: bool = False
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+
+DEFAULT_PACKAGE_CONFIG = PackageConfig()
+
+
+##
+
+
+def init_package(
+        name: str,
+        *,
+        codegen: bool = False,
+) -> None:
+    pass
+
+
+##
+
+
+class PackageConfigCache:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._dct: dict[str, PackageConfig | None] = {}
+
+    @ta.overload
+    def get(self, pkg: str, default: PackageConfig) -> PackageConfig:
+        ...
+
+    @ta.overload
+    def get(self, pkg: str, default: PackageConfig | None = None) -> PackageConfig | None:
+        ...
+
+    def get(self, pkg, default=None):
+        # try:
+        #     return self._dct[pkg]
+        # except KeyError:
+        #     pass
+        #
+        # try:
+        #     s = importlib.resources.read_text(pkg, PACKAGE_CONFIG_FILE_NAME)
+        # except FileNotFoundError:
+        #     self._dct[pkg] = None
+        # else:
+        #     c = PackageConfig.loads(s)
+        #     self._dct[pkg] = c
+        #     return c
+        #
+        # if '.' not in pkg:
+        #     return default
+        #
+        # return self.get(pkg.rpartition('.')[0], default)
+        return None
+
+
+PACKAGE_CONFIG_CACHE = PackageConfigCache()

{omlish-0.0.0.dev413 → omlish-0.0.0.dev415}/omlish/lite/maysyncs.py

@@ -100,6 +100,7 @@ class AnyMaysyncFn(abc.ABC, ta.Generic[_MaysyncRS, _MaysyncRA]):  # noqa
         raise NotImplementedError
 
 
+@ta.final
 class MaywaitableAlreadyConsumedError(Exception):
     pass
 

{omlish-0.0.0.dev413 → omlish-0.0.0.dev415}/omlish/manifests/base.py

@@ -15,7 +15,7 @@ class ModAttrManifest:
     module: str
     attr: str
 
-    def load(self) -> ta.Any:
+    def resolve(self) -> ta.Any:
         import importlib  # noqa
 
         mod = importlib.import_module(self.module)

{omlish-0.0.0.dev413 → omlish-0.0.0.dev415}/omlish/marshal/__init__.py

@@ -1,4 +1,48 @@
-from .base import (  # noqa
+"""
+TODO:
+ - redacted
+ - strongly typed MarshalerFactory base class?
+ - strongly typed Composite/Cached Marshaler/Unmarshaler factories - footgun
+ - streaming? Start/EndObject, etc..
+ - lang.Marker - class name, handle type[Foo]
+  - can't disambiguate from str - can't coexist in bare union
+ - factories being free MatchFns does more harm than good - in practice these are such big guns you want to write a
+   class body if only ceremonially
+
+See:
+ - https://github.com/python-attrs/cattrs
+ - https://github.com/jcrist/msgspec
+ - https://github.com/Fatal1ty/mashumaro
+ - https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serializers.md#custom-serializers
+"""
+
+
+from .base.contexts import (  # noqa
+    BaseContext,
+    MarshalContext,
+    UnmarshalContext,
+)
+
+from .base.errors import (  # noqa
+    ForbiddenTypeError,
+    MarshalError,
+    UnhandledTypeError,
+)
+
+from .base.options import (  # noqa
+    Option,
+)
+
+from .base.overrides import (  # noqa
+    Override,
+    ReflectOverride,
+)
+
+from .base.registries import (  # noqa
+    Registry,
+)
+
+from .base.types import (  # noqa
     Marshaler,
     Unmarshaler,
 
@@ -10,67 +54,55 @@ from .base import (  # noqa
 
     MarshalerFactory_,
     UnmarshalerFactory_,
+)
+
+from .base.values import (  # noqa
+    Value,
+)
 
+from .composite.iterables import (  # noqa
+    IterableMarshaler,
+    IterableUnmarshaler,
+)
+
+from .composite.wrapped import (  # noqa
+    WrappedMarshaler,
+    WrappedUnmarshaler,
+)
+
+from .factories.simple import (  # noqa
     SimpleMarshalerFactory,
     SimpleUnmarshalerFactory,
+)
 
+from .factories.match import (  # noqa
     MarshalerFactoryMatchClass,
     UnmarshalerFactoryMatchClass,
+)
 
+from .factories.multi import (  # noqa
     MultiMarshalerFactory,
     MultiUnmarshalerFactory,
+)
 
+from .factories.typemap import (  # noqa
     TypeMapMarshalerFactory,
     TypeMapUnmarshalerFactory,
+)
 
+from .factories.typecache import (  # noqa
     TypeCacheMarshalerFactory,
     TypeCacheUnmarshalerFactory,
+)
 
+from .factories.func import (  # noqa
     FuncMarshaler,
     FuncUnmarshaler,
+)
 
-    BaseContext,
-    MarshalContext,
-    UnmarshalContext,
-
+from .factories.recursive import (  # noqa
     RecursiveMarshalerFactory,
     RecursiveUnmarshalerFactory,
-
-    Override,
-    ReflectOverride,
-)
-
-from .composite.iterables import (  # noqa
-    IterableMarshaler,
-    IterableUnmarshaler,
-)
-
-from .composite.wrapped import (  # noqa
-    WrappedMarshaler,
-    WrappedUnmarshaler,
-)
-
-from .errors import (  # noqa
-    ForbiddenTypeError,
-    MarshalError,
-    UnhandledTypeError,
-)
-
-from .globals import (  # noqa
-    GLOBAL_REGISTRY,
-
-    global_marshaler_factory,
-    marshal,
-
-    global_unmarshaler_factory,
-    unmarshal,
-
-    register_global,
-)
-
-from .naming import (  # noqa
-    Naming,
-    translate_name,
 )
 
 from .objects.dataclasses import (  # noqa
@@ -152,20 +184,6 @@ from .singular.primitives import (  # noqa
     PRIMITIVE_TYPES,
 )
 
-from .registries import (  # noqa
-    Registry,
-)
-
-from .standard import (  # noqa
-    STANDARD_MARSHALER_FACTORIES,
-    new_standard_marshaler_factory,
-
-    STANDARD_UNMARSHALER_FACTORIES,
-    new_standard_unmarshaler_factory,
-
-    install_standard_factories,
-)
-
 from .trivial.forbidden import (  # noqa
     ForbiddenTypeMarshalerFactory,
     ForbiddenTypeUnmarshalerFactory,
@@ -176,8 +194,31 @@ from .trivial.nop import (  # noqa
     NopMarshalerUnmarshaler,
 )
 
-from .values import (  # noqa
-    Value,
+from .globals import (  # noqa
+    GLOBAL_REGISTRY,
+
+    global_marshaler_factory,
+    marshal,
+
+    global_unmarshaler_factory,
+    unmarshal,
+
+    register_global,
+)
+
+from .naming import (  # noqa
+    Naming,
+    translate_name,
+)
+
+from .standard import (  # noqa
+    STANDARD_MARSHALER_FACTORIES,
+    new_standard_marshaler_factory,
+
+    STANDARD_UNMARSHALER_FACTORIES,
+    new_standard_unmarshaler_factory,
+
+    install_standard_factories,
 )
 
 

omlish-0.0.0.dev415/omlish/marshal/base/contexts.py

@@ -0,0 +1,75 @@
+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 .errors import UnhandledTypeError
+from .options import Option
+from .overrides import ReflectOverride
+from .registries import Registry
+from .types import Marshaler
+from .types import MarshalerFactory
+from .types import Unmarshaler
+from .types import UnmarshalerFactory
+from .values import Value
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class BaseContext(lang.Abstract):
+    registry: Registry
+    options: col.TypeMap[Option] = col.TypeMap()
+
+    def _reflect(self, o: ta.Any) -> rfl.Type:
+        def override(o):
+            if (ovr := self.registry.get_of(o, ReflectOverride)):
+                return ovr[-1].rty
+            return None
+
+        return rfl.Reflector(override=override).type(o)
+
+
+@dc.dataclass(frozen=True)
+class MarshalContext(BaseContext, lang.Final):
+    factory: MarshalerFactory | None = None
+
+    def make(self, o: ta.Any) -> Marshaler:
+        rty = self._reflect(o)
+        try:
+            return check.not_none(self.factory).make_marshaler(self, rty)
+        except mfs.MatchGuardError:
+            raise UnhandledTypeError(rty)  # noqa
+
+    def marshal(self, obj: ta.Any, ty: ta.Any | None = None) -> Value:
+        return self.make(ty if ty is not None else type(obj)).marshal(self, obj)
+
+
+@dc.dataclass(frozen=True)
+class UnmarshalContext(BaseContext, lang.Final):
+    factory: UnmarshalerFactory | None = None
+
+    def make(self, o: ta.Any) -> Unmarshaler:
+        rty = self._reflect(o)
+        try:
+            return check.not_none(self.factory).make_unmarshaler(self, rty)
+        except mfs.MatchGuardError:
+            raise UnhandledTypeError(rty)  # noqa
+
+    @ta.overload
+    def unmarshal(self, v: Value, ty: type[T]) -> T:
+        ...
+
+    @ta.overload
+    def unmarshal(self, v: Value, ty: ta.Any) -> ta.Any:
+        ...
+
+    def unmarshal(self, v, ty):
+        return self.make(ty).unmarshal(self, v)

{omlish-0.0.0.dev413/omlish/marshal → omlish-0.0.0.dev415/omlish/marshal/base}/errors.py

@@ -1,4 +1,4 @@
-from .. import reflect as rfl
+from ... import reflect as rfl
 
 
 ##

omlish-0.0.0.dev415/omlish/marshal/base/options.py

@@ -0,0 +1,2 @@
+class Option:
+    pass

omlish-0.0.0.dev415/omlish/marshal/base/overrides.py

@@ -0,0 +1,25 @@
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from .registries import RegistryItem
+from .types import Marshaler
+from .types import MarshalerFactory
+from .types import Unmarshaler
+from .types import UnmarshalerFactory
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Override(RegistryItem, lang.Final):
+    marshaler: Marshaler | None = dc.xfield(None, check_type=(Marshaler, None))
+    marshaler_factory: MarshalerFactory | None = None
+
+    unmarshaler: Unmarshaler | None = dc.xfield(None, check_type=(Unmarshaler, None))
+    unmarshaler_factory: UnmarshalerFactory | None = None
+
+
+@dc.dataclass(frozen=True)
+class ReflectOverride(RegistryItem, lang.Final):
+    rty: rfl.Type

{omlish-0.0.0.dev413/omlish/marshal → omlish-0.0.0.dev415/omlish/marshal/base}/registries.py

@@ -1,13 +1,9 @@
-"""
-TODO:
- - inheritance
-"""
 import dataclasses as dc
 import threading
 import typing as ta
 
-from .. import collections as col
-from .. import lang
+from ... import collections as col
+from ... import lang
 
 
 ##
@@ -36,7 +32,7 @@ class Registry:
     def __init__(self) -> None:
         super().__init__()
 
-        self._mtx = threading.Lock()
+        self._lock = threading.Lock()
         self._idct: ta.MutableMapping[ta.Any, _KeyRegistryItems] = col.IdentityKeyDict()
         self._dct: dict[ta.Any, _KeyRegistryItems] = {}
 
@@ -46,7 +42,7 @@ class Registry:
             *items: RegistryItem,
             identity: bool = False,
     ) -> 'Registry':
-        with self._mtx:
+        with self._lock:
             dct: ta.Any = self._idct if identity else self._dct
             if (sr := dct.get(key)) is None:
                 sr = dct[key] = _KeyRegistryItems(key)