dinkleberg 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

dinkleberg/__init__.py

@@ -1,5 +1,5 @@
-from .dependency import Dependency
+from dinkleberg_abc import Dependency, DependencyScope
+
 from .dependency_configurator import DependencyConfigurator
-from .dependency_scope import DependencyScope
 
 __all__ = ['DependencyScope', 'DependencyConfigurator', 'Dependency']

dinkleberg/dependency_configurator.py

@@ -1,15 +1,14 @@
-import abc
 import asyncio
 import inspect
 import logging
+from functools import wraps
 from inspect import Signature
 from types import MappingProxyType
 from typing import AsyncGenerator, Callable, overload, get_type_hints, Mapping, get_origin
 
-from .dependency import Dependency
-from .dependency_scope import DependencyScope
+from dinkleberg_abc import DependencyScope, Dependency
 from .descriptor import Descriptor, Lifetime
-from .typing import get_static_params, get_public_methods, is_builtin_type
+from .typing import get_static_params, get_public_methods, is_builtin_type, is_abstract
 
 logger = logging.getLogger(__name__)
 
@@ -58,13 +57,45 @@ class DependencyConfigurator(DependencyScope):
         if exceptions:
             raise ExceptionGroup('Errors occurred during closing DependencyConfigurator', exceptions)
 
-    def _add(self, lifetime: Lifetime, *, t: type = None, generator: Callable[..., AsyncGenerator] = None,
-             callable: Callable = None):
-        if generator is None and callable is None:
-            raise ValueError('Invalid dependency registration. Either generator or callable must be provided.')
+    def _add(self, lifetime: Lifetime, *, t: type = None, i: type = None,
+             generator: Callable[..., AsyncGenerator] = None, callable: Callable = None):
+        if t is None and i is None and generator is None and callable is None:
+            raise ValueError(
+                'Invalid dependency registration. At least one of t, i, generator, or callable must be provided.')
+
+        if lifetime == 'singleton' and self._parent is not None:
+            raise RuntimeError(
+                'Singleton dependencies, which are not instances, can only be registered in the root DependencyConfigurator.')
+
+        if i is not None:
+            if is_builtin_type(i):
+                raise ValueError(f'Cannot use built-in type {i} as implementation.')
+
+            if get_origin(i) is not None:
+                raise ValueError(f'Cannot use generic type {i} as implementation.')
+
+            if is_abstract(i):
+                raise ValueError(f'Cannot use abstract class {i} as implementation.')
+
         if t is None:
-            t = self._infer_type(generator=generator, callable=callable)
-        self._descriptors[t] = Descriptor(generator=generator, callable=callable, lifetime=lifetime)
+            if i is not None:
+                t = i
+            else:
+                t = self._infer_type(generator=generator, callable=callable)
+        elif generator is None and callable is None:
+            if is_builtin_type(t):
+                raise ValueError(
+                    f'Cannot register built-in type {t} without explicit implementation, generator or callable.')
+
+            if get_origin(t) is not None:
+                raise ValueError(
+                    f'Cannot register generic type {t} without explicit implementation, generator or callable.')
+
+            if is_abstract(t):
+                raise ValueError(
+                    f'Cannot register abstract class {t} without explicit implementation, generator or callable.')
+
+        self._descriptors[t] = Descriptor(implementation=i, generator=generator, callable=callable, lifetime=lifetime)
 
     @staticmethod
     def _infer_type(*, generator: Callable[..., AsyncGenerator], callable: Callable) -> type:
@@ -105,9 +136,15 @@ class DependencyConfigurator(DependencyScope):
 
     # TODO circular dependency detection
     # TODO singleton race condition prevention (async.Lock)
-    async def resolve[T](self, t: type[T], **kwargs) -> T:
+    async def resolve[T](self, t: type[T] | Callable, **kwargs) -> T:
         self._raise_if_closed()
 
+        if not inspect.isclass(t):
+            if not inspect.isfunction(t):
+                raise ValueError(f'Cannot resolve type {t}. Only classes and functions are supported.')
+
+            return self._wrap_func(t)
+
         if t == DependencyScope:
             return self
 
@@ -117,8 +154,26 @@ class DependencyConfigurator(DependencyScope):
         if t in self._scoped_instances:
             return self._scoped_instances[t]
 
