dinkleberg 0.2.0__py3-none-any.whl → 0.3.0__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,4 +1,3 @@
-import abc
 import asyncio
 import inspect
 import logging
@@ -6,10 +5,9 @@ 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
+from .typing import get_static_params, get_public_methods, is_builtin_type, is_abstract
 
 logger = logging.getLogger(__name__)
 
@@ -58,13 +56,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:
@@ -117,8 +147,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,17 +175,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 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)
@@ -180,7 +217,7 @@ class DependencyConfigurator(DependencyScope):
             if not param.annotation or param.annotation is inspect.Parameter.empty:
                 continue
 
-            if is_builtin(param.annotation):
+            if is_builtin_type(param.annotation):
                 continue
 
             # TODO handle more complex cases (e.g., Union, Optional, etc.)
@@ -253,6 +290,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]):
         ...
@@ -269,11 +318,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)
@@ -282,6 +333,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]):
         ...
@@ -298,10 +361,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]):
@@ -311,6 +386,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,11 +1,16 @@
+import abc
 import inspect
 from inspect import Parameter, signature
 from typing import Callable, get_origin
 
 
-def is_builtin(t: type) -> bool:
+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) == 'builtins'
+    return getattr(origin, '__module__', None) in ('builtins', 'typing', 'types')
 
 
 def get_static_params(func: Callable) -> list[Parameter]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dinkleberg
-Version: 0.2.0
+Version: 0.3.0
 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.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dinkleberg/__init__.py,sha256=6gowHoL3xTWd2iyU09upgjXKUv_WWp6Tw1iqw2uz7Vc,192
+dinkleberg/dependency_configurator.py,sha256=vsXTHFUkhW5_bR95qFYOzaio-UwupIkS9qjPL2e8s4o,14356
+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/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.0.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=vc3m23BopF0rSFDRO-Fj-8cGmU4bbGve1Qa1ymYsF0g,11727
-dinkleberg/dependency_scope.py,sha256=sufXjQ6F62ZfohItUnrV7Fvh8gSSc7a6orO6PXu19Vw,318
-dinkleberg/descriptor.py,sha256=mVI00K1M2m4Rl5ANatGMeB_HpzeFONoULwg0UmNxfQ0,313
-dinkleberg/typing.py,sha256=kVawkc46Jblqa4XUdangv3ZL8X3RyP8TpZ08EU7RbP0,815
-dinkleberg-0.2.0.dist-info/METADATA,sha256=aVA9a_YmlnDJPMFVirD81BwTPBMBizhmnv02mf7Mkwc,1430
-dinkleberg-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-dinkleberg-0.2.0.dist-info/top_level.txt,sha256=6TjbaJ_eyRzoxzz2r1Eu0hgYfxBBM2bOV3u_TJ8yjjw,11
-dinkleberg-0.2.0.dist-info/RECORD,,