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

di/core/exceptions/provide_exception.py

@@ -0,0 +1,22 @@
+# pragma: no cover
+from typing import overload
+
+from di.core.helpers import get_service_name
+
+class ProvideException(Exception):
+    """
+    The ProvideException is raised when provider cannot provide service.
+    """
+
+    @overload
+    def __init__(self, service: type | str) -> None:
+        ...
+    @overload
+    def __init__(self, service: type | str, reason: str) -> None:
+        ...
+    def __init__(self, service: type | str, reason: str | None = None):
+        service = get_service_name(service)
+        if reason:
+            super().__init__(f"Cannot provide service '{service}': {reason}")
+        else:
+            super().__init__(f"Cannot provide service '{service}'")

di/core/exceptions/seal_exception.py

@@ -0,0 +1,9 @@
+# pragma: no cover
+class SealException(Exception):
+    """
+    The SealException is raised when container is being sealed and a preliminary check reveals that one or more
+    services cannot be provided. This could be due to a singleton service depending on a transient or scoped service which
+    isn't allowed..
+    """
+    def __init__(self, msg: str):
+        super().__init__(msg)

di/core/factories/dependency.py

@@ -0,0 +1,38 @@
+from typing import Any, cast
+from typingutils import get_optional_type
+
+from di.core.helpers import get_provided_service_from_annotation
+from di.core.reflection.undefined import Undefined
+
+class Dependency:
+    __slots__ = [ "__name", "__service", "__factory", "__optional", "__default" ]
+
+    def __init__(self, name: str, service: type[Any], default: Any ):
+        self.__name = name
+        service, self.__optional = cast(tuple[type[Any], bool], get_optional_type(service))
+        self.__service, self.__factory = cast(tuple[type[Any], bool], get_provided_service_from_annotation(service))
+        self.__default = default
+
+    @property
+    def name(self) -> str:
+        return self.__name # pragma: no cover
+
+    @property
+    def service(self) -> type[Any]:
+        return self.__service
+
+    @property
+    def is_optional(self) -> bool:
+        return self.__optional
+
+    @property
+    def is_factory(self) -> bool:
+        return self.__factory
+
+    @property
+    def has_default(self) -> bool:
+        return self.__default is not Undefined
+
+    @property
+    def default(self) -> Any:
+        return self.__default # pragma: no cover

di/core/factories/factory.py

@@ -0,0 +1,105 @@
+from typing import TypeVar, Callable, Generic, Any, cast
+from typingutils import get_optional_type, issubclass_typing, isinstance_typing
+
+from di.core.reflection import Undefined, ParameterKind, reflect_function, get_constructor
+from di.core.scope import Scope
+from di.core.named_service import NamedService
+from di.core.service_request import ServiceRequest
+
+from di.core.exceptions.implementation_exception import ImplementationException
+from di.core.exceptions.factory_provide_exception import FactoryProvideException
+from di.core.exceptions.provide_exception import ProvideException
+from di.core.protocols.container import Container
+from di.core.factories.dependency import Dependency
+
+T = TypeVar('T')
+
+class Factory(Generic[T]):
+    __slots__ = ["__container", "__service", "__implementation", "__ctor", "__dependencies"]
+
+    def __init__(self, container: Container, service: type[T], implementation: type[T] | Callable[..., T] | T | None = None):
+        self.__container = container
+        self.__service = service
+        self.__implementation = service if implementation is None else implementation
+        self.__dependencies: dict[str, Dependency] = {}
+
+        if not implementation:
+            if hasattr(service, "__origin__"):
+                sig = reflect_function(getattr(service, "__call__"), service)
+            else:
+                sig = get_constructor(service)
+        elif isinstance(implementation, type):
+            sig = get_constructor(cast(type, implementation))
+            if not service is NamedService and not issubclass_typing(implementation, service):
+                raise ImplementationException(service, implementation, "Implementation class is not derived from service")
+            elif implementation is service:
+                raise ImplementationException(service, implementation, "Implementation equals service")
+        elif isinstance_typing(implementation, service, recursive=True):
+            sig = None
+        elif callable(implementation):
+            sig = reflect_function(implementation)
+            if sig.return_type:
+                implementation_type, _ = get_optional_type(sig.return_type)
+            else:
+                implementation_type = None
+
+            if service is NamedService:
+                pass
+            elif not implementation_type:
+                raise ImplementationException(service, implementation, "Implementation is missing return annotation")
+            elif not issubclass_typing(implementation_type, service):
+                raise ImplementationException(service, implementation, "Implementation does not resolve into a class derived from service")
+        elif service is NamedService:
+            sig = None
+        else:
+            raise ImplementationException(service, implementation, "Implementation does not resolve into a class derived from service")
+
+        if sig != None:
+            parameters = [ p for p in sig.parameters if p.kind == ParameterKind.POSITIONAL_OR_KEYWORD ]
+            missing_annotations = [ p.name for p in parameters if not p.parameter_type ]
+            self.__dependencies = { p.name: Dependency(p.name, p.parameter_type, p.default) for p in parameters }
+
+            if len(missing_annotations) > 0:
+                parameters_missing_ann = ", ".join([f"'{p}'" for p in missing_annotations])
+                raise ImplementationException(service, implementation, f"Parameter(s) {parameters_missing_ann} missing annotation")
+
+            def ctor(scope: Scope | None = None) -> T:
+                provider = container.provider()
+                try:
+                    args = [
+                        provider._provide( # pyright: ignore[reportPrivateUsage]
+                            ServiceRequest(
+                                p.name,
+                                cast(type[T], p.parameter_type),
+                                None if p.default is Undefined else p.default
+                            ),
+                            scope
+                        ) for p in parameters
+                    ]
+                    return cast(Callable[[Any], T], self.__implementation)(*args)
+                except ProvideException as ex:
+                    failed_args = {
+                        p.name: cast(type, p.parameter_type)
+                        for p in parameters
+                        if not provider.provides(cast(type, p.parameter_type))
+                    }
+                    raise FactoryProvideException(service, failed_args) from ex
+
+            self.__ctor = ctor
+
+    @property
+    def container(self) -> Container:
+        return self.__container # pragma: no cover
+
+    @property
+    def service(self) -> type[T]:
+        return self .__service
+
+    @property
+    def dependencies(self) -> dict[str, Dependency]:
+        return self.__dependencies
+
+    def provide(self, scope: Scope | None = None) -> T:
+        return self.__ctor(scope)
+
+

di/core/factories/scoped_factory.py

@@ -0,0 +1,18 @@
+
+from typing import TypeVar, Callable
+
+from di.core.scope import Scope
+from di.core.factories.factory import Factory
+from di.core.protocols.container import Container
+
+T = TypeVar('T')
+
+class ScopedFactory(Factory[T]):
+    __slots__ = []
+
+    def __init__(self, container: Container, service: type[T], implementation: type[T] | Callable[..., T] | None = None):
+        super().__init__(container, service, implementation)
+
+    def provide(self, scope: Scope | None = None) -> T:
+        scope = scope or self.container.default_scope
+        return scope.provide(self.service, lambda : Factory[T].provide(self, scope))

di/core/factories/singleton_factory.py

@@ -0,0 +1,32 @@
+from typing import TypeVar, Callable, cast
+from typingutils import is_type, isinstance_typing
+
+from di.core.log import LOG
+from di.core.helpers import get_service_name
+from di.core.scope import Scope
+from di.core.named_service import NamedService
+from di.core.factories.factory import Factory
+from di.core.protocols.container import Container
+
+T = TypeVar('T')
+
+class SingletonFactory(Factory[T]):
+    __slots__ = ["__inst"]
+
+    def __init__(self, container: Container, service: type[T], implementation: type[T] | Callable[..., T] | T | None = None):
+        super().__init__(container, service, implementation)
+
+        if implementation and is_type(service) and isinstance_typing(implementation, service, recursive=True):
+            self.__inst: T | None = cast(T, implementation)
+        elif callable(implementation):
+            self.__inst: T | None = None
+        elif service is NamedService:
+            self.__inst: T | None = implementation
+        else:
+            self.__inst: T | None = None
+
+    def provide(self, scope: Scope | None = None) -> T:
+        if self.__inst is None:
+            LOG.debug(f"Creating singleton object for service '{get_service_name(self.service)}'")
+            self.__inst = super().provide(scope)
+        return self.__inst

di/core/factories/transient_factory.py

@@ -0,0 +1,17 @@
+from typing import TypeVar, Callable
+
+from di.core.scope import Scope
+from di.core.factories.factory import Factory
+from di.core.protocols.container import Container
+
+T = TypeVar('T')
+
+class TransientFactory(Factory[T]):
+    __slots__ = []
+
+    def __init__(self, container: Container, service: type[T], implementation: type[T] | Callable[..., T] | None = None):
+        super().__init__(container, service, implementation)
+
+    def provide(self, scope: Scope | None = None) -> T:
+        return Factory[T].provide(self, scope)
+

di/core/factory.py

@@ -0,0 +1,24 @@
+from typing import TypeVar, Generic
+
+from di.core.scope import Scope
+
+T = TypeVar("T")
+
+class Factory(Generic[T]):
+    """
+    The Factory[T] class is used to get the Provider to provide a factory instead of a service implementation ie. a lazy implementation.
+
+    Example:
+        class SomeClass:
+            def __init__(self, service: Factory[Service]):
+                svc = service() # => Service
+    """
+
+    def __new__(cls):
+        raise Exception("The Factory class is not intended for instantation") # pragma: no cover
+
+    def provide(self, scope: Scope | None = None) -> T: # pragma: no cover
+        raise NotImplementedError
+
+    def __call__(self, scope: Scope | None = None) -> T: # pragma: no cover
+        raise NotImplementedError

di/core/helpers.py

@@ -0,0 +1,51 @@
+from typing import MutableMapping, Protocol, TypeVar, cast, runtime_checkable
+from di.core.factory import Factory
+from types import TracebackType
+from typingutils import AnyType, issubclass_typing, get_type_name
+
+from di.core.factory import Factory
+
+
+T = TypeVar('T', covariant=True)
+
+@runtime_checkable
+class ContextManager(Protocol[T]): # pragma: no cover
+    def __enter__(self) -> T: ...
+    def __exit__(self, __exc_type: type[BaseException] | None, __exc_value: BaseException | None, __traceback: TracebackType | None) -> None: ...
+
+
+def get_service_name(service: AnyType | str) -> str: # pragma: no cover
+    if isinstance(service, str):
+        return service
+    elif hasattr(service, "__name__"):
+        return getattr(service, "__name__")
+    else:
+        return get_type_name(service)
+
+def clean_service_name(service: str) -> str:
+    return service.lower()
+
+def get_provided_service_from_annotation(annotation: AnyType) -> tuple[AnyType, bool]:
+    if issubclass_typing(annotation, Factory):
+        return cast(tuple[type], getattr(annotation, "__args__"))[0], True
+    else:
+        return annotation, False
+
+
+__CONTEXT_SERVICES__: MutableMapping[type, bool] = {}
+
+def is_context(cls: type) -> bool:
+    if not cls in __CONTEXT_SERVICES__:
+        # reflection = reflect_class(cls)
+
+        # if "__enter__" in reflection.functions and "__exit__" in reflection.functions:
+        #     result = reflection.functions["__enter__"].return_type is cls
+        # else:
+        #     result = False
+        if issubclass(cls, ContextManager):
+            result = True
+        else:
+            result = False
+
+        __CONTEXT_SERVICES__[cls] = result
+    return __CONTEXT_SERVICES__[cls]

di/core/log.py

@@ -0,0 +1,4 @@
+from logging import getLogger, DEBUG
+
+LOG = getLogger("dependency-injection")
+LOG.setLevel(DEBUG)

di/core/named_service.py

@@ -0,0 +1,3 @@
+class NamedService():
+    def __new__(cls):
+        raise Exception("The NamedService is a special class not meant to be instantiated") # pragma: no cover

di/core/protocols/container.py

@@ -0,0 +1,25 @@
+from typing import Protocol, TypeVar, runtime_checkable
+
+from di.core.protocols.provider import Provider
+from di.core.protocols.factory import Factory
+from di.core.scope import Scope
+from di.core.service_request import ServiceRequest
+
+
+T = TypeVar("T")
+
+@runtime_checkable
+class Container(Protocol): # pragma: no cover
+
+    @property
+    def default_scope(self) -> Scope:
+        ...
+
+    def provider(self) -> Provider:
+        ...
+
+    def _defines(self, service: str | type) -> bool:
+        ...
+
+    def _get(self, service: type[T] | ServiceRequest[T]) -> Factory[T] | T | None:
+        ...

di/core/protocols/factory.py

@@ -0,0 +1,7 @@
+from typing import Protocol, TypeVar, Generic, runtime_checkable
+
+T = TypeVar("T", covariant=True)
+
+@runtime_checkable
+class Factory(Generic[T], Protocol): # pragma: no cover
+    ...

di/core/protocols/provider.py

@@ -0,0 +1,24 @@
+from typing import Protocol, Any, TypeVar, overload, runtime_checkable
+
+from di.core.scope import Scope
+from di.core.service_request import ServiceRequest
+
+T = TypeVar("T")
+
+@runtime_checkable
+class Provider(Protocol): # pragma: no cover
+
+    def provides(self, service: str | type[Any]) -> bool:
+        ...
+
+    @overload
+    def provide(self, service: type[T]) -> T:
+        ...
+    @overload
+    def provide(self, service: type[T], scope: Scope) -> T:
+        ...
+    def provide(self, service: type[T], scope: Scope | None = None) -> T:
+        ...
+
+    def _provide(self, service: type[T] | ServiceRequest[T], scope: Scope | None = None) -> T:
+        ...

di/core/provider.py

@@ -0,0 +1,85 @@
+from typing import TypeVar, Any, cast, overload
+from typingutils import issubclass_typing, get_optional_type
+
+from di.core.exceptions.factory_provide_exception import FactoryProvideException
+from di.core.scope import Scope
+from di.core.factory import Factory as PublicFactory
+from di.core.factories.factory import Factory
+from di.core.service_request import ServiceRequest
+from di.core.protocols.container import Container
+
+T = TypeVar('T')
+
+class Provider:
+    """
+    The Provider is connected to the Container and provides the services defined.
+    """
+    __slots__ = ["__container"]
+
+    def __init__(self, container: Container):
+        self.__container = container
+
+
+    def provides(self, service: str | type[Any]) -> bool:
+        """
+        Indicates whether or not the specified service can be provided.
+
+        Args:
+            service (str | type[Any]) The service interface or name.
+
+        Returns:
+            bool: Returns True if specified service can be provided.
+        """
+        return self.__container._defines(service) # pyright: ignore[reportPrivateUsage]
+
+    @overload
+    def provide(self, service: type[T]) -> T:
+        """
+        Provides the specified service.
+
+        Args:
+            service (type[Any]) The service interface.
+
+        """
+        ...
+    @overload
+    def provide(self, service: type[T], scope: Scope) -> T:
+        """
+        Provides the specified service.
+
+        Args:
+            service (type[Any]) The service interface.
+            scope (Scope) A custom scope.
+        """
+        ...
+    def provide(self, service: type[T], scope: Scope | None = None) -> T:
+        return self._provide(service, scope)
+
+
+    def _provide(self, service: type[T] | ServiceRequest[T], scope: Scope | None = None) -> T:
+        scope = scope or self.__container.default_scope
+        svc_type = service.type if isinstance(service, ServiceRequest) else service
+        svc_type, is_optional = get_optional_type(svc_type)
+
+        if svc_type and issubclass_typing(svc_type, PublicFactory):
+            def factory() -> T:
+                return self._provide(cast(type[T], getattr(svc_type, "__args__")[0]))
+            return factory # pyright: ignore[reportReturnType]
+        else:
+            result = self.__container._get(cast(type[T], service)) # pyright: ignore[reportPrivateUsage]
+
+            if result == None:
+                # optional requirements may return None
+                if is_optional:
+                    return None # pyright: ignore[reportReturnType]
+                else:
+                    raise FactoryProvideException(svc_type) # pragma: no cover
+
+            elif isinstance(result, Factory):
+                result = cast(T | None, result.provide(scope))
+                if result or is_optional:
+                    return cast(T, result)
+                else:
+                    raise FactoryProvideException(svc_type)
+            else:
+                return cast(T, result)

