omlish 0.0.0.dev416__tar.gz → 0.0.0.dev418__tar.gz

{omlish-0.0.0.dev416/omlish.egg-info → omlish-0.0.0.dev418}/PKG-INFO

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

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev416'
-__revision__ = '2ad7f56508df7d9415fc8acee12cf5eb215afbf2'
+__version__ = '0.0.0.dev418'
+__revision__ = '768aa72e47d914554932c2598e2f832465969997'
 
 
 #

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/bootstrap/__init__.py

@@ -37,6 +37,6 @@ from .sys import (  # noqa
 ##
 
 
-from .. import lang as _lang
+from .. import marshal as _msh
 
-_lang.register_conditional_import('..marshal', '.marshal', __package__)
+_msh.register_global_module_import('._marshal', __package__)

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/dataclasses/__init__.py

@@ -31,18 +31,6 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
         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,
@@ -51,19 +39,41 @@ with _lang.auto_proxy_init(globals()) as _api_cap:
     ##
     # additional interface
 
-    from .impl.api import (  # noqa
+    from .impl.api.classes.decorator import (  # noqa
+        dataclass as xdataclass,
+    )
+
+    from .impl.api.classes.make import (  # noqa
+        make_dataclass as xmake_dataclass,
+    )
+
+    from .impl.api.classes.metadata import (  # noqa
         append_class_metadata,
         extra_class_params,
         init,
         metadata,
         validate,
+    )
 
+    from .impl.api.fields.metadata import (  # noqa
         extra_field_params,
         set_field_metadata,
         update_extra_field_params,
         with_extra_field_params,
     )
 
+    from .impl.api.fields.constructor import (  # noqa
+        field as xfield,
+    )
+
+    from .impl.concerns.replace import (  # noqa
+        replace as xreplace,
+    )
+
+    from .impl.configs import (  # noqa
+        init_package,
+    )
+
     from .errors import (  # noqa
         FieldFnValidationError,
         FieldTypeValidationError,

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/dataclasses/impl/configs.py

@@ -20,7 +20,7 @@ DEFAULT_PACKAGE_CONFIG = PackageConfig()
 
 
 def init_package(
-        name: str,
+        init_globals: ta.MutableMapping[str, ta.Any],
         *,
         codegen: bool = False,
 ) -> None:

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/dataclasses/impl/processing/base.py

@@ -1,6 +1,6 @@
 """
 TODO:
- - Configurable? class Config crtc?
+ - Configurable? class Config crtp?
   - all config on specs? prob not desirable purity, prob want ~some~ global config if only defaults
    - ProcessorConfigSpecProviderFactoryThingy?
   - FIXME: for now these are processor ctor kwargs that are never overridden

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/inject/__init__.py

@@ -1,6 +1,18 @@
 """
 ~> https://github.com/google/guice/commit/70248eafa90cd70a68b293763e53f6aec656e73c
 """
+from .. import dataclasses as _dc
+
+
+_dc.init_package(
+    globals(),
+    codegen=True,
+)
+
+
+##
+
+
 from .binder import (  # noqa
     bind,
     bind_as_fn,

omlish-0.0.0.dev418/omlish/marshal/__init__.py

@@ -0,0 +1,257 @@
+# ruff: noqa: I001
+"""
+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 .. import dataclasses as _dc  # noqa
+
+
+_dc.init_package(
+    globals(),
+    codegen=True,
+)
+
+
+##
+
+
+from .. import lang as _lang  # noqa
+
+
+with _lang.auto_proxy_init(globals()) as _api_cap:
+    ##
+
+    from .base.configs import (  # noqa
+        Config,
+        ConfigRegistry,
+    )
+
+    from .base.contexts import (  # noqa
+        BaseContext,
+        MarshalContext,
+        UnmarshalContext,
+    )
+
+    from .base.errors import (  # noqa
+        ForbiddenTypeError,
+        MarshalError,
+        UnhandledTypeError,
+    )
+
+    from .base.funcs import (  # noqa
+        FuncMarshaler,
+        FuncUnmarshaler,
+
+        FuncMarshalerFactory,
+        FuncUnmarshalerFactory,
+    )
+
+    from .base.options import (  # noqa
+        Option,
+    )
+
+    from .base.overrides import (  # noqa
+        Override,
+        ReflectOverride,
+    )
+
+    from .base.registries import (  # noqa
+        RegistrySealedError,
+        Registry,
+    )
+
+    from .base.types import (  # noqa
+        Marshaler,
+        Unmarshaler,
+
+        MarshalerMaker,
+        UnmarshalerMaker,
+
+        MarshalerFactory,
+        UnmarshalerFactory,
+
+        Marshaling,
+    )
+
+    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.moduleimport.configs import (  # noqa
+        ModuleImport,
+    )
+
+    from .factories.moduleimport.factories import (  # noqa
+        ModuleImportingMarshalerFactory,
+        ModuleImportingUnmarshalerFactory,
+    )
+
+    from .factories.multi import (  # noqa
+        MultiMarshalerFactory,
+        MultiUnmarshalerFactory,
+    )
+
+    from .factories.typemap import (  # noqa
+        TypeMapMarshalerFactory,
+        TypeMapUnmarshalerFactory,
+    )
+
+    from .factories.typecache import (  # noqa
+        TypeCacheMarshalerFactory,
+        TypeCacheUnmarshalerFactory,
+    )
+
+    from .factories.recursive import (  # noqa
+        RecursiveMarshalerFactory,
+        RecursiveUnmarshalerFactory,
+    )
+
+    from .objects.dataclasses import (  # noqa
+        AbstractDataclassFactory,
+        DataclassMarshalerFactory,
+        DataclassUnmarshalerFactory,
+        get_dataclass_field_infos,
+        get_dataclass_metadata,
+    )
+
+    from .objects.helpers import (  # noqa
+        update_fields_metadata,
+        update_object_metadata,
+        with_field_metadata,
+    )
+
+    from .objects.marshal import (  # noqa
+        ObjectMarshaler,
+        SimpleObjectMarshalerFactory,
+    )
+
+    from .objects.metadata import (  # noqa
+        FieldInfo,
+        FieldInfos,
+        FieldMetadata,
+        FieldOptions,
+        ObjectMetadata,
+        ObjectSpecials,
+    )
+
+    from .objects.unmarshal import (  # noqa
+        ObjectUnmarshaler,
+        SimpleObjectUnmarshalerFactory,
+    )
+
+    from .polymorphism.marshal import (  # noqa
+        PolymorphismMarshaler,
+        PolymorphismMarshalerFactory,
+        make_polymorphism_marshaler,
+    )
+
+    from .polymorphism.metadata import (  # noqa
+        FieldTypeTagging,
+        Impl,
+        Impls,
+        Polymorphism,
+        TypeTagging,
+        WrapperTypeTagging,
+        polymorphism_from_impls,
+        polymorphism_from_subclasses,
+    )
+
+    from .polymorphism.standard import (  # noqa
+        standard_polymorphism_factories,
+    )
+
+    from .polymorphism.unions import (  # noqa
+        PRIMITIVE_UNION_TYPES,
+        PolymorphismUnionMarshalerFactory,
+        PolymorphismUnionUnmarshalerFactory,
+        PrimitiveUnionMarshaler,
+        PrimitiveUnionMarshalerFactory,
+        PrimitiveUnionUnmarshaler,
+        PrimitiveUnionUnmarshalerFactory,
+    )
+
+    from .polymorphism.unmarshal import (  # noqa
+        PolymorphismUnmarshaler,
+        PolymorphismUnmarshalerFactory,
+        make_polymorphism_unmarshaler,
+    )
+
+    from .singular.base64 import (  # noqa
+        BASE64_MARSHALER_FACTORY,
+        BASE64_UNMARSHALER_FACTORY,
+    )
+
+    from .singular.primitives import (  # noqa
+        PRIMITIVE_TYPES,
+    )
+
+    from .trivial.forbidden import (  # noqa
+        ForbiddenTypeMarshalerFactory,
+        ForbiddenTypeUnmarshalerFactory,
+    )
+
+    from .trivial.nop import (  # noqa
+        NOP_MARSHALER_UNMARSHALER,
+        NopMarshalerUnmarshaler,
+    )
+
+    from .globals import (  # noqa
+        global_config_registry,
+        global_marshaler_factory,
+        global_unmarshaler_factory,
+        global_marshaling,
+
+        marshal,
+        unmarshal,
+
+        register_global_config,
+        register_global_module_import,
+    )
+
+    from .naming import (  # noqa
+        Naming,
+        translate_name,
+    )
+
+    from .standard import (  # noqa
+        StandardFactories,
+        DEFAULT_STANDARD_FACTORIES,
+
+        new_standard_marshaler_factory,
+        new_standard_unmarshaler_factory,
+
+        install_standard_factories,
+    )

omlish-0.0.0.dev418/omlish/marshal/base/configs.py

@@ -0,0 +1,18 @@
+import typing as ta
+
+from ... import lang
+from .registries import Registry
+from .registries import RegistryItem
+
+
+##
+
+
+class Config(RegistryItem, lang.Abstract):
+    pass
+
+
+ConfigRegistry: ta.TypeAlias = Registry[Config]
+
+
+EMPTY_CONFIG_REGISTRY = ConfigRegistry().seal()

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/marshal/base/contexts.py

@@ -1,18 +1,19 @@
+import dataclasses as dc
 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 .configs import EMPTY_CONFIG_REGISTRY
+from .configs import ConfigRegistry
 from .errors import UnhandledTypeError
 from .options import Option
 from .overrides import ReflectOverride
 
 
 if ta.TYPE_CHECKING:
-    from .registries import Registry
     from .types import Marshaler
     from .types import MarshalerFactory
     from .types import Unmarshaler
@@ -26,21 +27,21 @@ T = ta.TypeVar('T')
 ##
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, kw_only=True)
 class BaseContext(lang.Abstract):
-    registry: 'Registry'
+    config_registry: ConfigRegistry = EMPTY_CONFIG_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)):
+            if (ovr := self.config_registry.get_of(o, ReflectOverride)):
                 return ovr[-1].rty
             return None
 
         return rfl.Reflector(override=override).type(o)
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, kw_only=True)
 class MarshalContext(BaseContext, lang.Final):
     factory: ta.Optional['MarshalerFactory'] = None
 
