wireup 2.4.0__tar.gz → 2.6.0__tar.gz

{wireup-2.4.0 → wireup-2.6.0}/.vscode/settings.json

@@ -12,6 +12,7 @@
     "cursorpyright.analysis.autoImportCompletions": true,
     "cSpell.words": [
         "asyncio",
+        "Codegen",
         "pyrefly"
     ],
 }

{wireup-2.4.0 → wireup-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wireup
-Version: 2.4.0
+Version: 2.6.0
 Summary: Python Dependency Injection Library
 Project-URL: Homepage, https://github.com/maldoinc/wireup
 Project-URL: Repository, https://github.com/maldoinc/wireup
@@ -47,7 +47,9 @@ Description-Content-Type: text/markdown
 [![Documentation](https://img.shields.io/badge/%F0%9F%93%9A%20Documentation-3D9970)](https://maldoinc.github.io/wireup)
 </div>
 
-Automate dependency management using Python's type system. Build complex applications with native support for async and generators, plus integrations for popular frameworks out of the box.
+Automate dependency management using Python's type system. Build complex applications with native support for async and
+generators, plus integrations for popular frameworks out of the box. Wireup is thread-safe and ready for no-GIL
+Python (PEP 703).
 
 > [!TIP]
 > **New**: Inject Dependencies in FastAPI with zero runtime overhead using [Class-Based Handlers](https://maldoinc.github.io/wireup/latest/integrations/fastapi/class_based_handlers/).
@@ -339,26 +341,6 @@ def command(service: Injected[UserService]): ...
 def task(service: Injected[UserService]): ...
 ```
 
-```mermaid
-graph LR
-    subgraph "Core Business Logic"
-        Services[Injectables & Services]
-        Domain[Domain Models]
-    end
-
-    subgraph "Entry Points"
-        API[FastAPI / Web]
-        CLI[Click / CLI]
-        Worker[Celery / Worker]
-    end
-
-    API -->|Uses| Services
-    CLI -->|Uses| Services
-    Worker -->|Uses| Services
-
-    Services --> Domain
-```
-
 ### 🔌 Native Integration with popular frameworks
 
 Integrate with popular frameworks for a smoother developer experience.

{wireup-2.4.0 → wireup-2.6.0}/docs/pages/configuration.md

@@ -39,6 +39,44 @@ class DatabaseService:
         self.url = url
 ```
 
+### Dot Notation (Nested Configuration)
+
+Access nested configuration values using dot notation. Wireup allows you to inject configuration from any point in the
+tree, not just leaf values.
+
+```python
+import wireup
+from typing import Annotated, Any
+from wireup import injectable, Inject
+
+container = wireup.create_sync_container(
+    config={
+        "db": {
+            "host": "localhost",
+            "port": 5432,
+            "options": {"timeout": 30},
+        },
+    }
+)
+
+
+@injectable
+class DatabaseService:
+    def __init__(
+        self,
+        # Injects "localhost"
+        host: Annotated[str, Inject(config="db.host")],
+        # Injects 5432
+        port: Annotated[int, Inject(config="db.port")],
+        # Injects the entire dictionary: {"timeout": 30}
+        # You can inject any value from the config, not just primitives.
+        options: Annotated[dict[str, Any], Inject(config="db.options")],
+        # Injects the whole 'db' config: {"host": "...", "port": ..., "options": ...}
+        db_config: Annotated[dict[str, Any], Inject(config="db")],
+    ) -> None:
+        self.host = host
+```
+
 ### Structured Objects
 
 You are not limited to primitives. You can inject entire configuration objects, such as Dataclasses or Pydantic models.

{wireup-2.4.0 → wireup-2.6.0}/docs/pages/index.md

@@ -5,7 +5,8 @@ Performant, concise and type-safe Dependency Injection for Python.
 [![PyPI - Version](https://img.shields.io/pypi/v/wireup)](https://pypi.org/project/wireup/)
 
 Automate dependency management using Python's type system. Build complex applications with native support for async and
-generators, plus integrations for popular frameworks out of the box.
+generators, plus integrations for popular frameworks out of the box. Wireup is thread-safe and ready for no-GIL Python
+(PEP 703).
 
 !!! tip "Zero Runtime Overhead"
 

{wireup-2.4.0 → wireup-2.6.0}/pyproject.toml

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

{wireup-2.4.0 → wireup-2.6.0}/readme.md

@@ -9,7 +9,9 @@
 [![Documentation](https://img.shields.io/badge/%F0%9F%93%9A%20Documentation-3D9970)](https://maldoinc.github.io/wireup)
 </div>
 
-Automate dependency management using Python's type system. Build complex applications with native support for async and generators, plus integrations for popular frameworks out of the box.
+Automate dependency management using Python's type system. Build complex applications with native support for async and
+generators, plus integrations for popular frameworks out of the box. Wireup is thread-safe and ready for no-GIL
+Python (PEP 703).
 
 > [!TIP]
 > **New**: Inject Dependencies in FastAPI with zero runtime overhead using [Class-Based Handlers](https://maldoinc.github.io/wireup/latest/integrations/fastapi/class_based_handlers/).
@@ -301,26 +303,6 @@ def command(service: Injected[UserService]): ...
 def task(service: Injected[UserService]): ...
 ```
 
-```mermaid
-graph LR
-    subgraph "Core Business Logic"
-        Services[Injectables & Services]
-        Domain[Domain Models]
-    end
-
-    subgraph "Entry Points"
-        API[FastAPI / Web]
-        CLI[Click / CLI]
-        Worker[Celery / Worker]
-    end
-
-    API -->|Uses| Services
-    CLI -->|Uses| Services
-    Worker -->|Uses| Services
-
-    Services --> Domain
-```
-
 ### 🔌 Native Integration with popular frameworks
 
 Integrate with popular frameworks for a smoother developer experience.

{wireup-2.4.0 → wireup-2.6.0}/test/integration/flask/test_flask_integration.py

@@ -1,9 +1,11 @@
+from typing import Iterator, NewType
 from unittest.mock import MagicMock
 
 import pytest
 import wireup.integration.flask
 from flask import Flask
 from flask.testing import FlaskClient
+from wireup._annotations import Injected, injectable
 from wireup.integration.flask import get_app_container
 
 from test.integration.flask import services as flask_integration_services
@@ -73,3 +75,34 @@ def test_service_override(client: FlaskClient, app: Flask):
         res = client.get("/foo")
         assert res.status_code == 200
         assert res.json == {"test": "mocked"}
+
+
+def test_flask_err_cleanup() -> None:
+    Something = NewType("Something", str)
+    dep = {"created": False, "cleanup": False}
+
+    @injectable(lifetime="scoped")
+    def make_with_cleanup() -> Iterator[Something]:
+        dep["created"] = True
+        try:
+            yield Something("hello")
+        finally:
+            dep["cleanup"] = True
+
+    app = Flask(__name__)
+    app.config["PROPAGATE_EXCEPTIONS"] = True
+
+    @app.get("/err")
+    def _err_endpoint(with_cleanup: Injected[Something]) -> str:
+        assert with_cleanup == "hello"
+        raise Exception("err in endpoint")
+
+    container = wireup.create_sync_container(injectables=[make_with_cleanup])
+    wireup.integration.flask.setup(container, app)
+
+    client = app.test_client()
+    with pytest.raises(Exception):  # noqa: B017
+        client.get("/err")
+
+    assert dep["created"] is True
+    assert dep["cleanup"] is True

{wireup-2.4.0 → wireup-2.6.0}/test/unit/test_as_type.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import sys
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from typing import Optional, Protocol
 
 import pytest
@@ -171,3 +173,78 @@ def test_as_type_on_optional_factory_new_union_optional():
     instance = container.get(OptionalProto | None)
     assert isinstance(instance, OptionalImpl)
     assert instance.opt() == "opt"
+
+
+class AbstractFoo(ABC):
+    @abstractmethod
+    def bar(self) -> str: ...
+
+
+@injectable(as_type=AbstractFoo)
+class AbstractFooImpl(AbstractFoo):
+    def bar(self) -> str:
+        return "bar"
+
+
+def test_register_with_as_type_abc():
+    container = create_sync_container(injectables=[AbstractFooImpl])
+
+    # Should be resolvable via the abstraction
+    instance = container.get(AbstractFoo)
+    assert isinstance(instance, AbstractFooImpl)
+    assert instance.bar() == "bar"
+
+    # Should NOT be resolvable via the implementation class directly
+    with pytest.raises(UnknownServiceRequestedError):
+        container.get(AbstractFooImpl)
+
+
+class FunctionProto(Protocol):
+    def call(self) -> int: ...
+
+
+class RealService:
+    def call(self) -> int:
+        return 42
+
+
+def test_as_type_on_simple_function():
+    @injectable(as_type=FunctionProto)
+    def factory() -> RealService:
+        return RealService()
+
+    container = create_sync_container(injectables=[factory])
+
+    svc = container.get(FunctionProto)
+    assert svc.call() == 42
+    assert isinstance(svc, RealService)
+
+
+class DependencyProto(Protocol):
+    def do_something(self) -> str: ...
+
+
+class DependencyImpl:
+    def do_something(self) -> str:
+        return "dependency_impl"
+
+
+@injectable
+@dataclass
+class ServiceWithDependency:
+    dependency: DependencyProto
+
+
+def test_as_type_factory_dependency_injection():
+    # Test that a dependency produced by a factory with as_type
+    # is correctly injected into another service.
+
+    @injectable(as_type=DependencyProto)
+    def make_dependency() -> DependencyImpl:
+        return DependencyImpl()
+
+    container = create_sync_container(injectables=[make_dependency, ServiceWithDependency])
+
+    service = container.get(ServiceWithDependency)
+    assert isinstance(service.dependency, DependencyImpl)
+    assert service.dependency.do_something() == "dependency_impl"

wireup-2.6.0/test/unit/test_concurrency.py

@@ -0,0 +1,85 @@
+import asyncio
+
+import pytest
+from wireup import create_async_container, injectable
+
+
+class Counter:
+    pass
+
+
+class ScopedCounter:
+    pass
+
+
+@injectable
+async def counter_factory() -> Counter:
+    await asyncio.sleep(0.01)
+    return Counter()
+
+
+@injectable(lifetime="scoped")
+async def scoped_counter_factory() -> ScopedCounter:
+    await asyncio.sleep(0.01)
+    return ScopedCounter()
+
+
+async def test_singleton_concurrency() -> None:
+    container = create_async_container(services=[counter_factory])
+
+    results = await asyncio.gather(
+        container.get(Counter),
+        container.get(Counter),
+        container.get(Counter),
+        container.get(Counter),
+        container.get(Counter),
+    )
+
+    unique_instances = set(results)
+    assert len(unique_instances) == 1, f"Expected 1 singleton instance, got {len(unique_instances)}"
+
+
+async def test_scoped_concurrency_same_scope() -> None:
+    container = create_async_container(services=[scoped_counter_factory])
+
+    async with container.enter_scope() as scope:
+        results = await asyncio.gather(
+            scope.get(ScopedCounter),
+            scope.get(ScopedCounter),
+            scope.get(ScopedCounter),
+            scope.get(ScopedCounter),
+            scope.get(ScopedCounter),
+        )
+
+        unique_instances = set(results)
+        assert len(unique_instances) == 1, f"Expected 1 scoped instance within same scope, got {len(unique_instances)}"
+
+
+async def test_scoped_concurrency_different_scopes() -> None:
+    container = create_async_container(services=[scoped_counter_factory])
+
+    async with container.enter_scope() as scope1:
+        async with container.enter_scope() as scope2:
+            res1, res2 = await asyncio.gather(scope1.get(ScopedCounter), scope2.get(ScopedCounter))
+
+            assert res1 is not res2, "Different scopes should produce different instances"
+
+
+async def test_singleton_concurrency_cross_scope() -> None:
+    container = create_async_container(services=[counter_factory])
+
+    async with container.enter_scope() as scope1, container.enter_scope() as scope2:
+        # Concurrently request the SINGLETON from two different scopes
+        results = await asyncio.gather(
+            scope1.get(Counter),
+            scope1.get(Counter),
+            scope1.get(Counter),
+            scope2.get(Counter),
+            scope2.get(Counter),
+            scope2.get(Counter),
+            scope2.get(Counter),
+            container.get(Counter),
+        )
+
+        unique_instances = set(results)
+        assert len(unique_instances) == 1, f"Expected 1 singleton instance, got {len(unique_instances)}"

{wireup-2.4.0 → wireup-2.6.0}/test/unit/test_container_override.py

@@ -92,3 +92,26 @@ async def test_overrides_async_dependency() -> None:
 
     res = await container.get(FooBar)
     assert res.foo == "bar"
+
+
+async def test_override_async_transitive_dependency_with_sync_instance():
+    class FooDep:
+        pass
+
+    @wireup.injectable
+    async def async_foo_dep() -> FooDep:
+        return FooDep()
+
+    @wireup.injectable
+    class BarDep:
+        def __init__(self, foo: FooDep):
+            self.foo = foo
+
+    class FooOverride:
+        pass
+
+    container = wireup.create_async_container(injectables=[async_foo_dep, BarDep])
+
+    with container.override.injectable(FooDep, FooOverride()):
+        bar = await container.get(BarDep)
+        assert isinstance(bar.foo, FooOverride)

wireup-2.6.0/test/unit/test_container_override_extended.py

@@ -0,0 +1,118 @@
+from typing import Protocol
+from unittest.mock import MagicMock
+
+from wireup import abstract, create_async_container, create_sync_container, injectable
+
+
+@abstract
+class AbstractBase:
+    pass
+
+
+@injectable
+class ConcreteImpl(AbstractBase):
+    pass
+
+
+@injectable(lifetime="transient")
+class ServiceDependsOnAbstract:
+    def __init__(self, dep: AbstractBase):
+        self.dep = dep
+
+
+class Proto(Protocol):
+    def method(self): ...
+
+
+@injectable(as_type=Proto)
+class ProtoImpl:
+    def method(self):
+        return "impl"
+
+
+@injectable(lifetime="transient")
+class ServiceDependsOnProto:
+    def __init__(self, dep: Proto):
+        self.dep = dep
+
+
+def test_override_abstract_direct():
+    container = create_sync_container(injectables=[AbstractBase, ConcreteImpl])
+
+    mock_obj = MagicMock(spec=AbstractBase)
+
+    with container.override.injectable(target=AbstractBase, new=mock_obj):
+        assert container.get(AbstractBase) is mock_obj
+
+    assert isinstance(container.get(AbstractBase), ConcreteImpl)
+
+
+def test_override_abstract_indirect():
+    container = create_sync_container(injectables=[AbstractBase, ConcreteImpl, ServiceDependsOnAbstract])
+
+    mock_obj = MagicMock(spec=AbstractBase)
+
+    with container.override.injectable(target=AbstractBase, new=mock_obj):
+        with container.enter_scope() as scope:
+            svc = scope.get(ServiceDependsOnAbstract)
+            assert svc.dep is mock_obj
+
+    with container.enter_scope() as scope:
+        svc = scope.get(ServiceDependsOnAbstract)
+        assert isinstance(svc.dep, ConcreteImpl)
+
+
+async def test_override_abstract_indirect_async():
+    container = create_async_container(injectables=[AbstractBase, ConcreteImpl, ServiceDependsOnAbstract])
+
+    mock_obj = MagicMock(spec=AbstractBase)
+
+    with container.override.injectable(target=AbstractBase, new=mock_obj):
+        async with container.enter_scope() as scope:
+            svc = await scope.get(ServiceDependsOnAbstract)
+            assert svc.dep is mock_obj
+
+    async with container.enter_scope() as scope:
+        svc = await scope.get(ServiceDependsOnAbstract)
+        assert isinstance(svc.dep, ConcreteImpl)
+
+
+def test_override_as_type_direct():
+    container = create_sync_container(injectables=[ProtoImpl])
+
+    mock_obj = MagicMock(spec=Proto)
+
+    with container.override.injectable(target=Proto, new=mock_obj):
+        assert container.get(Proto) is mock_obj
+
+    assert isinstance(container.get(Proto), ProtoImpl)
+
+
+def test_override_as_type_indirect():
+    container = create_sync_container(injectables=[ProtoImpl, ServiceDependsOnProto])
+
+    mock_obj = MagicMock(spec=Proto)
+
+    with container.override.injectable(target=Proto, new=mock_obj):
+        with container.enter_scope() as scope:
+            svc = scope.get(ServiceDependsOnProto)
+            assert svc.dep is mock_obj
+
+    with container.enter_scope() as scope:
+        svc = scope.get(ServiceDependsOnProto)
+        assert isinstance(svc.dep, ProtoImpl)
+
+
+async def test_override_as_type_indirect_async():
+    container = create_async_container(injectables=[ProtoImpl, ServiceDependsOnProto])
+
+    mock_obj = MagicMock(spec=Proto)
+
+    with container.override.injectable(target=Proto, new=mock_obj):
+        async with container.enter_scope() as scope:
+            svc = await scope.get(ServiceDependsOnProto)
+            assert svc.dep is mock_obj
+
+    async with container.enter_scope() as scope:
+        svc = await scope.get(ServiceDependsOnProto)
+        assert isinstance(svc.dep, ProtoImpl)