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

dependency_injection_pattern-0.0.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: dependency-injection-pattern
+Version: 0.0.0
+Summary: Python implementation of the Dependency Injection pattern.
+Author-email: Anders Madsen <anders.madsen@alphavue.com>
+License: MIT
+Project-URL: repository, https://github.com/apmadsen/dependency-injection-pattern
+Keywords: windows,linux,dependency injection,di,dependency,injection,IoC
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 6 - Mature
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing-utilities==0.0.2
+Provides-Extra: test
+Requires-Dist: pytest>=8.3; extra == "test"
+Requires-Dist: pytest-cov>=6.1; extra == "test"
+Dynamic: license-file
+
+[![Test](https://github.com/apmadsen/dependency-injection-pattern/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/dependency-injection-pattern/actions/workflows/python-test.yml)
+[![Coverage](https://github.com/apmadsen/dependency-injection-pattern/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/dependency-injection-pattern/actions/workflows/python-test-coverage.yml)
+[![Stable Version](https://img.shields.io/pypi/v/dependency-injection-pattern?label=stable&sort=semver&color=blue)](https://github.com/apmadsen/dependency-injection-pattern/releases)
+![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/dependency-injection-pattern?label=pre-release&include_prereleases&sort=semver&color=blue)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dependency-injection-pattern)
+[![PyPI Downloads](https://static.pepy.tech/badge/dependency-injection-pattern/week)](https://pepy.tech/projects/dependency-injection-pattern)
+
+# dependency-injection-pattern
+> A Python implementation of the Dependency Injection pattern.
+
+This project extends python with a real dependency injection or Inversion of Control (IoC) implementation, relying on typing and inspection to achieve a seamless injection of dependencies.
+
+Though not normally associated with Python applications, dependency injection can greatly reduce time spent during development and testing. Usually, in a longrunning Python application or service, you would put the container registration inside the `__main_.py` file and similar code in test files, where service implementations can easily be substituted.
+
+## How it works
+When a service is requested, the provider looks it up in the factory dictionary, which then gets or creates a fitting instance. Any parameters needed for instantiation is supplied (injected) by the provider.
+
+A service implementation may be inferred by a service in which case the service constructor is used, and correspondingly a service may be inferred by the return type of an implementation function.
+
+## Conventions
+- All dependencies are resolved when container is sealed, which implements a fail-fast pattern. Only exceptions are optional dependencies or dependencies with a default value.
+
+- Singleton services may not depend on scoped or transient services, as this would negate the "transient" or "scoped" part since a singleton service would keep a reference to it's dependencies indefinitely.
+
+## Example:
+
+```python
+from logging import Logger
+from di import Container
+
+def get_logger() -> Logger:
+    return Logger("app")
+
+class Service1:
+    def get_value(self) -> str:
+        return "Some value"
+
+class Service2:
+    def __init__(self, service1: Service1, log: Logger):
+        self.service1 = service1
+        self.log = log
+
+    def get_value(self) -> str:
+        self.log.debug("Someone requested value...")
+        return f"Service1 returned: {self.service1.get_value()}"
+
+class Application:
+    def __init__(self, service2: Service2, log: Logger):
+        self.service2 = service2
+        log.info("Application starting")
+
+    def get_value(self) -> str:
+        return f"Service2 returned: {self.service2.get_value()}"
+
+
+container = Container()
+container.add_singleton(get_logger)
+container.add_transient(Service1)
+container.add_transient(Service2)
+container.add_transient(Application)
+
+provider = container.provider() # container is sealed beyond this point
+
+app = provider.provide(Application)
+
+value = app.get_value() # => "Service2 returned: Service1 returned: Some value"
+```
+
+## API
+
+[Go to API documentation](https://github.com/apmadsen/dependency-injection-pattern/blob/main/docs/api.md)

dependency_injection_pattern-0.0.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+dependency_injection_pattern-0.0.0.dist-info/licenses/LICENSE,sha256=arWCq6_BrCqO8UFdTrMBI356o9Qyqsp_RPvpthW5Yfk,1066
+di/__init__.py,sha256=drok-gOYlq2f6aL-fRBq5EVatHriE9eaKP-OPlWYbSw,288
+di/exceptions.py,sha256=oEZGKkSl-8E3E3mqB46ZovXMGyXC-R1y8Jq-d_HRs1k,588
+di/core/container.py,sha256=n4yYWUsd_PHROVhQkLE4dx4hc1eVHlYv5uBSWj1uq_E,14983
+di/core/default_scope.py,sha256=Bswkav9ImN4ysH9igZfdAg1w1PlkiH0IGecgxULrKJI,3536
+di/core/factory.py,sha256=ntNX0QuwL8CbgVw73hK-aJxbrKkBFpu0AuPSt-fgJEc,751
+di/core/helpers.py,sha256=2jwZRqo8NXn4c7G-OJTy5c5BpHhd9aN6F8ik2O09kGg,1702
+di/core/log.py,sha256=-oiqiq3xW9LRV8xwZIl6ENWQzuhwc62g4iwHMGmtXg4,97
+di/core/named_service.py,sha256=Yq4uB1RsqKm-UpCicaNVLrKiz3MFiZIpLj3sA3kCbo0,155
+di/core/provider.py,sha256=PHWYozeVYcMiA_Rfx1dUTLV_Eyh50mi_aGAkIKBCJzc,2964
+di/core/scope.py,sha256=kdqBL3baKEEouZBFrV4J1YRcI0UFCXx920_skZaXOuo,387
+di/core/service_request.py,sha256=16luchTWfMX_Qp8uLlP9zhXd-suL1CLDrGxh9yu4eCE,608
+di/core/exceptions/add_exception.py,sha256=GiLydWyoydZKcyz9TqSs5KovpI14qUeA_ANMHCVBLsA,286
+di/core/exceptions/container_sealed_error.py,sha256=kgC2Kucq_IUsFZXIgpwnys1rlJzjhEpfs-RUMOvCIlA,197
+di/core/exceptions/factory_provide_exception.py,sha256=CxKAQJMv8IjJQvMrWXKan3PeVQcWBd-BLasl9aR1WXY,1089
+di/core/exceptions/implementation_exception.py,sha256=T9TMLNcBye8TkDCumrHEPETlhYKxJ3r0QyYz1k3hIog,658
+di/core/exceptions/provide_exception.py,sha256=4FeYJHSYTI1c0o8uK753dB6NrND1T13yyT6Al9ucvCw,685
+di/core/exceptions/seal_exception.py,sha256=ySn6Xwh07NsUM625fg9ER7EPYBUVrTcImA8G0zK3YEY,386
+di/core/factories/dependency.py,sha256=WeKorQvGLHs2y117Fc01WvM48nzDF2D0fKPoJaxUJao,1148
+di/core/factories/factory.py,sha256=osh2eMV3xpR2c6c8tdlGwKfl39_D67WDae4jOZaA1Lg,4922
+di/core/factories/scoped_factory.py,sha256=h_zwEYaJ7AGTbgqgeAzeoFwI2RC1UOZIG0JMlo_RzP4,617
+di/core/factories/singleton_factory.py,sha256=GVgclQya0XpzKecVPkbnjGO66RUbj_8IBWLV3fODqdQ,1273
+di/core/factories/transient_factory.py,sha256=gfBFVwlhpC_o3ixNiKSmDAU5aDXykTL6gcwkIRznG7M,529
+di/core/protocols/container.py,sha256=KId3AAjJWq1PJVRZH7d4X_kF-JQJaSJl0opnUtowyTA,594
+di/core/protocols/factory.py,sha256=lF1ldZorxFeRf3zkRwAxtgipbMerGGC4ZxOdqF0VjFE,182
+di/core/protocols/provider.py,sha256=9itUX435vjxyRxsxfZ2Stgri4O4HyUNYiQZLzz51O9M,661
+di/core/reflection/__init__.py,sha256=ncHwkEs3kORETL5pEzWkWnUjusPBmGASPanIoRJYG_o,4493
+di/core/reflection/parameter.py,sha256=ZdD_z4YJrl2oz4ryvH1aW_Gr0CzwsOXoJKRZUoIOLhk,1850
+di/core/reflection/parameter_kind.py,sha256=KwhCxNu6hCCYvEufJeYxM_bbLLEk6Gh6sC_jDy3knuw,291
+di/core/reflection/parameter_mapper.py,sha256=CgKufyvmw7CQr5ORumzOLNYN2fzd_pROKdZsQhbKl0Y,1838
+di/core/reflection/signature.py,sha256=vEW__Jh0e9fq2bNQNTNnv_tDBkYtr5YAEBpCwe5ZQ10,1246
+di/core/reflection/undefined.py,sha256=jCJfBlGeMyjUuFtuSi7HTDdOF_t2lniey5F1j1Hlqzk,590
+dependency_injection_pattern-0.0.0.dist-info/METADATA,sha256=p-rU2BDxMzR8UKeAAgDGqmld_sLxOxyUPMRrtwHyNfs,5110
+dependency_injection_pattern-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dependency_injection_pattern-0.0.0.dist-info/top_level.txt,sha256=w4rm_1b_AMaR2CMWSKiKJ0JFWNHgEYIUil2ob6kFiMM,3
+dependency_injection_pattern-0.0.0.dist-info/RECORD,,

dependency_injection_pattern-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dependency_injection_pattern-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dagrofa BI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dependency_injection_pattern-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+di

di/__init__.py

@@ -0,0 +1,13 @@
+from di.core.container import Container
+from di.core.provider import Provider
+from di.core.scope import Scope
+from di.core.default_scope import DefaultScope
+from di.core.factory import Factory
+
+__all__ = [
+    'Container',
+    'Provider',
+    'Scope',
+    'DefaultScope',
+    'Factory'
+]

di/core/container.py

@@ -0,0 +1,336 @@
+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 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
+from di.core.factories.transient_factory import TransientFactory
+from di.core.factories.scoped_factory import ScopedFactory
+from di.core.default_scope import DefaultScope
+from di.core.named_service import NamedService
+from di.core.helpers import clean_service_name, get_service_name, is_context
+from di.core.exceptions.provide_exception import ProvideException
+from di.core.exceptions.add_exception import AddException
+from di.core.exceptions.seal_exception import SealException
+from di.core.exceptions.container_sealed_error import ContainerSealedError
+
+if TYPE_CHECKING:
+    from di.core.provider import Provider
+    from di.core.factories.factory import Factory
+
+T = TypeVar('T')
+
+class Container:
+    """
+    The Container handles the definition of services and implementations.
+
+    Example:
+        container = Container()
+        container.add_transient(Service)
+        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"]
+
+    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.__default_scope = DefaultScope()
+
+    @property
+    def default_scope(self) -> Scope:
+        return self.__default_scope
+
+    @overload
+    def add_singleton(self, service: type, /) -> None:
+        """Adds a singleton service to provider, which will result in same instance every time it's provided.
+
+        Args:
+            service (type): The service interface
+        """
+        ...
+    @overload
+    def add_singleton(self, implementation: AnyFunction, /) -> None:
+        """Adds a singleton service to provider, which will result in same instance every time it's provided.
+
+        Args:
+            implementation (AnyFunction) The service implementation
+        """
+        ...
+    @overload
+    def add_singleton(self, service: type[T], implementation: type[T] | Callable[..., T] | T, /) -> None:
+        """Adds a singleton service to provider, which will result in same instance every time it's provided.
+        Implementation may be a type derived from service, a callable or an object derived from, service.
+
+        Args:
+            service (type[T]) The service interface
+            implementation (type[T] | Callable[..., T] | T) The service implementation
+        """
+        ...
+    @overload
+    def add_singleton(self, service: str, implementation: type[T] | Callable[..., T] | T, /) -> None:
+        """Adds a singleton service to provider, which will result in same instance every time it's provided.
+        Implementation may be a type derived from service, a callable or an object derived from, service.
+
+        Args:
+            service (str) The service name
+            implementation (type[T] | Callable[..., T] | T) The service implementation
+        """
+        ...
+    def add_singleton(self, *args: Any) -> None:
+        self.__add_factory_pre(SingletonFactory, *args)
+
+    @overload
+    def add_transient(self, service: type, /) -> None:
+        """Adds a transient service to provider, which will result in a new instance every time it's provided.
+
+        Args:
+            service (type) The service interface
+
+        """
+        ...
+    @overload
+    def add_transient(self, implementation: AnyFunction, /) -> None:
+        """Adds a transient service to provider, which will result in a new instance every time it's provided.
+
+        Args:
+            implementation (AnyFunction) The service implementation
+        """
+        ...
+    @overload
+    def add_transient(self, service: type[T], implementation: type[T] | Callable[..., T], /) -> None:
+        """Adds a transient service to provider, which will result in a new instance every time it's provided.
+        Implementation may be a type derived from service or a callable.
+
+        Args:
+            service (str | type[T]) The service interface
+            implementation (type[T] | Callable[..., T]) The service implementation
+        """
+        ...
+    @overload
+    def add_transient(self, service: str, implementation: type[T] | Callable[..., T] | T, /) -> None:
+        """Adds a transient service to provider, which will result in a new instance every time it's provided.
+        Implementation may be a type derived from service or a callable.
+
+        Args:
+            service (str) The service name
+            implementation (type[T] | Callable[..., T] | T) The service implementation
+        """
+        ...
+    def add_transient(self, *args: Any) -> None:
+        self.__add_factory_pre(TransientFactory, *args)
+
+    @overload
+    def add_scoped(self, service: type, /) -> None:
+        """Adds a scoped service to provider, which will result in one instance every time it's provided in the same scope.
+        The default scope is thread-based, and bound to the lifetime of the thread in which a given service is provided.
+
+        Note: Scoped services should implement the ContextManager pattern.
+
+        Args:
+            service (type) The service interface
+        """
+        ...
+    @overload
+    def add_scoped(self, implementation: AnyFunction, /) -> None:
+        """Adds a scoped service to provider, which will result in one instance every time it's provided in the same scope.
+        The default scope is thread-based, and bound to the lifetime of the thread in which a given service is provided.
+
+        Note: Scoped services should implement the ContextManager pattern.
+
+        Args:
+            implementation (AnyFunction) The service implementation
+        """
+        ...
+    @overload
+    def add_scoped(self, service: type[T], implementation: type[T] | Callable[..., T], /) -> None:
+        """Adds a scoped service to provider, which will result in one instance every time it's provided in the same scope.
+        The default scope is thread-based, and bound to the lifetime of the thread in which a given service is provided.
+        Implementation may be a type derived from service or a callable.
+
+        Note: Scoped services should implement the ContextManager pattern.
+
+        Args:
+            service (str | type[T]) The service interface
+            implementation (type[T] | Callable[..., T]) The service implementation
+        """
+        ...
+    @overload
+    def add_scoped(self, service: str, implementation: type[T] | Callable[..., T] | T, /) -> None:
+        """Adds a scoped service to provider, which will result in one instance every time it's provided in the same scope.
+        The default scope is thread-based, and bound to the lifetime of the thread in which a given service is provided.
+        Implementation may be a type derived from service or a callable.
+
+        Note: Scoped services should implement the ContextManager pattern.
+
+        Args:
+            service (str) The service name
+            implementation (type[T] | Callable[..., T] | T) The service implementation
+        """
+        ...
+    def add_scoped(self, *args: Any) -> None:
+        service, svc_type = self.__add_factory_pre(ScopedFactory, *args)
+
+        if not is_context(svc_type):
+            LOG.warning(f"Scoped service '{service}' does not implement the context-manager pattern")
+
+    def provider(self) -> Provider:
+        """Seals Container and returns a Provider
+
+        Returns:
+            Provider -- The Provider instance
+        """
+        if self.__provider is None:
+            from di.core.provider import Provider
+            self.__provider = Provider(self)
+            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():
+                for dep in factory.dependencies.values():
+                    if not dep.service in factories:
+                        if not dep.is_optional and not dep.has_default:
+                            raise SealException(f"Service '{get_service_name(service)}' depends on service '{get_service_name(dep.service)}' which is not defined in container.")
+                        else:
+                            LOG.warning(f"Service '{get_service_name(service)}' depends on service '{get_service_name(dep.service)}' which is not defined in container.")
+                    elif not dep.is_factory and isinstance(factory, SingletonFactory):
+                        if isinstance(factories[dep.service], ScopedFactory):
+                            raise SealException(f"Singleton service '{get_service_name(service)}' depends on scoped service '{get_service_name(dep.service)}' which is not permitted.")
+                        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
+
+    def __add_factory_pre(self, factory_type: type[Factory[T]], *args: Any) -> tuple[str, type[Any]]:
+        if self.__provider != None:
+            raise ContainerSealedError
+
+        if len(args) == 2:
+            if not is_type(args[0]) and not isinstance_typing(args[0], str):
+                raise AddException("Service must be a string or a type")
+
+            service = cast(str | type, args[0])
+            implementation = cast(type | Callable[..., Any] | Any | None, args[1])
+        elif is_type(args[0]) or isinstance(args[0], str):
+            service = cast(str | type, args[0])
+            implementation = None
+        else:
+            if not isinstance(args[0], FunctionType):
+                raise AddException("Implementation must be a function or a type when no service is specified.")
+            implementation = cast(Callable[..., Any], args[0])
+            signature = reflect_function(implementation)
+            service, _ = get_optional_type(cast(type, signature.return_type))
+
+        return get_service_name(service), self.__add_factory(factory_type, cast(str | type[Any], service), implementation)
+
+
+    def __add_factory(self, factory_type: type[Factory[T]], service: str | type[T], implementation: type[T] | Callable[..., T] | T | None = None) -> type[T]:
+        if isinstance(service, str):
+            service = clean_service_name(service)
+            if service in self.__named_factories:
+                raise AddException(f"Service '{get_service_name(service)}' is already defined in provider")
+            elif implementation is None:
+                raise AddException(f"Cannot add named service '{get_service_name(service)}' without providing an implementation.")
+
+            if is_type(implementation):
+                svc_type = cast(type[T], implementation)
+            elif callable(implementation):
+                signature = reflect_function(implementation)
+                svc_type = cast(type[T], signature.return_type)
+            else:
+                svc_type = cast(type[T], type(implementation))
+
+            factory = factory_type(self, NamedService, implementation) # pyright: ignore[reportArgumentType]
+            self.__named_factories[service] = (svc_type, factory)
+            return svc_type
+
+        else:
+            if service in self.__factories:
+                raise AddException(f"Service '{get_service_name(service)}' is already defined in provider.")
+            else:
+                factory = factory_type(self, service, implementation)
+                self.__factories[cast(type, service)] = factory
+
+            return service
+
+    def _defines(self, service: str | type) -> bool:
+        """Indicates whether or not the specified service interface is defined.
+
+        Args:
+            service (str | type[T]) The service interface or name
+
+        Returns:
+            True or false (bool)
+        """
+        from di.core.provider import Provider
+
+        if isinstance(service, str):
+            return clean_service_name(service) in self.__named_factories
+        elif isinstance(service, type) and issubclass(service, Provider): # pyright: ignore[reportUnnecessaryIsInstance]
+            return True
+        elif is_type(service):
+            return service in self.__factories
+
+        return False
+
+    def _get_factory(self, service: type[T] | ServiceRequest[T]) -> tuple[Factory[T] | None, T | None, bool]:
+        svc_name: str | None = None
+        svc_type: type | None = None
+        is_optional = False
+        default: T | None = None
+        factory: Factory[T] | None = None
+
+        if isinstance(service, ServiceRequest):
+            svc_name = service.name
+            svc_type = service.type
+            default = service.default
+            svc_type, is_optional = cast(tuple[type[Any], bool], get_optional_type(svc_type))
+        else:
+            service, is_optional = get_optional_type(service)
+
+
+        for svc in [svc_type, svc_name, service]: # pyright: ignore[reportUnknownVariableType]
+            if svc is None:
+                pass
+            elif isinstance(svc, str):
+                svc = clean_service_name(svc)
+                if svc in self.__named_factories:
+                    svc_def = self.__named_factories[svc]
+                    if svc_def[0] is svc_type:
+                        factory = svc_def[1]
+                        break
+            elif is_type(svc):
+                if svc in self.__factories:
+                    factory = self.__factories[cast(type, svc)]
+                    break
+
+        return factory, default, is_optional
+
+    def _get(self, service: type[T] | ServiceRequest[T]) -> Factory[T] | T | None:
+        """Returns the factory for the specified service interface
+
+        Arguments:
+            service {type[T] | ServiceRequest[T]} -- The service interface
+
+        Raises:
+            ProvideException: If service cannot be resolved
+
+        Returns:
+            Factory[T] | T | None -- The service factory
+        """
+        factory, default, is_optional = self._get_factory(service)
+
+        if factory:
+            return factory
+        elif default != None:
+            return default
+        elif not is_optional:
+            if isinstance(service, ServiceRequest):
+                raise ProvideException(service.type)
+            else:
+                raise ProvideException(service)

di/core/default_scope.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from typing import TypeVar, Callable, MutableMapping, cast
+from threading import Thread, local, current_thread, main_thread
+
+from di.core.log import LOG
+from di.core.scope import Scope
+from di.core.exceptions.provide_exception import ProvideException
+from di.core.helpers import is_context, get_service_name
+
+T = TypeVar('T')
+
+
+class DefaultScope(Scope):
+    """
+    DefaultScope is as the name implies the default scope. This scope is thread-based, meaning it will supply
+    the same instance of a service, each time it's requested on the same thread.
+    It will automatically handle object lifetime of scoped services, which are required to implement
+    the Contextmanager pattern (supplying  standard Python __enter__ and __exit__ methods),
+    by finalizing them at the end of scope (i.e. thread exit).
+    """
+    __slots__ = ["__local"]
+
+    def __init__(self):
+        if not hasattr(self, "_DefaultScope__local"): # pragma: no cover
+            self.__local = local()
+
+    def provide(self, service: type[T], factory: Callable[[], T]) -> T:
+        if current_thread() == main_thread():
+            raise ProvideException(service,
+                """Using DefaultScope on main thread is not permitted.
+                If referencing a scoped service on a transient or singleton service,
+                consider using the Factory[Service] method""")
+
+        if not hasattr(self.__local, "dict"):
+            LOG.debug(f"Initializing scope for thread '{current_thread().name}'")
+            dict: MutableMapping[type[T], T] = {}
+            self.__local.dict = dict
+
+            def finalize(thread: Thread, dict: MutableMapping[type[T], T]) -> None:
+                thread.join() # wait until thread is finished
+                LOG.debug(f"Finalizing scope for thread '{current_thread().name}'")
+                for service, implementation in dict.items():
+                    try:
+                        if is_context(service):
+                            LOG.debug(f"Disposing service '{get_service_name(service)}' on thread '{current_thread().name}'")
+                            getattr(implementation, "__exit__")()
+
+                    except Exception as ex: # pragma: no cover
+                        # swallow exception, as it's caught in the finalizer thread
+                        LOG.error(f"Disposing of service '{get_service_name(service)}' failed: {ex}")
+
+
+                dict.clear()
+
+            if current_thread() != main_thread(): # only implement finalizer if thread is not main thread # pragma: no cover
+                self.__local.finalizer = Thread(target = finalize, args = [ current_thread(), dict ])
+                self.__local.finalizer.start()
+
+        if not service in self.__local.dict:
+            impl = factory()
+            if current_thread() != main_thread() and is_context(service):
+                # finalizer is only implemented when thread is not main thread, otherwise object would never be exited (eg. finalized)
+                LOG.debug(f"Initializing service '{get_service_name(service)}' on thread '{current_thread().name}'")
+                impl = cast(T, getattr(impl, "__enter__")())
+                if not isinstance(impl, service): # pragma: no cover
+                    raise ProvideException(service, f"Service '{get_service_name(service)}' implementation's __enter__() method returned an object of different type than service")
+
+            self.__local.dict[service] = impl
+
+        return cast(T, self.__local.dict[service])
+

di/core/exceptions/add_exception.py

@@ -0,0 +1,7 @@
+# pragma: no cover
+class AddException(Exception):
+    """
+    The AddException is raised when container cannot add a service either because service is already registered
+    or because the container encountered an error with the specified service and implementation arguments.
+    """
+

di/core/exceptions/container_sealed_error.py

@@ -0,0 +1,5 @@
+# pragma: no cover
+class ContainerSealedError(Exception):
+    """
+    The ContainerSealedError is raised when container has been sealed, and additional services are being added afterwards.
+    """

di/core/exceptions/factory_provide_exception.py

@@ -0,0 +1,25 @@
+# pragma: no cover
+from typing import Mapping, overload
+from typingutils import AnyType
+
+from di.core.helpers import get_service_name
+
+class FactoryProvideException(Exception):
+    """
+    The FactoryProvideException is raised when factory cannot provide service, because one or more
+    of it's arguments cannot be provided, or when implementation returns an unexpected value
+    or raises an exception.
+    """
+    @overload
+    def __init__(self, service: AnyType | str) -> None:
+        ...
+    @overload
+    def __init__(self, service: AnyType | str, failed_args: Mapping[str, type]) -> None:
+        ...
+    def __init__(self, service: AnyType | str, failed_args: Mapping[str, type] | None = None):
+        service = get_service_name(service)
+        if failed_args:
+            f_args = ", ".join([ f"'{arg}'({get_service_name(arg_type)})" for arg, arg_type in failed_args.items() ])
+            super().__init__(f"Cannot provide service '{service}' because argument(s) {f_args} cannot be provided")
+        else:
+            super().__init__(f"Cannot provide service '{service}'")

di/core/exceptions/implementation_exception.py

@@ -0,0 +1,13 @@
+# pragma: no cover
+from typing import Any
+
+from di.core.helpers import get_service_name
+
+class ImplementationException(Exception):
+    """
+    The ImplementationException is raised at initialization time when factory cannot provide service using the
+    specified implementation. This could be due to implementation not resolving to a class derived from service,
+    or that implementaion cannot be resolved at all due to missing type annotations.
+    """
+    def __init__(self, service: type | str, implementation: Any, error: str):
+        super().__init__(f"Factory cannot implement service '{get_service_name(service)}' via '{implementation}': {error}")