Possible fix for #43

Author: RobertoPrevato

CHANGELOG.md

@@ -5,13 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.1.0] - 2025-11-24 :notes:
+## [2.1.0] - 2026-03-??
 
 - Drop support for Python <= 3.10.
 - Add Python 3.14 to the build matrix and to classifiers.
 - Remove Codecov from GitHub Workflow and from README.
 - Upgrade type annotations to Python >= 3.10.
 - Remove code checks for Python <= 3.10.
+- Support mixing `__init__` parameters and class-level annotated properties for
+  dependency injection. Previously, when a class defined a custom `__init__`,
+  rodi would only inspect constructor parameters and ignore class-level type
+  annotations. Now both are resolved: constructor parameters are injected as
+  arguments, and any remaining class-level annotated properties are injected via
+  `setattr` after instantiation. This enables patterns like:
+
+  ```python
+  class MyService:
+      extra_dep: ExtraDependency  # injected via setattr
+
+      def __init__(self, main_dep: MainDependency) -> None:
+          self.main_dep = main_dep
+  ```
+
+  Resolves [issue #43](https://github.com/Neoteroi/rodi/issues/43), reported by
+  [@lucas-labs](https://github.com/lucas-labs).
 
 ## [2.0.8] - 2025-04-12
 

rodi/__init__.py

@@ -448,6 +448,28 @@ def factory(context, parent_type):
     return FactoryResolver(concrete_type, factory, life_style)(resolver_context)
 
 
+def get_mixed_type_provider(
+    concrete_type: Type,
+    args_callbacks: list,
+    annotation_resolvers: Mapping[str, Callable],
+    life_style: ServiceLifeStyle,
+    resolver_context: ResolutionContext,
+):
+    """
+    Provider that combines __init__ argument injection with class-level annotation
+    property injection. Used when a class defines both a custom __init__ (with or
+    without parameters) and class-level annotated attributes.
+    """
+
+    def factory(context, parent_type):
+        instance = concrete_type(*[fn(context, parent_type) for fn in args_callbacks])
+        for name, resolver in annotation_resolvers.items():
+            setattr(instance, name, resolver(context, parent_type))
+        return instance
+
+    return FactoryResolver(concrete_type, factory, life_style)(resolver_context)
+
+
 def _get_plain_class_factory(concrete_type: Type):
     def factory(*args):
         return concrete_type()
@@ -628,6 +650,47 @@ def _resolve_by_annotations(
             self.concrete_type, resolvers, self.life_style, context
         )
 
+    def _resolve_by_init_and_annotations(
+        self, context: ResolutionContext, extra_annotations: Dict[str, Type]
+    ):
+        """
+        Resolves by both __init__ parameters and class-level annotated properties.
+        Used when a class defines a custom __init__ AND class-level type annotations.
+        The __init__ parameters are injected as constructor arguments; the class
+        annotations are injected via setattr after instantiation.
+        """
+        sig = Signature.from_callable(self.concrete_type.__init__)
+        params = {
+            key: Dependency(key, value.annotation)
+            for key, value in sig.parameters.items()
+        }
+
+        if sys.version_info >= (3, 10):  # pragma: no cover
+            annotations = get_type_hints(
+                self.concrete_type.__init__,
+                vars(sys.modules[self.concrete_type.__module__]),
+                _get_obj_locals(self.concrete_type),
+            )
+            for key, value in params.items():
+                if key in annotations:
+                    value.annotation = annotations[key]
+
+        concrete_type = self.concrete_type
+        init_fns = self._get_resolvers_for_parameters(concrete_type, context, params)
+
+        ann_params = {
+            key: Dependency(key, value)
+            for key, value in extra_annotations.items()
+        }
+        ann_fns = self._get_resolvers_for_parameters(concrete_type, context, ann_params)
+        annotation_resolvers = {
+            name: ann_fns[i] for i, name in enumerate(ann_params.keys())
+        }
+
+        return get_mixed_type_provider(
+            concrete_type, init_fns, annotation_resolvers, self.life_style, context
+        )
+
     def __call__(self, context: ResolutionContext):
         concrete_type = self.concrete_type
 
@@ -651,6 +714,29 @@ def __call__(self, context: ResolutionContext):
                 concrete_type, _get_plain_class_factory(concrete_type), self.life_style
             )(context)
 
+        # Custom __init__: also check for class-level annotations to inject as properties
+        class_annotations = get_type_hints(
+            concrete_type,
+            vars(sys.modules[concrete_type.__module__]),
+            _get_obj_locals(concrete_type),
+        )
+        if class_annotations:
+            sig = Signature.from_callable(concrete_type.__init__)
+            init_param_names = set(sig.parameters.keys()) - {"self"}
+            extra_annotations = {
+                k: v
+                for k, v in class_annotations.items()
+                if k not in init_param_names
+                and not self._ignore_class_attribute(k, v)
+            }
+            if extra_annotations:
+                try:
+                    return self._resolve_by_init_and_annotations(
+                        context, extra_annotations
+                    )
+                except RecursionError:
+                    raise CircularDependencyException(chain[0], concrete_type)
+
         try:
             return self._resolve_by_init_method(context)
         except RecursionError:

tests/examples.py

@@ -264,3 +264,63 @@ class PrecedenceOfTypeHintsOverNames:
     def __init__(self, foo: Q, ko: P):
         self.q = foo
         self.p = ko
+
+
+# Classes for testing mixed __init__ + class annotation injection
+
+
+class MixedDep1:
+    pass
+
+
+class MixedDep2:
+    pass
+
+
+class MixedNoInitArgs:
+    """Has a custom __init__ with no injectable args, plus class-level annotations."""
+
+    injected: MixedDep1
+
+    def __init__(self) -> None:
+        self.value = "hello"
+
+
+class MixedWithInitArgs:
+    """Has a custom __init__ with injectable args, plus additional class-level annotations."""
+
+    extra: MixedDep2
+
+    def __init__(self, dep1: MixedDep1) -> None:
+        self.dep1 = dep1
+        self.value = "hello"
+
+
+class MixedSingleton:
+    """Singleton variant for mixed injection."""
+
+    dep2: MixedDep2
+
+    def __init__(self, dep1: MixedDep1) -> None:
+        self.dep1 = dep1
+
+
+class MixedScoped:
+    """Scoped variant for mixed injection."""
+
+    dep2: MixedDep2
+
+    def __init__(self, dep1: MixedDep1) -> None:
+        self.dep1 = dep1
+
+
+class MixedAnnotationOverlapsInit:
+    """
+    Class where a class annotation name matches an __init__ parameter.
+    The annotation should NOT be double-injected; init param takes precedence.
+    """
+
+    dep1: MixedDep1  # same name as __init__ param - should be handled by init only
+
+    def __init__(self, dep1: MixedDep1) -> None:
+        self.dep1 = dep1

tests/test_services.py

@@ -65,6 +65,13 @@
     Jang,
     Jing,
     Ko,
+    MixedAnnotationOverlapsInit,
+    MixedDep1,
+    MixedDep2,
+    MixedNoInitArgs,
+    MixedScoped,
+    MixedSingleton,
+    MixedWithInitArgs,
     Ok,
     P,
     PrecedenceOfTypeHintsOverNames,
@@ -2760,3 +2767,101 @@ async def test_nested_scope_async_1():
         nested_scope_async(),
         nested_scope_async(),
     )
+
+
+# Tests for mixed __init__ + class annotation injection (issue #43)
+
+
+def test_mixed_no_init_args_transient():
+    """
+    Class with a custom no-arg __init__ AND class-level annotations:
+    annotations should be injected via setattr after instantiation.
+    """
+    container = Container()
+    container.add_transient(MixedDep1)
+    container.add_transient(MixedNoInitArgs)
+    provider = container.build_provider()
+
+    instance = provider.get(MixedNoInitArgs)
+    assert instance is not None
+    assert isinstance(instance.injected, MixedDep1)
+    assert instance.value == "hello"
+
+
+def test_mixed_no_init_args_new_instance_each_time():
+    """Transient mixed services produce a new instance on each resolve."""
+    container = Container()
+    container.add_transient(MixedDep1)
+    container.add_transient(MixedNoInitArgs)
+    provider = container.build_provider()
+
+    a = provider.get(MixedNoInitArgs)
+    b = provider.get(MixedNoInitArgs)
+    assert a is not b
+
+
+def test_mixed_with_init_args_transient():
+    """
+    Class with a custom __init__ that has injectable params AND class-level annotations:
+    both should be injected.
+    """
+    container = Container()
+    container.add_transient(MixedDep1)
+    container.add_transient(MixedDep2)
+    container.add_transient(MixedWithInitArgs)
+    provider = container.build_provider()
+
+    instance = provider.get(MixedWithInitArgs)
+    assert instance is not None
+    assert isinstance(instance.dep1, MixedDep1)
+    assert isinstance(instance.extra, MixedDep2)
+    assert instance.value == "hello"
+
+
+def test_mixed_with_init_args_singleton():
+    """Singleton mixed service: same instance returned each time."""
+    container = Container()
+    container.add_singleton(MixedDep1)
+    container.add_singleton(MixedDep2)
+    container.add_singleton(MixedSingleton)
+    provider = container.build_provider()
+
+    a = provider.get(MixedSingleton)
+    b = provider.get(MixedSingleton)
+    assert a is b
+    assert isinstance(a.dep1, MixedDep1)
+    assert isinstance(a.dep2, MixedDep2)
+
+
+def test_mixed_with_init_args_scoped():
+    """Scoped mixed service: same instance within a scope, new across scopes."""
+    container = Container()
+    container.add_scoped(MixedDep1)
+    container.add_scoped(MixedDep2)
+    container.add_scoped(MixedScoped)
+    provider = container.build_provider()
+
+    with provider.create_scope() as scope1:
+        a = provider.get(MixedScoped, scope1)
+        b = provider.get(MixedScoped, scope1)
+        assert a is b
+        assert isinstance(a.dep1, MixedDep1)
+        assert isinstance(a.dep2, MixedDep2)
+
+    with provider.create_scope() as scope2:
+        c = provider.get(MixedScoped, scope2)
+        assert c is not a
+
+
+def test_mixed_annotation_overlaps_init_param():
+    """
+    When a class annotation has the same name as an __init__ parameter,
+    the annotation is NOT double-injected — init handles it, setattr is skipped.
+    """
+    container = Container()
+    container.add_transient(MixedDep1)
+    container.add_transient(MixedAnnotationOverlapsInit)
+    provider = container.build_provider()
+
+    instance = provider.get(MixedAnnotationOverlapsInit)
+    assert isinstance(instance.dep1, MixedDep1)