di/core/reflection/__init__.py

@@ -0,0 +1,126 @@
+from typing import Any, cast
+from typingutils import AnyFunction
+from types import FrameType, MethodType
+from sys import modules
+from inspect import Parameter as InspectParameter, FrameInfo, signature as get_signature, stack, unwrap
+
+from di.core.reflection.undefined import Undefined
+from di.core.reflection.signature import Signature
+from di.core.reflection.parameter import Parameter
+from di.core.reflection.parameter_kind import ParameterKind
+from di.core.reflection.parameter_mapper import ParameterMapper
+
+
+def resolve(
+    annotation: str,
+    globals: dict[str, Any] | None = None,
+    builtins: dict[str, Any] | None = None,
+    locals: dict[str, Any] | None = None
+) -> Any:
+    if globals: # pragma: no cover
+        globals = { **globals , **(builtins or  __builtins__)}
+
+        try:
+            result = eval(annotation, globals, locals)
+            return result
+        except:
+            pass
+
+    # fallback
+    for frame in stack()[1:]: # pragma: no cover
+        if frame.filename == __file__:
+            continue
+
+        globals = { **frame.frame.f_globals , **frame.frame.f_builtins}
+        locals = frame.frame.f_locals
+
+        try:
+            return eval(annotation, globals, locals)
+        except:
+            pass
+
+    raise Exception(f"Unable to resolve {annotation}") # pragma: no cover
+
+
+
+
+def get_frame(fn: Any, stack: list[FrameInfo], cls: Any | None) -> FrameType | None: # pragma: no cover
+    module = None
+
+    if hasattr(fn, "__module__"):
+        module = modules[getattr(fn, "__module__")]
+    elif cls and hasattr(cls, "__module__"):
+        module = modules[getattr(cls, "__module__")]
+
+    if module and hasattr(module, "__file__"):
+        for frame in stack:
+            if frame.filename == module.__file__:
+                frame_locals = frame.frame.f_locals.values()
+                if cls is not None and cls in frame_locals:
+                    return frame.frame
+                elif fn in frame_locals:
+                    return frame.frame
+
+
+def reflect_function(fn: AnyFunction, cls: object | None = None) -> Signature:
+    fn = unwrap(fn)
+    sig = get_signature(fn)
+
+    if hasattr(fn, "__self__") and ( self := getattr(fn, "__self__") ):
+        cls = self
+
+    parameters = list(sig.parameters.values())
+    globals: dict[str, Any] | None = getattr(fn, "__globals__") if hasattr(fn, "__globals__") else None
+    builtins: dict[str, Any] | None = getattr(fn, "__builtins__") if hasattr(fn, "__builtins__") else None
+    locals: dict[str, Any] | None = None
+
+    if frame := get_frame(fn, stack()[1:], cls): # pragma: no cover
+        locals = frame.f_locals
+
+    if parameters:
+        first_param = parameters[0].name.lower()
+
+        if isinstance(fn, MethodType) and first_param in ("self", "cls"):
+            parameters = parameters[1:] # pragma: no cover
+        elif first_param in ("self", "cls") and hasattr(fn, "__self__"):
+            parameters = parameters[1:] # pragma: no cover
+        elif first_param == "self":
+            if hasattr(fn, "__call__") and ( call := getattr(fn, "__call__") ): # pragma: no cover
+                if hasattr(call, "__text_signature__") and ( text_sig := getattr(call, "__text_signature__") ):
+                    if cast(str, text_sig).startswith("($self"):
+                        parameters = parameters[1:]
+
+    for index, parameter in enumerate(parameters):
+        changed = False
+
+        if isinstance(parameter.annotation, str):
+            parameter_type = resolve(parameter.annotation, globals, builtins, locals)
+            parameter = parameter.replace(annotation = parameter_type)
+            changed = True
+
+        if changed:
+            parameters[index] = parameter
+
+    if sig.return_annotation is InspectParameter.empty:
+        return_type = Undefined
+    elif isinstance(sig.return_annotation, str):
+        return_type = resolve(sig.return_annotation, globals, builtins, locals)
+    else:
+        return_type = sig.return_annotation
+
+    return Signature(
+        ParameterMapper(
+            [
+                Parameter(
+                    p.name,
+                    ParameterKind(p.kind),
+                    Undefined if p.annotation is InspectParameter.empty else p.annotation,
+                    Undefined if p.default is InspectParameter.empty else p.default
+                ) for p in parameters
+            ]
+        ), return_type
+    )
+
+
+def get_constructor(cls: type[Any]) -> Signature:
+    return reflect_function(getattr(cls, "__init__"), cls)

