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

{dependency_injection_pattern-0.0.0 → 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.0/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.0
+Version: 0.0.2
 Summary: Python implementation of the Dependency Injection pattern.
 Author-email: Anders Madsen <anders.madsen@alphavue.com>
 License: MIT
@@ -25,7 +25,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: typing-utilities==0.0.2
+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"
@@ -99,6 +100,6 @@ app = provider.provide(Application)
 value = app.get_value() # => "Service2 returned: Service1 returned: Some value"
 ```
 
-## API
+## Full documentation
 
-[Go to API documentation](https://github.com/apmadsen/dependency-injection-pattern/blob/main/docs/api.md)
+[Go to documentation](https://github.com/apmadsen/dependency-injection-pattern/blob/main/docs/documentation.md)

{dependency_injection_pattern-0.0.0 → dependency_injection_pattern-0.0.2}/README.md

@@ -66,6 +66,6 @@ app = provider.provide(Application)
 value = app.get_value() # => "Service2 returned: Service1 returned: Some value"
 ```
 
-## API
+## Full documentation
 
-[Go to API documentation](https://github.com/apmadsen/dependency-injection-pattern/blob/main/docs/api.md)
+[Go to documentation](https://github.com/apmadsen/dependency-injection-pattern/blob/main/docs/documentation.md)

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

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

{dependency_injection_pattern-0.0.0 → 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.0
+Version: 0.0.2
 Summary: Python implementation of the Dependency Injection pattern.
 Author-email: Anders Madsen <anders.madsen@alphavue.com>
 License: MIT
@@ -25,7 +25,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: typing-utilities==0.0.2
+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"
@@ -99,6 +100,6 @@ app = provider.provide(Application)
 value = app.get_value() # => "Service2 returned: Service1 returned: Some value"
 ```
 
-## API
+## Full documentation
 
-[Go to API documentation](https://github.com/apmadsen/dependency-injection-pattern/blob/main/docs/api.md)
+[Go to documentation](https://github.com/apmadsen/dependency-injection-pattern/blob/main/docs/documentation.md)

{dependency_injection_pattern-0.0.0 → 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.2/src/dependency_injection_pattern.egg-info/requires.txt

@@ -0,0 +1,6 @@
+typing-utilities<0.1,>=0.0.3
+runtime-reflection-lite<0.1,>=0.0.0
+
+[test]
+pytest>=8.3
+pytest-cov>=6.1

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

@@ -2,9 +2,10 @@ from __future__ import annotations
 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
@@ -34,12 +35,12 @@ class Container:
         provider = container.provider() # container is sealed, and no more services can be added beyound this point
         provider.provide(Service) # => Service
     """
-    __slots__ = ["__factories", "__named_factories", "__list_factories", "__default_scope", "__provider"]
+    __slots__ = ["__factories", "__named_factories", "__list_factories", "__default_scope", "__provider", "__weakref__"]
 
     def __init__(self):
         self.__factories: dict[type[Any], Factory[Any]] = {}
         self.__named_factories: dict[str, tuple[type[Any], Factory[Any]]] = {}
-        self.__provider: Provider | None = None
+        self.__provider: ref[Provider] | None = None
         self.__default_scope = DefaultScope()
 
     @property
@@ -185,10 +186,11 @@ class Container:
         Returns:
             Provider -- The Provider instance
         """
+        from di.core.provider import Provider
         if self.__provider is None:
-            from di.core.provider import Provider
-            self.__provider = Provider(self)
-            self.__add_factory(SingletonFactory, Provider, self.__provider)
+            provider = Provider(self)
+            self.__provider = ref(provider)
+            self.__add_factory(SingletonFactory, Provider, self.provider)
 
             factories = { **self.__factories, **{ service: factory for service, factory in self.__named_factories.values() } }
             for service, factory in factories.items():
@@ -204,7 +206,13 @@ class Container:
                         elif isinstance(factories[dep.service], TransientFactory):
                             raise SealException(f"Singleton service '{get_service_name(service)}' depends on transient service {get_service_name(dep.service)}' which is not permitted.")
 
-        return self.__provider
+            return provider
+        elif provider :=self.__provider():
+            return provider
+        else:
+            provider = Provider(self)
+            self.__provider = ref(provider)
+            return provider
 
     def __add_factory_pre(self, factory_type: type[Factory[T]], *args: Any) -> tuple[str, type[Any]]:
         if self.__provider != None:

{dependency_injection_pattern-0.0.0 → 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.0 → 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.0 → dependency_injection_pattern-0.0.2}/src/di/core/provider.py

@@ -14,7 +14,7 @@ class Provider:
     """
     The Provider is connected to the Container and provides the services defined.
     """
-    __slots__ = ["__container"]
+    __slots__ = ["__container", "__weakref__"]
 
     def __init__(self, container: Container):
         self.__container = container

{dependency_injection_pattern-0.0.0 → dependency_injection_pattern-0.0.2}/tests/test_container.py

@@ -3,11 +3,13 @@
 from typing import cast, Sequence
 from pytest import raises as assert_raises
 from threading import Thread
+from weakref import ref
+from gc import get_referrers, collect
 
-from di import Container, Provider
+from di import Container, Provider, Factory
 from di.exceptions import ImplementationException, AddException, SealException, ProvideException, ContainerSealedError
 
-from tests.classes import Service, Options1, DependentService, DependentServiceFail1, IService, Service2
+from tests.classes import Service, Options1, DependentService, DependentServiceFail1, IService, Service2, Service5, DependentService5, Application
 
 
 
@@ -93,3 +95,65 @@ def test_collections():
     with assert_raises(ImplementationException):
         container.add_singleton(Sequence[IService], [ Service, Service2 ])
 
+def test_lifetime():
+
+    container = Container()
+    container.add_transient(Service5)
+
+    provider = container.provider()
+    provider_id = id(provider)
+    svc = provider.provide(Service5)
+    provider = ref(provider)
+
+    collect()
+
+    assert not provider() # provider should have been collected
+
+    provider = container.provider()
+    assert id(provider) != provider_id # this provider be a new instance
+
+    provider = ref(provider)
+    container = ref(container)
+
+    collect()
+
+    # provider and container should have been collected
+    assert not provider()
+    assert not container()
+
+    ### cleanup
+    del container
+    del provider
+    del svc
+    collect()
+    ###
+
+    container = Container()
+    container.add_transient(Application)
+    container.add_transient(Service5)
+    container.add_transient(DependentService5)
+    provider = container.provider()
+
+    app = provider.provide(Application)
+    svc = app.service_factory()
+
+    container = ref(container)
+    provider = ref(provider)
+
+    collect()
+
+    # app has a live reference to Factory[Service5],
+    # so neither container or provider should be collected
+    assert container()
+    assert provider()
+
+    app = ref(app)
+
+    collect()
+
+    # app has been collected thus any references to container and provider
+    # has been removed and container and provider has therefore
+    # also been collected
+    assert not app()
+    assert not provider()
+    assert not container()

{dependency_injection_pattern-0.0.0 → dependency_injection_pattern-0.0.2}/tests/test_examples.py

@@ -175,4 +175,52 @@ def test_example_7():
     service1, service2 = app.services # => Service1, Service2
 
     assert isinstance(service1, Service1)
-    assert isinstance(service2, Service2)
+    assert isinstance(service2, Service2)
+
+
+def test_example_8():
+    from di import Container, DefaultScope, Scope, Provider
+    from random import Random
+    from threading import Thread
+
+    class RandGen:
+        rnd: Random | None
+
+        def generate(self) -> int:
+            if self.rnd:
+                return self.rnd.randint(0, 100)
+            else:
+                return -1
+
+        def __enter__(self):
+            self.rnd = Random()
+            return self
+
+        def __exit__(self):
+            del self.rnd
+
+    container = Container()
+    container.add_scoped(RandGen)
+
+    scope = DefaultScope()
+    provider = container.provider()
+
+    generators: set[int] = set()
+    ints: list[int] = []
+
+    def fn(provider: Provider, scope: Scope):
+        for i in range(3):
+            gen = provider.provide(RandGen, scope)
+            generators.add(id(gen))
+            ints.append(gen.generate())
+
+    thread1 = Thread(target = fn, args = (provider, scope))
+    thread1.start()
+    thread2 = Thread(target = fn, args = (provider, scope))
+    thread2.start()
+    thread1.join()
+    thread2.join()
+
+    assert len(generators) == 2
+    assert len(ints) == 6
+

dependency_injection_pattern-0.0.0/src/dependency_injection_pattern.egg-info/requires.txt

@@ -1,5 +0,0 @@
-typing-utilities==0.0.2
-
-[test]
-pytest>=8.3
-pytest-cov>=6.1

dependency_injection_pattern-0.0.0/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.0/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.0/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.0/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.0/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.0/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
-