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

omlish/marshal/standard.py

@@ -1,3 +1,9 @@
+"""
+FIXME:
+ - this is gross and temporary
+  - move to global registry somehow
+"""
+import threading
 import typing as ta
 
 from .base.types import MarshalerFactory
@@ -16,6 +22,10 @@ from .composite.optionals import OptionalMarshalerFactory
 from .composite.optionals import OptionalUnmarshalerFactory
 from .composite.special import SequenceNotStrMarshalerFactory
 from .composite.special import SequenceNotStrUnmarshalerFactory
+from .factories.invalidate import InvalidatableMarshalerFactory
+from .factories.invalidate import InvalidatableUnmarshalerFactory
+from .factories.moduleimport.factories import ModuleImportingMarshalerFactory
+from .factories.moduleimport.factories import ModuleImportingUnmarshalerFactory
 from .factories.multi import MultiMarshalerFactory
 from .factories.multi import MultiUnmarshalerFactory
 from .factories.recursive import RecursiveMarshalerFactory
@@ -45,24 +55,53 @@ from .trivial.any import ANY_UNMARSHALER_FACTORY
 ##
 
 
-STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
-    PRIMITIVE_MARSHALER_FACTORY,
-    NewtypeMarshalerFactory(),
-    OptionalMarshalerFactory(),
-    PrimitiveUnionMarshalerFactory(),
-    DataclassMarshalerFactory(),
-    NamedtupleMarshalerFactory(),
-    EnumMarshalerFactory(),
-    LiteralMarshalerFactory(),
-    NUMBERS_MARSHALER_FACTORY,
-    UUID_MARSHALER_FACTORY,
-    DATETIME_MARSHALER_FACTORY,
-    MaybeMarshalerFactory(),
-    MappingMarshalerFactory(),
-    SequenceNotStrMarshalerFactory(),
-    IterableMarshalerFactory(),
-    ANY_MARSHALER_FACTORY,
-]
+class StandardFactories(ta.NamedTuple):
+    marshaler_factories: ta.Sequence[MarshalerFactory]
+    unmarshaler_factories: ta.Sequence[UnmarshalerFactory]
+
+
+DEFAULT_STANDARD_FACTORIES = StandardFactories(
+    (
+        PRIMITIVE_MARSHALER_FACTORY,
+        NewtypeMarshalerFactory(),
+        OptionalMarshalerFactory(),
+        PrimitiveUnionMarshalerFactory(),
+        DataclassMarshalerFactory(),
+        NamedtupleMarshalerFactory(),
+        EnumMarshalerFactory(),
+        LiteralMarshalerFactory(),
+        NUMBERS_MARSHALER_FACTORY,
+        UUID_MARSHALER_FACTORY,
+        DATETIME_MARSHALER_FACTORY,
+        MaybeMarshalerFactory(),
+        MappingMarshalerFactory(),
+        SequenceNotStrMarshalerFactory(),
+        IterableMarshalerFactory(),
+        ANY_MARSHALER_FACTORY,
+    ),
+
+    (
+        PRIMITIVE_UNMARSHALER_FACTORY,
+        NewtypeUnmarshalerFactory(),
+        OptionalUnmarshalerFactory(),
+        PrimitiveUnionUnmarshalerFactory(),
+        DataclassUnmarshalerFactory(),
+        NamedtupleUnmarshalerFactory(),
+        EnumUnmarshalerFactory(),
+        LiteralUnmarshalerFactory(),
+        NUMBERS_UNMARSHALER_FACTORY,
+        UUID_UNMARSHALER_FACTORY,
+        DATETIME_UNMARSHALER_FACTORY,
+        MaybeUnmarshalerFactory(),
+        MappingUnmarshalerFactory(),
+        SequenceNotStrUnmarshalerFactory(),
+        IterableUnmarshalerFactory(),
+        ANY_UNMARSHALER_FACTORY,
+    ),
+)
+
+
+##
 
 
 def new_standard_marshaler_factory(
@@ -70,38 +109,32 @@ def new_standard_marshaler_factory(
         first: ta.Iterable[MarshalerFactory] | None = None,
         last: ta.Iterable[MarshalerFactory] | None = None,
 ) -> MarshalerFactory:
-    return TypeCacheMarshalerFactory(
-        RecursiveMarshalerFactory(
-            MultiMarshalerFactory([
-                *(first if first is not None else []),
-                *STANDARD_MARSHALER_FACTORIES,
-                *(last if last is not None else []),
-            ]),
-        ),
-    )
+    gl: ta.Any = None
 
+    def fi_fn():
+        nonlocal gl
+        gl = DEFAULT_STANDARD_FACTORIES
 
-##
+        fi: MarshalerFactory = MultiMarshalerFactory([
+            *(first if first is not None else []),
+            *gl.marshaler_factories,
+            *(last if last is not None else []),
+        ])
+
+        fi = RecursiveMarshalerFactory(fi)
+
+        fi = TypeCacheMarshalerFactory(fi)
 
+        return fi
 
-STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
-    PRIMITIVE_UNMARSHALER_FACTORY,
-    NewtypeUnmarshalerFactory(),
-    OptionalUnmarshalerFactory(),
-    PrimitiveUnionUnmarshalerFactory(),
-    DataclassUnmarshalerFactory(),
-    NamedtupleUnmarshalerFactory(),
-    EnumUnmarshalerFactory(),
-    LiteralUnmarshalerFactory(),
-    NUMBERS_UNMARSHALER_FACTORY,
-    UUID_UNMARSHALER_FACTORY,
-    DATETIME_UNMARSHALER_FACTORY,
-    MaybeUnmarshalerFactory(),
-    MappingUnmarshalerFactory(),
-    SequenceNotStrUnmarshalerFactory(),
-    IterableUnmarshalerFactory(),
-    ANY_UNMARSHALER_FACTORY,
-]
+    fo: MarshalerFactory = (iv := InvalidatableMarshalerFactory(
+        fi_fn,
+        lambda: DEFAULT_STANDARD_FACTORIES is not gl,
+    ))
+
+    fo = ModuleImportingMarshalerFactory(fo, iv.invalidate)
+
+    return fo
 
 
 def new_standard_unmarshaler_factory(
@@ -109,33 +142,67 @@ def new_standard_unmarshaler_factory(
         first: ta.Iterable[UnmarshalerFactory] | None = None,
         last: ta.Iterable[UnmarshalerFactory] | None = None,
 ) -> UnmarshalerFactory:
-    return TypeCacheUnmarshalerFactory(
-        RecursiveUnmarshalerFactory(
-            MultiUnmarshalerFactory([
-                *(first if first is not None else []),
-                *STANDARD_UNMARSHALER_FACTORIES,
-                *(last if last is not None else []),
-            ]),
-        ),
-    )
+    gl: ta.Any = None
+
+    def fi_fn():
+        nonlocal gl
+        gl = DEFAULT_STANDARD_FACTORIES
+
+        fi: UnmarshalerFactory = MultiUnmarshalerFactory([
+            *(first if first is not None else []),
+            *gl.unmarshaler_factories,
+            *(last if last is not None else []),
+        ])
+
+        fi = RecursiveUnmarshalerFactory(fi)
+
+        fi = TypeCacheUnmarshalerFactory(fi)
+
+        return fi
+
+    fo: UnmarshalerFactory = (iv := InvalidatableUnmarshalerFactory(
+        fi_fn,
+        lambda: DEFAULT_STANDARD_FACTORIES is not gl,
+    ))
+
+    fo = ModuleImportingUnmarshalerFactory(fo, iv.invalidate)
+
+    return fo
 
 
 ##
 
 
+_GLOBAL_LOCK = threading.RLock()
+
+
 def install_standard_factories(
         *factories: MarshalerFactory | UnmarshalerFactory,
 ) -> None:
-    for f in factories:
-        k = False
+    with _GLOBAL_LOCK:
+        global DEFAULT_STANDARD_FACTORIES
+
+        m_lst: list[MarshalerFactory] = list(DEFAULT_STANDARD_FACTORIES.marshaler_factories)
+        u_lst: list[UnmarshalerFactory] = list(DEFAULT_STANDARD_FACTORIES.unmarshaler_factories)
+
+        for f in factories:
+            k = False
+
+            if isinstance(f, MarshalerFactory):
+                m_lst[0:0] = [f]
+                k = True
+
+            if isinstance(f, UnmarshalerFactory):
+                u_lst[0:0] = [f]
+                k = True
 
-        if isinstance(f, MarshalerFactory):
-            STANDARD_MARSHALER_FACTORIES[0:0] = [f]
-            k = True
+            if not k:
+                raise TypeError(f)
 
-        if isinstance(f, UnmarshalerFactory):
-            STANDARD_UNMARSHALER_FACTORIES[0:0] = [f]
-            k = True
+        new = StandardFactories(
+            tuple(m_lst),
+            tuple(u_lst),
+        )
 
-        if not k:
-            raise TypeError(f)
+        if new != DEFAULT_STANDARD_FACTORIES:
+            DEFAULT_STANDARD_FACTORIES = new

omlish/reflect/__init__.py

@@ -1,50 +1,60 @@
-from .inspect import (  # noqa
-    get_annotations,
-    get_filtered_type_hints,
-    has_annotations,
-)
+from .. import lang as _lang
 
-from .ops import (  # noqa
-    get_concrete_type,
-    get_underlying,
-    strip_annotations,
-    strip_objs,
-    to_annotation,
-    types_equivalent,
-)
 
-from .subst import (  # noqa
-    ALIAS_UPDATING_GENERIC_SUBSTITUTION,
-    DEFAULT_GENERIC_SUBSTITUTION,
-    GenericSubstitution,
-    generic_mro,
-    get_generic_bases,
-    get_type_var_replacements,
-    replace_type_vars,
-)
+with _lang.auto_proxy_init(
+        globals(),
+        update_exports=True,
+        # eager=True,
+):
+    ##
 
-from .types import (  # noqa
-    ANY,
-    Annotated,
-    Any,
-    DEFAULT_REFLECTOR,
-    Generic,
-    GenericLike,
-    Literal,
-    NewType,
-    Protocol,
-    ReflectTypeError,
-    Reflector,
-    TYPES,
-    Type,
-    TypeInfo,
-    Union,
-    get_newtype_supertype,
-    get_orig_bases,
-    get_orig_class,
-    get_params,
-    get_type_var_bound,
-    is_type,
-    is_union_type,
-    type_,
-)
+    from .inspect import (  # noqa
+        get_annotations,
+        get_filtered_type_hints,
+        has_annotations,
+    )
+
+    from .ops import (  # noqa
+        get_concrete_type,
+        get_underlying,
+        strip_annotations,
+        strip_objs,
+        to_annotation,
+        types_equivalent,
+    )
+
+    from .subst import (  # noqa
+        ALIAS_UPDATING_GENERIC_SUBSTITUTION,
+        DEFAULT_GENERIC_SUBSTITUTION,
+        GenericSubstitution,
+        generic_mro,
+        get_generic_bases,
+        get_type_var_replacements,
+        replace_type_vars,
+    )
+
+    from .types import (  # noqa
+        ANY,
+        Annotated,
+        Any,
+        DEFAULT_REFLECTOR,
+        Generic,
+        GenericLike,
+        Literal,
+        NewType,
+        Protocol,
+        ReflectTypeError,
+        Reflector,
+        TYPES,
+        Type,
+        TypeInfo,
+        Union,
+        get_newtype_supertype,
+        get_orig_bases,
+        get_orig_class,
+        get_params,
+        get_type_var_bound,
+        is_type,
+        is_union_type,
+        type_,
+    )

omlish/reflect/types.py

@@ -18,6 +18,7 @@ TODO:
 """
 import abc
 import dataclasses as dc
+import threading
 import types
 import typing as ta
 
@@ -56,21 +57,149 @@ class _Special:
     origin: type
     nparams: int
 
+    @classmethod
+    def from_alias(cls, sa: _SpecialGenericAlias) -> '_Special':  # type: ignore
+        return cls(
+            sa._name,  # type: ignore  # noqa
+            sa,
+            sa.__origin__,  # type: ignore
+            sa._nparams,  # type: ignore  # noqa
+        )
 
-_KNOWN_SPECIALS = [
-    _Special(
-        v._name,  # noqa
-        v,
-        v.__origin__,
-        v._nparams,  # noqa
-    )
-    for v in ta.__dict__.values()  # noqa
-    if isinstance(v, _SpecialGenericAlias)
-]
 
-_KNOWN_SPECIALS_BY_NAME = {s.name: s for s in _KNOWN_SPECIALS}
-_KNOWN_SPECIALS_BY_ALIAS = {s.alias: s for s in _KNOWN_SPECIALS}
-_KNOWN_SPECIALS_BY_ORIGIN = {s.origin: s for s in _KNOWN_SPECIALS}
+@dc.dataclass(frozen=True)
+class _LazySpecial:
+    name: str
+
+
+class _KnownSpecials:
+    def __init__(
+            self,
+            specials: ta.Iterable[_Special] = (),
+            lazy_specials: ta.Iterable[_LazySpecial] = (),
+    ) -> None:
+        super().__init__()
+
+        self._lock = threading.RLock()
+
+        self._lst: list[_Special] = []
+        self._by_name: dict[str, _Special] = {}
+        self._by_alias: dict[_SpecialGenericAlias, _Special] = {}  # type: ignore
+        self._by_origin: dict[type, _Special] = {}
+
+        self._lazies_by_name: dict[str, _LazySpecial] = {}
+
+        for sp in specials:
+            self._add(sp)
+        for lz in lazy_specials:
+            self._add_lazy(lz)
+
+    #
+
+    def _add(self, sp: _Special) -> None:
+        uds: list[tuple[ta.Any, ta.MutableMapping]] = [
+            (sp.name, self._by_name),
+            (sp.alias, self._by_alias),
+            (sp.origin, self._by_origin),
+        ]
+        for k, dct in uds:
+            if k in dct:
+                raise KeyError(k)
+
+        if sp.name in self._lazies_by_name:
+            raise KeyError(sp.name)
+
+        self._lst.append(sp)
+        for k, dct in uds:
+            dct[k] = sp
+
+    def add(self, *specials: _Special) -> ta.Self:
+        with self._lock:
+            for sp in specials:
+                self._add(sp)
+        return self
+
+    #
+
+    def _add_lazy(self, lz: _LazySpecial) -> None:
+        if lz.name in self._lazies_by_name:
+            raise KeyError(lz.name)
+        if lz.name in self._by_name:
+            raise KeyError(lz.name)
+
+        self._lazies_by_name[lz.name] = lz
+
+    def add_lazy(self, *lazy_specials: _LazySpecial) -> ta.Self:
+        with self._lock:
+            for lz in lazy_specials:
+                self._add_lazy(lz)
+        return self
+
+    #
+
+    def _get_lazy_by_name(self, name: str) -> _Special | None:
+        if name not in self._lazies_by_name:
+            return None
+
+        with self._lock:
+            if (x := self._by_name.get(name)) is not None:
+                return x
+
+            if (lz := self._lazies_by_name.get(name)) is None:
+                return None
+
+            sa = getattr(ta, lz.name)
+            if not isinstance(sa, _SpecialGenericAlias):
+                raise TypeError(sa)
+
+            sp = _Special.from_alias(sa)
+            del self._lazies_by_name[lz.name]
+            self._add(sp)
+
+            return sp
+
+    def get_by_name(self, name: str) -> _Special | None:
+        try:
+            return self._by_name.get(name)
+        except KeyError:
+            pass
+        return self._get_lazy_by_name(name)
+
+    def get_by_alias(self, alias: _SpecialGenericAlias) -> _Special | None:  # type: ignore
+        try:
+            return self._by_alias[alias]
+        except KeyError:
+            pass
+        return self._get_lazy_by_name(alias._name)  # type: ignore  # noqa
+
+    def get_by_origin(self, origin: type) -> _Special | None:
+        return self._by_origin.get(origin)
+
+
+_KNOWN_SPECIALS = _KnownSpecials(
+    [
+        _Special.from_alias(v)
+        for v in ta.__dict__.values()  # noqa
+        if isinstance(v, _SpecialGenericAlias)
+    ],
+    [
+        _LazySpecial(n)
+        for n in [
+            # https://github.com/python/cpython/commit/e8be0c9c5a7c2327b3dd64009f45ee0682322dcb
+            'Pattern',
+            'Match',
+            'ContextManager',
+            'AsyncContextManager',
+            # https://github.com/python/cpython/commit/305be5fb1a1ece7f9651ae98053dbe79bf439aa4
+            'ForwardRef',
+        ]
+        if n not in ta.__dict__
+    ],
+)
+
+
+##
+
 
 _MAX_KNOWN_SPECIAL_TYPE_VARS = 16
 
@@ -99,7 +228,7 @@ def get_params(obj: ta.Any) -> tuple[ta.TypeVar, ...]:
         if issubclass(obj, ta.Generic):  # type: ignore
             return obj.__dict__.get('__parameters__', ())  # noqa
 
-        if (ks := _KNOWN_SPECIALS_BY_ORIGIN.get(obj)) is not None:
+        if (ks := _KNOWN_SPECIALS.get_by_origin(obj)) is not None:
             if (np := ks.nparams) < 0:
                 raise TypeError(obj)
             return _KNOWN_SPECIAL_TYPE_VARS[:np]
@@ -442,7 +571,7 @@ class Reflector:
         # Special Generic
 
         if isinstance(obj, _SpecialGenericAlias):
-            if (ks := _KNOWN_SPECIALS_BY_ALIAS.get(obj)) is not None:
+            if (ks := _KNOWN_SPECIALS.get_by_alias(obj)) is not None:
                 if check_only:
                     return None
 

omlish/secrets/all.py

@@ -16,12 +16,3 @@ from .secrets import (  # noqa
 )
 
 ref = SecretRef
-
-
-##
-
-
-from .. import lang as _lang  # noqa
-
-# FIXME: only happens when 'all' is imported lol
-_lang.register_conditional_import('..marshal', '.marshal', __package__)

omlish/secrets/secrets.py

@@ -20,6 +20,10 @@ import typing as ta
 
 from .. import dataclasses as dc
 from .. import lang
+from .. import marshal as msh
+
+
+msh.register_global_module_import('.marshal', __package__)
 
 
 log = logging.getLogger(__name__)
@@ -341,9 +345,3 @@ class EnvVarSecrets(Secrets):
             return dct.pop(ekey)
         else:
             return dct[ekey]
-
-
-##
-
-
-lang.register_conditional_import('..marshal', '.marshal', __package__)

omlish/specs/jsonrpc/__init__.py

@@ -36,6 +36,6 @@ from .types 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/specs/jsonschema/__init__.py

@@ -69,6 +69,6 @@ from .types 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/specs/openapi/__init__.py

@@ -6,6 +6,6 @@ from .openapi 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/sql/queries/__init__.py

@@ -112,8 +112,10 @@ Q = StdBuilder()
 ##
 
 
-from ... import lang as _lang  # noqa
+from ... import marshal as _msh  # noqa
+
+_msh.register_global_module_import('._marshal', __package__)
 
-_lang.register_conditional_import('...marshal', '.marshal', __package__)
+from ... import lang as _lang  # noqa
 
 _lang.trigger_conditional_imports(__package__)

omlish/sql/tabledefs/__init__.py

@@ -6,6 +6,6 @@ from .tabledefs 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/typedvalues/__init__.py

@@ -49,6 +49,6 @@ from .values 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__)