omlish 0.0.0.dev124__tar.gz → 0.0.0.dev125__tar.gz

{omlish-0.0.0.dev124/omlish.egg-info → omlish-0.0.0.dev125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev124
+Version: 0.0.0.dev125
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev124 → omlish-0.0.0.dev125}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev124'
-__revision__ = '25f7c36b35a9ecdd1e39499b47d408e602d102bb'
+__version__ = '0.0.0.dev125'
+__revision__ = 'ab4e58c3eaba25f0520ed6cb0df32e2322ca439a'
 
 
 #

{omlish-0.0.0.dev124 → omlish-0.0.0.dev125}/omlish/inject/impl/inspect.py

@@ -31,13 +31,15 @@ _SIGNATURE_CACHE: ta.MutableMapping[ta.Any, inspect.Signature] = weakref.WeakKey
 
 
 def signature(obj: ta.Any) -> inspect.Signature:
+    def get() -> inspect.Signature:
+        return inspect.signature(obj, eval_str=True)
     try:
         return _SIGNATURE_CACHE[obj]
     except TypeError:
-        return inspect.signature(obj)
+        return get()
     except KeyError:
         pass
-    sig = inspect.signature(obj)
+    sig = get()
     _SIGNATURE_CACHE[obj] = sig
     return sig
 

{omlish-0.0.0.dev124 → omlish-0.0.0.dev125}/omlish/lang/__init__.py

