omlish 0.0.0.dev415__py3-none-any.whl → 0.0.0.dev417__py3-none-any.whl

omlish/marshal/__init__.py

@@ -1,3 +1,4 @@
+# ruff: noqa: I001
 """
 TODO:
  - redacted
@@ -15,211 +16,231 @@ See:
  - https://github.com/Fatal1ty/mashumaro
  - https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serializers.md#custom-serializers
 """
+from .. import lang as _lang
 
 
-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,
-
-    MarshalerMaker,
-    UnmarshalerMaker,
-
-    MarshalerFactory,
-    UnmarshalerFactory,
-
-    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,
-)
-
-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_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,
-)
+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.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,
+
+        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.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.func import (  # noqa
+        FuncMarshaler,
+        FuncUnmarshaler,
+    )
+
+    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/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/marshal/base/contexts.py

@@ -1,20 +1,24 @@
+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
-from .registries import Registry
-from .types import Marshaler
-from .types import MarshalerFactory
-from .types import Unmarshaler
-from .types import UnmarshalerFactory
-from .values import Value
+
+
+if ta.TYPE_CHECKING:
+    from .types import Marshaler
+    from .types import MarshalerFactory
+    from .types import Unmarshaler
+    from .types import UnmarshalerFactory
+    from .values import Value
 
 
 T = ta.TypeVar('T')
@@ -23,40 +27,40 @@ 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: MarshalerFactory | None = None
+    factory: ta.Optional['MarshalerFactory'] = None
 
-    def make(self, o: ta.Any) -> Marshaler:
+    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:
+    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)
+@dc.dataclass(frozen=True, kw_only=True)
 class UnmarshalContext(BaseContext, lang.Final):
-    factory: UnmarshalerFactory | None = None
+    factory: ta.Optional['UnmarshalerFactory'] = None
 
-    def make(self, o: ta.Any) -> Unmarshaler:
+    def make(self, o: ta.Any) -> 'Unmarshaler':
         rty = self._reflect(o)
         try:
             return check.not_none(self.factory).make_unmarshaler(self, rty)
@@ -64,11 +68,11 @@ class UnmarshalContext(BaseContext, lang.Final):
             raise UnhandledTypeError(rty)  # noqa
 
     @ta.overload
-    def unmarshal(self, v: Value, ty: type[T]) -> T:
+    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: 'Value', ty: ta.Any) -> ta.Any:
         ...
 
     def unmarshal(self, v, ty):

omlish/marshal/base/overrides.py

@@ -1,25 +1,39 @@
-from ... import dataclasses as dc
+import dataclasses as dc
+import typing as ta
+
+from ... import check
 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
+from .configs import Config
+
+
+if ta.TYPE_CHECKING:
+    from . import types as _types
+    from .types import Marshaler
+    from .types import MarshalerFactory
+    from .types import Unmarshaler
+    from .types import UnmarshalerFactory
+
+else:
+    _types = lang.proxy_import('.types', __package__)
 
 
 ##
 
 
 @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
+class Override(Config, lang.Final):
+    marshaler: ta.Optional['Marshaler'] = None
+    marshaler_factory: ta.Optional['MarshalerFactory'] = None
+
+    unmarshaler: ta.Optional['Unmarshaler'] = None
+    unmarshaler_factory: ta.Optional['UnmarshalerFactory'] = None
 
-    unmarshaler: Unmarshaler | None = dc.xfield(None, check_type=(Unmarshaler, None))
-    unmarshaler_factory: UnmarshalerFactory | None = 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