python-injection 0.14.6.post1__tar.gz → 0.15.0__tar.gz

{python_injection-0.14.6.post1 → python_injection-0.15.0}/PKG-INFO

@@ -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 → python_injection-0.15.0}/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

{python_injection-0.14.6.post1 → python_injection-0.15.0}/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

{python_injection-0.14.6.post1 → python_injection-0.15.0}/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
 
 

python_injection-0.15.0/injection/utils.py

@@ -0,0 +1,130 @@
+import itertools
+import sys
+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 ClassVar, ContextManager, Self
+
+from injection import Module, mod
+
+__all__ = ("PythonModuleLoader", "load_packages", "load_profile")
+
+
+def load_profile(*names: str) -> ContextManager[Module]:
+    """
+    Injection module initialization function based on profile name.
+    A profile name is equivalent to an injection module name.
+    """
+
+    return mod().load_profile(*names)
+
+
+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.
+    """
+
+    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 __is_already_loaded(self, module_name: str) -> bool:
+        return any(
+            module_name in modules for modules in (self.__modules, self._sys_modules)
+        )
+
+    def __iter_modules(
+        self,
+        package: PythonModule | str,
+    ) -> Iterator[tuple[str, PythonModule | None]]:
+        if isinstance(package, str):
+            package = import_module(package)
+
+        package_name = package.__name__
+
+        try:
+            package_path = package.__path__
+        except AttributeError as exc:
+            raise TypeError(f"`{package_name}` isn't Python package.") from exc
+
+        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
+
+            module = import_module(name) if self.predicate(name) else None
+            yield name, module
+
+    @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.
+        """
+
+        def predicate(module_name: str) -> bool:
+            spec = find_spec(module_name)
+
+            if spec is None:
+                return False
+
+            module_path = spec.origin
+
+            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)
+
+        return cls(predicate)
+
+    @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)
+
+        return cls(predicate)
+
+    @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)
+
+        return cls(predicate)

{python_injection-0.14.6.post1 → python_injection-0.15.0}/pyproject.toml

@@ -25,7 +25,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.14.6.post1"
+version = "0.15.0"
 description = "Fast and easy dependency injection framework."
 license = { text = "MIT" }
 readme = "README.md"

python_injection-0.14.6.post1/injection/utils.py

@@ -1,96 +0,0 @@
-import sys
-from collections.abc import Callable, Collection, Iterator
-from importlib import import_module
-from importlib.util import find_spec
-from pkgutil import walk_packages
-from types import ModuleType as PythonModule
-from typing import ContextManager
-
-from injection import Module, mod
-from injection import __name__ as injection_package_name
-
-__all__ = ("load_modules_with_keywords", "load_packages", "load_profile")
-
-
-def load_profile(*names: str) -> ContextManager[Module]:
-    """
-    Injection module initialization function based on profile name.
-    A profile name is equivalent to an injection module name.
-    """
-
-    return mod().load_profile(*names)
-
-
-def load_modules_with_keywords(
-    *packages: PythonModule | str,
-    keywords: Collection[str] | None = None,
-) -> 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`
-    """
-
-    if keywords is None:
-        keywords = (
-            f"from {injection_package_name} ",
-            f"from {injection_package_name}.",
-            f"import {injection_package_name}",
-        )
-
-    def predicate(module_name: str) -> bool:
-        spec = find_spec(module_name)
-
-        if spec and (module_path := spec.origin):
-            with open(module_path, "r") as file:
-                python_script = file.read()
-
-            return bool(python_script) and any(
-                keyword in python_script for keyword in keywords
-            )
-
-        return False
-
-    return load_packages(*packages, predicate=predicate)
-
-
-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.
-    """
-
-    loaded: dict[str, PythonModule] = {}
-
-    for package in packages:
-        if isinstance(package, str):
-            package = import_module(package)
-
-        loaded |= __iter_modules_from(package, predicate)
-
-    return loaded
-
-
-def __iter_modules_from(
-    package: PythonModule,
-    predicate: Callable[[str], bool],
-) -> Iterator[tuple[str, PythonModule]]:
-    package_name = package.__name__
-
-    try:
-        package_path = package.__path__
-    except AttributeError as exc:
-        raise TypeError(f"`{package_name}` isn't Python package.") from exc
-
-    for info in walk_packages(path=package_path, prefix=f"{package_name}."):
-        name = info.name
-
-        if info.ispkg or name in sys.modules or not predicate(name):
-            continue
-
-        yield name, import_module(name)