@@ -1,3 +1,5 @@
+# This module should import nothing but stdlib modules, and as few as possible. That *includes* lite - no using lite.
+
 from .cached import (  # noqa
     cached_function,
     cached_property,
@@ -217,6 +219,7 @@ from .timeouts import (  # noqa
 )
 
 from .typing import (  # noqa
+    AnyFunc,
     BytesLike,
     Func0,
     Func1,

{omlish-0.0.0.dev124 → omlish-0.0.0.dev125}/omlish/lang/typing.py

@@ -106,6 +106,14 @@ def typed_partial(obj, **kw):  # noqa
 # A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
 
 
+@dc.dataclass(frozen=True)
+class AnyFunc(ta.Generic[T]):
+    fn: ta.Callable[..., T]
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self.fn(*args, **kwargs)
+
+
 @dc.dataclass(frozen=True)
 class Func0(ta.Generic[T]):
     fn: ta.Callable[[], T]

{omlish-0.0.0.dev124 → omlish-0.0.0.dev125}/omlish/lite/inject.py

@@ -9,10 +9,12 @@ import weakref
 
 from .check import check_isinstance
 from .check import check_not_isinstance
+from .check import check_not_none
 from .maybes import Maybe
 from .reflect import get_optional_alias_arg
 from .reflect import is_new_type
 from .reflect import is_optional_alias
+from .typing import Func
 
 
 T = ta.TypeVar('T')
@@ -31,7 +33,13 @@ InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 
 @dc.dataclass(frozen=True)
 class InjectorKey(ta.Generic[T]):
-    cls: InjectorKeyCls
+    # Before PEP-560 typing.Generic was a metaclass with a __new__ that takes a 'cls' arg, so instantiating a dataclass
+    # with kwargs (such as through dc.replace) causes `TypeError: __new__() got multiple values for argument 'cls'`.
+    # See:
+    #  - https://github.com/python/cpython/commit/d911e40e788fb679723d78b6ea11cabf46caed5a
+    #  - https://gist.github.com/wrmsr/4468b86efe9f373b6b114bfe85b98fd3
+    cls_: InjectorKeyCls
+
     tag: ta.Any = None
     array: bool = False
 
@@ -152,14 +160,14 @@ class FnInjectorProvider(InjectorProvider):
 
 @dc.dataclass(frozen=True)
 class CtorInjectorProvider(InjectorProvider):
-    cls: type
+    cls_: type
 
     def __post_init__(self) -> None:
-        check_isinstance(self.cls, type)
+        check_isinstance(self.cls_, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
-            return i.inject(self.cls)
+            return i.inject(self.cls_)
 
         return pfn
 
@@ -308,19 +316,42 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 # inspection
 
 
-_INJECTION_SIGNATURE_CACHE: ta.MutableMapping[ta.Any, inspect.Signature] = weakref.WeakKeyDictionary()
+# inspect.signature(eval_str=True) was added in 3.10 and we have to support 3.8, so we have to get_type_hints to eval
+# str annotations *in addition to* getting the signature for parameter information.
+class _InjectionInspection(ta.NamedTuple):
+    signature: inspect.Signature
+    type_hints: ta.Mapping[str, ta.Any]
+
+
+_INJECTION_INSPECTION_CACHE: ta.MutableMapping[ta.Any, _InjectionInspection] = weakref.WeakKeyDictionary()
 
 
-def _injection_signature(obj: ta.Any) -> inspect.Signature:
+def _do_injection_inspect(obj: ta.Any) -> _InjectionInspection:
+    uw = obj
+    while True:
+        if isinstance(uw, functools.partial):
+            uw = uw.func
+        else:
+            if (uw2 := inspect.unwrap(uw)) is uw:
+                break
+            uw = uw2
+
+    return _InjectionInspection(
+        inspect.signature(obj),
+        ta.get_type_hints(uw),
+    )
+
+
+def _injection_inspect(obj: ta.Any) -> _InjectionInspection:
     try:
-        return _INJECTION_SIGNATURE_CACHE[obj]
+        return _INJECTION_INSPECTION_CACHE[obj]
     except TypeError:
-        return inspect.signature(obj)
+        return _do_injection_inspect(obj)
     except KeyError:
         pass
-    sig = inspect.signature(obj)
-    _INJECTION_SIGNATURE_CACHE[obj] = sig
-    return sig
+    insp = _do_injection_inspect(obj)
+    _INJECTION_INSPECTION_CACHE[obj] = insp
+    return insp
 
 
 class InjectionKwarg(ta.NamedTuple):
@@ -341,20 +372,20 @@ def build_injection_kwargs_target(
         skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
         raw_optional: bool = False,
 ) -> InjectionKwargsTarget:
-    sig = _injection_signature(obj)
+    insp = _injection_inspect(obj)
 
     seen: ta.Set[InjectorKey] = set(map(as_injector_key, skip_kwargs)) if skip_kwargs is not None else set()
     kws: ta.List[InjectionKwarg] = []
-    for p in list(sig.parameters.values())[skip_args:]:
+    for p in list(insp.signature.parameters.values())[skip_args:]:
         if p.annotation is inspect.Signature.empty:
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
             continue
 
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
-            raise TypeError(sig)
+            raise TypeError(insp)
 
-        ann = p.annotation
+        ann = insp.type_hints.get(p.name, p.annotation)
         if (
                 not raw_optional and
                 is_optional_alias(ann)
@@ -379,6 +410,66 @@ def build_injection_kwargs_target(
     )
 
 
+###
+# injector
+
+
+_INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
+
+
+class _Injector(Injector):
+    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
+        super().__init__()
+
+        self._bs = check_isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
+
+        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
+
+        if _INJECTOR_INJECTOR_KEY in self._pfm:
+            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
+
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        key = as_injector_key(key)
+
+        if key == _INJECTOR_INJECTOR_KEY:
+            return Maybe.just(self)
+
+        fn = self._pfm.get(key)
+        if fn is not None:
+            return Maybe.just(fn(self))
+
+        if self._p is not None:
+            pv = self._p.try_provide(key)
+            if pv is not None:
+                return Maybe.empty()
+
+        return Maybe.empty()
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        v = self.try_provide(key)
+        if v.present:
+            return v.must()
+        raise UnboundInjectorKeyError(key)
+
+    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+        kt = build_injection_kwargs_target(obj)
+        ret: ta.Dict[str, ta.Any] = {}
+        for kw in kt.kwargs:
+            if kw.has_default:
+                if not (mv := self.try_provide(kw.key)).present:
+                    continue
+                v = mv.must()
+            else:
+                v = self.provide(kw.key)
+            ret[kw.name] = v
+        return ret
+
+    def inject(self, obj: ta.Any) -> ta.Any:
+        kws = self.provide_kwargs(obj)
+        return obj(**kws)
+
+
 ###
 # binder
 
@@ -428,7 +519,7 @@ class InjectorBinder:
             to_key: ta.Any = None,
 
             singleton: bool = False,
-    ) -> InjectorBinding:
+    ) -> InjectorBindingOrBindings:
         if obj is None or obj is inspect.Parameter.empty:
             raise TypeError(obj)
         if isinstance(obj, cls._BANNED_BIND_TYPES):
@@ -458,8 +549,8 @@ class InjectorBinder:
         elif cls._is_fn(obj) and not has_to:
             to_fn = obj
             if key is None:
-                sig = _injection_signature(obj)
-                key_cls = check_valid_injector_key_cls(sig.return_annotation)
+                insp = _injection_inspect(obj)
+                key_cls: ta.Any = check_valid_injector_key_cls(check_not_none(insp.type_hints.get('return')))
                 key = InjectorKey(key_cls)
         else:
             if to_const is not None:
@@ -511,67 +602,21 @@ class InjectorBinder:
 
 
 ###
-# injector
-
-
-_INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
-
-
-class _Injector(Injector):
-    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
-        super().__init__()
-
-        self._bs = check_isinstance(bs, InjectorBindings)
-        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
-
-        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
-
-        if _INJECTOR_INJECTOR_KEY in self._pfm:
-            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
-
-    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
-        key = as_injector_key(key)
-
-        if key == _INJECTOR_INJECTOR_KEY:
-            return Maybe.just(self)
-
-        fn = self._pfm.get(key)
-        if fn is not None:
-            return Maybe.just(fn(self))
-
-        if self._p is not None:
-            pv = self._p.try_provide(key)
-            if pv is not None:
-                return Maybe.empty()
-
-        return Maybe.empty()
-
-    def provide(self, key: ta.Any) -> ta.Any:
-        v = self.try_provide(key)
-        if v.present:
-            return v.must()
-        raise UnboundInjectorKeyError(key)
+# injection helpers
 
-    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
-        kt = build_injection_kwargs_target(obj)
-        ret: ta.Dict[str, ta.Any] = {}
-        for kw in kt.kwargs:
-            if kw.has_default:
-                if not (mv := self.try_provide(kw.key)).present:
-                    continue
-                v = mv.must()
-            else:
-                v = self.provide(kw.key)
-            ret[kw.name] = v
-        return ret
 
-    def inject(self, obj: ta.Any) -> ta.Any:
-        kws = self.provide_kwargs(obj)
-        return obj(**kws)
+def make_injector_factory(
+        factory_cls: ta.Any,
+        factory_fn: ta.Callable[..., T],
+) -> ta.Callable[..., Func[T]]:
+    def outer(injector: Injector) -> factory_cls:
+        def inner(*args, **kwargs):
+            return injector.inject(functools.partial(factory_fn, *args, **kwargs))
+        return Func(inner)
+    return outer
 
 
-###
-# injection helpers
+##
 
 
 class Injection:
@@ -602,6 +647,12 @@ class Injection:
     def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
+    # injector
+
+    @classmethod
+    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), p)
+
     # binder
 
     @classmethod
@@ -619,7 +670,7 @@ class Injection:
             to_key: ta.Any = None,
 
             singleton: bool = False,
-    ) -> InjectorBinding:
+    ) -> InjectorBindingOrBindings:
         return InjectorBinder.bind(
             obj,
 
@@ -635,11 +686,15 @@ class Injection:
             singleton=singleton,
         )
 
-    # injector
+    # helpers
 
     @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
-        return _Injector(as_injector_bindings(*args), p)
+    def bind_factory(
+            cls,
+            factory_cls: ta.Any,
+            factory_fn: ta.Callable[..., T],
+    ) -> InjectorBindingOrBindings:
+        return cls.bind(make_injector_factory(factory_cls, factory_fn))
 
 
 inj = Injection

omlish-0.0.0.dev125/omlish/lite/typing.py

@@ -0,0 +1,13 @@
+import dataclasses as dc
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True)
+class Func(ta.Generic[T]):
+    fn: ta.Callable[..., T]
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self.fn(*args, **kwargs)

{omlish-0.0.0.dev124 → omlish-0.0.0.dev125/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev124
+Version: 0.0.0.dev125
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev124 → omlish-0.0.0.dev125}/omlish.egg-info/SOURCES.txt

@@ -328,6 +328,7 @@ omlish/lite/socket.py
 omlish/lite/socketserver.py
 omlish/lite/strings.py
 omlish/lite/subprocesses.py
+omlish/lite/typing.py
 omlish/lite/http/__init__.py
 omlish/lite/http/coroserver.py
 omlish/lite/http/handlers.py

{omlish-0.0.0.dev124 → omlish-0.0.0.dev125}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev124'
+version = '0.0.0.dev125'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',