-        if t in self._descriptors:
-            descriptor = self._descriptors[t]
+        descriptor = self._descriptors.get(t)
+        if descriptor is None or descriptor['generator'] is None and descriptor['callable'] is None:
+            if descriptor is None:
+                if is_builtin_type(t):
+                    raise ValueError(f'Cannot resolve built-in type {t} without explicit registration.')
+
+                if get_origin(t) is not None:
+                    raise ValueError(f'Cannot resolve generic type {t} without explicit registration.')
+
+                if is_abstract(t):
+                    raise ValueError(f'Cannot resolve abstract class {t} without explicit registration.')
+
+                factory = t
+            else:
+                factory = descriptor['implementation'] or t
+
+            is_generator = False
+            lifetime = descriptor['lifetime'] if descriptor else 'transient'
+            deps = await self._resolve_deps(factory.__init__)
+        else:
             lifetime = descriptor['lifetime']
             if lifetime == 'singleton' and self._parent:
                 # we need to resolve singleton from the root scope
@@ -127,20 +182,6 @@ class DependencyConfigurator(DependencyScope):
             is_generator = descriptor['generator'] is not None
             factory = descriptor['generator'] or descriptor['callable']
             deps = await self._resolve_deps(factory)
-        else:
-            if is_builtin_type(t):
-                raise ValueError(f'Cannot resolve built-in type {t} without explicit registration.')
-
-            if get_origin(t) is not None:
-                raise ValueError(f'Cannot resolve generic type {t} without explicit registration.')
-
-            if inspect.isabstract(t) or t is abc.ABC:
-                raise ValueError(f'Cannot resolve abstract class {t} without explicit registration.')
-
-            is_generator = False
-            lifetime = 'transient'
-            factory = t
-            deps = await self._resolve_deps(t.__init__)
 
         if is_generator:
             generator = factory(**deps, **kwargs)
@@ -215,6 +256,28 @@ class DependencyConfigurator(DependencyScope):
 
         return actual_kwargs
 
+    def _wrap_func(self, func: Callable):
+        signature = inspect.signature(func)
+
+        dep_params = MappingProxyType({
+            param_name: param
+            for param_name, param in signature.parameters.items()
+            if isinstance(param.default, Dependency)
+        })
+
+        if not dep_params:
+            return func
+
+        if not asyncio.iscoroutinefunction(func):
+            raise NotImplementedError('Synchronous functions with Dependency() defaults are not supported.')
+
+        @wraps(func)
+        async def wrapped_func(*args, **kwargs):
+            new_kwargs = await self._resolve_kwargs(signature, func.__name__, args, kwargs, dep_params)
+            return await func(*args, **new_kwargs)
+
+        return wrapped_func
+
     # TODO handle __slots__
     def _wrap_instance(self, instance):
         if getattr(instance, '__dinkleberg__', False):
@@ -222,25 +285,11 @@ class DependencyConfigurator(DependencyScope):
 
         methods = get_public_methods(instance)
         for name, value in methods:
-            signature = inspect.signature(value)
-
-            dep_params = MappingProxyType({
-                param_name: param
-                for param_name, param in signature.parameters.items()
-                if isinstance(param.default, Dependency)
-            })
-            if not dep_params:
-                continue
-
             instance_method = getattr(instance, name)
-            if asyncio.iscoroutinefunction(instance_method):
-                async def wrapped_method(*args, __m=instance_method, __s=signature, __n=name, __d=dep_params, **kwargs):
-                    new_kwargs = await self._resolve_kwargs(__s, __n, args, kwargs, __d)
-                    return await __m(*args, **new_kwargs)
 
-                setattr(instance, name, wrapped_method)
-            else:
-                raise NotImplementedError('Synchronous methods with Dependency() defaults are not supported.')
+            wrapped_method = self._wrap_func(instance_method)
+
+            setattr(instance, name, wrapped_method)
 
         try:
             setattr(instance, '__dinkleberg__', True)
@@ -256,6 +305,18 @@ class DependencyConfigurator(DependencyScope):
     def add_singleton[T, I](self, *, t: type[T], instance: I):
         ...
 
