pydepinject 0.0.1.dev0__tar.gz

pydepinject-0.0.1.dev0/LICENSE

@@ -0,0 +1,9 @@
+ The MIT License (MIT)
+
+Copyright © 2024 pydepinject
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pydepinject-0.0.1.dev0/MANIFEST.in

@@ -0,0 +1,3 @@
+graft src
+exclude Dockerfile noxfile.py tasks.py scripts/*
+global-exclude *~ *.py[cod] *.so .devcontainer/*

pydepinject-0.0.1.dev0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: pydepinject
+Version: 0.0.1.dev0
+Summary: A package to dynamically inject requirements into a virtual environment.
+Author: pydepinject
+License: MIT
+Project-URL: homepage, https://github.com/pydepinject/pydepinject
+Project-URL: documentation, https://github.com/pydepinject/pydepinject
+Project-URL: repository, https://github.com/pydepinject/pydepinject
+Keywords: virtualenv,requirements,dependency management
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: lint
+Requires-Dist: ruff==0.4.7; extra == "lint"
+Requires-Dist: pyright==1.1.365; extra == "lint"
+Requires-Dist: isort==5.13.2; extra == "lint"
+Provides-Extra: test
+Requires-Dist: pytest==8.2.1; extra == "test"
+Requires-Dist: pytest-cov==5.0.0; extra == "test"
+Provides-Extra: build
+Requires-Dist: check-manifest==0.49; extra == "build"
+Requires-Dist: build==1.2.1; extra == "build"
+Requires-Dist: wheel==0.43.0; extra == "build"
+Requires-Dist: setuptools==70.0.0; extra == "build"
+
+# Requirement Manager
+
+This project provides a `RequirementManager` (`requires` is an alias) class to manage Python package requirements using virtual environments. It can be used as a decorator or context manager to ensure specific packages are installed and available during the execution of a function or code block.
+
+## Features
+
+- Automatically creates and manages virtual environments.
+- Checks if the required packages are already installed.
+- Installs packages if they are not already available.
+- Supports ephemeral virtual environments that are deleted after use.
+- Can be used as a decorator or context manager.
+
+## Installation
+
+`pip install pydepinject`
+
+
+## Usage
+
+### Decorator
+
+To use the `requires` as a decorator, simply decorate your function with the required packages:
+
+```python
+from pydepinject import requires
+
+
+@requires("requests", "numpy")
+def my_function():
+    import requests
+    import numpy as np
+    print(requests.__version__)
+    print(np.__version__)
+
+my_function()
+```
+
+### Context Manager
+
+You can also use the `requires` as a context manager:
+
+```python
+from pydepinject import requires
+
+
+with requires("requests", "numpy"):
+    import requests
+    import numpy as np
+    print(requests.__version__)
+    print(np.__version__)
+```
+
+### Reusable Virtual Environments
+
+The `requires` can create named virtual environments and reuse them across multiple functions or code blocks:
+
+```python
+@requires("requests", venv_name="myenv", ephemeral=False)
+def my_function():
+    import requests
+    print(requests.__version__)
+
+
+with requires("pylint", venv_name="myenv", ephemeral=False):
+    import pylint
+    print(pylint.__version__)
+    import requests  # This is also available here because it was installed in the same virtual environment
+    print(requests.__version__)
+```
+
+### Managing Virtual Environments
+
+The `requires` can automatically delete ephemeral virtual environments after use. This is useful when you want to ensure that the virtual environment is clean and does not persist after the function or code block completes:
+
+```python
+@requires("requests", venv_name="myenv", ephemeral=True)
+def my_function():
+    import requests
+    print(requests.__version__)
+
+my_function()
+```
+
+## Logging
+
+The `requires` uses the `logging` module to provide debug information. By default, it logs to the console at the DEBUG level. You can adjust the logging configuration as needed.
+
+## Unit Tests
+
+Unit tests are provided to verify the functionality of the `requires`. The tests use `pytest` and cover various scenarios including decorator usage, context manager usage, ephemeral environments, and more.
+
+### Running Tests
+
+To run the unit tests, ensure you have `pytest` installed, and then execute the following command:
+
+```bash
+pytest
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

pydepinject-0.0.1.dev0/Readme.md

@@ -0,0 +1,102 @@
+# Requirement Manager
+
+This project provides a `RequirementManager` (`requires` is an alias) class to manage Python package requirements using virtual environments. It can be used as a decorator or context manager to ensure specific packages are installed and available during the execution of a function or code block.
+
+## Features
+
+- Automatically creates and manages virtual environments.
+- Checks if the required packages are already installed.
+- Installs packages if they are not already available.
+- Supports ephemeral virtual environments that are deleted after use.
+- Can be used as a decorator or context manager.
+
+## Installation
+
+`pip install pydepinject`
+
+
+## Usage
+
+### Decorator
+
+To use the `requires` as a decorator, simply decorate your function with the required packages:
+
+```python
+from pydepinject import requires
+
+
+@requires("requests", "numpy")
+def my_function():
+    import requests
+    import numpy as np
+    print(requests.__version__)
+    print(np.__version__)
+
+my_function()
+```
+
+### Context Manager
+
+You can also use the `requires` as a context manager:
+
+```python
+from pydepinject import requires
+
+
+with requires("requests", "numpy"):
+    import requests
+    import numpy as np
+    print(requests.__version__)
+    print(np.__version__)
+```
+
+### Reusable Virtual Environments
+
+The `requires` can create named virtual environments and reuse them across multiple functions or code blocks:
+
+```python
+@requires("requests", venv_name="myenv", ephemeral=False)
+def my_function():
+    import requests
+    print(requests.__version__)
+
+
+with requires("pylint", venv_name="myenv", ephemeral=False):
+    import pylint
+    print(pylint.__version__)
+    import requests  # This is also available here because it was installed in the same virtual environment
+    print(requests.__version__)
+```
+
+### Managing Virtual Environments
+
+The `requires` can automatically delete ephemeral virtual environments after use. This is useful when you want to ensure that the virtual environment is clean and does not persist after the function or code block completes:
+
+```python
+@requires("requests", venv_name="myenv", ephemeral=True)
+def my_function():
+    import requests
+    print(requests.__version__)
+
+my_function()
+```
+
+## Logging
+
+The `requires` uses the `logging` module to provide debug information. By default, it logs to the console at the DEBUG level. You can adjust the logging configuration as needed.
+
+## Unit Tests
+
+Unit tests are provided to verify the functionality of the `requires`. The tests use `pytest` and cover various scenarios including decorator usage, context manager usage, ephemeral environments, and more.
+
+### Running Tests
+
+To run the unit tests, ensure you have `pytest` installed, and then execute the following command:
+
+```bash
+pytest
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

pydepinject-0.0.1.dev0/pyproject.toml

@@ -0,0 +1,132 @@
+[build-system]
+requires = [
+    "setuptools >= 61",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pydepinject"
+dynamic = ["version"]
+description = "A package to dynamically inject requirements into a virtual environment."
+readme = "Readme.md"
+authors = [
+    { name="pydepinject" }
+]
+license = { text="MIT" }
+keywords = ["virtualenv", "requirements", "dependency management"]
+requires-python = ">=3.9"
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Software Development :: Libraries",
+  "Typing :: Typed",
+]
+
+[project.urls]
+homepage = "https://github.com/pydepinject/pydepinject"
+documentation = "https://github.com/pydepinject/pydepinject"
+repository = "https://github.com/pydepinject/pydepinject"
+
+[project.optional-dependencies]
+lint = [
+    "ruff==0.4.7",
+    "pyright==1.1.365",
+    "isort==5.13.2",
+]
+test = [
+    "pytest==8.2.1",
+    "pytest-cov==5.0.0",
+]
+build = [
+    "check-manifest==0.49",
+    "build==1.2.1",
+    "wheel==0.43.0",
+    "setuptools==70.0.0",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.dynamic]
+version = {attr = "pydepinject.VERSION"}
+
+[tool.pytest]
+log_cli = true
+log_level = "DEBUG"
+
+[tool.pytest.ini_options]
+pythonpath = "src"
+
+
+[tool.ruff]
+preview = true
+extend-exclude = [
+     "/..*"
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/test_pydepinject.py" = ["F401", "F811"]
+
+[tool.pyright]
+include = ["src"]
+strict = ["src"]
+
+deprecateTypingAliases = true
+reportCallInDefaultInitializer = true
+reportImplicitOverride = true
+reportImplicitStringConcatenation = true
+reportImportCycles = true
+reportMissingSuperCall = false
+reportPropertyTypeMismatch = true
+reportShadowedImports = true
+reportUninitializedInstanceVariable = true
+reportUnnecessaryTypeIgnoreComment = true
+reportUnusedCallResult = false
+
+[tool.isort]
+profile = "black"
+add_imports = ["from __future__ import annotations"]
+known_first_party = ["pydepinject"]
+skip_gitignore = true
+src_paths = [
+    "src",
+]
+
+[tool.coverage.run]
+branch = true
+dynamic_context = "test_function"
+cover_pylib = false
+data_file = ".coverage"
+parallel = false
+relative_files = true
+
+[tool.coverage.report]
+exclude_also = [
+    "if TYPE_CHECKING:",
+    "if __name__ == .__main__.:",
+]
+format = "text"
+show_missing = true
+
+[tool.coverage.html]
+directory = "htmlcov"
+show_contexts = true
+title = "Coverage report for pydepinject"
+
+[tool.check-manifest]
+ignore = []
+
+[tool.custom.pipxtools]
+uv = {version = "0.2.5"}
+invoke = {version = "2.2.0", preinstall = ["tomli"]}
+nox = {version = "2024.4.15"}
+twine = {version = "5.1.1"}
+
+[tool.custom.ci]
+python_versions = ["3.9", "3.10", "3.11", "3.12"]

pydepinject-0.0.1.dev0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pydepinject-0.0.1.dev0/src/pydepinject/__init__.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import functools
+import hashlib
+import logging
+import os
+import pathlib
+import shutil
+import subprocess
+import sys
+import tempfile
+import typing
+import venv
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import TracebackType
+    from typing import Any
+
+
+VERSION = "0.0.1dev"
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
+
+VENV_ROOT = pathlib.Path(tempfile.gettempdir()) / __name__.split(".")[0] / "venvs"
+logger.debug("VENV_ROOT: %s", VENV_ROOT)
+
+
+def is_requirements_satisfied(*packages: str):
+    """Check if the requirements are already satisfied. Return None if it cannot be determined."""
+    try:
+        if "pkg_resources" in sys.modules:
+            del sys.modules["pkg_resources"]
+        import pkg_resources
+    except ImportError:
+        logger.debug(
+            "pkg_resources not found. Cannot check if requirements are satisfied."
+        )
+        return None
+
+    try:
+        for package in packages:
+            logger.debug("Checking package: %s", package)
+            req = pkg_resources.Requirement.parse(package)
+            pkg_resources.require(str(req))
+            logger.debug("Requirement %s is satisfied", package)
+        return True
+    except (pkg_resources.DistributionNotFound, pkg_resources.VersionConflict):
+        logger.debug("Requirements %s are not satisfied. Return False", packages)
+        return False
+
+
+class RequirementManager:
+    """A decorator and context manager to manage Python package requirements."""
+
+    def __init__(
+        self,
+        *packages: str,
+        venv_name: str | None = None,
+        venv_root: pathlib.Path = VENV_ROOT,
+        recreate: bool = False,
+        ephemeral: bool = False,
+    ):
+        """Initialize the RequirementManager.
+
+        Args:
+            *packages: A list of package requirements.
+            venv_name: The name of the virtual environment. If not provided,
+                a unique name will be generated based on the package requirements.
+            venv_root: The root directory for virtual environments.
+            recreate: If True, the virtual environment will be recreated if it exists.
+            ephemeral: If True, the virtual environment will be deleted after use.
+        """
+        self.packages = packages
+        self.venv_name = venv_name
+        self.original_pythonpath = os.environ.get("PYTHONPATH", "")
+        self.original_path = os.environ.get("PATH", "")
+        self.original_syspath = sys.path.copy()
+        self._venv_path = venv_root / self.venv_name if self.venv_name else None
+        self._venv_root = venv_root
+        self.ephemeral = ephemeral
+        self.recreate = recreate
+        self._activated = False
+
+    @property
+    def venv_path(self):
+        if self._venv_path:
+            """Returns a path to the virtual environment. If not set, a unique path is generated."""
+            return self._venv_path
+        # Create a unique hash for the package requirements
+        reqs_str = ",".join(self.packages)
+        reqs_hash = hashlib.md5(reqs_str.encode()).hexdigest()
+
+        self._venv_path = self._venv_root / reqs_hash
+        return self._venv_path
+
+    def _create_virtualenv(self):
+        """Create a virtual environment if it does not exist."""
+        if self.venv_path.exists() and not self.recreate:
+            return
+        logger.debug("Creating virtualenv: %s", self.venv_path)
+        venv.create(str(self.venv_path), with_pip=True, clear=self.recreate)
+
+    def _install_packages(self):
+        logger.info("Installing packages: %s", self.packages)
+        pip_executable = pathlib.Path(self.venv_path) / "bin" / "pip"
+        pip_args = [
+            str(pip_executable),
+            "install",
+            "--quiet",
+            "--no-python-version-warning",
+            "--disable-pip-version-check",
+            *self.packages,
+        ]
+        logger.debug("Running command: %s", " ".join(pip_args))
+        subprocess.check_call(pip_args)
+
+    def _activate_venv(self):
+        if is_requirements_satisfied(*self.packages):
+            logger.debug(
+                "Requirements %s already satisfied. No need to create venv",
+                self.packages,
+            )
+            return self
+
+        self.original_pythonpath = os.environ.get("PYTHONPATH", "")
+        self.original_path = os.environ.get("PATH", "")
+        self.original_syspath = sys.path.copy()
+
+        self._create_virtualenv()
+
+        venv_site_packages = (
+            pathlib.Path(self.venv_path)
+            / "lib"
+            / f"python{sys.version_info.major}.{sys.version_info.minor}"
+            / "site-packages"
+        )
+        os.environ["PYTHONPATH"] = str(venv_site_packages) + (
+            os.pathsep + self.original_pythonpath if self.original_pythonpath else ""
+        )
+        os.environ["PATH"] = (
+            str(pathlib.Path(self.venv_path) / "bin") + os.pathsep + self.original_path
+        )
+        sys.path.insert(0, str(venv_site_packages))
+        self._activated = True
+        if is_requirements_satisfied(*self.packages):
+            logger.debug(
+                "Requirements %s already satisfied within %s",
+                self.packages,
+                self.venv_path,
+            )
+            return self
+        self._install_packages()
+
+    def _deactivate_venv(self):
+        if not self._activated:
+            return
+        os.environ["PATH"] = self.original_path
+        os.environ["PYTHONPATH"] = self.original_pythonpath
+        sys.path = self.original_syspath
+        # Cleanup imported cached modules from the temporary venv.
+        venv_imports: set[str] = set()
+        for name, module in sys.modules.items():
+            module_path = getattr(module, "__file__", None)
+            if module_path and pathlib.Path(module_path).is_relative_to(self.venv_path):
+                venv_imports.add(name)
+        for name in venv_imports:
+            del sys.modules[name]
+        self._activated = False
+        if self.ephemeral:
+            logger.debug("Deleting ephemeral venv: %s", self.venv_path)
+            shutil.rmtree(self.venv_path)
+
+    def __enter__(self):
+        self._activate_venv()
+        return self
+
+    def __exit__(
+        self,
+        exctype: type[BaseException] | None,
+        excinst: BaseException | None,
+        exctb: TracebackType | None,
+    ) -> None:
+        del exctype, excinst, exctb
+        self._deactivate_venv()
+
+    def __call__(self, func: Callable[..., Any] | None = None):
+        if func is None:
+            self._activate_venv()
+            return
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any):
+            with self:
+                print("returning func()")
+                return func(*args, **kwargs)
+
+        return wrapper
+
+
+requires = RequirementManager

pydepinject-0.0.1.dev0/src/pydepinject.egg-info/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: pydepinject
+Version: 0.0.1.dev0
+Summary: A package to dynamically inject requirements into a virtual environment.
+Author: pydepinject
+License: MIT
+Project-URL: homepage, https://github.com/pydepinject/pydepinject
+Project-URL: documentation, https://github.com/pydepinject/pydepinject
+Project-URL: repository, https://github.com/pydepinject/pydepinject
+Keywords: virtualenv,requirements,dependency management
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: lint
+Requires-Dist: ruff==0.4.7; extra == "lint"
+Requires-Dist: pyright==1.1.365; extra == "lint"
+Requires-Dist: isort==5.13.2; extra == "lint"
+Provides-Extra: test
+Requires-Dist: pytest==8.2.1; extra == "test"
+Requires-Dist: pytest-cov==5.0.0; extra == "test"
+Provides-Extra: build
+Requires-Dist: check-manifest==0.49; extra == "build"
+Requires-Dist: build==1.2.1; extra == "build"
+Requires-Dist: wheel==0.43.0; extra == "build"
+Requires-Dist: setuptools==70.0.0; extra == "build"
+
+# Requirement Manager
+
+This project provides a `RequirementManager` (`requires` is an alias) class to manage Python package requirements using virtual environments. It can be used as a decorator or context manager to ensure specific packages are installed and available during the execution of a function or code block.
+
+## Features
+
+- Automatically creates and manages virtual environments.
+- Checks if the required packages are already installed.
+- Installs packages if they are not already available.
+- Supports ephemeral virtual environments that are deleted after use.
+- Can be used as a decorator or context manager.
+
+## Installation
+
+`pip install pydepinject`
+
+
+## Usage
+
+### Decorator
+
+To use the `requires` as a decorator, simply decorate your function with the required packages:
+
+```python
+from pydepinject import requires
+
+
+@requires("requests", "numpy")
+def my_function():
+    import requests
+    import numpy as np
+    print(requests.__version__)
+    print(np.__version__)
+
+my_function()
+```
+
+### Context Manager
+
+You can also use the `requires` as a context manager:
+
+```python
+from pydepinject import requires
+
+
+with requires("requests", "numpy"):
+    import requests
+    import numpy as np
+    print(requests.__version__)
+    print(np.__version__)
+```
+
+### Reusable Virtual Environments
+
+The `requires` can create named virtual environments and reuse them across multiple functions or code blocks:
+
+```python
+@requires("requests", venv_name="myenv", ephemeral=False)
+def my_function():
+    import requests
+    print(requests.__version__)
+
+
+with requires("pylint", venv_name="myenv", ephemeral=False):
+    import pylint
+    print(pylint.__version__)
+    import requests  # This is also available here because it was installed in the same virtual environment
+    print(requests.__version__)
+```
+
+### Managing Virtual Environments
+
+The `requires` can automatically delete ephemeral virtual environments after use. This is useful when you want to ensure that the virtual environment is clean and does not persist after the function or code block completes:
+
+```python
+@requires("requests", venv_name="myenv", ephemeral=True)
+def my_function():
+    import requests
+    print(requests.__version__)
+
+my_function()
+```
+
+## Logging
+
+The `requires` uses the `logging` module to provide debug information. By default, it logs to the console at the DEBUG level. You can adjust the logging configuration as needed.
+
+## Unit Tests
+
+Unit tests are provided to verify the functionality of the `requires`. The tests use `pytest` and cover various scenarios including decorator usage, context manager usage, ephemeral environments, and more.
+
+### Running Tests
+
+To run the unit tests, ensure you have `pytest` installed, and then execute the following command:
+
+```bash
+pytest
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

pydepinject-0.0.1.dev0/src/pydepinject.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+Readme.md
+pyproject.toml
+src/pydepinject/__init__.py
+src/pydepinject.egg-info/PKG-INFO
+src/pydepinject.egg-info/SOURCES.txt
+src/pydepinject.egg-info/dependency_links.txt
+src/pydepinject.egg-info/requires.txt
+src/pydepinject.egg-info/top_level.txt
+src/requirementmanager.egg-info/PKG-INFO
+src/requirementmanager.egg-info/SOURCES.txt
+src/requirementmanager.egg-info/dependency_links.txt
+src/requirementmanager.egg-info/requires.txt
+src/requirementmanager.egg-info/top_level.txt
+tests/test_pydepinject.py

pydepinject-0.0.1.dev0/src/pydepinject.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pydepinject-0.0.1.dev0/src/pydepinject.egg-info/requires.txt

@@ -0,0 +1,15 @@
+
+[build]
+check-manifest==0.49
+build==1.2.1
+wheel==0.43.0
+setuptools==70.0.0
+
+[lint]
+ruff==0.4.7
+pyright==1.1.365
+isort==5.13.2
+
+[test]
+pytest==8.2.1
+pytest-cov==5.0.0

pydepinject-0.0.1.dev0/src/pydepinject.egg-info/top_level.txt

@@ -0,0 +1 @@
+pydepinject

pydepinject-0.0.1.dev0/src/requirementmanager.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: requirementmanager
+Version: 0.0.1.dev0
+Summary: A package to dynamically inject requirements into a virtual environment.
+Author-email: Your Name <your.email@example.com>
+Maintainer-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: homepage, https://github.com/yourusername/requirementmanager
+Project-URL: documentation, https://github.com/yourusername/requirementmanager
+Project-URL: repository, https://github.com/yourusername/requirementmanager
+Keywords: virtualenv,requirements,dependency management
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Description-Content-Type: text/x-rst
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"

pydepinject-0.0.1.dev0/src/requirementmanager.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+pyproject.toml
+src/pydepinject/__init__.py
+src/requirementmanager.egg-info/PKG-INFO
+src/requirementmanager.egg-info/SOURCES.txt
+src/requirementmanager.egg-info/dependency_links.txt
+src/requirementmanager.egg-info/requires.txt
+src/requirementmanager.egg-info/top_level.txt

pydepinject-0.0.1.dev0/src/requirementmanager.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pydepinject-0.0.1.dev0/src/requirementmanager.egg-info/requires.txt

@@ -0,0 +1,11 @@
+
+[dev]
+ruff
+pytest
+flake8
+black
+pyright
+twine
+wheel
+setuptools
+pre-commit

pydepinject-0.0.1.dev0/src/requirementmanager.egg-info/top_level.txt

@@ -0,0 +1 @@
+pydepinject

pydepinject-0.0.1.dev0/tests/test_pydepinject.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import pytest
+
+from pydepinject import requires  # noqa: E402
+
+
+@pytest.fixture
+def venv_root(tmp_path):
+    """Return the root directory for virtual environments."""
+    path = tmp_path / "venvs"
+    path.mkdir()
+    return path
+
+
+@pytest.mark.parametrize("ephemeral", [True, False], ids=["ephemeral", "non-ephemeral"])
+def test_decorator(venv_root, ephemeral):
+    assert not list(venv_root.iterdir())
+
+    with pytest.raises(ImportError):
+        import six
+
+    @requires("six", venv_root=venv_root, ephemeral=ephemeral)
+    def examplefn():
+        print("examplefn")
+        import six
+
+        assert six.__version__
+
+    examplefn()
+    with pytest.raises(ImportError):
+        import six
+
+    if ephemeral:
+        assert not list(venv_root.iterdir())
+    else:
+        assert len(list(venv_root.iterdir())) == 1
+
+
+@pytest.mark.parametrize("ephemeral", [True, False], ids=["ephemeral", "non-ephemeral"])
+def test_context_manager(venv_root, ephemeral):
+    assert not list(venv_root.iterdir())
+
+    with pytest.raises(ImportError):
+        import six
+
+    with requires("six", venv_root=venv_root, ephemeral=ephemeral):
+        import six
+
+        assert six.__version__
+
+    with pytest.raises(ImportError):
+        import six
+
+    if ephemeral:
+        assert not list(venv_root.iterdir())
+    else:
+        assert len(list(venv_root.iterdir())) == 1
+
+
+def test_function_call(venv_root):
+    assert not list(venv_root.iterdir())
+
+    with pytest.raises(ImportError):
+        import six
+
+    requires_instance = requires("six", venv_root=venv_root)
+    requires_instance()
+    import six
+
+    assert six.__version__
+    assert len(list(venv_root.iterdir())) == 1
+
+    requires_instance._deactivate_venv()
+    with pytest.raises(ImportError):
+        import six
+
+
+def test_no_installs(venv_root):
+    assert not list(venv_root.iterdir())
+
+    @requires("pytest", venv_root=venv_root, ephemeral=False)
+    def examplefn():
+        print("examplefn")
+
+    examplefn()
+    assert not list(venv_root.iterdir())
+
+
+def test_reuse_venv(venv_root):
+    assert not list(venv_root.iterdir())
+
+    @requires("six", venv_root=venv_root, ephemeral=False)
+    def examplea():
+        import six
+
+        assert six.__version__
+        examplea.called = True
+
+    @requires("six", venv_root=venv_root, ephemeral=False)
+    def exampleb():
+        import six
+
+        assert six.__version__
+        global exampleb_called
+        exampleb.called = True
+
+    examplea()
+    with pytest.raises(ImportError):
+        import six
+
+    exampleb()
+    with pytest.raises(ImportError):
+        import six
+
+    assert examplea.called is exampleb.called is True
+    assert len(list(venv_root.iterdir())) == 1
+
+
+def test_one_venv_multiple_packages(venv_root):
+    assert not list(venv_root.iterdir())
+
+    venv_name = "test_one_venv_multiple_packages"
+
+    @requires("six", venv_root=venv_root, venv_name=venv_name, ephemeral=False)
+    def examplefn():
+        import six
+
+        assert six.__version__
+
+    @requires("pyparsing", venv_root=venv_root, venv_name=venv_name, ephemeral=False)
+    def examplefn2():
+        import pyparsing
+
+        assert pyparsing.__version__
+
+        import six
+
+        assert six.__version__
+
+    examplefn()
+    examplefn2()
+
+    with pytest.raises(ImportError):
+        import six
+    with pytest.raises(ImportError):
+        import pyparsing
+
+    assert len(list(venv_root.iterdir())) == 1