anydi 0.42.0__tar.gz → 0.43.0__tar.gz

{anydi-0.42.0 → anydi-0.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.42.0
+Version: 0.43.0
 Summary: Dependency Injection library
 Project-URL: Repository, https://github.com/antonrh/anydi
 Author-email: Anton Ruhlov <antonruhlov@gmail.com>

{anydi-0.42.0 → anydi-0.43.0}/anydi/_container.py

@@ -11,12 +11,13 @@ import uuid
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterable, Iterator
 from contextvars import ContextVar
-from typing import Annotated, Any, Callable, TypeVar, cast, overload
+from typing import Any, Callable, TypeVar, cast, overload
 
 from typing_extensions import ParamSpec, Self, get_args, get_origin
 
 from ._async import run_sync
 from ._context import InstanceContext
+from ._decorators import is_provided
 from ._module import ModuleDef, ModuleRegistrar
 from ._provider import (
     Provider,
@@ -441,17 +442,13 @@ class Container:
         except LookupError:
             if self.strict or interface is inspect.Parameter.empty:
                 raise
-            if get_origin(interface) is Annotated and (args := get_args(interface)):
-                call = args[0]
-            else:
-                call = interface
-            if inspect.isclass(call) and not is_builtin_type(call):
+            if inspect.isclass(interface) and not is_builtin_type(interface):
                 # Try to get defined scope
-                if hasattr(call, "__scope__"):
-                    scope = getattr(call, "__scope__")
+                if is_provided(interface):
+                    scope = interface.__provided__["scope"]
                 else:
                     scope = parent_scope
-                return self._register_provider(call, scope, interface, **defaults)
+                return self._register_provider(interface, scope, interface, **defaults)
             raise
 
     def _set_provider(self, provider: Provider) -> None:
@@ -793,8 +790,8 @@ class Container:
             return cast(Callable[P, T], self._inject_cache[call])
 
         injected_params = self._get_injected_params(call)
-
         if not injected_params:
+            self._inject_cache[call] = call
             return call
 
         if inspect.iscoroutinefunction(call):

{anydi-0.42.0 → anydi-0.43.0}/anydi/_decorators.py

@@ -1,22 +1,41 @@
 from collections.abc import Iterable
-from typing import Callable, Concatenate, ParamSpec, TypedDict, TypeVar, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Concatenate,
+    ParamSpec,
+    Protocol,
+    TypedDict,
+    TypeGuard,
+    TypeVar,
+    overload,
+)
+
+if TYPE_CHECKING:
+    from ._module import Module
+
 
-from ._module import Module
 from ._scope import Scope
 
 T = TypeVar("T")
 P = ParamSpec("P")
 
 ClassT = TypeVar("ClassT", bound=type)
-ModuleT = TypeVar("ModuleT", bound=Module)
+ModuleT = TypeVar("ModuleT", bound="Module")
+
+
+class ProvidedMetadata(TypedDict):
+    """Metadata for classes marked as provided by AnyDI."""
+
+    scope: Scope
 
 
 def provided(*, scope: Scope) -> Callable[[ClassT], ClassT]:
     """Decorator for marking a class as provided by AnyDI with a specific scope."""
 
     def decorator(cls: ClassT) -> ClassT:
-        cls.__provided__ = True
-        cls.__scope__ = scope
+        cls.__provided__ = ProvidedMetadata(scope=scope)
         return cls
 
     return decorator
@@ -28,6 +47,14 @@ request = provided(scope="request")
 singleton = provided(scope="singleton")
 
 
+class Provided(Protocol):
+    __provided__: ProvidedMetadata
+
+
+def is_provided(cls: Any) -> TypeGuard[type[Provided]]:
+    return hasattr(cls, "__provided__")
+
+
 class ProviderMetadata(TypedDict):
     scope: Scope
     override: bool
@@ -49,8 +76,15 @@ def provider(
     return decorator
 
 
+class Provider(Protocol):
+    __provider__: ProviderMetadata
+
+
+def is_provider(obj: Callable[..., Any]) -> TypeGuard[Provider]:
+    return hasattr(obj, "__provider__")
+
+
 class InjectableMetadata(TypedDict):
-    wrapped: bool
     tags: Iterable[str] | None
 
 
@@ -71,10 +105,18 @@ def injectable(
     """Decorator for marking a function or method as requiring dependency injection."""
 
     def decorator(inner: Callable[P, T]) -> Callable[P, T]:
-        inner.__injectable__ = InjectableMetadata(wrapped=True, tags=tags)  # type: ignore
+        inner.__injectable__ = InjectableMetadata(tags=tags)  # type: ignore
         return inner
 
     if func is None:
         return decorator
 
     return decorator(func)
+
+
+class Injectable(Protocol):
+    __injectable__: InjectableMetadata
+
+
+def is_injectable(obj: Callable[..., Any]) -> TypeGuard[Injectable]:
+    return hasattr(obj, "__injectable__")

{anydi-0.42.0 → anydi-0.43.0}/anydi/_module.py

@@ -4,9 +4,10 @@ import importlib
 import inspect
 from typing import TYPE_CHECKING, Any, Callable
 
+from ._decorators import ProviderMetadata, is_provider
+
 if TYPE_CHECKING:
     from ._container import Container
-    from ._decorators import ProviderMetadata
 
 
 class ModuleMeta(type):
@@ -14,9 +15,9 @@ class ModuleMeta(type):
 
     def __new__(cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> Any:
         attrs["providers"] = [
-            (name, getattr(value, "__provider__"))
+            (name, value.__provider__)
             for name, value in attrs.items()
-            if hasattr(value, "__provider__")
+            if is_provider(value)
         ]
         return super().__new__(cls, name, bases, attrs)
 

{anydi-0.42.0 → anydi-0.43.0}/anydi/_scan.py

@@ -6,9 +6,9 @@ import pkgutil
 from collections.abc import Iterable
 from dataclasses import dataclass
 from types import ModuleType
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any, Callable, Union
 
-from ._decorators import InjectableMetadata
+from ._decorators import is_injectable
 from ._typing import get_typed_parameters, is_marker
 
 if TYPE_CHECKING:
@@ -73,9 +73,8 @@ class Scanner:
 
         return dependencies
 
-    @staticmethod
     def _scan_module(
-        module: ModuleType, *, tags: Iterable[str]
+        self, module: ModuleType, *, tags: Iterable[str]
     ) -> list[ScannedDependency]:
         """Scan a module for decorated members."""
         dependencies: list[ScannedDependency] = []
@@ -84,27 +83,28 @@ class Scanner:
             if getattr(member, "__module__", None) != module.__name__:
                 continue
 
-            metadata: InjectableMetadata = getattr(
-                member,
-                "__injectable__",
-                InjectableMetadata(wrapped=False, tags=[]),
-            )
-
-            should_include = False
-            if metadata["wrapped"]:
-                should_include = True
-            elif tags and metadata["tags"]:
-                should_include = bool(set(metadata["tags"]) & set(tags))
-            elif tags and not metadata["tags"]:
-                continue  # tags are provided but member has none
-
-            if not should_include:
-                for param in get_typed_parameters(member):
-                    if is_marker(param.default):
-                        should_include = True
-                        break
-
-            if should_include:
+            if self._should_include_member(member, tags=tags):
                 dependencies.append(ScannedDependency(member=member, module=module))
 
         return dependencies
+
+    @staticmethod
+    def _should_include_member(
+        member: Callable[..., Any], *, tags: Iterable[str]
+    ) -> bool:
+        """Determine if a member should be included based on tags or marker defaults."""
+
+        if is_injectable(member):
+            member_tags = set(member.__injectable__["tags"] or [])
+            if tags:
+                return bool(set(tags) & member_tags)
+            return True  # No tags passed → include all injectables
+
+        # If no tags are passed and not explicitly injectable,
+        # check for parameter markers
+        if not tags:
+            for param in get_typed_parameters(member):
+                if is_marker(param.default):
+                    return True
+
+        return False

{anydi-0.42.0 → anydi-0.43.0}/anydi/ext/django/_utils.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from functools import wraps
 from typing import Annotated, Any
 
 from django.conf import settings
@@ -9,7 +8,6 @@ from django.core.cache import BaseCache, caches
 from django.db import connections
 from django.db.backends.base.base import BaseDatabaseWrapper
 from django.urls import URLPattern, URLResolver, get_resolver
-from typing_extensions import get_origin
 
 from anydi import Container
 
@@ -29,14 +27,11 @@ def register_settings(
             continue
 
         container.register(
-            Annotated[Any, f"{prefix}{setting_name}"],
+            Annotated[type(setting_value), f"{prefix}{setting_name}"],
             _get_setting_value(setting_value),
             scope="singleton",
         )
 
-    # Patch AnyDI to resolve Any types for annotated settings
-    _patch_any_typed_annotated(container, prefix=prefix)
-
 
 def register_components(container: Container) -> None:
     """Register Django components into the container."""
@@ -91,38 +86,3 @@ def iter_urlpatterns(
 
 def _get_setting_value(value: Any) -> Any:
     return lambda: value
-
-
-def _any_typed_interface(interface: Any, prefix: str) -> Any:
-    origin = get_origin(interface)
-    if origin is not Annotated:
-        return interface  # pragma: no cover
-    named = interface.__metadata__[-1]
-
-    if isinstance(named, str) and named.startswith(prefix):
-        _, setting_name = named.rsplit(prefix, maxsplit=1)
-        return Annotated[Any, f"{prefix}{setting_name}"]
-    return interface
-
-
-def _patch_any_typed_annotated(container: Container, *, prefix: str) -> None:
-    def _patch_resolve(resolve: Any) -> Any:
-        @wraps(resolve)
-        def wrapper(interface: Any) -> Any:
-            return resolve(_any_typed_interface(interface, prefix))
-
-        return wrapper
-
-    def _patch_aresolve(resolve: Any) -> Any:
-        @wraps(resolve)
-        async def wrapper(interface: Any) -> Any:
-            return await resolve(_any_typed_interface(interface, prefix))
-
-        return wrapper
-
-    container.resolve = _patch_resolve(  # type: ignore
-        container.resolve
-    )
-    container.aresolve = _patch_aresolve(  # type: ignore
-        container.aresolve
-    )

{anydi-0.42.0 → anydi-0.43.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.42.0"
+version = "0.43.0"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = "~=3.9"
@@ -65,6 +65,7 @@ dev = [
     "pydantic-settings>=2.4.0,<3",
     "bump-my-version>=1.1.4",
     "pyright>=1.1.401",
+    "pytest-mock>=3.14.1",
 ]
 docs = [
     "mkdocs>=1.4.2,<2",
@@ -136,7 +137,7 @@ omit = [
 ]
 
 [tool.bumpversion]
-current_version = "0.42.0"
+current_version = "0.43.0"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

{anydi-0.42.0 → anydi-0.43.0}/tests/test_container.py

@@ -10,7 +10,7 @@ from typing import Annotated, Any, Callable, Union
 import pytest
 from typing_extensions import Self
 
-from anydi import Container, Provider, Scope, auto
+from anydi import Container, Provider, Scope, auto, request, singleton, transient
 from anydi._provider import ProviderKind
 from anydi._typing import Event
 
@@ -979,8 +979,9 @@ class TestContainer:
     def test_resolve_non_strict_provider_scope_defined(
         self, container: Container
     ) -> None:
+        @singleton
         class Service:
-            __scope__ = "singleton"
+            pass
 
         _ = container.resolve(Service)
 
@@ -990,17 +991,6 @@ class TestContainer:
         assert provider.scope == "singleton"
         assert provider.interface == Service
 
-    def test_resolve_non_strict_annotated(self, container: Container) -> None:
-        class Service:
-            pass
-
-        service_1 = container.resolve(Annotated[Service, "service_1"])
-        service_2 = container.resolve(Annotated[Service, "service_2"])
-
-        assert service_1 != service_2
-        assert container.is_registered(Annotated[Service, "service_1"])
-        assert container.is_registered(Annotated[Service, "service_2"])
-
     def test_resolve_non_strict_provider_scope_from_sub_provider_request(
         self,
         container: Container,
@@ -1039,13 +1029,13 @@ class TestContainer:
     def test_resolve_non_strict_nested_singleton_provider(
         self, container: Container
     ) -> None:
-        @dataclass
+        @singleton
         class Repository:
-            __scope__ = "singleton"
+            pass
 
-        @dataclass
         class Service:
-            repository: Repository
+            def __init__(self, repository: Repository) -> None:
+                self.repository = repository
 
         with container.request_context():
             _ = container.resolve(Service)
@@ -1099,9 +1089,8 @@ class TestContainer:
     def test_resolve_non_strict_with_as_context_manager(
         self, container: Container
     ) -> None:
+        @singleton
         class Resource:
-            __scope__ = "singleton"
-
             def __init__(self) -> None:
                 self.entered = False
                 self.exited = False
@@ -1125,9 +1114,8 @@ class TestContainer:
         self,
         container: Container,
     ) -> None:
+        @singleton
         class Service:
-            __scope__ = "singleton"
-
             def __init__(self) -> None:
                 self.entered = False
                 self.exited = False
@@ -1326,11 +1314,10 @@ class TestContainer:
         assert kwargs == {"a": 10, "b": 1.0, "c": "test"}
 
     def test_create_transient_non_strict(self) -> None:
-        @dataclass
+        @transient
         class Component:
-            __scope__ = "transient"
-
-            name: str
+            def __init__(self, name: str) -> None:
+                self.name = name
 
         container = Container(strict=False)
 
@@ -1339,11 +1326,10 @@ class TestContainer:
         assert instance.name == "test"
 
     def test_create_singleton_non_strict(self) -> None:
-        @dataclass
+        @singleton
         class Component:
-            __scope__ = "singleton"
-
-            name: str
+            def __init__(self, name: str) -> None:
+                self.name = name
 
         container = Container(strict=False)
 
@@ -1352,11 +1338,10 @@ class TestContainer:
         assert instance.name == "test"
 
     def test_create_scoped_non_strict(self) -> None:
-        @dataclass
+        @request
         class Component:
-            __scope__ = "request"
-
-            name: str
+            def __init__(self, name: str) -> None:
+                self.name = name
 
         container = Container(strict=False)
 
@@ -1366,8 +1351,9 @@ class TestContainer:
         assert instance.name == "test"
 
     def test_create_non_existing_keyword_arg(self) -> None:
+        @singleton
         class Component:
-            __scope__ = "singleton"
+            pass
 
         container = Container(strict=False)
 
@@ -1375,11 +1361,10 @@ class TestContainer:
             container.create(Component, param="test")
 
     async def test_create_async_transient_non_strict(self) -> None:
-        @dataclass
+        @transient
         class Component:
-            __scope__ = "transient"
-
-            name: str
+            def __init__(self, name: str) -> None:
+                self.name = name
 
         container = Container(strict=False)
 
@@ -1388,11 +1373,10 @@ class TestContainer:
         assert instance.name == "test"
 
     async def test_create_async_singleton_non_strict(self) -> None:
-        @dataclass
+        @singleton
         class Component:
-            __scope__ = "singleton"
-
-            name: str
+            def __init__(self, name: str) -> None:
+                self.name = name
 
         container = Container(strict=False)
 
@@ -1401,11 +1385,10 @@ class TestContainer:
         assert instance.name == "test"
 
     async def test_create_async_scoped_non_strict(self) -> None:
-        @dataclass
+        @request
         class Component:
-            __scope__ = "request"
-
-            name: str
+            def __init__(self, name: str) -> None:
+                self.name = name
 
         container = Container(strict=False)
 
@@ -1415,8 +1398,9 @@ class TestContainer:
         assert instance.name == "test"
 
     async def test_create_async_non_existing_keyword_arg(self) -> None:
+        @singleton
         class Component:
-            __scope__ = "singleton"
+            pass
 
         container = Container(strict=False)
 

{anydi-0.42.0 → anydi-0.43.0}/tests/test_decorators.py

@@ -1,4 +1,5 @@
 from anydi import Module, injectable, provider, request, singleton, transient
+from anydi._decorators import is_injectable, is_provided
 
 from tests.fixtures import Service
 
@@ -18,22 +19,28 @@ def test_provider_decorator() -> None:
 def test_request_decorator() -> None:
     request(Service)
 
-    assert getattr(Service, "__scope__") == "request"
-    assert getattr(Service, "__provided__")
+    assert is_provided(Service)
+    assert Service.__provided__ == {
+        "scope": "request",
+    }
 
 
 def test_transient_decorator() -> None:
     transient(Service)
 
-    assert getattr(Service, "__scope__") == "transient"
-    assert getattr(Service, "__provided__")
+    assert is_provided(Service)
+    assert Service.__provided__ == {
+        "scope": "transient",
+    }
 
 
 def test_singleton_decorator() -> None:
     singleton(Service)
 
-    assert getattr(Service, "__scope__") == "singleton"
-    assert getattr(Service, "__provided__")
+    assert is_provided(Service)
+    assert Service.__provided__ == {
+        "scope": "singleton",
+    }
 
 
 def test_injectable_no_args() -> None:
@@ -41,8 +48,8 @@ def test_injectable_no_args() -> None:
     def my_func() -> None:
         pass
 
-    assert getattr(my_func, "__injectable__") == {
-        "wrapped": True,
+    assert is_injectable(my_func)
+    assert my_func.__injectable__ == {
         "tags": None,
     }
 
@@ -52,7 +59,10 @@ def test_injectable_no_args_provided() -> None:
     def my_func() -> None:
         pass
 
-    assert getattr(my_func, "__injectable__") == {"wrapped": True, "tags": None}
+    assert is_injectable(my_func)
+    assert my_func.__injectable__ == {
+        "tags": None,
+    }
 
 
 def test_injectable_with_tags() -> None:
@@ -60,7 +70,7 @@ def test_injectable_with_tags() -> None:
     def my_func() -> None:
         pass
 
-    assert getattr(my_func, "__injectable__") == {
-        "wrapped": True,
+    assert is_injectable(my_func)
+    assert my_func.__injectable__ == {
         "tags": ["tag1", "tag2"],
     }

anydi-0.43.0/tests/test_scan.py

@@ -0,0 +1,68 @@
+import pytest
+from pytest_mock import MockerFixture
+
+from anydi import Container
+
+from tests.scan_app import ScanAppModule
+
+
+class TestContainerScan:
+    @pytest.fixture
+    def container(self) -> Container:
+        return Container()
+
+    def test_scan_registers_all_dependencies(
+        self, container: Container, mocker: MockerFixture
+    ) -> None:
+        inject_spy = mocker.spy(container, "inject")
+
+        container.register_module(ScanAppModule)
+        container.scan(["tests.scan_app"])
+
+        # Expecting 7 total inject calls from all eligible @injectable functions
+        assert inject_spy.call_count == 7
+
+        from .scan_app.a.a3.handlers import a_a3_handler_1, a_a3_handler_2
+
+        assert a_a3_handler_1() == "a.a1.str_provider"
+        assert a_a3_handler_2().ident == "a.a1.str_provider"
+
+    def test_scan_single_module_registers_limited_dependencies(
+        self, container: Container, mocker: MockerFixture
+    ) -> None:
+        inject_spy = mocker.spy(container, "inject")
+
+        container.register_module(ScanAppModule)
+        container.scan("tests.scan_app.a.a3.handlers")
+
+        # Expecting only 2 handlers to be registered from this specific module
+        assert inject_spy.call_count == 2
+
+        from .scan_app.a.a3.handlers import a_a3_handler_1
+
+        assert a_a3_handler_1() == "a.a1.str_provider"
+
+    def test_scan_with_unknown_tag_registers_nothing(
+        self, container: Container, mocker: MockerFixture
+    ) -> None:
+        inject_spy = mocker.spy(container, "inject")
+
+        container.scan(["tests.scan_app"], tags=["non_existing_tag"])
+
+        # No injectable functions should be picked up with unmatched tags
+        inject_spy.assert_not_called()
+
+    def test_scan_with_matching_tag_registers_only_matching_dependencies(
+        self, container: Container, mocker: MockerFixture
+    ) -> None:
+        inject_spy = mocker.spy(container, "inject")
+
+        container.register_module(ScanAppModule)
+        container.scan(["tests.scan_app"], tags=["inject"])
+
+        # Only handlers with @injectable(..., tags=["inject"]) should be included
+        assert inject_spy.call_count == 1
+
+        from .scan_app.a.a3.handlers import a_a3_handler_1
+
+        assert a_a3_handler_1() == "a.a1.str_provider"

{anydi-0.42.0 → anydi-0.43.0}/tests/test_testing.py

@@ -6,7 +6,7 @@ from unittest import mock
 
 import pytest
 
-from anydi import Container, auto
+from anydi import Container, auto, singleton
 from anydi.testing import TestContainer
 
 from tests.fixtures import Service
@@ -99,9 +99,8 @@ class TestTestContainer:
             def get_user(self) -> str:
                 return "user"
 
+        @singleton
         class UserService:
-            __scope__ = "singleton"
-
             def __init__(self, repo: UserRepo, param: Annotated[str, "param"]) -> None:
                 self.repo = repo
                 self.param = param
@@ -130,9 +129,8 @@ class TestTestContainer:
         container = TestContainer(strict=False)
         container.register(Annotated[str, "param"], lambda: "param", scope="singleton")
 
+        @singleton
         class UserService:
-            __scope__ = "singleton"
-
             def __init__(self, param: Annotated[str, "param"]) -> None:
                 self.param = param
 

{anydi-0.42.0 → anydi-0.43.0}/uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "anydi"
-version = "0.42.0"
+version = "0.43.0"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },
@@ -35,6 +35,7 @@ dev = [
     { name = "pytest" },
     { name = "pytest-cov" },
     { name = "pytest-django" },
+    { name = "pytest-mock" },
     { name = "redis" },
     { name = "ruff" },
     { name = "starlette" },
@@ -65,6 +66,7 @@ dev = [
     { name = "pytest", specifier = ">=8.4.0,<9" },
     { name = "pytest-cov", specifier = ">=6.0.0,<7" },
     { name = "pytest-django", specifier = ">=4.8.0,<5" },
+    { name = "pytest-mock", specifier = ">=3.14.1" },
     { name = "redis", specifier = ">=5.0.4,<6" },
     { name = "ruff", specifier = ">=0.11.10,<1.0" },
     { name = "starlette", specifier = ">=0.37.2" },
@@ -973,6 +975,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/47/fe/54f387ee1b41c9ad59e48fb8368a361fad0600fe404315e31a12bacaea7d/pytest_django-4.9.0-py3-none-any.whl", hash = "sha256:1d83692cb39188682dbb419ff0393867e9904094a549a7d38a3154d5731b2b99", size = 23723, upload-time = "2024-09-02T15:49:17.127Z" },
 ]
 
+[[package]]
+name = "pytest-mock"
+version = "3.14.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/28/67172c96ba684058a4d24ffe144d64783d2a270d0af0d9e792737bddc75c/pytest_mock-3.14.1.tar.gz", hash = "sha256:159e9edac4c451ce77a5cdb9fc5d1100708d2dd4ba3c3df572f14097351af80e", size = 33241, upload-time = "2025-05-26T13:58:45.167Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/05/77b60e520511c53d1c1ca75f1930c7dd8e971d0c4379b7f4b3f9644685ba/pytest_mock-3.14.1-py3-none-any.whl", hash = "sha256:178aefcd11307d874b4cd3100344e7e2d888d9791a6a1d9bfe90fbc1b74fd1d0", size = 9923, upload-time = "2025-05-26T13:58:43.487Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"

anydi-0.42.0/tests/test_scan.py

@@ -1,41 +0,0 @@
-import pytest
-
-from anydi import Container
-
-from tests.scan_app import ScanAppModule
-
-
-class TestContainerScan:
-    @pytest.fixture
-    def container(self) -> Container:
-        return Container()
-
-    def test_scan(self, container: Container) -> None:
-        container.register_module(ScanAppModule)
-        container.scan(["tests.scan_app"])
-
-        from .scan_app.a.a3.handlers import a_a3_handler_1, a_a3_handler_2
-
-        assert a_a3_handler_1() == "a.a1.str_provider"
-        assert a_a3_handler_2().ident == "a.a1.str_provider"
-
-    def test_scan_single_package(self, container: Container) -> None:
-        container.register_module(ScanAppModule)
-        container.scan("tests.scan_app.a.a3.handlers")
-
-        from .scan_app.a.a3.handlers import a_a3_handler_1
-
-        assert a_a3_handler_1() == "a.a1.str_provider"
-
-    def test_scan_non_existing_tag(self, container: Container) -> None:
-        container.scan(["tests.scan_app"], tags=["non_existing_tag"])
-
-        assert not container.providers
-
-    def test_scan_tagged(self, container: Container) -> None:
-        container.register_module(ScanAppModule)
-        container.scan(["tests.scan_app.a"], tags=["inject"])
-
-        from .scan_app.a.a3.handlers import a_a3_handler_1
-
-        assert a_a3_handler_1() == "a.a1.str_provider"