python-injection 0.14.6.post1__py3-none-any.whl → 0.15.0__py3-none-any.whl

injection/_core/common/invertible.py

@@ -6,6 +6,8 @@ from typing import Protocol, runtime_checkable
 
 @runtime_checkable
 class Invertible[T](Protocol):
+    __slots__ = ()
+
     @abstractmethod
     def __invert__(self) -> T:
         raise NotImplementedError

injection/_core/module.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import threading
 from abc import ABC, abstractmethod
 from collections import OrderedDict, deque
 from collections.abc import (
@@ -27,7 +28,6 @@ from inspect import (
 )
 from inspect import signature as inspect_signature
 from logging import Logger, getLogger
-from threading import Lock
 from types import MethodType
 from typing import (
     Any,
@@ -982,7 +982,7 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
 
     def __init__(self, wrapped: Callable[P, T], /, threadsafe: bool) -> None:
         self.__dependencies = Dependencies.empty()
-        self.__lock = Lock() if threadsafe else nullcontext()
+        self.__lock = threading.Lock() if threadsafe else nullcontext()
         self.__owner = None
         self.__tasks = deque()
         self.__wrapped = wrapped

injection/_core/scope.py

@@ -157,18 +157,18 @@ def get_scope(name, default=...):  # type: ignore[no-untyped-def]
 def _bind_scope(name: str, scope: Scope, shared: bool) -> Iterator[None]:
     if shared:
         is_already_defined = bool(get_active_scopes(name))
-        state = __SHARED_SCOPES[name]
+        states = __SHARED_SCOPES
 
     else:
         is_already_defined = bool(get_scope(name, default=None))
-        state = __CONTEXTUAL_SCOPES[name]
+        states = __CONTEXTUAL_SCOPES
 
     if is_already_defined:
         raise ScopeAlreadyDefinedError(
             f"Scope `{name}` is already defined in the current context."
         )
 
-    with state.bind(scope):
+    with states[name].bind(scope):
         yield
 
 

injection/utils.py

@@ -1,15 +1,18 @@
+import itertools
 import sys
-from collections.abc import Callable, Collection, Iterator
+from collections.abc import Callable, Iterator, Mapping
+from dataclasses import dataclass, field
 from importlib import import_module
 from importlib.util import find_spec
+from os.path import isfile
 from pkgutil import walk_packages
+from types import MappingProxyType
 from types import ModuleType as PythonModule
-from typing import ContextManager
+from typing import ClassVar, ContextManager, Self
 
 from injection import Module, mod
-from injection import __name__ as injection_package_name
 
-__all__ = ("load_modules_with_keywords", "load_packages", "load_profile")
+__all__ = ("PythonModuleLoader", "load_packages", "load_profile")
 
 
 def load_profile(*names: str) -> ContextManager[Module]:
@@ -21,76 +24,107 @@ def load_profile(*names: str) -> ContextManager[Module]:
     return mod().load_profile(*names)
 
 
-def load_modules_with_keywords(
+def load_packages(
     *packages: PythonModule | str,
-    keywords: Collection[str] | None = None,
+    predicate: Callable[[str], bool] = lambda module_name: True,
 ) -> dict[str, PythonModule]:
     """
-    Function to import modules from a Python package if one of the keywords is contained in the Python script.
-    The default keywords are:
-        - `from injection `
-        - `from injection.`
-        - `import injection`
+    Function for importing all modules in a Python package.
+    Pass the `predicate` parameter if you want to filter the modules to be imported.
     """
 
-    if keywords is None:
-        keywords = (
-            f"from {injection_package_name} ",
-            f"from {injection_package_name}.",
-            f"import {injection_package_name}",
+    return PythonModuleLoader(predicate).load(*packages).modules
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class PythonModuleLoader:
+    predicate: Callable[[str], bool]
+    __modules: dict[str, PythonModule | None] = field(
+        default_factory=dict,
+        init=False,
+    )
+
+    # To easily mock `sys.modules` in tests
+    _sys_modules: ClassVar[Mapping[str, PythonModule]] = MappingProxyType(sys.modules)
+
+    @property
+    def modules(self) -> dict[str, PythonModule]:
+        return {
+            name: module
+            for name, module in self.__modules.items()
+            if module is not None
+        }
+
+    def load(self, *packages: PythonModule | str) -> Self:
+        modules = itertools.chain.from_iterable(
+            self.__iter_modules(package) for package in packages
         )
+        self.__modules.update(modules)
+        return self
 
-    def predicate(module_name: str) -> bool:
-        spec = find_spec(module_name)
+    def __is_already_loaded(self, module_name: str) -> bool:
+        return any(
+            module_name in modules for modules in (self.__modules, self._sys_modules)
+        )
 
-        if spec and (module_path := spec.origin):
-            with open(module_path, "r") as file:
-                python_script = file.read()
+    def __iter_modules(
+        self,
+        package: PythonModule | str,
+    ) -> Iterator[tuple[str, PythonModule | None]]:
+        if isinstance(package, str):
+            package = import_module(package)
 
-            return bool(python_script) and any(
-                keyword in python_script for keyword in keywords
-            )
+        package_name = package.__name__
 
-        return False
+        try:
+            package_path = package.__path__
+        except AttributeError as exc:
+            raise TypeError(f"`{package_name}` isn't Python package.") from exc
 
-    return load_packages(*packages, predicate=predicate)
+        for info in walk_packages(path=package_path, prefix=f"{package_name}."):
+            name = info.name
 
+            if info.ispkg or self.__is_already_loaded(name):
+                continue
 
-def load_packages(
-    *packages: PythonModule | str,
-    predicate: Callable[[str], bool] = lambda module_name: True,
-) -> dict[str, PythonModule]:
-    """
-    Function for importing all modules in a Python package.
-    Pass the `predicate` parameter if you want to filter the modules to be imported.
-    """
+            module = import_module(name) if self.predicate(name) else None
+            yield name, module
 
-    loaded: dict[str, PythonModule] = {}
+    @classmethod
+    def from_keywords(cls, *keywords: str) -> Self:
+        """
+        Create loader to import modules from a Python package if one of the keywords is
+        contained in the Python script.
+        """
 
-    for package in packages:
-        if isinstance(package, str):
-            package = import_module(package)
+        def predicate(module_name: str) -> bool:
+            spec = find_spec(module_name)
+
+            if spec is None:
+                return False
 
-        loaded |= __iter_modules_from(package, predicate)
+            module_path = spec.origin
 
-    return loaded
+            if module_path is None or not isfile(module_path):
+                return False
 
+            with open(module_path, "r") as script:
+                return any(keyword in line for line in script for keyword in keywords)
 
-def __iter_modules_from(
-    package: PythonModule,
-    predicate: Callable[[str], bool],
-) -> Iterator[tuple[str, PythonModule]]:
-    package_name = package.__name__
+        return cls(predicate)
 
-    try:
-        package_path = package.__path__
-    except AttributeError as exc:
-        raise TypeError(f"`{package_name}` isn't Python package.") from exc
+    @classmethod
+    def startswith(cls, *prefixes: str) -> Self:
+        def predicate(module_name: str) -> bool:
+            script_name = module_name.split(".")[-1]
+            return any(script_name.startswith(prefix) for prefix in prefixes)
 
-    for info in walk_packages(path=package_path, prefix=f"{package_name}."):
-        name = info.name
+        return cls(predicate)
 
-        if info.ispkg or name in sys.modules or not predicate(name):
-            continue
+    @classmethod
+    def endswith(cls, *suffixes: str) -> Self:
+        def predicate(module_name: str) -> bool:
+            script_name = module_name.split(".")[-1]
+            return any(script_name.endswith(suffix) for suffix in suffixes)
 
-        yield name, import_module(name)
+        return cls(predicate)

{python_injection-0.14.6.post1.dist-info → python_injection-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.14.6.post1
+Version: 0.15.0
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd

{python_injection-0.14.6.post1.dist-info → python_injection-0.15.0.dist-info}/RECORD

@@ -2,17 +2,17 @@ injection/__init__.py,sha256=a-rBAlBTiH6TzZ-11NGK6diovfibyKmmnf99PZUog1A,1166
 injection/__init__.pyi,sha256=rOl1kA9BkIeXDr7OdBMifAg9xWwvme447yjDZooir18,10398
 injection/exceptions.py,sha256=v57yMujiq6H_zwwn30A8UYEZX9R9k-bY8FnsdaimPM4,1025
 injection/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/utils.py,sha256=EuHMrix6gx2YnnUAn2_BPsDkvucGS5-pFhM3596oBK4,2796
+injection/utils.py,sha256=bLIVA_3N3mTEQ3kGV4YzrWEnokHxUGqWYNKPggOOnpg,4065
 injection/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/descriptors.py,sha256=7fSHlgAqmgR_Uta8KocBapOt1Xyj2dI7RY9ZdoStTzw,726
 injection/_core/injectables.py,sha256=idNkQZZ29vd73G_lE-eS5C7zGeVe_ALNkUt8M6YjZrk,5519
-injection/_core/module.py,sha256=DLw0pD3HDXfNhzbWM0yeCDKg-Mwg8JAzqZq43tFAXik,31814
-injection/_core/scope.py,sha256=fZ6zvuP9RO_9wZvMcM13_elSoztMaYKen1MgTP3s8t4,6555
+injection/_core/module.py,sha256=KrEr66q1lazwz7F7jYscpr-ExX8aOwYHEho1IotXa54,31814
+injection/_core/scope.py,sha256=LGT_Sk0b2FXB_ScXfLhU2BWz_bEE0vdJOV5p-ijCDq4,6552
 injection/_core/slots.py,sha256=6LoG0XtaRnIGDSG8s-FfUIw_50gL0bl4X3Fo_n-hdak,680
 injection/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/common/asynchronous.py,sha256=QeS2Lc4gEBFvTA_snOWfme5mTL4BFZWqZ8EzJwOdVos,1816
 injection/_core/common/event.py,sha256=XjzV8gxtGlGvzZs_ykvoC60qmdpd3RN08Eiqz5QUwes,1236
-injection/_core/common/invertible.py,sha256=YZlAdh6bNJgf1-74TRjwJTm8xrlgY95ZhOUGLSJ4XcY,482
+injection/_core/common/invertible.py,sha256=gA_vw5nBjgp_w9MrDK5jMO8lhuOQWON8BbPpKzEuIY0,502
 injection/_core/common/key.py,sha256=ghkZD-Y8Moz6SEPNgMh3xgsZUjDVq-XYAmXaCu5VuCA,80
 injection/_core/common/lazy.py,sha256=6xh5h0lmaNvl32V0WoX4VCTsNJ3zUJdWVqpLJ_YeIIU,1363
 injection/_core/common/type.py,sha256=SCDtmBv9qFvEf5o5tTgCuwMDfuo1fgjSW0bUqA8ACis,2251
@@ -20,6 +20,6 @@ injection/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 injection/integrations/fastapi.py,sha256=YHSs85_3m6TUVtOwUcV157b3UZJQIw_aXWAg199a-YE,594
 injection/testing/__init__.py,sha256=SiImXDd0-DO1a8S5nbUQRtgDX8iaU_nHcp8DdqwtD2M,896
 injection/testing/__init__.pyi,sha256=iOii0i9F5n7znltGeGQYI2KXC_if9SAogLh1h03yx-0,540
-python_injection-0.14.6.post1.dist-info/METADATA,sha256=g-UJxN15zRFae7U8t5Fv2KU-naXLksipOjwefxrmBhs,3205
-python_injection-0.14.6.post1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_injection-0.14.6.post1.dist-info/RECORD,,
+python_injection-0.15.0.dist-info/METADATA,sha256=LA4sTrPDIUAk-dwOH1zKj1Rjk-feJwq1r2eYHpLIJTw,3199
+python_injection-0.15.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_injection-0.15.0.dist-info/RECORD,,