dinkleberg 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

dinkleberg/dependency_configurator.py

@@ -1,6 +1,7 @@
 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
@@ -20,10 +21,17 @@ class DependencyConfigurator(DependencyScope):
         self._descriptors: dict[type, Descriptor] = {}
         self._singleton_instances = {}
         self._scoped_instances = {}
+        self._configurators: dict[type, list[Callable[[object], object | None]]] = {}
         self._active_generators = []
         self._scopes = []
         self._closed = False
 
+    def configure[T](self, t: type[T], configurator: Callable[[T], T | None]) -> None:
+        self._raise_if_closed()
+        if t not in self._configurators:
+            self._configurators[t] = []
+        self._configurators[t].append(configurator)
+
     async def close(self) -> None:
         if self._closed:
             return
@@ -50,6 +58,7 @@ class DependencyConfigurator(DependencyScope):
         self._singleton_instances.clear()
         self._active_generators.clear()
         self._scoped_instances.clear()
+        self._configurators.clear()
         self._descriptors.clear()
         self._scopes.clear()
 
@@ -57,7 +66,7 @@ class DependencyConfigurator(DependencyScope):
             raise ExceptionGroup('Errors occurred during closing DependencyConfigurator', exceptions)
 
     def _add(self, lifetime: Lifetime, *, t: type = None, i: type = None,
-             generator: Callable[..., AsyncGenerator] = None, callable: Callable = None):
+             generator: Callable[..., AsyncGenerator] = None, callable: Callable = None, override: bool = False):
         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.')
@@ -81,7 +90,7 @@ class DependencyConfigurator(DependencyScope):
                 t = i
             else:
                 t = self._infer_type(generator=generator, callable=callable)
-        elif generator is None and callable is None:
+        elif generator is None and callable is None and i is None:
             if is_builtin_type(t):
                 raise ValueError(
                     f'Cannot register built-in type {t} without explicit implementation, generator or callable.')
@@ -94,6 +103,9 @@ class DependencyConfigurator(DependencyScope):
                 raise ValueError(
                     f'Cannot register abstract class {t} without explicit implementation, generator or callable.')
 
+        if t in self._descriptors and not override:
+            raise ValueError(f'Type {t} is already registered.')
+
         self._descriptors[t] = Descriptor(implementation=i, generator=generator, callable=callable, lifetime=lifetime)
 
     @staticmethod
@@ -117,12 +129,13 @@ class DependencyConfigurator(DependencyScope):
 
     def _raise_if_closed(self):
         if self._closed:
-            raise RuntimeError('DependencyConfigurator is already closed.')
+            raise RuntimeError('DependencyScope is already closed.')
 
     def scope(self) -> 'DependencyConfigurator':
         self._raise_if_closed()
         scope = DependencyConfigurator(self)
         scope._descriptors = self._descriptors.copy()
+        scope._configurators = self._configurators.copy()
         self._scopes.append(scope)
         return scope
 
@@ -135,9 +148,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
 
@@ -199,7 +218,7 @@ class DependencyConfigurator(DependencyScope):
             finally:
                 await instance.aclose()
 
-        self._wrap_instance(instance)
+        self._wrap_instance(t, instance)
 
         if lifetime == 'singleton':
             self._singleton_instances[t] = instance
@@ -249,32 +268,46 @@ 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):
+    def _wrap_instance(self, t: type, instance: object):
+        if getattr(instance, '__dinkleberg__', False) or is_builtin_type(t):
             return
 
+        configurators = self._configurators.get(t, [])
+        for configurator in configurators:
+            result = configurator(instance)
+            if result is not None:
+                instance = result
+
         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)
@@ -283,109 +316,117 @@ class DependencyConfigurator(DependencyScope):
             pass
 
     @overload
-    def add_singleton[I](self, *, instance: I):
+    def add_singleton[I](self, *, instance: I, override: bool = False):
         ...
 
     @overload
