ps-dependency-injection 0.2.9__tar.gz

ps_dependency_injection-0.2.9/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: ps-dependency-injection
+Version: 0.2.9
+Summary: Lightweight, thread-safe dependency injection container for Python
+Author: ztBlackGad
+Requires-Python: >=3.10,<3.14
+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
+Project-URL: Homepage, https://github.com/BlackGad/ps-poetry
+Project-URL: Repository, https://github.com/BlackGad/ps-poetry
+Description-Content-Type: text/markdown
+
+# Overview
+
+PS DI is a lightweight, thread-safe dependency injection container for Python. It provides a `DI` class that manages service registration, resolution, and automatic constructor injection. Registrations support singleton and transient lifetimes, priority-based ordering, and resolution by type or string name.
+
+# Installation
+
+```bash
+pip install ps-dependency-injection
+```
+
+Or with Poetry:
+
+```bash
+poetry add ps-dependency-injection
+```
+
+# Quick Start
+
+```python
+from ps.di import DI, Lifetime
+
+di = DI()
+
+di.register(Logger).factory(Logger, "app")
+di.register(UserRepository, Lifetime.TRANSIENT).implementation(UserRepository)
+
+repo = di.resolve(UserRepository)
+```
+
+[View full example](https://github.com/BlackGad/ps-poetry/blob/main/src/examples/ps-dependency-injection/basic_usage_example.py)
+
+# Register Services
+
+The `register` method accepts a type (or string key), an optional `Lifetime`, and an optional `Priority`. It returns a `Binding` object that configures how the service is created.
+
+* `.factory(callable, *args, **kwargs)` — Registers a callable that produces the service. Typed parameters not covered by explicit arguments are resolved from the container at registration time, using the same injection rules as `satisfy`. Explicit positional and keyword arguments take precedence over container resolution.
+* `.implementation(cls)` — Registers a class whose constructor is invoked via `spawn`, allowing the container to inject known dependencies automatically.
+
+```python
+from ps.di import DI, Lifetime
+
+di = DI()
+
+# Singleton (default) — one shared instance
+di.register(Logger).factory(Logger, "app")
+
+# Transient — new instance on every resolve
+di.register(UserRepository, Lifetime.TRANSIENT).implementation(UserRepository)
+```
+
+`Lifetime` values:
+
+* `SINGLETON` — The factory is called once; all subsequent resolves return the same instance. This is the default.
+* `TRANSIENT` — The factory is called on every resolve, producing a new instance each time.
+
+# Resolve Services
+
+Use `resolve` to retrieve the highest-priority registration for a type, or `resolve_many` to retrieve all registrations ordered by priority.
+
+```python
+service = di.resolve(Logger)          # Logger | None
+all_loggers = di.resolve_many(Logger) # list[Logger]
+```
+
+`resolve` returns `None` when no registration exists for the requested type. `resolve_many` returns an empty list in that case.
+
+Both methods also accept a string type name instead of a class:
+
+```python
+service = di.resolve("Logger")
+```
+
+String resolution matches against the `__name__` attribute of registered types and raises `ValueError` when no match is found.
+
+# Priority
+
+Each registration carries a `Priority` that determines its position relative to other registrations for the same type. Higher-priority registrations are resolved first by `resolve` and appear earlier in the list returned by `resolve_many`.
+
+```python
+from ps.di import DI, Priority
+
+di = DI()
+
+di.register(NotificationService, priority=Priority.LOW).factory(NotificationService, "email")
+di.register(NotificationService, priority=Priority.HIGH).factory(NotificationService, "sms")
+di.register(NotificationService, priority=Priority.MEDIUM).factory(NotificationService, "push")
+
+primary = di.resolve(NotificationService)  # sms (HIGH wins)
+```
+
+[View full example](https://github.com/BlackGad/ps-poetry/blob/main/src/examples/ps-dependency-injection/priority_example.py)
+
+`Priority` values: `LOW` (default), `MEDIUM`, `HIGH`. When multiple registrations share the same priority, the most recently registered one wins.
+
+# Spawn Objects
+
+`spawn` instantiates a class without registering it, injecting constructor dependencies from the container automatically. It inspects type hints on `__init__` parameters and resolves them as follows:
+
+* A parameter typed as `DI` or a subclass of `DI` receives the container itself.
+* A parameter typed as `List[T]` receives the result of `resolve_many(T)`.
+* A parameter typed as `Optional[T]` receives the result of `resolve(T)`, falling back to the default value when nothing is registered.
+* Any other typed parameter receives the result of `resolve(T)`. If `resolve` returns `None` and no default exists, `spawn` raises `ValueError`.
+
+Positional and keyword arguments passed to `spawn` override automatic resolution:
+
+```python
+from ps.di import DI
+
+di = DI()
+di.register(Logger).factory(Logger, "app")
+
+repo = di.spawn(UserRepository)                       # Logger injected from container
+repo = di.spawn(UserRepository, logger=custom_logger)  # explicit override
+```
+
+# Satisfy Functions
+
+`satisfy` binds a callable to dependencies resolved from the container at the time of the call, returning a new callable that accepts any remaining parameters at invocation time.
+
+* Parameters with registered types are resolved from the container automatically.
+* Parameters with defaults fall back to their default values when no registration exists.
+* Parameters typed as `List[T]` receive all registered instances of `T`.
+* Parameters typed as `Optional[T]` receive `None` when no registration exists.
+* Parameters marked with `REQUIRED` are excluded from DI resolution and must be supplied by the caller.
+
+```python
+from ps.di import DI, REQUIRED
+
+log_message = di.satisfy(format_log, message=REQUIRED)
+
+print(log_message(message="Application started"))
+print(log_message(message="Low disk space", level="WARNING"))
+```
+
+[View full example](https://github.com/BlackGad/ps-poetry/blob/main/src/examples/ps-dependency-injection/satisfy_example.py)
+
+The returned callable accepts keyword arguments at invocation time. Any keyword argument passed at invocation time overrides the corresponding resolved value, including DI-resolved parameters.
+
+# Scopes
+
+`scope()` creates a child `DI` instance that inherits all registrations from the parent but maintains its own isolated registry. This is useful for per-request, per-session, or any other short-lived context that needs additional or overriding registrations without affecting the parent container.
+
+Resolution in a scoped container follows these rules:
+
+* `resolve` checks the scoped registry first; if nothing is registered, it falls through to the parent.
+* `resolve_many` returns scoped registrations followed by parent registrations, with scoped results first.
+* `spawn` and `satisfy` use the scoped resolver, so injected dependencies prefer scoped registrations.
+* A parameter typed as `DI` receives the scoped instance, not the parent.
+
+Scopes support the context manager protocol. Exiting the `with` block clears the scoped registry and releases all singleton instances held by the scope, enabling deterministic cleanup of resources such as database connections or file handles.
+
+```python
+with di.scope() as request_scope:
+    request_scope.register(RequestContext).factory(RequestContext, request_id)
+    handler = request_scope.spawn(RequestHandler)
+    handler.handle()
+# scoped singletons released here; parent container unaffected
+```
+
+[View full example](https://github.com/BlackGad/ps-poetry/blob/main/src/examples/ps-dependency-injection/scope_example.py)
+
+The root container supports the same context manager protocol. Exiting a `with di:` block clears all registrations and releases every singleton instance held by the container.
+
+Scopes can be nested arbitrarily. Each level sees its own registrations plus all ancestor registrations, with closer scopes taking precedence.
+
+# Thread Safety
+
+All registration and resolution operations are protected by internal locks. Singleton creation uses double-checked locking so the factory is called exactly once even under concurrent access. Transient registrations produce independent instances per call with no shared mutable state.
+

ps_dependency_injection-0.2.9/README.md

@@ -0,0 +1,168 @@
+# Overview
+
+PS DI is a lightweight, thread-safe dependency injection container for Python. It provides a `DI` class that manages service registration, resolution, and automatic constructor injection. Registrations support singleton and transient lifetimes, priority-based ordering, and resolution by type or string name.
+
+# Installation
+
+```bash
+pip install ps-dependency-injection
+```
+
+Or with Poetry:
+
+```bash
+poetry add ps-dependency-injection
+```
+
+# Quick Start
+
+```python
+from ps.di import DI, Lifetime
+
+di = DI()
+
+di.register(Logger).factory(Logger, "app")
+di.register(UserRepository, Lifetime.TRANSIENT).implementation(UserRepository)
+
+repo = di.resolve(UserRepository)
+```
+
+[View full example](https://github.com/BlackGad/ps-poetry/blob/main/src/examples/ps-dependency-injection/basic_usage_example.py)
+
+# Register Services
+
+The `register` method accepts a type (or string key), an optional `Lifetime`, and an optional `Priority`. It returns a `Binding` object that configures how the service is created.
+
+* `.factory(callable, *args, **kwargs)` — Registers a callable that produces the service. Typed parameters not covered by explicit arguments are resolved from the container at registration time, using the same injection rules as `satisfy`. Explicit positional and keyword arguments take precedence over container resolution.
+* `.implementation(cls)` — Registers a class whose constructor is invoked via `spawn`, allowing the container to inject known dependencies automatically.
+
+```python
+from ps.di import DI, Lifetime
+
+di = DI()
+
+# Singleton (default) — one shared instance
+di.register(Logger).factory(Logger, "app")
+
+# Transient — new instance on every resolve
+di.register(UserRepository, Lifetime.TRANSIENT).implementation(UserRepository)
+```
+
+`Lifetime` values:
+
+* `SINGLETON` — The factory is called once; all subsequent resolves return the same instance. This is the default.
+* `TRANSIENT` — The factory is called on every resolve, producing a new instance each time.
+
+# Resolve Services
+
+Use `resolve` to retrieve the highest-priority registration for a type, or `resolve_many` to retrieve all registrations ordered by priority.
+
+```python
+service = di.resolve(Logger)          # Logger | None
+all_loggers = di.resolve_many(Logger) # list[Logger]
+```
+
+`resolve` returns `None` when no registration exists for the requested type. `resolve_many` returns an empty list in that case.
+
+Both methods also accept a string type name instead of a class:
+
+```python
+service = di.resolve("Logger")
+```
+
+String resolution matches against the `__name__` attribute of registered types and raises `ValueError` when no match is found.
+
+# Priority
+
+Each registration carries a `Priority` that determines its position relative to other registrations for the same type. Higher-priority registrations are resolved first by `resolve` and appear earlier in the list returned by `resolve_many`.
+
+```python
+from ps.di import DI, Priority
+
+di = DI()
+
+di.register(NotificationService, priority=Priority.LOW).factory(NotificationService, "email")
+di.register(NotificationService, priority=Priority.HIGH).factory(NotificationService, "sms")
+di.register(NotificationService, priority=Priority.MEDIUM).factory(NotificationService, "push")
+
+primary = di.resolve(NotificationService)  # sms (HIGH wins)
+```
+
+[View full example](https://github.com/BlackGad/ps-poetry/blob/main/src/examples/ps-dependency-injection/priority_example.py)
+
+`Priority` values: `LOW` (default), `MEDIUM`, `HIGH`. When multiple registrations share the same priority, the most recently registered one wins.
+
+# Spawn Objects
+
+`spawn` instantiates a class without registering it, injecting constructor dependencies from the container automatically. It inspects type hints on `__init__` parameters and resolves them as follows:
+
+* A parameter typed as `DI` or a subclass of `DI` receives the container itself.
+* A parameter typed as `List[T]` receives the result of `resolve_many(T)`.
+* A parameter typed as `Optional[T]` receives the result of `resolve(T)`, falling back to the default value when nothing is registered.
+* Any other typed parameter receives the result of `resolve(T)`. If `resolve` returns `None` and no default exists, `spawn` raises `ValueError`.
+
+Positional and keyword arguments passed to `spawn` override automatic resolution:
+
+```python
+from ps.di import DI
+
+di = DI()
+di.register(Logger).factory(Logger, "app")
+
+repo = di.spawn(UserRepository)                       # Logger injected from container
+repo = di.spawn(UserRepository, logger=custom_logger)  # explicit override
+```
+
+# Satisfy Functions
+
+`satisfy` binds a callable to dependencies resolved from the container at the time of the call, returning a new callable that accepts any remaining parameters at invocation time.
+
+* Parameters with registered types are resolved from the container automatically.
+* Parameters with defaults fall back to their default values when no registration exists.
+* Parameters typed as `List[T]` receive all registered instances of `T`.
+* Parameters typed as `Optional[T]` receive `None` when no registration exists.
+* Parameters marked with `REQUIRED` are excluded from DI resolution and must be supplied by the caller.
+
+```python
+from ps.di import DI, REQUIRED
+
+log_message = di.satisfy(format_log, message=REQUIRED)
+
+print(log_message(message="Application started"))
+print(log_message(message="Low disk space", level="WARNING"))
+```
+
+[View full example](https://github.com/BlackGad/ps-poetry/blob/main/src/examples/ps-dependency-injection/satisfy_example.py)
+
+The returned callable accepts keyword arguments at invocation time. Any keyword argument passed at invocation time overrides the corresponding resolved value, including DI-resolved parameters.
+
+# Scopes
+
+`scope()` creates a child `DI` instance that inherits all registrations from the parent but maintains its own isolated registry. This is useful for per-request, per-session, or any other short-lived context that needs additional or overriding registrations without affecting the parent container.
+
+Resolution in a scoped container follows these rules:
+
+* `resolve` checks the scoped registry first; if nothing is registered, it falls through to the parent.
+* `resolve_many` returns scoped registrations followed by parent registrations, with scoped results first.
+* `spawn` and `satisfy` use the scoped resolver, so injected dependencies prefer scoped registrations.
+* A parameter typed as `DI` receives the scoped instance, not the parent.
+
+Scopes support the context manager protocol. Exiting the `with` block clears the scoped registry and releases all singleton instances held by the scope, enabling deterministic cleanup of resources such as database connections or file handles.
+
+```python
+with di.scope() as request_scope:
+    request_scope.register(RequestContext).factory(RequestContext, request_id)
+    handler = request_scope.spawn(RequestHandler)
+    handler.handle()
+# scoped singletons released here; parent container unaffected
+```
+
+[View full example](https://github.com/BlackGad/ps-poetry/blob/main/src/examples/ps-dependency-injection/scope_example.py)
+
+The root container supports the same context manager protocol. Exiting a `with di:` block clears all registrations and releases every singleton instance held by the container.
+
+Scopes can be nested arbitrarily. Each level sees its own registrations plus all ancestor registrations, with closer scopes taking precedence.
+
+# Thread Safety
+
+All registration and resolution operations are protected by internal locks. Singleton creation uses double-checked locking so the factory is called exactly once even under concurrent access. Transient registrations produce independent instances per call with no shared mutable state.

ps_dependency_injection-0.2.9/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name        = "ps-dependency-injection"
+description = "Lightweight, thread-safe dependency injection container for Python"
+readme      = "README.md"
+requires-python = ">=3.10,<3.14"
+version = "0.2.9"
+authors = [
+    { name = "ztBlackGad" },
+]
+
+[project.urls]
+Homepage   = "https://github.com/BlackGad/ps-poetry"
+Repository = "https://github.com/BlackGad/ps-poetry"
+
+[tool.poetry]
+packages = [ { include = "ps/di", from = "src" } ]
+
+[tool.ps-plugin]
+host-project = "../.."
+
+[build-system]
+requires    = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

ps_dependency_injection-0.2.9/src/ps/di/__init__.py

@@ -0,0 +1,10 @@
+from ._enums import Lifetime, Priority
+from ._di import Binding, DI, REQUIRED
+
+__all__ = [
+    "DI",
+    "Binding",
+    "Lifetime",
+    "Priority",
+    "REQUIRED",
+]

ps_dependency_injection-0.2.9/src/ps/di/_di.py

@@ -0,0 +1,197 @@
+import inspect
+import threading
+from typing import Any, Callable, List, Optional, Self, Type, TypeVar, Union, cast, get_args, get_origin, get_type_hints
+
+from ._enums import Lifetime, Priority
+from ._registration import _Registration, _Registrations
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+class _Sentinel:
+    def __repr__(self) -> str:
+        return "REQUIRED"
+
+
+REQUIRED: _Sentinel = _Sentinel()
+
+
+class Binding[T]:
+    def __init__(self, di: "DI", cls: Type[T], lifetime: Lifetime, priority: Priority) -> None:
+        self._di = di
+        self._cls = cls
+        self._lifetime = lifetime
+        self._priority = priority
+
+    def implementation(self, impl: Type[T]) -> None:
+        self._di._register(self._cls, _Registration(self._lifetime, self._priority, lambda: self._di.spawn(impl)))
+
+    def factory(self, factory: Callable[..., T], *args: Any, **kwargs: Any) -> None:
+        explicit: dict[str, Any] = dict(kwargs)
+        if args:
+            sig = inspect.signature(factory)
+            params = list(sig.parameters.values())
+            explicit = {p.name: v for p, v in zip(params, args, strict=False)} | explicit
+        self._di._register(self._cls, _Registration(self._lifetime, self._priority, self._di.satisfy(factory, **explicit)))
+
+
+class DI:
+    def __init__(self) -> None:
+        self._registry: dict[Type, _Registrations] = {}
+        self._lock_registry_access = threading.Lock()
+        self._signature_cache: dict[Any, inspect.Signature] = {}
+        self._type_name_cache: dict[str, Type] = {}
+
+    def _resolve_type(self, key: Type[T] | str) -> Type[T]:
+        if isinstance(key, str):
+            if key not in self._type_name_cache:
+                found = next((t for t in self._registry if t.__name__ == key), None)
+                if found is None:
+                    raise ValueError(f"Cannot resolve type from string '{key}' - no matching type registered")
+                self._type_name_cache[key] = found
+            return self._type_name_cache[key]
+        return key
+
+    def register(self, cls: Type[T] | str, lifetime: Lifetime = Lifetime.SINGLETON, priority: Priority = Priority.LOW) -> Binding[T]:
+        resolved_cls = cast(Type[T], self._resolve_type(cls)) if isinstance(cls, str) else cls
+        return Binding(self, resolved_cls, lifetime=lifetime, priority=priority)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        with self._lock_registry_access:
+            self._registry.clear()
+        self._signature_cache.clear()
+        self._type_name_cache.clear()
+
+    def resolve(self, key: Type[T] | str) -> Optional[T]:
+        resolved_key = self._resolve_type(key) if isinstance(key, str) else key
+        with self._lock_registry_access:
+            registrations = self._registry.get(resolved_key)
+        if registrations is None:
+            return None
+        return cast(T, registrations.resolve_first())
+
+    def resolve_many(self, key: Type[T] | str) -> List[T]:
+        resolved_key = self._resolve_type(key) if isinstance(key, str) else key
+        with self._lock_registry_access:
+            registrations = self._registry.get(resolved_key)
+        if registrations is None:
+            return []
+        return registrations.resolve_all()
+
+    def _register(self, cls: Type[T], registration: _Registration[T]) -> None:
+        with self._lock_registry_access:
+            registrations = self._registry.setdefault(cls, _Registrations())
+        registrations.add_registration(registration)
+
+    def _try_resolve_annotation(self, annotation: Any, has_default: bool, default: Any) -> tuple[bool, Any]:
+        if annotation is DI or (isinstance(annotation, type) and issubclass(annotation, DI)):
+            return True, self
+
+        origin = get_origin(annotation)
+
+        if origin is list:
+            type_args = get_args(annotation)
+            return True, self.resolve_many(type_args[0]) if type_args else []
+
+        if origin is Union:
+            type_args = get_args(annotation)
+            if type(None) in type_args:
+                non_none_type = next(t for t in type_args if t is not type(None))
+                resolved = self.resolve(non_none_type)
+                if resolved is not None:
+                    return True, resolved
+                return True, default if has_default else None
+
+        resolved = self.resolve(annotation)
+        if resolved is not None:
+            return True, resolved
+        if has_default:
+            return True, default
+        return False, None
+
+    def _resolve_kwargs(self, fn: Callable, skip_self: bool, explicit_kwargs: dict[str, Any]) -> dict[str, Any]:
+        if fn not in self._signature_cache:
+            self._signature_cache[fn] = inspect.signature(fn)
+        sig = self._signature_cache[fn]
+
+        hints_target = fn.__init__ if isinstance(fn, type) else fn
+        try:
+            type_hints = get_type_hints(hints_target)
+        except Exception:
+            type_hints = {}
+
+        required_params = {k for k, v in explicit_kwargs.items() if v is REQUIRED}
+        final_kwargs = {k: explicit_kwargs[k] for k in explicit_kwargs.keys() - required_params}
+        params = list(sig.parameters.values())[1 if skip_self else 0:]
+
+        for param in params:
+            if param.name in final_kwargs or param.name in required_params:
+                continue
+
+            annotation = type_hints.get(param.name, param.annotation)
+            if annotation == inspect.Parameter.empty:
+                continue
+
+            has_default = param.default != inspect.Parameter.empty
+            ok, value = self._try_resolve_annotation(annotation, has_default, param.default)
+            if not ok:
+                raise ValueError(f"Cannot resolve required dependency {annotation} for parameter {param.name}")
+            final_kwargs[param.name] = value
+
+        return final_kwargs
+
+    def spawn(self, cls: Type[T], *args: Any, **kwargs: Any) -> T:
+        fn = cls.__init__
+        if args:
+            if fn not in self._signature_cache:
+                self._signature_cache[fn] = inspect.signature(fn)
+            params = list(self._signature_cache[fn].parameters.values())[1:]
+            kwargs = {p.name: v for p, v in zip(params, args, strict=False)} | kwargs
+        return cls(**self._resolve_kwargs(fn, skip_self=True, explicit_kwargs=kwargs))
+
+    def satisfy(self, fn: Callable[..., R], **kwargs: Any) -> Callable[..., R]:
+        resolved_kwargs = self._resolve_kwargs(fn, skip_self=False, explicit_kwargs=kwargs)
+
+        def wrapper(**override: Any) -> R:
+            return fn(**resolved_kwargs | override)
+
+        return wrapper
+
+    def scope(self) -> "DI":
+        return _ScopedDI(self)
+
+
+class _ScopedDI(DI):
+    def __init__(self, parent: DI) -> None:
+        super().__init__()
+        self._parent = parent
+
+    def _resolve_type(self, key: Type[T] | str) -> Type[T]:
+        if isinstance(key, str):
+            if key not in self._type_name_cache:
+                found = next((t for t in self._registry if t.__name__ == key), None)
+                if found is None:
+                    return self._parent._resolve_type(key)
+                self._type_name_cache[key] = found
+            return self._type_name_cache[key]
+        return key
+
+    def resolve(self, key: Type[T] | str) -> Optional[T]:
+        resolved_key = self._resolve_type(key) if isinstance(key, str) else key
+        with self._lock_registry_access:
+            registrations = self._registry.get(resolved_key)
+        if registrations is not None:
+            return cast(T, registrations.resolve_first())
+        return self._parent.resolve(key)
+
+    def resolve_many(self, key: Type[T] | str) -> List[T]:
+        resolved_key = self._resolve_type(key) if isinstance(key, str) else key
+        with self._lock_registry_access:
+            registrations = self._registry.get(resolved_key)
+        scoped_results: List[T] = registrations.resolve_all() if registrations is not None else []
+        parent_results: List[T] = self._parent.resolve_many(key)
+        return scoped_results + parent_results

ps_dependency_injection-0.2.9/src/ps/di/_enums.py

@@ -0,0 +1,13 @@
+from enum import IntEnum
+
+
+class Lifetime(IntEnum):
+    UNKNOWN = 0
+    SINGLETON = 1
+    TRANSIENT = 2
+
+
+class Priority(IntEnum):
+    LOW = 0
+    MEDIUM = 1
+    HIGH = 2

ps_dependency_injection-0.2.9/src/ps/di/_registration.py

@@ -0,0 +1,52 @@
+import threading
+from typing import Callable, List, Optional
+
+from ._enums import Lifetime, Priority
+
+
+class _Registration[T]:
+    def __init__(self, lifetime: Lifetime, priority: Priority, factory: Callable[[], T]) -> None:
+        self.lifetime = lifetime
+        self.priority = priority
+        self.factory = factory
+        self.instance: Optional[T] = None
+        self._lock_singleton_creation = threading.Lock()
+
+    def resolve(self) -> T:
+        match self.lifetime:
+            case Lifetime.SINGLETON:
+                if self.instance is None:
+                    with self._lock_singleton_creation:
+                        if self.instance is None:
+                            self.instance = self.factory()
+                return self.instance
+            case Lifetime.TRANSIENT:
+                return self.factory()
+            case _:
+                raise ValueError("Unknown lifetime for registration.")
+
+
+class _Registrations:
+    def __init__(self) -> None:
+        self._registrations: List[_Registration] = []
+        self._lock_registrations_access = threading.Lock()
+
+    def add_registration(self, registration: _Registration) -> None:
+        with self._lock_registrations_access:
+            insert_pos = 0
+            for i, existing in enumerate(self._registrations):
+                if registration.priority >= existing.priority:
+                    insert_pos = i
+                    break
+                insert_pos = i + 1
+            self._registrations.insert(insert_pos, registration)
+
+    def resolve_first(self) -> object:
+        with self._lock_registrations_access:
+            registration = self._registrations[0]
+        return registration.resolve()
+
+    def resolve_all(self) -> List:
+        with self._lock_registrations_access:
+            registrations = list(self._registrations)
+        return [registration.resolve() for registration in registrations]