+    @overload
+    def add_singleton[T](self, *, t: type[T]):
+        ...
+
+    @overload
+    def add_singleton[I](self, *, i: type[I]):
+        ...
+
+    @overload
+    def add_singleton[T, I](self, *, t: type[T], i: type[I]):
+        ...
+
     @overload
     def add_singleton[I](self, *, callable: Callable[..., I]):
         ...
@@ -272,11 +333,13 @@ class DependencyConfigurator(DependencyScope):
     def add_singleton[T, I](self, *, t: type[T], generator: Callable[..., AsyncGenerator[I]]):
         ...
 
-    def add_singleton[T, I](self, *, t: type[T] = None, generator: Callable[..., AsyncGenerator[I]] = None,
+    def add_singleton[T, I](self, *, t: type[T] = None, i: type[I] = None,
+                            generator: Callable[..., AsyncGenerator[I]] = None,
                             callable: Callable[..., I] = None, instance: I = None):
         self._raise_if_closed()
+
         if instance is None:
-            self._add('singleton', t=t, generator=generator, callable=callable)
+            self._add('singleton', t=t, i=i, generator=generator, callable=callable)
             return
         elif t is None:
             t = type(instance)
@@ -285,6 +348,18 @@ class DependencyConfigurator(DependencyScope):
 
         self._singleton_instances[t] = instance
 
+    @overload
+    def add_scoped[T](self, *, t: type[T]):
+        ...
+
+    @overload
+    def add_scoped[I](self, *, i: type[I]):
+        ...
+
+    @overload
+    def add_scoped[T, I](self, *, t: type[T], i: type[I]):
+        ...
+
     @overload
     def add_scoped[I](self, *, callable: Callable[..., I]):
         ...
@@ -301,10 +376,22 @@ class DependencyConfigurator(DependencyScope):
     def add_scoped[T, I](self, *, t: type[T], generator: Callable[..., AsyncGenerator[I]]):
         ...
 
-    def add_scoped[T, I](self, *, t: type[T] = None, generator: Callable[..., AsyncGenerator[I]] = None,
-                         callable: Callable[..., I] = None):
+    def add_scoped[T, I](self, *, t: type[T] = None, i: type[I] = None,
+                         generator: Callable[..., AsyncGenerator[I]] = None, callable: Callable[..., I] = None):
         self._raise_if_closed()
-        self._add('scoped', t=t, generator=generator, callable=callable)
+        self._add('scoped', t=t, i=i, generator=generator, callable=callable)
+
+    @overload
+    def add_transient[T](self, *, t: type[T]):
+        ...
+
+    @overload
+    def add_transient[I](self, *, i: type[I]):
+        ...
+
+    @overload
+    def add_transient[T, I](self, *, t: type[T], i: type[I]):
+        ...
 
     @overload
     def add_transient[I](self, *, callable: Callable[..., I]):
@@ -314,6 +401,6 @@ class DependencyConfigurator(DependencyScope):
     def add_transient[T, I](self, *, t: type[T], callable: Callable[..., I]):
         ...
 
-    def add_transient[T, I](self, *, t: type[T] = None, callable: Callable[..., I] = None):
+    def add_transient[T, I](self, *, t: type[T] = None, i: type[I] = None, callable: Callable[..., I] = None):
         self._raise_if_closed()
-        self._add('transient', t=t, callable=callable)
+        self._add('transient', i=i, t=t, callable=callable)

dinkleberg/descriptor.py

@@ -4,6 +4,7 @@ Lifetime = Union[Literal['singleton'], Literal['scoped'], Literal['transient']]
 
 
 class Descriptor(TypedDict):
+    implementation: Optional[type]
     generator: Optional[Callable[..., AsyncGenerator]]
     callable: Optional[Callable]
     lifetime: Lifetime

dinkleberg/fastapi/__init__.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from _dinkleberg_fastapi import di
+
+try:
+    from _dinkleberg_fastapi import di
+
+    __all__ = ['di']
+except ImportError:
+    raise ImportError(
+        "dinkleberg-fastapi is not installed. Please install it with 'pip install dinkleberg[fastapi]' to use FastAPI integration."
+    )

dinkleberg/typing.py

@@ -1,8 +1,13 @@
+import abc
 import inspect
 from inspect import Parameter, signature
 from typing import Callable, get_origin
 
 
+def is_abstract(t: type) -> bool:
+    return inspect.isabstract(t) or t is abc.ABC
+
+
 def is_builtin_type(t: type) -> bool:
     origin = get_origin(t) or t
     return getattr(origin, '__module__', None) in ('builtins', 'typing', 'types')

{dinkleberg-0.2.1.dist-info → dinkleberg-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dinkleberg
-Version: 0.2.1
+Version: 0.3.1
 Summary: Your friendly neighbour when it comes to dependency management.
 Project-URL: Homepage, https://github.com/DavidVollmers/dinkleberg
 Project-URL: Documentation, https://github.com/DavidVollmers/dinkleberg/blob/main/libs/dinkleberg/README.md
@@ -17,6 +17,9 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
+Requires-Dist: dinkleberg-abc>=0.3.0
+Provides-Extra: fastapi
+Requires-Dist: dinkleberg-fastapi>=0.3.0; extra == "fastapi"
 
 # dinkleberg
 

dinkleberg-0.3.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+dinkleberg/__init__.py,sha256=6gowHoL3xTWd2iyU09upgjXKUv_WWp6Tw1iqw2uz7Vc,192
+dinkleberg/dependency_configurator.py,sha256=gSuizzr28qwO9Q5Z1IYytxaIRB5dAAKiPKe3GozKUuk,14660
+dinkleberg/descriptor.py,sha256=ZtVwJihvCLugakHx201iX7Jm4A50Z0SzPu9zeHfD320,349
+dinkleberg/typing.py,sha256=qAdSQomntQfI4bSWc9X32DXGftuyj56WP7nG3Pia7ZE,942
+dinkleberg/fastapi/__init__.py,sha256=boj1ywpWhuuOjHLwdUha2EPBG2f1zbc374N35k1CJxk,352
+dinkleberg-0.3.1.dist-info/METADATA,sha256=zK12ZPnFptOjz9QiF8i13yqHnG2UtWz1qSMzUkzE8rQ,1555
+dinkleberg-0.3.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+dinkleberg-0.3.1.dist-info/top_level.txt,sha256=6TjbaJ_eyRzoxzz2r1Eu0hgYfxBBM2bOV3u_TJ8yjjw,11
+dinkleberg-0.3.1.dist-info/RECORD,,

dinkleberg/dependency.py

@@ -1,2 +0,0 @@
-class Dependency:
-    pass

dinkleberg/dependency_scope.py

@@ -1,15 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class DependencyScope(ABC):
-    @abstractmethod
-    async def resolve[T](self, t: type[T], **kwargs) -> T:
-        pass
-
-    @abstractmethod
-    async def close(self) -> None:
-        pass
-
-    @abstractmethod
-    def scope(self) -> 'DependencyScope':
-        pass

dinkleberg-0.2.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-dinkleberg/__init__.py,sha256=HGu8mjYt-Fa0y9_aMtJZFYo3s9Yb0q5dmbMKtHrAV_k,217
-dinkleberg/dependency.py,sha256=YcGvuvhoBRxShgSRaznKyZg49GCgOWy_L8HD0sXAMYo,29
-dinkleberg/dependency_configurator.py,sha256=N0mF78B9HnCKPwhDo4DTt8aDGbLwKEPFqEfo5ZtrrxA,11877
-dinkleberg/dependency_scope.py,sha256=sufXjQ6F62ZfohItUnrV7Fvh8gSSc7a6orO6PXu19Vw,318
-dinkleberg/descriptor.py,sha256=mVI00K1M2m4Rl5ANatGMeB_HpzeFONoULwg0UmNxfQ0,313
-dinkleberg/typing.py,sha256=_T2plzKBU_GTMNazpU8bqKuqTvQotJPuWEHQH2dF76g,841
-dinkleberg-0.2.1.dist-info/METADATA,sha256=Mv6RezK3xmMBpnRY0DKkwXSxPnm6mTezMRcMWFMiNs8,1430
-dinkleberg-0.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-dinkleberg-0.2.1.dist-info/top_level.txt,sha256=6TjbaJ_eyRzoxzz2r1Eu0hgYfxBBM2bOV3u_TJ8yjjw,11
-dinkleberg-0.2.1.dist-info/RECORD,,