-    def add_singleton[T, I](self, *, t: type[T], instance: I):
+    def add_singleton[T, I](self, *, t: type[T], instance: I, override: bool = False):
         ...
 
     @overload
-    def add_singleton[T](self, *, t: type[T]):
+    def add_singleton[T](self, *, t: type[T], override: bool = False):
         ...
 
     @overload
-    def add_singleton[I](self, *, i: type[I]):
+    def add_singleton[I](self, *, i: type[I], override: bool = False):
         ...
 
     @overload
-    def add_singleton[T, I](self, *, t: type[T], i: type[I]):
+    def add_singleton[T, I](self, *, t: type[T], i: type[I], override: bool = False):
         ...
 
     @overload
-    def add_singleton[I](self, *, callable: Callable[..., I]):
+    def add_singleton[I](self, *, callable: Callable[..., I], override: bool = False):
         ...
 
     @overload
-    def add_singleton[T, I](self, *, t: type[T], callable: Callable[..., I]):
+    def add_singleton[T, I](self, *, t: type[T], callable: Callable[..., I], override: bool = False):
         ...
 
     @overload
-    def add_singleton[I](self, *, generator: Callable[..., AsyncGenerator[I]]):
+    def add_singleton[I](self, *, generator: Callable[..., AsyncGenerator[I]], override: bool = False):
         ...
 
     @overload
-    def add_singleton[T, I](self, *, t: type[T], generator: Callable[..., AsyncGenerator[I]]):
+    def add_singleton[T, I](self, *, t: type[T], generator: Callable[..., AsyncGenerator[I]], override: bool = False):
         ...
 
     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):
+                            callable: Callable[..., I] = None, instance: I = None, override: bool = False):
         self._raise_if_closed()
 
         if instance is None:
-            self._add('singleton', t=t, i=i, generator=generator, callable=callable)
+            self._add('singleton', t=t, i=i, generator=generator, callable=callable, override=override)
             return
         elif t is None:
             t = type(instance)
 
-        self._wrap_instance(instance)
+        if t in self._descriptors:
+            raise ValueError(f'Type {t} is already registered with a descriptor. Cannot register singleton instance.')
+
+        if t in self._singleton_instances and not override:
+            raise ValueError(f'Type {t} already has a singleton instance registered.')
+
+        self._wrap_instance(t, instance)
 
         self._singleton_instances[t] = instance
 
     @overload
-    def add_scoped[T](self, *, t: type[T]):
+    def add_scoped[T](self, *, t: type[T], override: bool = False):
         ...
 
     @overload
-    def add_scoped[I](self, *, i: type[I]):
+    def add_scoped[I](self, *, i: type[I], override: bool = False):
         ...
 
     @overload
-    def add_scoped[T, I](self, *, t: type[T], i: type[I]):
+    def add_scoped[T, I](self, *, t: type[T], i: type[I], override: bool = False):
         ...
 
     @overload
-    def add_scoped[I](self, *, callable: Callable[..., I]):
+    def add_scoped[I](self, *, callable: Callable[..., I], override: bool = False):
         ...
 
     @overload
-    def add_scoped[T, I](self, *, t: type[T], callable: Callable[..., I]):
+    def add_scoped[T, I](self, *, t: type[T], callable: Callable[..., I], override: bool = False):
         ...
 
     @overload
-    def add_scoped[I](self, *, generator: Callable[..., AsyncGenerator[I]]):
+    def add_scoped[I](self, *, generator: Callable[..., AsyncGenerator[I]], override: bool = False):
         ...
 
     @overload
-    def add_scoped[T, I](self, *, t: type[T], generator: Callable[..., AsyncGenerator[I]]):
+    def add_scoped[T, I](self, *, t: type[T], generator: Callable[..., AsyncGenerator[I]], override: bool = False):
         ...
 
     def add_scoped[T, I](self, *, t: type[T] = None, i: type[I] = None,
-                         generator: Callable[..., AsyncGenerator[I]] = None, callable: Callable[..., I] = None):
+                         generator: Callable[..., AsyncGenerator[I]] = None, callable: Callable[..., I] = None,
+                         override: bool = False):
         self._raise_if_closed()
