feat: add PyCharm 2026.1 type hint support for functional dependencies

Author: DavidVollmers

libs/dinkleberg/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dinkleberg"
-version = "2.3.1"
+version = "3.0.0"
 description = "Your friendly neighbour when it comes to dependency management."
 requires-python = ">=3.12"
 readme = "README.md"

libs/dinkleberg/src/dinkleberg/dependency.py

@@ -1,3 +1,9 @@
-class Dependency:
-    def __init__(self, **kwargs):
+class _Dependency:
+    def __init__(self, t: type = None, **kwargs):
+        self._t = t
         self._kwargs = kwargs
+
+
+# noinspection PyPep8Naming
+def Dependency[T](t: type[T] = None, **kwargs) -> T:
+    return _Dependency(t, **kwargs)

libs/dinkleberg/src/dinkleberg/dependency_configurator.py

@@ -7,7 +7,7 @@
 from typing import AsyncGenerator, Callable, overload, get_type_hints, Mapping, get_origin, get_args
 
 from .dependency_scope import DependencyScope
-from .dependency import Dependency
+from .dependency import _Dependency
 from .dependency_resolution_error import DependencyResolutionError
 from .descriptor import Descriptor, Lifetime
 from .resolution_step import ResolutionStep
@@ -388,6 +388,7 @@ async def _resolve_factory_kwargs(self, factory: Callable, kwargs: dict, generic
 
         return final_kwargs
 
+    # noinspection PyProtectedMember
     async def _resolve_kwargs(self, signature: Signature, name: str, args: tuple, kwargs: dict,
                               dep_params: Mapping[str, inspect.Parameter], chain: tuple[ResolutionStep, ...]) -> dict:
         bound_args = signature.bind_partial(*args, **kwargs)
@@ -401,13 +402,15 @@ async def _resolve_kwargs(self, signature: Signature, name: str, args: tuple, kw
 
             ann = p_param.annotation
             if ann is inspect.Parameter.empty:
-                raise DependencyResolutionError(chain,
-                                                message=f'Parameter "{p_name}" in {name} is missing a type annotation, '
-                                                        f'which is required for dependency resolution.')
+                if p_param.default._t is not None:
+                    ann = p_param.default._t
+                else:
+                    raise DependencyResolutionError(chain,
+                                                    message=f'Parameter "{p_name}" in {name} is missing a type '
+                                                            f'annotation, which is required for dependency resolution.')
 
             is_optional, resolve_type = is_type_optional(ann)
 
-            # noinspection PyProtectedMember
             dep_kwargs = p_param.default._kwargs
             merged_kwargs = {**dep_kwargs, **kwargs}
 
@@ -424,13 +427,13 @@ def _wrap_func(self, func: Callable, chain: tuple[ResolutionStep, ...]) -> Calla
         dep_params = MappingProxyType({
             param_name: param
             for param_name, param in signature.parameters.items()
-            if isinstance(param.default, Dependency)
+            if isinstance(param.default, _Dependency)
         })
 
         if not dep_params:
             return func
 
-        if not asyncio.iscoroutinefunction(func):
+        if not inspect.iscoroutinefunction(func):
             raise NotImplementedError('Synchronous functions with Dependency() defaults are not supported.')
 
         @wraps(func)

libs/dinkleberg/src/dinkleberg/typing.py

@@ -5,7 +5,7 @@
 from types import UnionType
 from typing import Callable, get_origin, get_type_hints, Union, get_args
 
-from .dependency import Dependency
+from .dependency import _Dependency
 
 
 @lru_cache(maxsize=4096)
@@ -67,7 +67,7 @@ def get_methods_to_wrap(cls: type) -> tuple[str, ...]:
 
             sig = get_signature(attr)
             for param in sig.parameters.values():
-                if isinstance(param.default, Dependency):
+                if isinstance(param.default, _Dependency):
                     methods_to_wrap.append(name)
                     break
         except (AttributeError, ValueError):

libs/dinkleberg/tests/test_functions.py

@@ -19,6 +19,22 @@ async def test(t: Test = Dependency()):
     assert result == 'Hello, World!'
 
 
+@pytest.mark.asyncio
+async def test_resolve_function_without_annotation(di):
+    class Test:
+        def get_message(self):
+            return 'Hello, World!'
+
+    async def test(t=Dependency(Test)):
+        return t.get_message()
+
+    f = await di.resolve(test)
+
+    result = await f()
+
+    assert result == 'Hello, World!'
+
+
 @pytest.mark.asyncio
 async def test_resolve_function_with_kwargs(di):
     class Test: