dependency-injection-pattern 0.0.1__tar.gz → 0.0.2__tar.gz

{dependency_injection_pattern-0.0.1 → dependency_injection_pattern-0.0.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Dagrofa BI
+Copyright (c) 2025 Anders Madsen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{dependency_injection_pattern-0.0.1/src/dependency_injection_pattern.egg-info → dependency_injection_pattern-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dependency-injection-pattern
-Version: 0.0.1
+Version: 0.0.2
 Summary: Python implementation of the Dependency Injection pattern.
 Author-email: Anders Madsen <anders.madsen@alphavue.com>
 License: MIT
@@ -26,6 +26,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typing-utilities<0.1,>=0.0.3
+Requires-Dist: runtime-reflection-lite<0.1,>=0.0.0
 Provides-Extra: test
 Requires-Dist: pytest>=8.3; extra == "test"
 Requires-Dist: pytest-cov>=6.1; extra == "test"

{dependency_injection_pattern-0.0.1 → dependency_injection_pattern-0.0.2}/pyproject.toml

@@ -27,7 +27,8 @@ classifiers = [
     "Typing :: Typed"
 ]
 dependencies = [
-    "typing-utilities >= 0.0.3, < 0.1"
+    "typing-utilities >= 0.0.3, < 0.1",
+    "runtime-reflection-lite >= 0.0.0, < 0.1"
 ]
 requires-python = ">=3.10"
 

{dependency_injection_pattern-0.0.1 → dependency_injection_pattern-0.0.2/src/dependency_injection_pattern.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dependency-injection-pattern
-Version: 0.0.1
+Version: 0.0.2
 Summary: Python implementation of the Dependency Injection pattern.
 Author-email: Anders Madsen <anders.madsen@alphavue.com>
 License: MIT
@@ -26,6 +26,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typing-utilities<0.1,>=0.0.3
+Requires-Dist: runtime-reflection-lite<0.1,>=0.0.0
 Provides-Extra: test
 Requires-Dist: pytest>=8.3; extra == "test"
 Requires-Dist: pytest-cov>=6.1; extra == "test"

{dependency_injection_pattern-0.0.1 → dependency_injection_pattern-0.0.2}/src/dependency_injection_pattern.egg-info/SOURCES.txt

@@ -31,12 +31,6 @@ src/di/core/factories/transient_factory.py
 src/di/core/protocols/container.py
 src/di/core/protocols/factory.py
 src/di/core/protocols/provider.py
-src/di/core/reflection/__init__.py
-src/di/core/reflection/parameter.py
-src/di/core/reflection/parameter_kind.py
-src/di/core/reflection/parameter_mapper.py
-src/di/core/reflection/signature.py
-src/di/core/reflection/undefined.py
 tests/test_container.py
 tests/test_examples.py
 tests/test_factory.py

{dependency_injection_pattern-0.0.1 → dependency_injection_pattern-0.0.2}/src/dependency_injection_pattern.egg-info/requires.txt

@@ -1,4 +1,5 @@
 typing-utilities<0.1,>=0.0.3
+runtime-reflection-lite<0.1,>=0.0.0
 
 [test]
 pytest>=8.3

{dependency_injection_pattern-0.0.1 → dependency_injection_pattern-0.0.2}/src/di/core/container.py

@@ -3,9 +3,9 @@ from typing import TypeVar, Callable, Any, cast, overload, TYPE_CHECKING
 from typingutils import is_type, isinstance_typing, get_optional_type, AnyFunction
 from types import FunctionType
 from weakref import ref
+from runtime.reflection.lite import reflect_function
 
 from di.core.log import LOG
-from di.core.reflection import reflect_function
 from di.core.scope import Scope
 from di.core.service_request import ServiceRequest
 from di.core.factories.singleton_factory import SingletonFactory

{dependency_injection_pattern-0.0.1 → dependency_injection_pattern-0.0.2}/src/di/core/factories/dependency.py

@@ -1,8 +1,8 @@
 from typing import Any, cast
 from typingutils import get_optional_type
+from runtime.reflection.lite import Undefined
 
 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" ]

{dependency_injection_pattern-0.0.1 → dependency_injection_pattern-0.0.2}/src/di/core/factories/factory.py

@@ -1,7 +1,7 @@
 from typing import TypeVar, Callable, Generic, Any, cast
 from typingutils import get_optional_type, issubclass_typing, isinstance_typing
+from runtime.reflection.lite import Undefined, ParameterKind, reflect_function, get_constructor
 
-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

dependency_injection_pattern-0.0.1/src/di/core/reflection/__init__.py

@@ -1,126 +0,0 @@
-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)

dependency_injection_pattern-0.0.1/src/di/core/reflection/parameter.py

@@ -1,66 +0,0 @@
-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

dependency_injection_pattern-0.0.1/src/di/core/reflection/parameter_kind.py

@@ -1,9 +0,0 @@
-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

dependency_injection_pattern-0.0.1/src/di/core/reflection/parameter_mapper.py

@@ -1,55 +0,0 @@
-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

dependency_injection_pattern-0.0.1/src/di/core/reflection/signature.py

@@ -1,45 +0,0 @@
-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
-

dependency_injection_pattern-0.0.1/src/di/core/reflection/undefined.py

@@ -1,24 +0,0 @@
-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
-