anydi 0.55.0__tar.gz → 0.56.0__tar.gz

anydi-0.56.0/PKG-INFO

@@ -0,0 +1,267 @@
+Metadata-Version: 2.4
+Name: anydi
+Version: 0.56.0
+Summary: Dependency Injection library
+Keywords: dependency injection,dependencies,di,async,asyncio,application
+Author: Anton Ruhlov
+Author-email: Anton Ruhlov <antonruhlov@gmail.com>
+License-Expression: MIT
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Dist: typing-extensions>=4.15.0,<5
+Requires-Dist: anyio>=3.7.1
+Requires-Dist: wrapt>=1.17.0
+Requires-Python: >=3.10.0, <3.15
+Project-URL: Repository, https://github.com/antonrh/anydi
+Description-Content-Type: text/markdown
+
+# AnyDI
+
+<div style="text-align: center;">
+
+Modern, lightweight Dependency Injection library using type annotations.
+
+[![CI](https://github.com/antonrh/anydi/actions/workflows/ci.yml/badge.svg)](https://github.com/antonrh/anydi/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/antonrh/anydi/branch/main/graph/badge.svg)](https://codecov.io/gh/antonrh/anydi)
+[![Documentation](https://readthedocs.org/projects/anydi/badge/?version=latest)](https://anydi.readthedocs.io/en/latest/)
+
+</div>
+
+---
+Documentation
+
+http://anydi.readthedocs.io/
+
+---
+
+`AnyDI` is a modern, lightweight Dependency Injection library suitable for any synchronous or asynchronous applications with Python 3.10+, based on type annotations ([PEP 484](https://peps.python.org/pep-0484/)).
+
+The key features are:
+
+* **Type-safe**: Dependency resolution is driven by type hints.
+* **Async-ready**: Works the same for sync and async providers or injections.
+* **Scoped**: Built-in singleton, transient, and request lifetimes.
+* **Simple**: Small surface area keeps boilerplate low.
+* **Fast**: Resolver still adds only microseconds of overhead.
+* **Named**: `Annotated[...]` makes multiple bindings per type simple.
+* **Managed**: Providers can open/close resources via context managers.
+* **Modular**: Compose containers or modules for large apps.
+* **Scanning**: Auto-discovers injectable callables.
+* **Integrated**: Extensions for popular frameworks.
+* **Testable**: Override providers directly in tests.
+
+## Installation
+
+```shell
+pip install anydi
+```
+
+## Comprehensive Example
+
+### Define a Service (`app/services.py`)
+
+```python
+class GreetingService:
+    def greet(self, name: str) -> str:
+        return f"Hello, {name}!"
+```
+
+### Create the Container and Providers (`app/container.py`)
+
+```python
+from anydi import Container
+
+from app.services import GreetingService
+
+
+container = Container()
+
+
+@container.provider(scope="singleton")
+def service() -> GreetingService:
+    return GreetingService()
+```
+
+### Resolve Dependencies Directly
+
+```python
+from app.container import container
+from app.services import GreetingService
+
+
+service = container.resolve(GreetingService)
+
+if __name__ == "__main__":
+    print(service.greet("World"))
+```
+
+### Inject Into Functions (`app/main.py`)
+
+```python
+from anydi import Inject
+
+from app.container import container
+from app.services import GreetingService
+
+
+@container.inject
+def greet(service: GreetingService = Inject()) -> str:
+    return service.greet("World")
+
+
+if __name__ == "__main__":
+    print(greet())
+```
+
+### Test with Overrides (`tests/test_app.py`)
+
+```python
+from unittest import mock
+
+from app.container import container
+from app.services import GreetingService
+from app.main import greet
+
+
+def test_greet() -> None:
+    service_mock = mock.Mock(spec=GreetingService)
+    service_mock.greet.return_value = "Mocked"
+
+    with container.override(GreetingService, service_mock):
+        result = greet()
+
+    assert result == "Mocked"
+```
+
+### Integrate with FastAPI (`app/api.py`)
+
+```python
+from typing import Annotated
+
+import anydi.ext.fastapi
+from fastapi import FastAPI
+from anydi.ext.fastapi import Inject
+
+from app.container import container
+from app.services import GreetingService
+
+
+app = FastAPI()
+
+
+@app.get("/greeting")
+async def greet(
+    service: Annotated[GreetingService, Inject()]
+) -> dict[str, str]:
+    return {"greeting": service.greet("World")}
+
+
+anydi.ext.fastapi.install(app, container)
+```
+
+### Test the FastAPI Integration (`test_api.py`)
+
+```python
+from unittest import mock
+
+from fastapi.testclient import TestClient
+
+from app.api import app
+from app.container import container
+from app.services import GreetingService
+
+
+client = TestClient(app)
+
+
+def test_api_greeting() -> None:
+    service_mock = mock.Mock(spec=GreetingService)
+    service_mock.greet.return_value = "Mocked"
+
+    with container.override(GreetingService, service_mock):
+        response = client.get("/greeting")
+
+    assert response.json() == {"greeting": "Mocked"}
+```
+
+### Integrate with Django Ninja
+
+Install the Django integration extras:
+
+```sh
+pip install 'anydi-django[ninja]'
+```
+
+Expose the container factory (`app/container.py`):
+
+```python
+from anydi import Container
+
+from app.services import GreetingService
+
+
+container = Container()
+
+
+@container.provider(scope="singleton")
+def service() -> GreetingService:
+    return GreetingService()
+```
+
+Configure Django (`settings.py`):
+
+```python
+INSTALLED_APPS = [
+    ...
+    "anydi_django",
+]
+
+ANYDI = {
+    "CONTAINER_FACTORY": "app.container.container",
+    "PATCH_NINJA": True,
+}
+```
+
+Wire Django Ninja (`urls.py`):
+
+```python
+from typing import Annotated, Any
+
+from anydi import Inject
+from django.http import HttpRequest
+from django.urls import path
+from ninja import NinjaAPI
+
+from app.services import GreetingService
+
+
+api = NinjaAPI()
+
+
+@api.get("/greeting")
+def greet(request: HttpRequest, service: Annotated[GreetingService, Inject()]) -> Any:
+    return {"greeting": service.greet("World")}
+
+
+urlpatterns = [
+    path("api/", api.urls),
+]
+```

anydi-0.56.0/README.md

@@ -0,0 +1,232 @@
+# AnyDI
+
+<div style="text-align: center;">
+
+Modern, lightweight Dependency Injection library using type annotations.
+
+[![CI](https://github.com/antonrh/anydi/actions/workflows/ci.yml/badge.svg)](https://github.com/antonrh/anydi/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/antonrh/anydi/branch/main/graph/badge.svg)](https://codecov.io/gh/antonrh/anydi)
+[![Documentation](https://readthedocs.org/projects/anydi/badge/?version=latest)](https://anydi.readthedocs.io/en/latest/)
+
+</div>
+
+---
+Documentation
+
+http://anydi.readthedocs.io/
+
+---
+
+`AnyDI` is a modern, lightweight Dependency Injection library suitable for any synchronous or asynchronous applications with Python 3.10+, based on type annotations ([PEP 484](https://peps.python.org/pep-0484/)).
+
+The key features are:
+
+* **Type-safe**: Dependency resolution is driven by type hints.
+* **Async-ready**: Works the same for sync and async providers or injections.
+* **Scoped**: Built-in singleton, transient, and request lifetimes.
+* **Simple**: Small surface area keeps boilerplate low.
+* **Fast**: Resolver still adds only microseconds of overhead.
+* **Named**: `Annotated[...]` makes multiple bindings per type simple.
+* **Managed**: Providers can open/close resources via context managers.
+* **Modular**: Compose containers or modules for large apps.
+* **Scanning**: Auto-discovers injectable callables.
+* **Integrated**: Extensions for popular frameworks.
+* **Testable**: Override providers directly in tests.
+
+## Installation
+
+```shell
+pip install anydi
+```
+
+## Comprehensive Example
+
+### Define a Service (`app/services.py`)
+
+```python
+class GreetingService:
+    def greet(self, name: str) -> str:
+        return f"Hello, {name}!"
+```
+
+### Create the Container and Providers (`app/container.py`)
+
+```python
+from anydi import Container
+
+from app.services import GreetingService
+
+
+container = Container()
+
+
+@container.provider(scope="singleton")
+def service() -> GreetingService:
+    return GreetingService()
+```
+
+### Resolve Dependencies Directly
+
+```python
+from app.container import container
+from app.services import GreetingService
+
+
+service = container.resolve(GreetingService)
+
+if __name__ == "__main__":
+    print(service.greet("World"))
+```
+
+### Inject Into Functions (`app/main.py`)
+
+```python
+from anydi import Inject
+
+from app.container import container
+from app.services import GreetingService
+
+
+@container.inject
+def greet(service: GreetingService = Inject()) -> str:
+    return service.greet("World")
+
+
+if __name__ == "__main__":
+    print(greet())
+```
+
+### Test with Overrides (`tests/test_app.py`)
+
+```python
+from unittest import mock
+
+from app.container import container
+from app.services import GreetingService
+from app.main import greet
+
+
+def test_greet() -> None:
+    service_mock = mock.Mock(spec=GreetingService)
+    service_mock.greet.return_value = "Mocked"
+
+    with container.override(GreetingService, service_mock):
+        result = greet()
+
+    assert result == "Mocked"
+```
+
+### Integrate with FastAPI (`app/api.py`)
+
+```python
+from typing import Annotated
+
+import anydi.ext.fastapi
+from fastapi import FastAPI
+from anydi.ext.fastapi import Inject
+
+from app.container import container
+from app.services import GreetingService
+
+
+app = FastAPI()
+
+
+@app.get("/greeting")
+async def greet(
+    service: Annotated[GreetingService, Inject()]
+) -> dict[str, str]:
+    return {"greeting": service.greet("World")}
+
+
+anydi.ext.fastapi.install(app, container)
+```
+
+### Test the FastAPI Integration (`test_api.py`)
+
+```python
+from unittest import mock
+
+from fastapi.testclient import TestClient
+
+from app.api import app
+from app.container import container
+from app.services import GreetingService
+
+
+client = TestClient(app)
+
+
+def test_api_greeting() -> None:
+    service_mock = mock.Mock(spec=GreetingService)
+    service_mock.greet.return_value = "Mocked"
+
+    with container.override(GreetingService, service_mock):
+        response = client.get("/greeting")
+
+    assert response.json() == {"greeting": "Mocked"}
+```
+
+### Integrate with Django Ninja
+
+Install the Django integration extras:
+
+```sh
+pip install 'anydi-django[ninja]'
+```
+
+Expose the container factory (`app/container.py`):
+
+```python
+from anydi import Container
+
+from app.services import GreetingService
+
+
+container = Container()
+
+
+@container.provider(scope="singleton")
+def service() -> GreetingService:
+    return GreetingService()
+```
+
+Configure Django (`settings.py`):
+
+```python
+INSTALLED_APPS = [
+    ...
+    "anydi_django",
+]
+
+ANYDI = {
+    "CONTAINER_FACTORY": "app.container.container",
+    "PATCH_NINJA": True,
+}
+```
+
+Wire Django Ninja (`urls.py`):
+
+```python
+from typing import Annotated, Any
+
+from anydi import Inject
+from django.http import HttpRequest
+from django.urls import path
+from ninja import NinjaAPI
+
+from app.services import GreetingService
+
+
+api = NinjaAPI()
+
+
+@api.get("/greeting")
+def greet(request: HttpRequest, service: Annotated[GreetingService, Inject()]) -> Any:
+    return {"greeting": service.greet("World")}
+
+
+urlpatterns = [
+    path("api/", api.urls),
+]
+```

{anydi-0.55.0 → anydi-0.56.0}/anydi/_container.py

@@ -339,6 +339,7 @@ class Container:
                     default=default,
                     has_default=has_default,
                     provider=sub_provider,
+                    shared_scope=sub_provider.scope == scope and scope != "transient",
                 )
             )
 
@@ -389,10 +390,10 @@ class Container:
     @staticmethod
     def _validate_provider_scope(scope: Scope, name: str, is_resource: bool) -> None:
         """Validate the provider scope."""
-        if scope not in (allowed_scopes := get_args(Scope)):
+        if scope not in ALLOWED_SCOPES:
             raise ValueError(
                 f"The provider `{name}` scope is invalid. Only the following "
-                f"scopes are supported: {', '.join(allowed_scopes)}. "
+                f"scopes are supported: {', '.join(ALLOWED_SCOPES)}. "
                 "Please use one of the supported scopes when registering a provider."
             )
         if scope == "transient" and is_resource:
@@ -670,13 +671,17 @@ class Container:
     ) -> None:
         self._scanner.scan(packages=packages, tags=tags)
 
-    # == Testing ==
+    # == Testing / Override Support ==
 
     @contextlib.contextmanager
     def override(self, interface: Any, instance: Any) -> Iterator[None]:
-        raise RuntimeError(
-            "Dependency overriding is not supported in this container.\n"
-            "Wrap your container with `anydi.testing.Container` instead.\n"
-            "Example:\n\n"
-            "    container = TestContainer.from_container(container)"
-        )
+        """Override a dependency with a specific instance for testing."""
+        if not self.has_provider_for(interface):
+            raise LookupError(
+                f"The provider interface `{type_repr(interface)}` not registered."
+            )
+        self._resolver.add_override(interface, instance)
+        try:
+            yield
+        finally:
+            self._resolver.remove_override(interface)

{anydi-0.55.0 → anydi-0.56.0}/anydi/_provider.py

@@ -40,6 +40,7 @@ class ProviderParameter:
     default: Any
     has_default: bool
     provider: Provider | None = None
+    shared_scope: bool = False
 
 
 @dataclass(frozen=True, slots=True)