omlish 0.0.0.dev470__py3-none-any.whl → 0.0.0.dev472__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev470'
-__revision__ = '967906fd30a40d061ede9f7aeda9dad0ec608508'
+__version__ = '0.0.0.dev472'
+__revision__ = '78c62ff9afe49d9f0ae12b27ff595b2079e9c082'
 
 
 #

omlish/inject/__init__.py

@@ -57,8 +57,12 @@ with _lang.auto_proxy_init(globals()):
         Element,
         Elements,
         Elemental,
+
         as_elements,
         iter_elements,
+
+        CollectedElements,
+        collect_elements,
     )
 
     from .errors import (  # noqa

omlish/inject/elements.py

@@ -6,6 +6,12 @@ from .. import lang
 from .impl.origins import HasOriginsImpl
 
 
+if ta.TYPE_CHECKING:
+    from .impl import elements as _elements
+else:
+    _elements = lang.proxy_import('.impl.elements', __package__)
+
+
 ##
 
 
@@ -74,3 +80,14 @@ def iter_elements(*args: Elemental) -> ta.Iterator[Element]:
             yield from a
         else:
             raise TypeError(a)
+
+
+##
+
+
+class CollectedElements(lang.PackageSealed, lang.Abstract):
+    pass
+
+
+def collect_elements(es: Elements | CollectedElements) -> CollectedElements:
+    return _elements.collect_elements(es)

omlish/inject/impl/elements.py

@@ -27,6 +27,7 @@ from ... import collections as col
 from ... import lang
 from ..bindings import Binding
 from ..eagers import Eager
+from ..elements import CollectedElements
 from ..elements import Element
 from ..elements import Elements
 from ..errors import ConflictingKeyError
@@ -47,7 +48,7 @@ from .multis import make_multi_provider_impl
 from .origins import Origins
 from .origins import set_origins
 from .providers import ProviderImpl
-from .providers2 import make_provider_impl
+from .providersmap import make_provider_impl
 from .scopes import make_scope_impl
 
 
@@ -80,7 +81,7 @@ _NON_BINDING_ELEMENT_TYPES: tuple[type[Element], ...] = (
 )
 
 
-class ElementCollection(lang.Final):
+class ElementCollection(CollectedElements, lang.Final):
     def __init__(self, es: Elements) -> None:
         super().__init__()
 
@@ -208,6 +209,10 @@ class ElementCollection(lang.Final):
 
     ##
 
+    @lang.cached_function
+    def scope_binding_scopes(self) -> ta.Sequence[Scope]:
+        return [sb.scope for sb in self.elements_of_type(ScopeBinding)]
+
     @lang.cached_function
     def eager_keys_by_scope(self) -> ta.Mapping[Scope, ta.Sequence[Key]]:
         bim = self.binding_impl_map()
@@ -216,3 +221,13 @@ class ElementCollection(lang.Final):
             bi = bim[e.key]
             ret.setdefault(bi.scope, []).append(e.key)
         return ret
+
+
+##
+
+
+def collect_elements(es: Elements | CollectedElements) -> ElementCollection:
+    if isinstance(es, CollectedElements):
+        return check.isinstance(es, ElementCollection)
+    else:
+        return ElementCollection(es)

omlish/inject/impl/injector.py

@@ -2,14 +2,12 @@
 TODO:
  - ** can currently bind in a child/private scope shadowing an external parent binding **
  - better source tracking
- - cache/export ElementCollections lol
  - scope bindings, auto in root
  - injector-internal / blacklisted bindings (Injector itself, default scopes) without rebuilding ElementCollection
  - config - proxies, impl select, etc
   - config is probably shared with ElementCollection... but not 'bound', must be shared everywhere
   - InjectorRoot object?
  - ** eagers in any scope, on scope init/open
- - injection listeners
  - unions - raise on ambiguous - usecase: sql.AsyncEngineLike
  - multiple live request scopes on single injector - use private injectors?
  - more listeners - UnboundKeyListener
@@ -24,7 +22,7 @@ import weakref
 from ... import check
 from ... import lang
 from ...logs import all as logs
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..errors import CyclicDependencyError
 from ..errors import UnboundKeyError
 from ..injector import AsyncInjector
@@ -33,7 +31,6 @@ from ..keys import Key
 from ..keys import as_key
 from ..listeners import ProvisionListener
 from ..listeners import ProvisionListenerBinding
-from ..scopes import ScopeBinding
 from ..scopes import Singleton
 from ..scopes import ThreadScope
 from ..types import Scope
@@ -61,14 +58,12 @@ DEFAULT_SCOPES: list[Scope] = [
 class AsyncInjectorImpl(AsyncInjector, lang.Final):
     def __init__(
             self,
-            ec: ElementCollection,
+            ec: CollectedElements,
             p: ta.Optional['AsyncInjectorImpl'] = None,
             *,
             internal_consts: dict[Key, ta.Any] | None = None,
     ) -> None:
-        super().__init__()
-
-        self._ec = check.isinstance(ec, ElementCollection)
+        self._ec = (ec := check.isinstance(ec, ElementCollection))
         self._p: AsyncInjectorImpl | None = check.isinstance(p, (AsyncInjectorImpl, None))
 
         self._internal_consts: dict[Key, ta.Any] = {
@@ -77,28 +72,31 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         }
 
         self._bim = ec.binding_impl_map()
+
         self._ekbs = ec.eager_keys_by_scope()
+
         self._pls: tuple[ProvisionListener, ...] = tuple(
             b.listener  # type: ignore[attr-defined]
             for b in itertools.chain(
                 ec.elements_of_type(ProvisionListenerBinding),
-                (p._pls if p is not None else ()),  # noqa
+                p._pls if p is not None else (),  # noqa
             )
         )
 
-        self._cs: weakref.WeakSet[AsyncInjectorImpl] | None = None  # noqa
         self._root: AsyncInjectorImpl = p._root if p is not None else self  # noqa
 
-        self.__cur_req: AsyncInjectorImpl._Request | None = None
-
-        ss = [
-            *DEFAULT_SCOPES,
-            *[sb.scope for sb in ec.elements_of_type(ScopeBinding)],
-        ]
         self._scopes: dict[Scope, ScopeImpl] = {
-            s: make_scope_impl(s) for s in ss
+            s: make_scope_impl(s)
+            for s in itertools.chain(
+                DEFAULT_SCOPES,
+                ec.scope_binding_scopes(),
+            )
         }
 
+    _cs: weakref.WeakSet['AsyncInjectorImpl'] | None = None  # noqa
+
+    __cur_req: ta.Optional['AsyncInjectorImpl._Request'] = None
+
     #
 
     _has_run_init: bool = False
@@ -259,7 +257,7 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         return obj(**kws)
 
 
-async def create_async_injector(es: Elements) -> AsyncInjector:
-    i = AsyncInjectorImpl(ElementCollection(es))
+async def create_async_injector(ce: CollectedElements) -> AsyncInjector:
+    i = AsyncInjectorImpl(ce)
     await i._init()  # noqa
     return i

omlish/inject/impl/maysync.py

@@ -1,13 +1,12 @@
 import typing as ta
 
 from ... import lang
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..maysync import MaysyncInjector
 from ..sync import Injector
-from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
 
 
@@ -30,10 +29,10 @@ class MaysyncInjectorImpl(MaysyncInjector, lang.Final):
         return lang.run_maysync(self._ai.inject(obj))
 
 
-def create_maysync_injector(es: Elements) -> MaysyncInjector:
+def create_maysync_injector(ce: CollectedElements) -> MaysyncInjector:
     si = MaysyncInjectorImpl()
     ai = AsyncInjectorImpl(
-        ElementCollection(es),
+        ce,
         internal_consts={
             Key(MaysyncInjector): si,
             Key(Injector): si,

omlish/inject/impl/sync.py

@@ -1,12 +1,11 @@
 import typing as ta
 
 from ... import lang
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..sync import Injector
-from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
 
 
@@ -29,10 +28,10 @@ class InjectorImpl(Injector, lang.Final):
         return lang.sync_await(self._ai.inject(obj))
 
 
-def create_injector(es: Elements) -> Injector:
+def create_injector(ce: CollectedElements) -> Injector:
     si = InjectorImpl()
     ai = AsyncInjectorImpl(
-        ElementCollection(es),
+        ce,
         internal_consts={
             Key(Injector): si,
         },

omlish/inject/injector.py

@@ -1,9 +1,12 @@
 import abc
 import typing as ta
 
+from .. import check
 from .. import lang
+from .elements import CollectedElements
 from .elements import Elemental
 from .elements import as_elements
+from .elements import collect_elements
 from .inspect import KwargsTarget
 from .keys import Key
 
@@ -44,5 +47,31 @@ class AsyncInjector(lang.Abstract):
         return self.provide(target)
 
 
-def create_async_injector(*args: Elemental) -> ta.Awaitable[AsyncInjector]:
-    return _injector.create_async_injector(as_elements(*args))
+##
+
+
+@ta.final
+class _InjectorCreator(ta.Generic[T]):
+    def __init__(self, fac: ta.Callable[[CollectedElements], T]) -> None:
+        self._fac = fac
+
+    @ta.overload
+    def __call__(self, es: CollectedElements, /) -> T: ...
+
+    @ta.overload
+    def __call__(self, *es: Elemental) -> T: ...
+
+    def __call__(self, arg0, *argv):
+        ce: CollectedElements
+        if isinstance(arg0, CollectedElements):
+            check.arg(not argv)
+            ce = arg0
+        else:
+            ce = collect_elements(as_elements(arg0, *argv))
+        return self._fac(ce)
+
+
+##
+
+
+create_async_injector = _InjectorCreator[ta.Awaitable[AsyncInjector]](lambda ce: _injector.create_async_injector(ce))

omlish/inject/maysync.py

@@ -1,8 +1,7 @@
 import typing as ta
 
 from .. import lang
-from .elements import Elemental
-from .elements import as_elements
+from .injector import _InjectorCreator
 from .sync import Injector
 
 
@@ -25,5 +24,4 @@ class MaysyncInjector(Injector, lang.Abstract):
 ##
 
 
-def create_maysync_injector(*args: Elemental) -> MaysyncInjector:
-    return _maysync.create_maysync_injector(as_elements(*args))
+create_maysync_injector = _InjectorCreator[MaysyncInjector](lambda ce: _maysync.create_maysync_injector(ce))

omlish/inject/sync.py

@@ -2,8 +2,7 @@ import abc
 import typing as ta
 
 from .. import lang
-from .elements import Elemental
-from .elements import as_elements
+from .injector import _InjectorCreator
 from .inspect import KwargsTarget
 from .keys import Key
 
@@ -44,5 +43,7 @@ class Injector(lang.Abstract):
         return self.provide(target)
 
 
-def create_injector(*args: Elemental) -> Injector:
-    return _sync.create_injector(as_elements(*args))
+##
+
+
+create_injector = _InjectorCreator[Injector](lambda ce: _sync.create_injector(ce))

omlish/lang/imports/proxy.py

@@ -342,6 +342,8 @@ def proxy_import(
         spec: str,
         package: str | None = None,
         extras: ta.Iterable[str] | None = None,
+        *,
+        no_cache: bool = False,
 ) -> types.ModuleType:
     """'Legacy' proxy import mechanism."""
 
@@ -352,12 +354,19 @@ def proxy_import(
 
     def __getattr__(att):  # noqa
         nonlocal omod
+
         if omod is None:
             omod = importlib.import_module(spec, package=package)
             if extras:
                 for x in extras:
                     importlib.import_module(f'{spec}.{x}', package=package)
-        return getattr(omod, att)
+
+        v = getattr(omod, att)
+
+        if not no_cache:
+            setattr(lmod, att, v)
+
+        return v
 
     lmod = types.ModuleType(spec)
     lmod.__getattr__ = __getattr__  # type: ignore[method-assign]

omlish/lite/abstract.py

@@ -3,6 +3,9 @@ import abc
 import typing as ta
 
 
+T = ta.TypeVar('T')
+
+
 ##
 
 
@@ -14,25 +17,49 @@ def is_abstract_method(obj: ta.Any) -> bool:
     return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
-def update_abstracts(cls, *, force=False):
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
     if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
         # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
         # implementation (especially during testing), and we want to handle both cases.
         return cls
 
-    abstracts: ta.Set[str] = set()
-
-    for scls in cls.__bases__:
-        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
-            value = getattr(cls, name, None)
-            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-                abstracts.add(name)
-
-    for name, value in cls.__dict__.items():
-        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-            abstracts.add(name)
-
-    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
     return cls
 
 
@@ -86,23 +113,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
-
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 

omlish/lite/dataclasses.py

@@ -191,3 +191,17 @@ def dataclass_kw_only_init():
         return cls
 
     return inner
+
+
+##
+
+
+@dc.dataclass()
+class DataclassFieldRequiredError(Exception):
+    name: str
+
+
+def dataclass_field_required(name: str) -> ta.Callable[[], ta.Any]:
+    def inner() -> ta.NoReturn:
+        raise DataclassFieldRequiredError(name)
+    return inner