-        self._add('scoped', t=t, i=i, generator=generator, callable=callable)
+        self._add('scoped', t=t, i=i, generator=generator, callable=callable, override=override)
 
     @overload
-    def add_transient[T](self, *, t: type[T]):
+    def add_transient[T](self, *, t: type[T], override: bool = False):
         ...
 
     @overload
-    def add_transient[I](self, *, i: type[I]):
+    def add_transient[I](self, *, i: type[I], override: bool = False):
         ...
 
     @overload
-    def add_transient[T, I](self, *, t: type[T], i: type[I]):
+    def add_transient[T, I](self, *, t: type[T], i: type[I], override: bool = False):
         ...
 
     @overload
-    def add_transient[I](self, *, callable: Callable[..., I]):
+    def add_transient[I](self, *, callable: Callable[..., I], override: bool = False):
         ...
 
     @overload
-    def add_transient[T, I](self, *, t: type[T], callable: Callable[..., I]):
+    def add_transient[T, I](self, *, t: type[T], callable: Callable[..., I], override: bool = False):
         ...
 
-    def add_transient[T, I](self, *, t: type[T] = None, i: type[I] = None, callable: Callable[..., I] = None):
+    def add_transient[T, I](self, *, t: type[T] = None, i: type[I] = None, callable: Callable[..., I] = None,
+                            override: bool = False):
         self._raise_if_closed()
-        self._add('transient', i=i, t=t, callable=callable)
+        self._add('transient', i=i, t=t, callable=callable, override=override)

{dinkleberg-0.3.0.dist-info → dinkleberg-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dinkleberg
-Version: 0.3.0
+Version: 0.3.2
 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

{dinkleberg-0.3.0.dist-info → dinkleberg-0.3.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
 dinkleberg/__init__.py,sha256=6gowHoL3xTWd2iyU09upgjXKUv_WWp6Tw1iqw2uz7Vc,192
-dinkleberg/dependency_configurator.py,sha256=vsXTHFUkhW5_bR95qFYOzaio-UwupIkS9qjPL2e8s4o,14356
+dinkleberg/dependency_configurator.py,sha256=lS_IPK2nLdVPQZpYOxlk6pv1fzQ9MK2PdJ9ucOrptww,16514
 dinkleberg/descriptor.py,sha256=ZtVwJihvCLugakHx201iX7Jm4A50Z0SzPu9zeHfD320,349
 dinkleberg/typing.py,sha256=qAdSQomntQfI4bSWc9X32DXGftuyj56WP7nG3Pia7ZE,942
 dinkleberg/fastapi/__init__.py,sha256=boj1ywpWhuuOjHLwdUha2EPBG2f1zbc374N35k1CJxk,352
-dinkleberg-0.3.0.dist-info/METADATA,sha256=sGBRFKAmbtQS1vc79a5tyotUivlciNlhZAbwYqSC1FQ,1555
-dinkleberg-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-dinkleberg-0.3.0.dist-info/top_level.txt,sha256=6TjbaJ_eyRzoxzz2r1Eu0hgYfxBBM2bOV3u_TJ8yjjw,11
-dinkleberg-0.3.0.dist-info/RECORD,,
+dinkleberg-0.3.2.dist-info/METADATA,sha256=sKUDY2mt75smvk6Em79QVJXf8kgL16M1KYDxCVUvCes,1555
+dinkleberg-0.3.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+dinkleberg-0.3.2.dist-info/top_level.txt,sha256=6TjbaJ_eyRzoxzz2r1Eu0hgYfxBBM2bOV3u_TJ8yjjw,11
+dinkleberg-0.3.2.dist-info/RECORD,,