feat: ✨ Skip injectable

injection/_core/module.py

@@ -73,6 +73,7 @@
     ModuleLockError,
     ModuleNotUsedError,
     NoInjectable,
+    SkipInjectable,
 )
 
 """
@@ -620,7 +621,7 @@ async def aget_instance[T](
     async def aget_instance(self, cls, default=None):  # type: ignore[no-untyped-def]
         try:
             return await self.afind_instance(cls)
-        except KeyError:
+        except (KeyError, SkipInjectable):
             return default
 
     @overload
@@ -640,7 +641,7 @@ def get_instance[T](
     def get_instance(self, cls, default=None):  # type: ignore[no-untyped-def]
         try:
             return self.find_instance(cls)
-        except KeyError:
+        except (KeyError, SkipInjectable):
             return default
 
     @overload
@@ -866,29 +867,28 @@ class Dependencies:
     lazy_mapping: Lazy[Mapping[str, Injectable[Any]]]
 
     def __iter__(self) -> Iterator[tuple[str, Any]]:
-        for name, injectable in self.mapping.items():
-            instance = injectable.get_instance()
-            yield name, instance
+        for name, injectable in self.items():
+            with suppress(SkipInjectable):
+                yield name, injectable.get_instance()
 
     async def __aiter__(self) -> AsyncIterator[tuple[str, Any]]:
-        for name, injectable in self.mapping.items():
-            instance = await injectable.aget_instance()
-            yield name, instance
+        for name, injectable in self.items():
+            with suppress(SkipInjectable):
+                yield name, await injectable.aget_instance()
 
     @property
     def are_resolved(self) -> bool:
         return self.lazy_mapping.is_set
 
-    @property
-    def mapping(self) -> Mapping[str, Injectable[Any]]:
-        return ~self.lazy_mapping
-
     async def aget_arguments(self) -> dict[str, Any]:
         return {key: value async for key, value in self}
 
     def get_arguments(self) -> dict[str, Any]:
         return dict(self)
 
+    def items(self) -> Iterator[tuple[str, Injectable[Any]]]:
+        return iter((~self.lazy_mapping).items())
+
     @classmethod
     def from_iterable(cls, iterable: Iterable[tuple[str, Injectable[Any]]]) -> Self:
         lazy_mapping = Lazy(lambda: dict(iterable))

injection/exceptions.py

@@ -10,6 +10,7 @@
     "ScopeAlreadyDefinedError",
     "ScopeError",
     "ScopeUndefinedError",
+    "SkipInjectable",
 )
 
 
@@ -30,6 +31,9 @@ def cls(self) -> type[T]:
         return self.__class
 
 
+class SkipInjectable(InjectionError): ...
+
+
 class ModuleError(InjectionError): ...
 
 
@@ -42,7 +46,7 @@ class ModuleNotUsedError(KeyError, ModuleError): ...
 class ScopeError(InjectionError): ...
 
 
-class ScopeUndefinedError(LookupError, ScopeError): ...
+class ScopeUndefinedError(LookupError, SkipInjectable, ScopeError): ...
 
 
 class ScopeAlreadyDefinedError(ScopeError): ...

tests/test_scoped.py

@@ -1,4 +1,5 @@
 from collections.abc import AsyncIterator, Iterator
+from dataclasses import dataclass
 
 import pytest
 
@@ -173,3 +174,30 @@ async def some_injectable_recipe() -> AsyncIterator[SomeInjectable]:
             instance_2 = await afind_instance(SomeInjectable)
 
         assert instance_1 is instance_2
+
+    async def test_scoped_with_scope_not_defined(self):
+        @scoped("test")
+        class A: ...
+
+        @injectable
+        @dataclass
+        class B:
+            a: A | None = None
+
+        # sync
+        b = find_instance(B)
+        assert b.a is None
+
+        with define_scope("test"):
+            b = find_instance(B)
+
+        assert isinstance(b.a, A)
+
+        # async
+        b = await afind_instance(B)
+        assert b.a is None
+
+        async with adefine_scope("test"):
+            b = await afind_instance(B)
+
+        assert isinstance(b.a, A)