@@ -55,7 +56,7 @@ class MarshalContext(BaseContext, lang.Final):
         return self.make(ty if ty is not None else type(obj)).marshal(self, obj)
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, kw_only=True)
 class UnmarshalContext(BaseContext, lang.Final):
     factory: ta.Optional['UnmarshalerFactory'] = None
 

omlish-0.0.0.dev418/omlish/marshal/base/funcs.py

@@ -0,0 +1,57 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from .contexts import MarshalContext
+from .contexts import UnmarshalContext
+from .types import Marshaler
+from .types import MarshalerFactory
+from .types import MarshalerMaker
+from .types import Unmarshaler
+from .types import UnmarshalerFactory
+from .types import UnmarshalerMaker
+from .values import Value
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FuncMarshaler(Marshaler, lang.Final):
+    fn: ta.Callable[[MarshalContext, ta.Any], Value]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        return self.fn(ctx, o)
+
+
+@dc.dataclass(frozen=True)
+class FuncUnmarshaler(Unmarshaler, lang.Final):
+    fn: ta.Callable[[UnmarshalContext, Value], ta.Any]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return self.fn(ctx, v)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FuncMarshalerFactory(MarshalerFactory):  # noqa
+    guard: ta.Callable[[MarshalContext, rfl.Type], bool]
+    fn: ta.Callable[[MarshalContext, rfl.Type], Marshaler]
+
+    @lang.cached_property
+    def make_marshaler(self) -> MarshalerMaker:
+        return mfs.simple(self.guard, self.fn)
+
+
+@dc.dataclass(frozen=True)
+class FuncUnmarshalerFactory(UnmarshalerFactory):  # noqa
+    guard: ta.Callable[[UnmarshalContext, rfl.Type], bool]
+    fn: ta.Callable[[UnmarshalContext, rfl.Type], Unmarshaler]
+
+    @lang.cached_property
+    def make_unmarshaler(self) -> UnmarshalerMaker:
+        return mfs.simple(self.guard, self.fn)

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/marshal/base/overrides.py

