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

dinkleberg/dependency_configurator.py

@@ -21,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
@@ -51,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()
 
@@ -58,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.')
@@ -82,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.')
@@ -95,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
@@ -118,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
 
@@ -206,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
@@ -279,10 +291,16 @@ class DependencyConfigurator(DependencyScope):
         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:
             instance_method = getattr(instance, name)
@@ -298,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.1.dist-info → dinkleberg-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dinkleberg
-Version: 0.3.1
+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.1.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=gSuizzr28qwO9Q5Z1IYytxaIRB5dAAKiPKe3GozKUuk,14660
+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.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-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,,