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

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.post2.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.post2
+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.post2.dist-info → python_injection-0.15.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ 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
@@ -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.post2.dist-info/METADATA,sha256=ST2y_3loRYXo9ugZ7yMrLNCBNMCaUTRdVenvDib8Dxc,3205
-python_injection-0.14.6.post2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_injection-0.14.6.post2.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,,