feat: ✨ More precise exceptions

Author: remimd

injection/common/formatting.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+__all__ = ("format_type",)
+
+
+def format_type(cls: type | Any) -> str:
+    try:
+        return f"{cls.__module__}.{cls.__qualname__}"
+    except AttributeError:
+        return str(cls)

injection/common/lazy.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable, Iterator, Mapping
 from types import MappingProxyType, new_class
-from typing import Any, Callable, Generic, Iterator, Mapping, TypeVar
+from typing import Any, Generic, TypeVar
 
 __all__ = ("Lazy", "LazyMapping")
 

injection/core/module.py

@@ -2,29 +2,19 @@
 
 import inspect
 from abc import ABC, abstractmethod
-from collections import ChainMap, OrderedDict
-from contextlib import ContextDecorator, contextmanager
+from collections import OrderedDict
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from contextlib import ContextDecorator, contextmanager, suppress
 from dataclasses import dataclass, field
 from enum import Enum, auto
 from functools import cached_property, singledispatchmethod, wraps
 from inspect import Signature, get_annotations
 from logging import getLogger
 from types import MappingProxyType
-from typing import (
-    Any,
-    Callable,
-    Iterable,
-    Iterator,
-    Mapping,
-    NamedTuple,
-    Protocol,
-    TypeVar,
-    cast,
-    final,
-    runtime_checkable,
-)
+from typing import Any, NamedTuple, Protocol, TypeVar, cast, final, runtime_checkable
 
 from injection.common.event import Event, EventChannel, EventListener
+from injection.common.formatting import format_type
 from injection.common.lazy import Lazy, LazyMapping
 from injection.exceptions import (
     ModuleCircularUseError,
@@ -40,13 +30,6 @@
 T = TypeVar("T")
 
 
-def _format_type(cls: type) -> str:
-    try:
-        return f"{cls.__module__}.{cls.__qualname__}"
-    except AttributeError:
-        return str(cls)
-
-
 """
 Events
 """
@@ -64,7 +47,7 @@ class ContainerDependenciesUpdated(ContainerEvent):
     def __str__(self) -> str:
         length = len(self.references)
         formatted_references = ", ".join(
-            f"`{_format_type(reference)}`" for reference in self.references
+            f"`{format_type(reference)}`" for reference in self.references
         )
         return (
             f"{length} container dependenc{'ies' if length > 1 else 'y'} have been "
@@ -196,7 +179,7 @@ def __getitem__(self, reference: type[T], /) -> Injectable[T]:
         try:
             return self.__data[cls]
         except KeyError as exc:
-            raise NoInjectable(f"No injectable for `{_format_type(cls)}`.") from exc
+            raise NoInjectable(reference) from exc
 
     def set_multiple(self, references: Iterable[type], injectable: Injectable):
         references = set(self.__get_origin(reference) for reference in references)
@@ -216,7 +199,7 @@ def check_if_exists(self, reference: type) -> type:
         if reference in self.__data:
             raise RuntimeError(
                 "An injectable already exists for the reference "
-                f"class `{_format_type(reference)}`."
+                f"class `{format_type(reference)}`."
             )
 
         return reference
@@ -266,7 +249,11 @@ def __post_init__(self):
         self.__container.add_listener(self)
 
     def __getitem__(self, reference: type[T], /) -> Injectable[T]:
-        return ChainMap(*self.__modules, self.__container)[reference]
+        for getter in *self.__modules, self.__container:
+            with suppress(KeyError):
+                return getter[reference]
+
+        raise NoInjectable(reference)
 
     def __setitem__(self, on: type | Iterable[type], injectable: Injectable, /):
         references = on if isinstance(on, Iterable) else (on,)

injection/exceptions.py

@@ -1,18 +1,37 @@
+from injection.common.formatting import format_type
+
+__all__ = (
+    "InjectionError",
+    "NoInjectable",
+    "ModuleError",
+    "ModuleCircularUseError",
+    "ModuleNotUsedError",
+)
+
+
 class InjectionError(Exception):
-    ...
+    __slots__ = ()
 
 
 class NoInjectable(KeyError, InjectionError):
-    ...
+    __slots__ = ("__reference",)
+
+    def __init__(self, reference: type):
+        super().__init__(f"No injectable for `{format_type(reference)}`.")
+        self.__reference = reference
+
+    @property
+    def reference(self) -> type:
+        return self.__reference
 
 
 class ModuleError(InjectionError):
-    ...
+    __slots__ = ()
 
 
 class ModuleCircularUseError(ModuleError):
-    ...
+    __slots__ = ()
 
 
 class ModuleNotUsedError(KeyError, ModuleError):
-    ...
+    __slots__ = ()

injection/utils.py

@@ -1,11 +1,11 @@
 from importlib import import_module
 from pkgutil import walk_packages
-from types import ModuleType as Package
+from types import ModuleType
 
 __all__ = ("load_package",)
 
 
-def load_package(package: Package):
+def load_package(package: ModuleType):
     """
     Function for importing all modules in a Python package.
     """

tests/helpers/event_helper.py

@@ -1,5 +1,5 @@
+from collections.abc import Iterator
 from dataclasses import dataclass, field
-from typing import Iterator
 
 from injection.common.event import Event, EventListener