omlish 0.0.0.dev282__py3-none-any.whl → 0.0.0.dev284__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev282'
-__revision__ = '7838e4a0dc1a1434797f27f330d5d3efdd410927'
+__version__ = '0.0.0.dev284'
+__revision__ = 'e10caaddb37a1fedcbe1bf3e711062e82a8cc7cb'
 
 
 #
@@ -35,7 +35,7 @@ class Project(ProjectBase):
             'anyio ~= 4.9',
             'sniffio ~= 1.3',
 
-            'greenlet ~= 3.1',
+            'greenlet ~= 3.2',
 
             'trio ~= 0.29',
             'trio-asyncio ~= 0.15',
@@ -92,7 +92,7 @@ class Project(ProjectBase):
             # 'psycopg ~= 3.2',
 
             'pymysql ~= 1.1',
-            # 'mysql-connector-python ~= 9.1',
+            # 'mysql-connector-python ~= 9.3',
             # 'mysqlclient ~= 2.2',
 
             'aiomysql ~= 0.2',

omlish/collections/__init__.py

@@ -31,7 +31,7 @@ from .coerce import (  # noqa
     seq_or_none,
 )
 
-from .exceptions import (  # noqa
+from .errors import (  # noqa
     DuplicateKeyError,
 )
 

omlish/collections/mappings.py

@@ -23,6 +23,9 @@ def multikey_dict(dct: ta.Mapping[ta.Iterable[K] | K, V], *, deep: bool = False)
     return ret
 
 
+##
+
+
 def guarded_map_update(
         dst: ta.MutableMapping[ta.Any, ta.Any],
         *srcs: ta.Mapping[ta.Any, ta.Any],
@@ -35,6 +38,9 @@ def guarded_map_update(
     return dst
 
 
+##
+
+
 class TypeMap(ta.Generic[T]):
     def __init__(self, items: ta.Iterable[T] = ()) -> None:
         super().__init__()
@@ -99,6 +105,9 @@ class DynamicTypeMap(ta.Generic[V]):
             return ret
 
 
+##
+
+
 class MissingDict(dict[K, V]):
     def __init__(self, missing_fn: ta.Callable[[K], V]) -> None:
         if not callable(missing_fn):

omlish/collections/utils.py

@@ -1,7 +1,7 @@
 import typing as ta
 
 from .. import lang
-from .exceptions import DuplicateKeyError
+from .errors import DuplicateKeyError
 from .identity import IdentityKeyDict
 from .identity import IdentitySet
 
@@ -30,6 +30,9 @@ def partition(items: ta.Iterable[T], pred: ta.Callable[[T], bool]) -> PartitionR
     return PartitionResult(t, f)
 
 
+##
+
+
 def unique(
         it: ta.Iterable[T],
         *,
@@ -52,6 +55,9 @@ def unique(
     return ret
 
 
+##
+
+
 def make_map(
         kvs: ta.Iterable[tuple[K, V]],
         *,
@@ -82,6 +88,9 @@ def make_map_by(
     )
 
 
+##
+
+
 def multi_map(kvs: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, list[V]]:
     d: ta.MutableMapping[K, list[V]] = IdentityKeyDict() if identity else {}
     l: list[V]

omlish/dataclasses/__init__.py

@@ -28,7 +28,7 @@ from .impl.api import (  # noqa
     dataclass as xdataclass,
     make_dataclass as xmake_dataclass,
 
-    extra_params,
+    extra_class_params,
 )
 
 from .impl.as_ import (  # noqa
@@ -65,7 +65,7 @@ globals()['make_dataclass'] = xmake_dataclass
 ##
 
 
-from .impl.exceptions import (  # noqa
+from .impl.errors import (  # noqa
     FieldValidationError,
     ValidationError,
 )

omlish/dataclasses/impl/api.py

@@ -247,7 +247,7 @@ class _ExtraParamsKwargs:
     pass
 
 
-def extra_params(  # noqa
+def extra_class_params(  # noqa
         *,
         reorder=MISSING,
         cache_hash=MISSING,

omlish/dataclasses/impl/{exceptions.py → errors.py}

@@ -2,6 +2,9 @@ import types
 import typing as ta
 
 
+##
+
+
 class ValidationError(Exception):
     pass
 

omlish/dataclasses/impl/fields.py

@@ -8,7 +8,7 @@ import typing as ta
 
 from ... import check as check_
 from ... import lang
-from .exceptions import FieldValidationError
+from .errors import FieldValidationError
 from .internals import FIELDS_ATTR
 from .internals import FieldType
 from .internals import is_classvar

omlish/dataclasses/impl/init.py

@@ -3,7 +3,7 @@ import inspect
 import typing as ta
 
 from ... import lang
-from .exceptions import ValidationError
+from .errors import ValidationError
 from .fields import field_init
 from .fields import field_type
 from .fields import has_default

omlish/dataclasses/impl/order.py

@@ -40,7 +40,17 @@ class OrderProcessor(Processor):
             ('__gt__', '>'),
             ('__ge__', '>='),
         ]:
-            if set_new_attribute(self._cls, name, cmp_fn(name, op, self_tuple, other_tuple, globals=self._info.globals)):  # noqa
+            if set_new_attribute(
+                    self._cls,  # noqa
+                    name,
+                    cmp_fn(
+                        name,
+                        op,
+                        self_tuple,
+                        other_tuple,
+                        globals=self._info.globals,
+                    ),
+            ):
                 raise TypeError(
                     f'Cannot overwrite attribute {name} in class {self._cls.__name__}. '
                     f'Consider using functools.total_ordering',

omlish/inject/__init__.py

@@ -21,7 +21,7 @@ from .elements import (  # noqa
     as_elements,
 )
 
-from .exceptions import (  # noqa
+from .errors import (  # noqa
     BaseKeyError,
     ConflictingKeyError,
     CyclicDependencyError,

omlish/inject/bindings.py

@@ -12,7 +12,7 @@ from .types import Unscoped
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Binding(Element, lang.Final):
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))
     provider: Provider = dc.xfield(coerce=check.of_isinstance(Provider))

omlish/inject/eagers.py

@@ -13,6 +13,6 @@ from .keys import Key
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Eager(Element, lang.Final):
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/impl/bindings.py

@@ -11,7 +11,7 @@ from .providers import ProviderImpl
 
 
 @dc.dataclass(frozen=True, eq=False)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class BindingImpl(lang.Final):
     key: Key
     provider: ProviderImpl

omlish/inject/impl/elements.py

@@ -29,8 +29,8 @@ from ..bindings import Binding
 from ..eagers import Eager
 from ..elements import Element
 from ..elements import Elements
-from ..exceptions import ConflictingKeyError
-from ..exceptions import UnboundKeyError
+from ..errors import ConflictingKeyError
+from ..errors import UnboundKeyError
 from ..keys import Key
 from ..listeners import ProvisionListenerBinding
 from ..multis import MapBinding

omlish/inject/impl/injector.py

@@ -23,8 +23,8 @@ import weakref
 from ... import check
 from ... import lang
 from ..elements import Elements
-from ..exceptions import CyclicDependencyError
-from ..exceptions import UnboundKeyError
+from ..errors import CyclicDependencyError
+from ..errors import UnboundKeyError
 from ..injector import Injector
 from ..inspect import KwargsTarget
 from ..keys import Key

omlish/inject/impl/inspect.py

@@ -12,7 +12,7 @@ import weakref
 
 from ... import check
 from ... import reflect as rfl
-from ..exceptions import ConflictingKeyError
+from ..errors import ConflictingKeyError
 from ..inspect import Kwarg
 from ..inspect import KwargsTarget
 from ..keys import Key

omlish/inject/impl/scopes.py

@@ -15,8 +15,8 @@ from ... import lang
 from ..bindings import Binding
 from ..elements import Elements
 from ..elements import as_elements
-from ..exceptions import ScopeAlreadyOpenError
-from ..exceptions import ScopeNotOpenError
+from ..errors import ScopeAlreadyOpenError
+from ..errors import ScopeNotOpenError
 from ..injector import Injector
 from ..keys import Key
 from ..providers import FnProvider

omlish/inject/keys.py

@@ -14,7 +14,7 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Key(lang.Final, ta.Generic[T]):
     ty: rfl.Type = dc.xfield(coerce=rfl.type_)
 

omlish/inject/listeners.py

@@ -20,7 +20,7 @@ ProvisionListener: ta.TypeAlias = ta.Callable[[
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class ProvisionListenerBinding(Element, lang.Final):
     listener: ProvisionListener
 

omlish/inject/multis.py

@@ -30,14 +30,14 @@ def _check_set_multi_key(mk: Key) -> bool:
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class SetBinding(Element, lang.Final):
     multi_key: Key = dc.xfield(validate=_check_set_multi_key)
     dst: Key = dc.xfield(coerce=check.of_isinstance(Key))
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class SetProvider(Provider):
     multi_key: Key = dc.xfield(validate=_check_set_multi_key)
 
@@ -50,7 +50,7 @@ def _check_map_multi_key(mk: Key) -> bool:
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class MapBinding(Element, lang.Final):
     multi_key: Key = dc.xfield(validate=_check_map_multi_key)
     map_key: ta.Any = dc.xfield()
@@ -58,7 +58,7 @@ class MapBinding(Element, lang.Final):
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class MapProvider(Provider):
     multi_key: Key = dc.xfield(validate=_check_map_multi_key)
 

omlish/inject/origins.py

@@ -12,13 +12,13 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Origin:
     lst: ta.Sequence[str]
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Origins:
     lst: ta.Sequence[Origin]
 

omlish/inject/overrides.py

@@ -12,7 +12,7 @@ from .elements import as_elements
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Overrides(Element, lang.Final):
     ovr: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
     src: Elements = dc.xfield(coerce=check.of_isinstance(Elements))

omlish/inject/privates.py

@@ -13,13 +13,13 @@ from .keys import as_key
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Expose(Element, lang.Final):
     key: Key = dc.xfield(coerce=as_key)
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Private(Element, lang.Final):
     elements: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
 

omlish/inject/providers.py

@@ -18,24 +18,24 @@ class Provider(lang.Abstract):
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class FnProvider(Provider):
     fn: ta.Any = dc.xfield(validate=callable)
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class CtorProvider(Provider):
     ty: type = dc.xfield(coerce=check.of_isinstance(type))
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class ConstProvider(Provider):
     v: ta.Any
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class LinkProvider(Provider):
     k: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/scopes.py

@@ -27,7 +27,7 @@ SCOPE_ALIASES: dict[str, Scope] = {}
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class ScopeBinding(Element, lang.Final):
     scope: Scope = dc.xfield(coerce=check.of_isinstance(Scope))
 
@@ -60,7 +60,7 @@ SCOPE_ALIASES['thread'] = ThreadScope()
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class SeededScope(Scope, lang.Final):
     tag: ta.Any = dc.xfield(coerce=check.not_none)
 
@@ -71,7 +71,7 @@ class SeededScope(Scope, lang.Final):
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class ScopeSeededProvider(Provider):
     ss: SeededScope = dc.xfield(coerce=check.of_isinstance(SeededScope))
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/lang/__init__.py

@@ -122,8 +122,8 @@ from .descriptors import (  # noqa
     update_wrapper,
 )
 
-from .exceptions import (  # noqa
-    Unreachable,
+from .enums import (  # noqa
+    enum_name_repr,
 )
 
 from .functions import (  # noqa
@@ -166,6 +166,7 @@ from .generators import (  # noqa
 )
 
 from .imports import (  # noqa
+    LazyGlobals,
     can_import,
     get_real_module_name,
     import_all,
@@ -204,7 +205,6 @@ from .objects import (  # noqa
     SimpleProxy,
     anon_object,
     arg_repr,
-    attr_repr,
     can_weakref,
     deep_subclasses,
     dir_dict,
@@ -303,6 +303,11 @@ from ..lite.imports import (  # noqa
     import_module_attr,
 )
 
+from ..lite.reprs import (  # noqa
+    AttrRepr,
+    attr_repr,
+)
+
 from ..lite.timeouts import (  # noqa
     DeadlineTimeout,
     InfiniteTimeout,

omlish/lang/cached/function.py

@@ -1,6 +1,10 @@
 """
 TODO:
+ - !!! lighter weight bound methods
+  - keymaker overhead less important than not rebuilding a whole dc every __get__ on a new instance
  - !! specialize nullary, explicit kwarg
+ - !! use c-backed functools.cache if possible
+  - also just riic
  - !! reconcile A().f() with A.f(A())
   - unbound descriptor *should* still hit instance cache
  - integrate / expose with collections.cache
@@ -10,6 +14,7 @@ TODO:
   - 'staticmethod' or effective equiv - which must resolve to the shared instance
    - and must be transient?
  - use __transient_dict__ to support common state nuking
+ - use __set_name__ ?
 """
 import dataclasses as dc
 import functools
@@ -353,10 +358,14 @@ class _DescriptorCachedFunction(_CachedFunction[T]):
 def cached_function(fn=None, **kwargs):  # noqa
     if fn is None:
         return functools.partial(cached_function, **kwargs)
+
     opts = _CachedFunction.Opts(**kwargs)
+
     if isinstance(fn, staticmethod):
         return _FreeCachedFunction(fn, opts=opts, value_fn=unwrap_func(fn))
+
     scope = classmethod if isinstance(fn, classmethod) else None
+
     return _DescriptorCachedFunction(fn, scope, opts=opts)
 
 

omlish/lang/cached/property.py

@@ -112,7 +112,9 @@ class _TransientCachedProperty(_CachedProperty):
 def cached_property(fn=None, *, transient=False, **kwargs):  # noqa
     if fn is None:
         return functools.partial(cached_property, transient=transient, **kwargs)
-    if transient:
+
+    elif transient:
         return _TransientCachedProperty(fn, **kwargs)
+
     else:
         return _DictCachedProperty(fn, **kwargs)

omlish/lang/comparison.py

@@ -8,6 +8,9 @@ def cmp(l: ta.Any, r: ta.Any) -> int:
     return int(l > r) - int(l < r)
 
 
+##
+
+
 class InfinityType:
     def __repr__(self) -> str:
         return 'Infinity'

omlish/lang/enums.py

@@ -0,0 +1,8 @@
+import typing as ta
+
+
+##
+
+
+def enum_name_repr(e: ta.Any) -> str:
+    return f'{e.__class__.__name__}.{e.name}'

omlish/lang/imports.py

@@ -3,6 +3,7 @@ TODO:
  - proxy_init 'as' alias support - attrs of (src, dst)
 """
 import contextlib
+import functools
 import importlib.util
 import sys
 import types
@@ -254,6 +255,64 @@ def _trigger_conditional_imports(package: str) -> None:
 ##
 
 
+class LazyGlobals:
+    def __init__(
+            self,
+            *,
+            globals: ta.MutableMapping[str, ta.Any] | None = None,  # noqa
+            update_globals: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._globals = globals
+        self._update_globals = update_globals
+
+        self._attr_fns: dict[str, ta.Callable[[], ta.Any]] = {}
+
+    @classmethod
+    def install(cls, globals: ta.MutableMapping[str, ta.Any]) -> 'LazyGlobals':  # noqa
+        try:
+            xga = globals['__getattr__']
+        except KeyError:
+            pass
+        else:
+            if not isinstance(xga, cls):
+                raise RuntimeError(f'Module already has __getattr__ hook: {xga}')  # noqa
+            return xga
+
+        lm = cls(
+            globals=globals,
+            update_globals=True,
+        )
+
+        globals['__getattr__'] = lm
+
+        return lm
+
+    def set_fn(self, attr: str, fn: ta.Callable[[], ta.Any]) -> 'LazyGlobals':
+        self._attr_fns[attr] = fn
+        return self
+
+    def get(self, attr: str) -> ta.Any:
+        try:
+            fn = self._attr_fns[attr]
+        except KeyError:
+            raise AttributeError(attr) from None
+
+        val = fn()
+
+        if self._update_globals and self._globals is not None:
+            self._globals[attr] = val
+
+        return val
+
+    def __call__(self, attr: str) -> ta.Any:
+        return self.get(attr)
+
+
+##
+
+
 class NamePackage(ta.NamedTuple):
     name: str
     package: str
@@ -266,16 +325,13 @@ class _ProxyInit:
 
     def __init__(
             self,
+            lazy_globals: LazyGlobals,
             name_package: NamePackage,
-            *,
-            globals: ta.MutableMapping[str, ta.Any] | None = None,  # noqa
-            update_globals: bool = False,
     ) -> None:
         super().__init__()
 
+        self._lazy_globals = lazy_globals
         self._name_package = name_package
-        self._globals = globals
-        self._update_globals = update_globals
 
         self._imps_by_attr: dict[str, _ProxyInit._Import] = {}
         self._mods_by_pkgs: dict[str, ta.Any] = {}
@@ -287,13 +343,17 @@ class _ProxyInit:
     def add(self, package: str, attrs: ta.Iterable[str | tuple[str, str]]) -> None:
         if isinstance(attrs, str):
             raise TypeError(attrs)
+
         for attr in attrs:
             if isinstance(attr, tuple):
                 imp_attr, attr = attr
             else:
                 imp_attr = attr
+
             self._imps_by_attr[attr] = self._Import(package, imp_attr)
 
+            self._lazy_globals.set_fn(attr, functools.partial(self.get, attr))
+
     def get(self, attr: str) -> ta.Any:
         try:
             imp = self._imps_by_attr[attr]
@@ -307,9 +367,6 @@ class _ProxyInit:
 
         val = getattr(mod, imp.attr)
 
-        if self._update_globals and self._globals is not None:
-            self._globals[attr] = val
-
         return val
 
 
@@ -329,13 +386,14 @@ def proxy_init(
     pi: _ProxyInit
     try:
         pi = globals['__proxy_init__']
+
     except KeyError:
         pi = _ProxyInit(
+            LazyGlobals.install(globals),
             init_name_package,
-            globals=globals,
         )
         globals['__proxy_init__'] = pi
-        globals['__getattr__'] = pi.get
+
     else:
         if pi.name_package != init_name_package:
             raise Exception(f'Wrong init name: {pi.name_package=} != {init_name_package=}')