di/core/reflection/parameter.py

@@ -0,0 +1,66 @@
+from typing import Any, cast
+from typingutils import get_type_name
+from inspect import Parameter as InspectParameter
+
+from di.core.reflection.undefined import Undefined
+from di.core.reflection.parameter_kind import ParameterKind
+
+class Parameter:
+    __slots__ = ["__name", "__kind", "__doc", "__type", "__default"]
+
+    def __init__(
+        self,
+        name: str,
+        kind: ParameterKind,
+        parameter_type: type[Any],
+        default: Any
+    ):
+        self.__name = name
+        self.__kind = kind
+        self.__type = parameter_type
+        self.__default = default
+
+    @property
+    def name(self) -> str:
+        """The parameter name
+        """
+        return self.__name
+
+    @property
+    def kind(self) -> ParameterKind:
+        """The parameter kind
+        """
+        return self.__kind
+
+    @property
+    def parameter_type(self) -> type[Any]:
+        """The parameter type
+        """
+        return self.__type
+
+    @property
+    def default(self) -> Any:
+        """The parameter default
+        """
+        return self.__default
+
+    def __repr__(self) -> str:
+        str_type = f": {get_type_name(cast(type, self.__type))}" if self.__type and self.__type != Undefined else ""
+        str_default = f"={self.__default}" if self.__default else ""
+        return f"{self.__name}{str_type}{str_default}"
+
+    def __eq__(self, o: object) -> bool: # pragma: no cover
+        if isinstance(o, Parameter):
+            return (
+                self.name == o.name
+                and self.kind == o.kind
+                and self.parameter_type == o.parameter_type
+            )
+        elif isinstance(o, InspectParameter):
+            return (
+                self.name == o.name
+                and cast(int, self.kind) == o.kind
+                and self.parameter_type == o.annotation
+            )
+
+        return False