@@ -1,9 +1,10 @@
+import dataclasses as dc
 import typing as ta
 
-from ... import dataclasses as dc
+from ... import check
 from ... import lang
 from ... import reflect as rfl
-from .registries import RegistryItem
+from .configs import Config
 
 
 if ta.TYPE_CHECKING:
@@ -21,14 +22,18 @@ else:
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class Override(RegistryItem, lang.Final):
-    marshaler: ta.Optional['Marshaler'] = dc.xfield(None, validate=lambda v: isinstance(v, (_types.Marshaler, type(None))))  # noqa
+class Override(Config, lang.Final):
+    marshaler: ta.Optional['Marshaler'] = None
     marshaler_factory: ta.Optional['MarshalerFactory'] = None
 
-    unmarshaler: ta.Optional['Unmarshaler'] = dc.xfield(None, validate=lambda v: isinstance(v, (_types.Unmarshaler, type(None))))  # noqa
+    unmarshaler: ta.Optional['Unmarshaler'] = None
     unmarshaler_factory: ta.Optional['UnmarshalerFactory'] = None
 
+    def __post_init__(self) -> None:
+        check.isinstance(self.marshaler, (_types.Marshaler, None))
+        check.isinstance(self.unmarshaler, (_types.Unmarshaler, None))
+
 
 @dc.dataclass(frozen=True)
