python-injection 0.26.3__tar.gz → 0.27.0__tar.gz

{python_injection-0.26.3 → python_injection-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-injection
-Version: 0.26.3
+Version: 0.27.0
 Summary: Dead-simple dependency injection framework for Python.
 Project-URL: Documentation, https://python-injection.remimd.dev
 Project-URL: Repository, https://github.com/100nm/python-injection
@@ -32,12 +32,12 @@ Description-Content-Type: text/markdown
 
 # python-injection
 
-[![PyPI - Version](https://img.shields.io/pypi/v/python-injection.svg?color=546d78&style=for-the-badge)](https://pypi.org/project/python-injection)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/python-injection.svg?color=546d78&style=for-the-badge)](https://pypistats.org/packages/python-injection)
+[![PyPI - Version](https://shieldcn.dev/pypi/v/python-injection.svg?variant=secondary)](https://pypi.org/project/python-injection)
+[![PyPI - Downloads](https://shieldcn.dev/pypi/dm/python-injection.svg?variant=secondary)](https://pypistats.org/packages/python-injection)
 
 ## Project motivations
 
-Dependency injection in Python has long been a source of frustration. 
+Dependency injection in Python has long been a source of frustration.
 
 Existing solutions are often verbose, require extensive boilerplate, or fail to leverage Python's type hints effectively. `python-injection` was created to solve these problems once and for all by providing a simple, elegant, and powerful dependency injection framework that feels natural to Python developers.
 
@@ -47,13 +47,13 @@ The goal is straightforward: make dependency injection so easy that you'll wonde
 
 - **Type-driven resolution**: Dependencies are automatically resolved using Python's type annotations.
 - **Decorator-based registration**: Register your dependencies with simple, readable decorators.
-- **Flexible lifetimes**: Choose from 4 type of lifetimes to match your needs:
+- **Flexible lifetimes**: Choose from four types of lifetimes to match your needs:
     - **Transient**: A new instance every time
     - **Singleton**: One instance for the entire application
     - **Scoped**: One instance per scope, with context manager support
-    - **Constant**: Register pre-existing values
+    - **Constant**: A value created once and never re-resolved, either pre-existing or computed lazily
 - **Profile support**: Ability to swap certain dependencies based on a profile.
-- **Pull-based instantiation**: Dependencies are only created when needed, improving startup time and resource usage.
+- **Pull-based instantiation**: Dependencies registered with decorators are only created when needed, improving startup time and resource usage.
 - **Full sync/async support**: Works seamlessly with both synchronous and asynchronous code.
 
 ## Installation

{python_injection-0.26.3 → python_injection-0.27.0}/docs/index.md

@@ -1,11 +1,11 @@
 # python-injection
 
-[![PyPI - Version](https://img.shields.io/pypi/v/python-injection.svg?color=546d78&style=for-the-badge)](https://pypi.org/project/python-injection)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/python-injection.svg?color=546d78&style=for-the-badge)](https://pypistats.org/packages/python-injection)
+[![PyPI - Version](https://shieldcn.dev/pypi/v/python-injection.svg?variant=secondary)](https://pypi.org/project/python-injection)
+[![PyPI - Downloads](https://shieldcn.dev/pypi/dm/python-injection.svg?variant=secondary)](https://pypistats.org/packages/python-injection)
 
 ## Project motivations
 
-Dependency injection in Python has long been a source of frustration. 
+Dependency injection in Python has long been a source of frustration.
 
 Existing solutions are often verbose, require extensive boilerplate, or fail to leverage Python's type hints effectively. `python-injection` was created to solve these problems once and for all by providing a simple, elegant, and powerful dependency injection framework that feels natural to Python developers.
 
@@ -15,13 +15,13 @@ The goal is straightforward: make dependency injection so easy that you'll wonde
 
 - **Type-driven resolution**: Dependencies are automatically resolved using Python's type annotations.
 - **Decorator-based registration**: Register your dependencies with simple, readable decorators.
-- **Flexible lifetimes**: Choose from 4 type of lifetimes to match your needs:
+- **Flexible lifetimes**: Choose from four types of lifetimes to match your needs:
     - **Transient**: A new instance every time
     - **Singleton**: One instance for the entire application
     - **Scoped**: One instance per scope, with context manager support
-    - **Constant**: Register pre-existing values
+    - **Constant**: A value created once and never re-resolved, either pre-existing or computed lazily
 - **Profile support**: Ability to swap certain dependencies based on a profile.
-- **Pull-based instantiation**: Dependencies are only created when needed, improving startup time and resource usage.
+- **Pull-based instantiation**: Dependencies registered with decorators are only created when needed, improving startup time and resource usage.
 - **Full sync/async support**: Works seamlessly with both synchronous and asynchronous code.
 
 ## Installation

{python_injection-0.26.3 → python_injection-0.27.0}/injection/_core/common/asynchronous.py

@@ -4,7 +4,7 @@ from contextlib import AbstractAsyncContextManager
 from dataclasses import dataclass
 from typing import Any, NoReturn, Protocol, runtime_checkable
 
-AsyncSemaphore: Callable[[int], AbstractAsyncContextManager[Any]]
+AsyncLock: Callable[[], AbstractAsyncContextManager[Any]]
 
 try:
     import anyio
@@ -12,10 +12,10 @@ try:
 except ImportError:  # pragma: no cover
     import asyncio
 
-    AsyncSemaphore = asyncio.Semaphore
+    AsyncLock = asyncio.Lock
 
 else:
-    AsyncSemaphore = anyio.Semaphore
+    AsyncLock = anyio.Lock
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)

{python_injection-0.26.3 → python_injection-0.27.0}/injection/_core/common/threading.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from contextlib import AbstractContextManager, nullcontext
 from os import getenv
-from threading import RLock
+from threading import Lock
 from typing import Any, Final
 
 _PYTHON_INJECTION_THREADSAFE: Final[bool] = bool(
@@ -8,6 +10,13 @@ _PYTHON_INJECTION_THREADSAFE: Final[bool] = bool(
 )
 
 
-def get_lock(threadsafe: bool | None = None) -> AbstractContextManager[Any]:
+def lock_if_threadsafe(
+    lock: AbstractContextManager[Any] | None = None,
+    threadsafe: bool | None = None,
+) -> AbstractContextManager[Any]:
     threadsafe = _PYTHON_INJECTION_THREADSAFE if threadsafe is None else threadsafe
-    return RLock() if threadsafe else nullcontext()
+
+    if not threadsafe:
+        return nullcontext()
+
+    return lock or Lock()

{python_injection-0.26.3 → python_injection-0.27.0}/injection/_core/injectables.py

@@ -12,7 +12,7 @@ from typing import (
     runtime_checkable,
 )
 
-from injection._core.common.asynchronous import AsyncSemaphore, Caller
+from injection._core.common.asynchronous import AsyncLock, Caller
 from injection._core.common.type import InputType
 from injection._core.scope import Scope, get_first_scope, in_scope_cache
 from injection._core.slots import SlotKey
@@ -51,12 +51,12 @@ class TransientInjectable[T](Injectable[T]):
 
 
 class CacheLogic[T]:
-    __slots__ = ("__semaphore",)
+    __slots__ = ("__lock",)
 
-    __semaphore: AbstractAsyncContextManager[Any]
+    __lock: AbstractAsyncContextManager[Any]
 
     def __init__(self) -> None:
-        self.__semaphore = AsyncSemaphore(1)
+        self.__lock = AsyncLock()
 
     async def aget_or_create[K](
         self,
@@ -64,7 +64,7 @@ class CacheLogic[T]:
         key: K,
         factory: Callable[..., Awaitable[T]],
     ) -> T:
-        async with self.__semaphore:
+        async with self.__lock:
             with suppress(KeyError):
                 return cache[key]
 

{python_injection-0.26.3 → python_injection-0.27.0}/injection/_core/module.py

@@ -35,6 +35,7 @@ from inspect import (
 )
 from inspect import signature as inspect_signature
 from logging import Logger, getLogger
+from threading import RLock
 from types import MethodType
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, NamedTuple, Self, overload
 
@@ -44,7 +45,7 @@ from injection._core.common.asynchronous import Caller, SimpleAwaitable
 from injection._core.common.event import Event, EventChannel, EventListener
 from injection._core.common.invertible import Invertible, SimpleInvertible
 from injection._core.common.lazy import Lazy
-from injection._core.common.threading import get_lock
+from injection._core.common.threading import lock_if_threadsafe
 from injection._core.common.type import (
     InputType,
     TypeInfo,
@@ -180,6 +181,11 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         init=False,
         repr=False,
     )
+    __lock: RLock = field(
+        default_factory=RLock,
+        init=False,
+        repr=False,
+    )
     __loggers: list[Logger] = field(
         default_factory=lambda: [getLogger("python-injection")],
         init=False,
@@ -350,7 +356,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         /,
         threadsafe: bool | None = None,
     ) -> InjectMetadata[P, T]:
-        return InjectMetadata(wrapped, threadsafe).listen(self)
+        return InjectMetadata(wrapped, self.__lock, threadsafe).listen(self)
 
     if TYPE_CHECKING:  # pragma: no cover
 
@@ -397,7 +403,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         *,
         threadsafe: bool | None = None,
     ) -> T:
-        with get_lock(threadsafe):
+        with lock_if_threadsafe(self.__lock, threadsafe):
             injectable = self[cls]
             return await injectable.aget_instance()
 
@@ -407,7 +413,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         *,
         threadsafe: bool | None = None,
     ) -> T:
-        with get_lock(threadsafe):
+        with lock_if_threadsafe(self.__lock, threadsafe):
             injectable = self[cls]
             return injectable.get_instance()
 
@@ -598,11 +604,12 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         return self
 
     def stop_using(self, module: Module) -> Self:
-        event = ModuleRemoved(self, module)
+        if module in self.__modules:
+            event = ModuleRemoved(self, module)
 
-        with suppress(KeyError), self.dispatch(event):
-            self.__modules.pop(module)
-            module.remove_listener(self)
+            with self.dispatch(event):
+                self.__modules.pop(module)
+                module.remove_listener(self)
 
         return self
 
@@ -833,11 +840,12 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
     def __init__(
         self,
         wrapped: Callable[P, T],
+        lock: RLock,
         /,
         threadsafe: bool | None = None,
     ) -> None:
         self.__dependencies = Dependencies.empty()
-        self.__lock = get_lock(threadsafe)
+        self.__lock = lock_if_threadsafe(lock, threadsafe)
         self.__owner = None
         self.__tasks = deque()
         self.__wrapped = wrapped

{python_injection-0.26.3 → python_injection-0.27.0}/injection/_core/scope.py

@@ -16,6 +16,7 @@ from contextvars import ContextVar
 from dataclasses import dataclass, field
 from enum import StrEnum
 from functools import partial
+from threading import Lock
 from types import EllipsisType, TracebackType
 from typing import (
     TYPE_CHECKING,
@@ -29,7 +30,7 @@ from typing import (
     runtime_checkable,
 )
 
-from injection._core.common.threading import get_lock
+from injection._core.common.threading import lock_if_threadsafe
 from injection._core.slots import SlotKey
 from injection.exceptions import (
     InjectionError,
@@ -38,6 +39,8 @@ from injection.exceptions import (
     ScopeUndefinedError,
 )
 
+__thread_lock: Final[Lock] = Lock()
+
 
 class ScopeKind(StrEnum):
     CONTEXTUAL = "contextual"
@@ -197,7 +200,7 @@ def _bind_scope(
     kind: ScopeKind | ScopeKindStr,
     threadsafe: bool | None,
 ) -> Iterator[ScopeFacade]:
-    lock = get_lock(threadsafe)
+    lock = lock_if_threadsafe(__thread_lock, threadsafe)
 
     with lock:
         if get_first_scope(name, default=None):
@@ -209,7 +212,7 @@ def _bind_scope(
         stack.enter_context(__scope_resolvers[kind][name].bind(scope))
 
     try:
-        yield _UserScope(scope, lock)
+        yield _UserScope(scope, lock_if_threadsafe(threadsafe=threadsafe))
 
     finally:
         with lock:

{python_injection-0.26.3 → python_injection-0.27.0}/injection/loaders.py

@@ -5,6 +5,7 @@ import sys
 from abc import abstractmethod
 from collections.abc import Callable, Iterator, Mapping, Sequence
 from dataclasses import dataclass, field
+from fnmatch import fnmatchcase
 from importlib import import_module
 from importlib.util import find_spec
 from os.path import isfile
@@ -99,6 +100,13 @@ class PythonModuleLoader:
             module = import_module(name) if self.predicate(name) else None
             yield name, module
 
+    @classmethod
+    def fnmatch(cls, *patterns: str) -> Self:
+        def predicate(module_name: str) -> bool:
+            return any(fnmatchcase(module_name, pattern) for pattern in patterns)
+
+        return cls(predicate)
+
     @classmethod
     def from_keywords(cls, *keywords: str) -> Self:
         """

{python_injection-0.26.3 → python_injection-0.27.0}/pyproject.toml

@@ -10,12 +10,12 @@ dev = [
     "ruff",
 ]
 docs = [
-    "mkdocs",
-    "mkdocs-material",
+    "ghp-import",
+    "zensical",
 ]
 test = [
     "fastapi",
-    "httpx",
+    "httpx2",
     "pydantic",
     "pytest",
     "pytest-asyncio",
@@ -24,7 +24,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.26.3"
+version = "0.27.0"
 description = "Dead-simple dependency injection framework for Python."
 license = "MIT"
 license-files = ["LICENSE"]