python-injection 0.19.0__tar.gz → 0.19.2__tar.gz

{python_injection-0.19.0 → python_injection-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.19.0
+Version: 0.19.2
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd

{python_injection-0.19.0 → python_injection-0.19.2}/injection/__init__.pyi

@@ -5,6 +5,7 @@ from enum import Enum
 from logging import Logger
 from typing import Any, Final, Protocol, Self, final, overload, runtime_checkable
 
+from ._core.asfunction import AsFunctionWrappedType as _AsFunctionWrappedType
 from ._core.common.invertible import Invertible as _Invertible
 from ._core.common.type import InputType as _InputType
 from ._core.common.type import TypeInfo as _TypeInfo
@@ -32,7 +33,7 @@ singleton = __MODULE.singleton
 
 @overload
 def asfunction[**P, T](
-    wrapped: type[Callable[P, T]],
+    wrapped: _AsFunctionWrappedType[P, T],
     /,
     *,
     module: Module = ...,
@@ -45,7 +46,7 @@ def asfunction[**P, T](
     *,
     module: Module = ...,
     threadsafe: bool | None = ...,
-) -> Callable[[type[Callable[P, T]]], Callable[P, T]]: ...
+) -> Callable[[_AsFunctionWrappedType[P, T]], Callable[P, T]]: ...
 @asynccontextmanager
 def adefine_scope(
     name: str,

python_injection-0.19.2/injection/_core/asfunction.py

@@ -0,0 +1,59 @@
+from abc import abstractmethod
+from collections.abc import Callable
+from functools import wraps
+from inspect import iscoroutinefunction
+from types import MethodType
+from typing import Any, Protocol, runtime_checkable
+
+from injection._core.common.asynchronous import Caller
+from injection._core.module import Module, mod
+
+type AsFunctionWrappedType[**P, T] = type[AsFunctionCallable[P, T]]
+
+
+@runtime_checkable
+class AsFunctionCallable[**P, T](Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    def call(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        raise NotImplementedError
+
+
+def asfunction[**P, T](
+    wrapped: AsFunctionWrappedType[P, T] | None = None,
+    /,
+    *,
+    module: Module | None = None,
+    threadsafe: bool | None = None,
+) -> Any:
+    module = module or mod()
+
+    def decorator(wp: AsFunctionWrappedType[P, T]) -> Callable[P, T]:
+        fake_method = MethodType(wp.call, NotImplemented)
+        factory: Caller[..., AsFunctionCallable[P, T]] = module.make_injected_function(
+            wp,
+            threadsafe=threadsafe,
+        ).__inject_metadata__
+
+        wrapper: Callable[P, T]
+
+        if iscoroutinefunction(fake_method):
+
+            @wraps(fake_method)
+            async def wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
+                self = await factory.acall()
+                return await self.call(*args, **kwargs)  # type: ignore[misc]
+
+        else:
+
+            @wraps(fake_method)
+            def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+                self = factory.call()
+                return self.call(*args, **kwargs)
+
+        wrapper.__name__ = wp.__name__
+        wrapper.__qualname__ = wp.__qualname__
+        return wrapper
+
+    return decorator(wrapped) if wrapped else decorator

{python_injection-0.19.0 → python_injection-0.19.2}/pyproject.toml

@@ -30,7 +30,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.19.0"
+version = "0.19.2"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 license-files = ["LICENSE"]

python_injection-0.19.0/injection/_core/asfunction.py

@@ -1,47 +0,0 @@
-from collections.abc import Callable
-from functools import wraps
-from inspect import iscoroutinefunction
-from typing import Any
-
-from injection._core.common.asynchronous import Caller
-from injection._core.module import Module, mod
-
-
-def asfunction[**P, T](
-    wrapped: type[Callable[P, T]] | None = None,
-    /,
-    *,
-    module: Module | None = None,
-    threadsafe: bool | None = None,
-) -> Any:
-    module = module or mod()
-
-    def decorator(wp: type[Callable[P, T]]) -> Callable[P, T]:
-        get_method = wp.__call__.__get__
-        method = get_method(NotImplemented)
-        factory: Caller[..., Callable[P, T]] = module.make_injected_function(
-            wp,
-            threadsafe=threadsafe,
-        ).__inject_metadata__
-
-        wrapper: Callable[P, T]
-
-        if iscoroutinefunction(method):
-
-            @wraps(method)
-            async def wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
-                self = await factory.acall()
-                return await get_method(self)(*args, **kwargs)
-
-        else:
-
-            @wraps(method)
-            def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-                self = factory.call()
-                return get_method(self)(*args, **kwargs)
-
-        wrapper.__name__ = wp.__name__
-        wrapper.__qualname__ = wp.__qualname__
-        return wrapper
-
-    return decorator(wrapped) if wrapped else decorator