-class ReflectOverride(RegistryItem, lang.Final):
+class ReflectOverride(Config, lang.Final):
     rty: rfl.Type

{omlish-0.0.0.dev416 → omlish-0.0.0.dev418}/omlish/marshal/base/registries.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - col.TypeMap?
+  - at least get_any
+"""
 import dataclasses as dc
 import threading
 import typing as ta
@@ -14,21 +19,26 @@ class RegistryItem(lang.Abstract):
 
 
 RegistryItemT = ta.TypeVar('RegistryItemT', bound=RegistryItem)
+RegistryItemU = ta.TypeVar('RegistryItemU', bound=RegistryItem)
 
 
 @dc.dataclass(frozen=True)
-class _KeyRegistryItems:
+class _KeyRegistryItems(ta.Generic[RegistryItemT]):
     key: ta.Any
-    items: list[RegistryItem] = dc.field(default_factory=list)
-    item_lists_by_ty: dict[type[RegistryItem], list[RegistryItem]] = dc.field(default_factory=dict)
+    items: list[RegistryItemT] = dc.field(default_factory=list)
+    item_lists_by_ty: dict[type[RegistryItemT], list[RegistryItemT]] = dc.field(default_factory=dict)
 
-    def add(self, *items: RegistryItem) -> None:
+    def add(self, *items: RegistryItemT) -> None:
         for i in items:
             self.items.append(i)
             self.item_lists_by_ty.setdefault(type(i), []).append(i)
 
 
-class Registry:
+class RegistrySealedError(Exception):
+    pass
+
+
+class Registry(ta.Generic[RegistryItemT]):
     def __init__(
             self,
             *,
@@ -39,22 +49,54 @@ class Registry:
         if lock is None:
             lock = threading.RLock()
         self._lock = lock
-        self._idct: ta.MutableMapping[ta.Any, _KeyRegistryItems] = col.IdentityKeyDict()
-        self._dct: dict[ta.Any, _KeyRegistryItems] = {}
+
+        self._dct: dict[ta.Any, _KeyRegistryItems[RegistryItemT]] = {}
+        self._id_dct: ta.MutableMapping[ta.Any, _KeyRegistryItems[RegistryItemT]] = col.IdentityKeyDict()
+
+        self._sealed = False
+
+    #
+
+    def is_sealed(self) -> bool:
+        if self._sealed:
+            return True
+        with self._lock:
+            return self._sealed
+
+    def seal(self) -> ta.Self:
+        if self._sealed:
+            raise RegistrySealedError(self)
+        with self._lock:
+            self._seal()
+        return self
+
+    def _seal(self) -> None:
+        if self._sealed:
+            raise RegistrySealedError(self)
+
+        self._sealed = True
+
+    #
 
     def register(
             self,
             key: ta.Any,
-            *items: RegistryItem,
+            *items: RegistryItemT,
             identity: bool = False,
-    ) -> 'Registry':
+    ) -> ta.Self:
         with self._lock:
-            dct: ta.Any = self._idct if identity else self._dct
+            if self._sealed:
+                raise RegistrySealedError(self)
+
+            dct: ta.Any = self._id_dct if identity else self._dct
             if (sr := dct.get(key)) is None:
                 sr = dct[key] = _KeyRegistryItems(key)
             sr.add(*items)
+
         return self
 
+    #
+
     def get(
             self,
             key: ta.Any,
@@ -66,7 +108,8 @@ class Registry:
                 *self.get(key, identity=True),
                 *self.get(key, identity=False),
             )
-        dct: ta.Any = self._idct if identity else self._dct
+
+        dct: ta.Any = self._id_dct if identity else self._dct
         try:
             return dct[key].items
         except KeyError:
@@ -75,16 +118,17 @@ class Registry:
     def get_of(
             self,
             key: ta.Any,
-            item_ty: type[RegistryItemT],
+            item_ty: type[RegistryItemU],
             *,
             identity: bool | None = None,
-    ) -> ta.Sequence[RegistryItemT]:
+    ) -> ta.Sequence[RegistryItemU]:
         if identity is None:
             return (
                 *self.get_of(key, item_ty, identity=True),
                 *self.get_of(key, item_ty, identity=False),
             )
-        dct: ta.Any = self._idct if identity else self._dct
+
+        dct: ta.Any = self._id_dct if identity else self._dct
         try:
             sr = dct[key]
         except KeyError: