wireup 2.12.0__tar.gz → 2.12.1__tar.gz

{wireup-2.12.0 → wireup-2.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: wireup
-Version: 2.12.0
+Version: 2.12.1
 Summary: Python Dependency Injection Library
 Project-URL: Homepage, https://github.com/maldoinc/wireup
 Project-URL: Repository, https://github.com/maldoinc/wireup

{wireup-2.12.0 → wireup-2.12.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wireup"
-version = "2.12.0"
+version = "2.12.1"
 description = "Python Dependency Injection Library"
 authors = [{ name = "Aldo Mateli", email = "aldo.mateli@gmail.com" }]
 license = { text = "MIT" }

wireup-2.12.1/test/unit/services/collection_scan/greeters.py

@@ -0,0 +1,31 @@
+from typing import Protocol
+
+from wireup import injectable
+
+
+class Greeter(Protocol):
+    def hi(self) -> str: ...
+
+
+@injectable(as_type=Greeter, qualifier="delta")
+class Delta:
+    def hi(self) -> str:
+        return "delta"
+
+
+@injectable(as_type=Greeter, qualifier="beta")
+class Beta:
+    def hi(self) -> str:
+        return "beta"
+
+
+@injectable(as_type=Greeter)
+class Alpha:
+    def hi(self) -> str:
+        return "alpha"
+
+
+@injectable(as_type=Greeter, qualifier="gamma")
+class Gamma:
+    def hi(self) -> str:
+        return "gamma"

{wireup-2.12.0 → wireup-2.12.1}/test/unit/test_container_creation.py

@@ -10,6 +10,8 @@ import pytest
 import wireup
 from wireup._annotations import Inject, abstract, injectable
 from wireup.errors import WireupError
+from wireup.ioc import registry_validation
+from wireup.ioc.types import get_container_object_id
 
 from test.unit.services.no_annotations.random.random_service import RandomService
 
@@ -208,6 +210,131 @@ def test_validates_container_does_not_raise_when_no_dependency_cycle() -> None:
     wireup.create_sync_container(injectables=[make_foo, make_bar, make_foo_no_dependency])
 
 
+def test_validates_container_walks_shared_dependencies_once(monkeypatch: pytest.MonkeyPatch) -> None:
+    @wireup.injectable
+    class Leaf: ...
+
+    @wireup.injectable
+    @dataclass
+    class Shared:
+        leaf: Leaf
+
+    @wireup.injectable
+    @dataclass
+    class Foo:
+        shared: Shared
+
+    @wireup.injectable
+    @dataclass
+    class Bar:
+        shared: Shared
+
+    @wireup.injectable
+    @dataclass
+    class Baz:
+        foo: Foo
+        bar: Bar
+        shared: Shared
+
+    reached: list[type] = []
+    descended: list[type] = []
+    walk = registry_validation.assert_valid_resolution_path
+
+    def recording_walk(**kwargs) -> None:
+        dependency = kwargs["dependency"]
+        reached.append(dependency.klass)
+        object_id = get_container_object_id(dependency.klass, dependency.qualifier_value)
+        # Dependencies known to be cycle-free return immediately, only record the rest.
+        if object_id not in kwargs["known_cycle_free_objects"]:
+            descended.append(dependency.klass)
+        walk(**kwargs)
+
+    monkeypatch.setattr(registry_validation, "assert_valid_resolution_path", recording_walk)
+    wireup.create_sync_container(injectables=[Leaf, Shared, Foo, Bar, Baz])
+
+    assert reached.count(Shared) > 1
+    # Every dependency in the graph is walked exactly once no matter how many paths reach it.
+    assert descended.count(Shared) == 1
+    assert descended.count(Leaf) == 1
+    assert descended.count(Foo) == 1
+    assert descended.count(Bar) == 1
+
+
+def test_validates_container_raises_when_cycle_is_behind_a_walked_dependency() -> None:
+    class Shared: ...
+
+    class Foo:
+        def __init__(self, shared, bar): ...
+
+    class Bar:
+        def __init__(self, shared, foo): ...
+
+    @wireup.injectable
+    def make_shared() -> Shared:
+        return Shared()
+
+    # Walking 'shared' clears it, the cycle behind 'bar' must still be found.
+    @wireup.injectable
+    def make_foo(shared: Shared, bar: Bar) -> Foo:
+        return Foo(shared, bar)
+
+    @wireup.injectable
+    def make_bar(shared: Shared, foo: Foo) -> Bar:
+        return Bar(shared, foo)
+
+    with pytest.raises(
+        WireupError,
+        match=re.escape(
+            f"Circular dependency detected for {Bar!r} (created via {make_bar.__module__}.{make_bar.__name__})"
+            f"\n -> {Foo!r} (created via {make_foo.__module__}.{make_foo.__name__})"
+            f"\n -> {Bar!r} (created via {make_bar.__module__}.{make_bar.__name__})"
+            " ! Cycle here"
+        ),
+    ):
+        wireup.create_sync_container(injectables=[make_shared, make_foo, make_bar])
+
+
+def test_validates_container_does_not_reuse_walked_dependencies_between_containers() -> None:
+    class Foo:
+        def __init__(self, bar): ...
+
+    class Bar:
+        def __init__(self, foo): ...
+
+    class Baz:
+        def __init__(self, foo): ...
+
+    @wireup.injectable
+    def make_foo() -> Foo:
+        return Foo(None)
+
+    @wireup.injectable
+    def make_baz(foo: Foo) -> Baz:
+        return Baz(foo)
+
+    # Foo is walked and recorded cycle-free here, which says nothing about another container's graph.
+    wireup.create_sync_container(injectables=[make_foo, make_baz])
+
+    @wireup.injectable
+    def make_cyclical_foo(bar: Bar) -> Foo:
+        return Foo(bar)
+
+    @wireup.injectable
+    def make_bar(foo: Foo) -> Bar:
+        return Bar(foo)
+
+    with pytest.raises(
+        WireupError,
+        match=re.escape(
+            f"Circular dependency detected for {Bar!r} (created via {make_bar.__module__}.{make_bar.__name__})"
+            f"\n -> {Foo!r} (created via {make_cyclical_foo.__module__}.{make_cyclical_foo.__name__})"
+            f"\n -> {Bar!r} (created via {make_bar.__module__}.{make_bar.__name__})"
+            " ! Cycle here"
+        ),
+    ):
+        wireup.create_sync_container(injectables=[make_cyclical_foo, make_bar])
+
+
 def test_lifetimes_match_factories() -> None:
     class ScopedService: ...
 

{wireup-2.12.0 → wireup-2.12.1}/test/unit/test_container_generator_factory.py

@@ -12,6 +12,21 @@ from wireup.ioc.types import InjectableLifetime
 from test.conftest import Container
 
 
+class AsyncContextManagerResource:
+    def __init__(self, cleanup_events: list[str]) -> None:
+        self.cleanup_events = cleanup_events
+        self.entered = False
+        self.exited = False
+
+    async def __aenter__(self) -> "AsyncContextManagerResource":
+        self.entered = True
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        self.exited = True
+        self.cleanup_events.append("resource")
+
+
 def test_cleans_up_on_exit(container: Container) -> None:
     _cleanup_performed = False
     Something = NewType("Something", str)
@@ -50,6 +65,26 @@ async def test_async_cleans_up_on_exit() -> None:
     assert _cleanup_performed
 
 
+async def test_async_generator_factory_closes_async_context_manager_on_container_close() -> None:
+    cleanup_events: list[str] = []
+
+    @injectable
+    async def some_factory() -> AsyncIterator[AsyncContextManagerResource]:
+        async with AsyncContextManagerResource(cleanup_events) as resource:
+            yield resource
+
+    container = wireup.create_async_container(injectables=[some_factory])
+    resource = await container.get(AsyncContextManagerResource)
+
+    assert resource.entered
+    assert not resource.exited
+
+    await container.close()
+
+    assert resource.exited
+    assert cleanup_events == ["resource"]
+
+
 def test_injects_transient() -> None:
     _cleanups: list[str] = []
     Something = NewType("Something", str)
@@ -103,6 +138,28 @@ async def test_async_injects_transient_sync_depends_on_async_result() -> None:
     assert _cleanups == ["f2", "f1"]
 
 
+@pytest.mark.parametrize("lifetime", ["scoped", "transient"])
+async def test_async_generator_factory_closes_async_context_manager_on_scope_exit(
+    lifetime: InjectableLifetime,
+) -> None:
+    cleanup_events: list[str] = []
+
+    @injectable(lifetime=lifetime)
+    async def some_factory() -> AsyncIterator[AsyncContextManagerResource]:
+        async with AsyncContextManagerResource(cleanup_events) as resource:
+            yield resource
+
+    container = wireup.create_async_container(injectables=[some_factory])
+
+    async with container.enter_scope() as scoped:
+        resource = await scoped.get(AsyncContextManagerResource)
+        assert resource.entered
+        assert not resource.exited
+
+    assert resource.exited
+    assert cleanup_events == ["resource"]
+
+
 def test_cleans_up_in_order() -> None:
     _cleanups: list[str] = []
     Something = NewType("Something", str)

wireup-2.12.1/test/unit/test_discovery_order.py

@@ -0,0 +1,20 @@
+import unittest
+from collections.abc import Sequence
+
+import wireup
+
+from test.unit.services.collection_scan import greeters
+
+
+class DiscoveryOrderTest(unittest.TestCase):
+    def test_module_scan_collection_injection_has_deterministic_order(self):
+        container = wireup.create_sync_container(injectables=[greeters])
+        result = [g.hi() for g in container.get(Sequence[greeters.Greeter])]
+
+        self.assertEqual(["delta", "beta", "alpha", "gamma"], result)
+
+    def test_module_scan_discovery_order_is_stable_across_repeated_scans(self):
+        first = [g.hi() for g in wireup.create_sync_container(injectables=[greeters]).get(Sequence[greeters.Greeter])]
+        second = [g.hi() for g in wireup.create_sync_container(injectables=[greeters]).get(Sequence[greeters.Greeter])]
+
+        self.assertEqual(first, second)

{wireup-2.12.0 → wireup-2.12.1}/test/unit/test_inject_from_container.py

@@ -18,6 +18,9 @@ from test.unit.services.async_reg import AsyncDependency, make_async_dependency
 from test.unit.services.no_annotations.random.random_service import RandomService
 from test.unit.services.with_annotations.services import Foo, FooImpl, OtherFooImpl, random_service_factory
 
+# CPython renders id() as uppercase hex on Windows and lowercase elsewhere.
+HEX_ADDR = r"0x[0-9a-fA-F]+"
+
 
 async def test_injects_targets(container: Container) -> None:
     class NotManagedByWireup: ...
@@ -149,7 +152,7 @@ async def test_raises_on_unknown_service(container: Container, qualifier: str) -
     with pytest.raises(
         WireupError,
         match=(
-            r"Parameter 'not_managed_by_wireup' of <function .*test_raises_on_unknown_service.*\._ at 0x[0-9a-f]+> "
+            rf"Parameter 'not_managed_by_wireup' of <function .*test_raises_on_unknown_service.*\._ at {HEX_ADDR}> "
             + re.escape(f"has an unknown dependency on {NotManagedByWireup!r}{expected_qualifier_str}.")
         ),
     ):
@@ -164,7 +167,7 @@ async def test_raises_on_unknown_parameter(container: Container) -> None:
     with pytest.raises(
         WireupError,
         match=(
-            r"Parameter 'not_managed_by_wireup' of <function .*test_raises_on_unknown_parameter.*\._ at 0x[0-9a-f]+> "
+            rf"Parameter 'not_managed_by_wireup' of <function .*test_raises_on_unknown_parameter.*\._ at {HEX_ADDR}> "
             + re.escape("depends on an unknown Wireup config key 'invalid'.")
         ),
     ):

wireup-2.12.1/test/unit/test_inject_from_container_stringified.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import pytest
+import wireup
+from wireup._decorators import inject_from_container
+
+
+@wireup.injectable
+class Bar: ...
+
+
+@pytest.mark.parametrize("hide_annotated_names", [True, False])
+def test_inject_from_container_contains_stringified_annotated_types(*, hide_annotated_names: bool) -> None:
+    container = wireup.create_sync_container(injectables=[Bar])
+
+    @inject_from_container(container, hide_annotated_names=hide_annotated_names)
+    def get_bar(bar: wireup.Injected[Bar]) -> Bar:
+        return bar
+
+    assert get_bar() is container.get(Bar)

{wireup-2.12.0 → wireup-2.12.1}/uv.lock

@@ -1540,7 +1540,7 @@ wheels = [
 
 [[package]]
 name = "wireup"
-version = "2.12.0"
+version = "2.12.1"
 source = { editable = "." }
 dependencies = [
     { name = "typing-extensions" },

{wireup-2.12.0 → wireup-2.12.1}/wireup/_discovery.py

@@ -24,9 +24,9 @@ def discover_wireup_registrations(
         # "from flask import g" would cause a hasattr call to g outside of app context.
         return (isinstance(obj, FunctionType) or inspect.isclass(obj)) and hasattr(obj, "__wireup_registration__")
 
-    all_targets = {
-        m for module in injectable_modules for m in _find_objects_in_module(module, predicate=_is_valid_wireup_target)
-    }
+    all_targets: dict[type, None] = {}
+    for module in injectable_modules:
+        all_targets.update(dict.fromkeys(_find_objects_in_module(module, predicate=_is_valid_wireup_target)))
 
     for cls in all_targets:
         reg = getattr(cls, "__wireup_registration__", None)
@@ -39,14 +39,19 @@ def discover_wireup_registrations(
     return abstract_registrations, injectable_registrations
 
 
-def _find_objects_in_module(module: ModuleType, predicate: Callable[[Any], bool]) -> set[type]:
-    classes: set[type[Any]] = set()
+def _find_objects_in_module(module: ModuleType, predicate: Callable[[Any], bool]) -> list[type]:
+    classes: dict[type[Any], None] = {}
 
-    def _module_get_objects(m: ModuleType) -> set[type]:
-        return {obj for _, obj in inspect.getmembers(m) if predicate(obj)}
+    def _module_get_objects(m: ModuleType) -> list[type]:
+        # inspect.getmembers sorts by name (via dir()), which reads as an
+        # arbitrary reshuffle once "seen order" is the contract this file
+        # exists to keep. A module's own __dict__ is insertion-ordered by
+        # the interpreter as it executes the file top to bottom, so this
+        # is declaration order for free, with no separate tracking needed.
+        return [obj for obj in vars(m).values() if predicate(obj)]
 
     def _find_in_path(path: Path, parent_module_name: str) -> None:
-        for file in path.iterdir():
+        for file in sorted(path.iterdir()):
             if file.name == "__pycache__":
                 continue
 
@@ -60,12 +65,12 @@ def _find_objects_in_module(module: ModuleType, predicate: Callable[[Any], bool]
                     parent_module_name if file.name == "__init__.py" else f"{parent_module_name}.{file.name[:-3]}"
                 )
                 sub_module = importlib.import_module(full_module_name)
-                classes.update(_module_get_objects(sub_module))
+                classes.update(dict.fromkeys(_module_get_objects(sub_module)))
 
     if f := module.__file__:
         if f.endswith("__init__.py"):
             _find_in_path(Path(f).parent, module.__name__)
         else:
-            classes.update(_module_get_objects(module))
+            classes.update(dict.fromkeys(_module_get_objects(module)))
 
-    return classes
+    return list(classes)

{wireup-2.12.0 → wireup-2.12.1}/wireup/ioc/registry_validation.py

@@ -13,11 +13,16 @@ from wireup.util import format_name, stringify_type
 
 if TYPE_CHECKING:
     from wireup.ioc.registry import ContainerRegistry, InjectableFactory
-    from wireup.ioc.types import Qualifier
+    from wireup.ioc.types import ContainerObjectIdentifier, Qualifier
 
 
 def validate_registry(registry: ContainerRegistry) -> None:
     """Assert that all required dependencies exist for this registry instance."""
+    # Dependencies are shared between injectables, so the same subtree is reachable via many paths.
+    # Remember the ones already known to be cycle-free to avoid walking them again.
+    # Only valid for this run as a different registry describes a different graph.
+    known_cycle_free_objects: set[ContainerObjectIdentifier] = set()
+
     for obj_id, injectable_factory in registry.factories.items():
         if isinstance(obj_id, tuple):
             impl, impl_qualifier = obj_id
@@ -54,6 +59,7 @@ def validate_registry(registry: ContainerRegistry) -> None:
                 dependencies=registry.dependencies,
                 dependency=dependency,
                 path=[],
+                known_cycle_free_objects=known_cycle_free_objects,
             )
 
         for name in unknown_dependencies_with_default:
@@ -118,18 +124,26 @@ def assert_dependency_exists(
         raise WireupError(msg)
 
 
-def assert_valid_resolution_path(
+def assert_valid_resolution_path(  # noqa: PLR0913
     *,
     interfaces: dict[type, dict[Qualifier | None, type]],
     factories: dict[Any, InjectableFactory],
     dependencies: dict[Any, dict[str, AnnotatedParameter]],
     dependency: AnnotatedParameter,
     path: list[tuple[AnnotatedParameter, Any]],
+    known_cycle_free_objects: set[ContainerObjectIdentifier],
 ) -> None:
     """Assert that the resolution path for a dependency does not create a cycle."""
     if dependency.klass in interfaces or dependency.is_parameter:
         return
-    dependency_injectable_factory = factories[get_container_object_id(dependency.klass, dependency.qualifier_value)]
+    object_id = get_container_object_id(dependency.klass, dependency.qualifier_value)
+
+    # A dependency whose subtree came back clean cannot lead to a cycle. Were it part of one,
+    # the walk would have come back to it while it was still on the current path.
+    if object_id in known_cycle_free_objects:
+        return
+
+    dependency_injectable_factory = factories[object_id]
     new_path: list[tuple[AnnotatedParameter, Any]] = [*path, (dependency, dependency_injectable_factory)]
 
     if any(p.klass == dependency.klass and p.qualifier_value == dependency.qualifier_value for p, _ in path):
@@ -154,4 +168,7 @@ def assert_valid_resolution_path(
             dependencies=dependencies,
             dependency=next_dependency,
             path=new_path,
+            known_cycle_free_objects=known_cycle_free_objects,
         )
+
+    known_cycle_free_objects.add(object_id)

{wireup-2.12.0 → wireup-2.12.1}/wireup/ioc/util.py

@@ -117,6 +117,8 @@ def get_globals(obj: type[Any] | Callable[..., Any]) -> dict[str, Any]:
     while isinstance(obj, functools.partial):
         obj = obj.func
 
+    obj = inspect.unwrap(obj)
+
     return obj.__globals__
 
 

{wireup-2.12.0 → wireup-2.12.1}/z_docs/.obsidian/workspace.json

@@ -183,8 +183,10 @@
       "bases:Create new base": false
     }
   },
-  "active": "938a00d0142609f9",
+  "active": "343c91a25fcd38f2",
   "lastOpenFiles": [
+    "ideas/scoped_override.md",
+    "Untitled.md",
     "ideas/readme update - advanced section.md",
     "ideas/post_aggregates_followups.md",
     "ideas/nested scopes.md",
@@ -195,7 +197,6 @@
     "ideas/collection_injection_docs_draft.md",
     "ideas/wireup_provided.md",
     "ideas/transactional.md",
-    "ideas/scoped_override.md",
     "ideas/z_test_wireup_seo_plan_2026.md",
     "drafts/What every programmer should know about memory, Part 1.md",
     "drafts/hrt.md",
@@ -209,7 +210,6 @@
     "ideas/dependency_injector_post.md",
     "ideas/coxed_fastapi_reddit.md",
     "drafts/dodona2_en.md",
-    "drafts/dodona2_al.md",
-    "drafts/coxed_fastmcp_post.md"
+    "drafts/dodona2_al.md"
   ]
 }