dependency-injection-pattern 0.0.0__py3-none-any.whl

di/core/reflection/parameter_kind.py

@@ -0,0 +1,9 @@
+from enum import Enum
+from inspect import Parameter
+
+class ParameterKind(Enum):
+    POSITIONAL = Parameter.POSITIONAL_ONLY
+    KEYWORD = Parameter.KEYWORD_ONLY
+    POSITIONAL_OR_KEYWORD = Parameter.POSITIONAL_OR_KEYWORD
+    ARGS = Parameter.VAR_POSITIONAL
+    KWARGS = Parameter.VAR_KEYWORD

di/core/reflection/parameter_mapper.py

@@ -0,0 +1,55 @@
+from typing import Iterator, Mapping, Iterable, Sequence
+
+from di.core.reflection.parameter import Parameter
+
+class ParameterMapper(Iterable[Parameter]):
+    __slots__ = ["__parameters", "__index"]
+
+    def __init__(self, parameters: Sequence[Parameter]):
+        self.__parameters = list(parameters)
+        self.__index: Mapping[str, int] | None = None
+
+    def __get_index(self) -> Mapping[str, int]:
+        if not self.__index:
+            self.__index = {
+                parameter.name: self.__parameters.index(parameter)
+                for parameter in self.__parameters
+            }
+        return self.__index # pragma: no cover
+
+    def __getitem__(self, index: int | str) -> Parameter: # pragma: no cover
+        if isinstance(index, int):
+            return self.__parameters[index]
+        else:
+            p_index = self.__get_index()
+
+            if index in p_index:
+                return self.__parameters[p_index[index]]
+            else:
+                raise KeyError(index)
+
+    def __iter__(self) -> Iterator[Parameter]:
+        return iter(self.__parameters)
+
+    def __len__(self) -> int: # pragma: no cover
+        return len(self.__parameters)
+
+    def __delitem__(self, index: int | str) -> None: # pragma: no cover
+        if isinstance(index, int):
+            del self.__parameters[index]
+        else:
+            p_index = self.__get_index()
+
+            if index in p_index:
+                del self.__parameters[p_index[index]]
+            else:
+                raise KeyError(index)
+
+    def __contains__(self, name: str) -> bool: # pragma: no cover
+        p_index = self.__get_index()
+        return name in p_index
+
+    def __eq__(self, o: object) -> bool: # pragma: no cover
+        if isinstance(o, ParameterMapper):
+            return self.__parameters == o.__parameters
+        return False

di/core/reflection/signature.py

@@ -0,0 +1,45 @@
+from typing import Any
+from typingutils import get_type_name
+
+from di.core.reflection.parameter_mapper import ParameterMapper
+
+class Signature:
+    __slots__ = ["__parameters", "__return_type"]
+
+    def __init__(
+        self,
+        parameters: ParameterMapper,
+        return_type: type[Any]
+    ):
+        self.__parameters = parameters
+        self.__return_type = return_type
+
+    @property
+    def parameters(self) -> ParameterMapper:
+        """The signature parameters
+        """
+        return self.__parameters
+
+    @property
+    def return_type(self) -> type[Any]:
+        """The signature return type
+        """
+        return self.__return_type
+
+
+
+    def __repr__(self) -> str:
+        str_parameters = ", ".join([ str(p) for p in self.__parameters ]) if self.__parameters else ""
+        str_return = f" -> {get_type_name(self.__return_type)}" if self.__return_type else ""
+        return f"({str_parameters}){str_return}"
+
+    def __eq__(self, o: object) -> bool: # pragma: no cover
+        if self is o:
+            return True
+        elif isinstance(o, Signature):
+            return (
+                self.parameters == o.parameters
+                and self.return_type == o.return_type
+            )
+        return False
+

di/core/reflection/undefined.py

@@ -0,0 +1,24 @@
+from inspect import Signature, Parameter
+
+class Meta(type): # pragma: no cover
+
+    def __bool__(self):
+        return False
+
+    def __eq__(self, other: object) -> bool:
+        return other is Undefined or other in [ Signature.empty, Parameter.empty, None ]
+
+    def __repr__(cls):
+        return "Undefined"
+
+    def __str__(self) -> str:
+        return "Undefined"
+
+    def __hash__(self) -> int:
+        return type.__hash__(self)
+
+
+class Undefined(metaclass=Meta):
+    def __new__(cls):
+        raise Exception("Undefined type is not supposed to be instantiated") # pragma: no cover
+

di/core/scope.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Callable, TypeVar
+
+T = TypeVar('T')
+
+class Scope(ABC):
+    """
+    Scope is the base class from which scopes are derived, and its superclasses handle provision of
+    scoped services.
+    """
+
+    @abstractmethod
+    def provide(self, service: type[T], factory: Callable[..., T]) -> T:
+        ...

di/core/service_request.py

@@ -0,0 +1,26 @@
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+class ServiceRequest(Generic[T]):
+    """
+    The ServiceRequest[T] class is used internally to request a service by name.
+    """
+    __slots__ = ["__name", "__type", "__default"]
+
+    def __init__(self, name: str, type: type[T], default: T):
+        self.__name = name.lower()
+        self.__type = type
+        self.__default = default
+
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    @property
+    def type(self) -> type[T]:
+        return self.__type
+
+    @property
+    def default(self) -> T:
+        return self.__default

di/exceptions.py

@@ -0,0 +1,15 @@
+from di.core.exceptions.add_exception import AddException
+from di.core.exceptions.implementation_exception import ImplementationException
+from di.core.exceptions.factory_provide_exception import FactoryProvideException
+from di.core.exceptions.container_sealed_error import ContainerSealedError
+from di.core.exceptions.seal_exception import SealException
+from di.core.exceptions.provide_exception import ProvideException
+
+__all__ = [
+    'AddException',
+    'ImplementationException',
+    'FactoryProvideException',
+    'ContainerSealedError',
+    'SealException',
+    'ProvideException'
+]