dinkleberg 0.1.0__py3-none-any.whl

dinkleberg/__init__.py

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

dinkleberg/dependency.py

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

dinkleberg/dependency_configurator.py

@@ -0,0 +1,286 @@
+import asyncio
+import inspect
+import logging
+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 .descriptor import Descriptor, Lifetime
+from .typing import get_static_params, get_public_methods
+
+logger = logging.getLogger(__name__)
+
+
+# noinspection PyShadowingBuiltins
+class DependencyConfigurator(DependencyScope):
+    def __init__(self, parent: 'DependencyConfigurator' = None) -> None:
+        super().__init__()
+        self._parent = parent
+        self._descriptors: dict[type, Descriptor] = {}
+        self._singleton_instances = {}
+        self._scoped_instances = {}
+        self._active_generators = []
+        self._scopes = []
+        self._closed = False
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+
+        exceptions = []
+
+        # TODO close generators in reverse order of creation (LIFO)
+        for generator in self._active_generators:
+            try:
+                await generator.__anext__()
+                raise RuntimeError('Generator did not stop after yielding a single value.')
+            except StopAsyncIteration:
+                pass
+            except Exception as e:
+                exceptions.append(e)
+
+        for scope in self._scopes:
+            try:
+                await scope.close()
+            except Exception as e:
+                exceptions.append(e)
+
+        self._singleton_instances.clear()
+        self._active_generators.clear()
+        self._scoped_instances.clear()
+        self._descriptors.clear()
+        self._scopes.clear()
+
+        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 configuration.')
+        if t is None:
+            t = self._infer_type(generator=generator, callable=callable)
+        self._descriptors[t] = Descriptor(generator=generator, callable=callable, lifetime=lifetime)
+
+    @staticmethod
+    def _infer_type(*, generator: Callable[..., AsyncGenerator], callable: Callable) -> type:
+        # noinspection PyBroadException
+        try:
+            hints = get_type_hints(generator or callable)
+            return_hint = hints.get('return')
+
+            if not return_hint:
+                pass
+
+            # This looks for the generic arguments of the return type
+            # e.g., if hint is AsyncGenerator[User, None], it extracts User
+            if hasattr(return_hint, '__args__'):
+                return return_hint.__args__[0]
+            return return_hint
+        except Exception:
+            pass
+        raise ValueError('Could not infer type from generator. Please provide the type explicitly.')
+
+    def _raise_if_closed(self):
+        if self._closed:
+            raise RuntimeError('DependencyConfigurator is already closed.')
+
+    def scope(self) -> 'DependencyConfigurator':
+        self._raise_if_closed()
+        scope = DependencyConfigurator(self)
+        scope._descriptors = self._descriptors.copy()
+        self._scopes.append(scope)
+        return scope
+
+    def _lookup_singleton(self, t: type):
+        if t in self._singleton_instances:
+            return self._singleton_instances[t]
+        if self._parent:
+            return self._parent._lookup_singleton(t)
+        return None
+
+    # TODO circular dependency detection
+    async def resolve[T](self, t: type[T], **kwargs) -> T:
+        self._raise_if_closed()
+
+        if t == DependencyScope:
+            return self
+
+        singleton = self._lookup_singleton(t)
+        if singleton is not None:
+            return singleton
+        if t in self._scoped_instances:
+            return self._scoped_instances[t]
+
+        if t in self._descriptors:
+            descriptor = self._descriptors[t]
+            lifetime = descriptor['lifetime']
+            if lifetime == 'singleton' and self._parent:
+                # we need to resolve singleton from the root scope
+                return await self._parent.resolve(t, **kwargs)
+
+            is_generator = descriptor['generator'] is not None
+            factory = descriptor['generator'] or descriptor['callable']
+            deps = await self._resolve_deps(factory)
+        else:
+            origin = get_origin(t)
+            if origin is not None:
+                raise ValueError(f'Cannot resolve generic type {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)
+            try:
+                instance = await generator.__anext__()
+            except StopAsyncIteration:
+                raise RuntimeError(f'Generator {t} did not yield any value.')
+
+            self._active_generators.append(generator)
+        else:
+            instance = factory(**deps, **kwargs)
+
+        self._wrap_instance(instance)
+
+        if lifetime == 'singleton':
+            self._singleton_instances[t] = instance
+        elif lifetime == 'scoped':
+            self._scoped_instances[t] = instance
+
+        return instance
+
+    async def _resolve_deps(self, func: Callable) -> dict:
+        params = get_static_params(func)
+        tasks = []
+        names = []
+
+        for param in params:
+            if not param.annotation or param.annotation is inspect.Parameter.empty:
+                continue
+
+            # TODO handle more complex cases (e.g., Union, Optional, etc.)
+            # TODO handle native types (int, str, etc.)
+            names.append(param.name)
+            tasks.append(self.resolve(param.annotation))
+
+        results = await asyncio.gather(*tasks)
+        return dict(zip(names, results))
+
+    async def _resolve_kwargs(self, signature: Signature, name: str, args: tuple, kwargs: dict,
+                              dep_params: Mapping[str, inspect.Parameter]) -> dict:
+        bound_args = signature.bind_partial(*args, **kwargs)
+        actual_kwargs = kwargs.copy()
+
+        params_to_resolve = []
+        for p_name, p_obj in dep_params.items():
+            if p_name not in bound_args.arguments:
+                if p_obj.annotation is inspect.Parameter.empty:
+                    raise TypeError(f'Parameter "{p_name}" in {name} is marked as a Dependency but lacks a type hint.')
+                params_to_resolve.append((p_name, p_obj.annotation))
+
+        if not params_to_resolve:
+            return actual_kwargs
+
+        names, types = zip(*params_to_resolve)
+        resolved_values = await asyncio.gather(*(self.resolve(t, **kwargs) for t in types))
+
+        actual_kwargs.update(dict(zip(names, resolved_values)))
+
+        return actual_kwargs
+
+    # TODO handle __slots__
+    def _wrap_instance(self, instance):
+        if getattr(instance, '__di_wrapped__', False):
+            return
+
+        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.')
+
+        try:
+            setattr(instance, '__di_wrapped__', True)
+        except (AttributeError, TypeError):
+            # Some objects (like those with __slots__) might not allow new attributes
+            pass
+
+    @overload
+    def add_singleton[I](self, *, instance: I):
+        ...
+
+    @overload
+    def add_singleton[T, I](self, *, t: type[T], instance: I):
+        ...
+
+    @overload
+    def add_singleton[I](self, *, callable: Callable[..., I]):
+        ...
+
+    @overload
+    def add_singleton[T, I](self, *, t: type[T], callable: Callable[..., I]):
+        ...
+
+    @overload
+    def add_singleton[I](self, *, generator: Callable[..., AsyncGenerator[I]]):
+        ...
+
+    @overload
+    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,
+                            callable: Callable[..., I] = None, instance: I = None):
+        self._raise_if_closed()
+        if instance is None:
+            self._add('singleton', t=t, generator=generator, callable=callable)
+            return
+        elif t is None:
+            t = type(instance)
+
+        self._wrap_instance(instance)
+
+        self._singleton_instances[t] = instance
+
+    @overload
+    def add_scoped[I](self, *, callable: Callable[..., I]):
+        ...
+
+    @overload
+    def add_scoped[T, I](self, *, t: type[T], callable: Callable[..., I]):
+        ...
+
+    @overload
+    def add_scoped[I](self, *, generator: Callable[..., AsyncGenerator[I]]):
+        ...
+
+    @overload
+    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):
+        self._raise_if_closed()
+        self._add('scoped', t=t, generator=generator, callable=callable)

dinkleberg/dependency_scope.py

@@ -0,0 +1,15 @@
+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/descriptor.py

@@ -0,0 +1,9 @@
+from typing import Optional, TypedDict, Callable, AsyncGenerator, Literal, Union
+
+Lifetime = Union[Literal['singleton'], Literal['scoped'], Literal['transient']]
+
+
+class Descriptor(TypedDict):
+    generator: Optional[Callable[..., AsyncGenerator]]
+    callable: Optional[Callable]
+    lifetime: Lifetime

dinkleberg/typing.py

@@ -0,0 +1,26 @@
+import inspect
+from inspect import Parameter, signature
+from typing import Callable
+
+
+def get_static_params(func: Callable) -> list[Parameter]:
+    sig = signature(func)
+
+    params = list(sig.parameters.values())
+
+    if params and params[0].name in ('self', 'cls'):
+        params = params[1:]
+
+    return params
+
+
+def get_public_methods(obj: object) -> list[tuple[str, Callable]]:
+    methods = []
+
+    for name in dir(obj.__class__):
+        attr = getattr(obj.__class__, name)
+
+        if inspect.isroutine(attr) and not isinstance(attr, property) and not name.startswith('_'):
+            methods.append((name, attr))
+
+    return methods

dinkleberg-0.1.0.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: dinkleberg
+Version: 0.1.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
+Project-URL: Repository, https://github.com/DavidVollmers/dinkleberg.git
+Project-URL: Issues, https://github.com/DavidVollmers/dinkleberg/issues
+Project-URL: Changelog, https://github.com/DavidVollmers/dinkleberg/blob/main/CHANGELOG.md
+Keywords: automation,dependency,package-management
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# dinkleberg
+
+> "And this is where I'd put my working dependencies... IF I HAD ANY!"
+
+**dinkleberg** is a lightweight Python utility designed to make dependency management less of a neighborhood feud. Built
+to work seamlessly in any project, it ensures your environment stays green—unlike the guy's next door.
+
+## Installation
+
+```bash
+pip install dinkleberg
+
+uv add dinkleberg
+```

dinkleberg-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dinkleberg/__init__.py,sha256=HGu8mjYt-Fa0y9_aMtJZFYo3s9Yb0q5dmbMKtHrAV_k,217
+dinkleberg/dependency.py,sha256=YcGvuvhoBRxShgSRaznKyZg49GCgOWy_L8HD0sXAMYo,29
+dinkleberg/dependency_configurator.py,sha256=IeGSUUbaaxbcb1I6NcIqWyqGs0iWygVzjXzsj0VmOGg,10473
+dinkleberg/dependency_scope.py,sha256=sufXjQ6F62ZfohItUnrV7Fvh8gSSc7a6orO6PXu19Vw,318
+dinkleberg/descriptor.py,sha256=mVI00K1M2m4Rl5ANatGMeB_HpzeFONoULwg0UmNxfQ0,313
+dinkleberg/typing.py,sha256=9AGDNz_aQ8p7ToyJwkj2fg92o0L3-zXwZBEmoTNS1to,670
+dinkleberg-0.1.0.dist-info/METADATA,sha256=vU4SQ-0fafwgtOETUAtr_-zuPTEJX4Haesa4i8OT8L8,1396
+dinkleberg-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dinkleberg-0.1.0.dist-info/RECORD,,

dinkleberg-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any