pydepinject 0.0.1.dev1__tar.gz → 0.0.2.dev0__tar.gz

pydepinject-0.0.2.dev0/MANIFEST.in

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

{pydepinject-0.0.1.dev1/src/pydepinject.egg-info → pydepinject-0.0.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pydepinject
-Version: 0.0.1.dev1
+Version: 0.0.2.dev0
 Summary: A package to dynamically inject requirements into a virtual environment.
 Author: pydepinject
 License: MIT
@@ -21,6 +21,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: packaging>=22.0
+Requires-Dist: typing_extensions
 Provides-Extra: lint
 Requires-Dist: ruff==0.4.7; extra == "lint"
 Requires-Dist: pyright==1.1.365; extra == "lint"
@@ -28,6 +30,7 @@ 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"
+Requires-Dist: pytest-xdist==3.6.1; extra == "test"
 Provides-Extra: build
 Requires-Dist: check-manifest==0.49; extra == "build"
 Requires-Dist: build==1.2.1; extra == "build"

{pydepinject-0.0.1.dev1 → pydepinject-0.0.2.dev0}/pyproject.toml

@@ -15,6 +15,10 @@ authors = [
 license = { text="MIT" }
 keywords = ["virtualenv", "requirements", "dependency management"]
 requires-python = ">=3.9"
+dependencies = [
+    "packaging>=22.0",
+    "typing_extensions",
+]
 classifiers = [
   "Development Status :: 4 - Beta",
   "Intended Audience :: Developers",
@@ -42,6 +46,7 @@ lint = [
 test = [
     "pytest==8.2.1",
     "pytest-cov==5.0.0",
+    "pytest-xdist==3.6.1",
 ]
 build = [
     "check-manifest==0.49",
@@ -62,7 +67,9 @@ log_level = "DEBUG"
 
 [tool.pytest.ini_options]
 pythonpath = "src"
-
+testpaths = ["tests"]
+addopts = "--durations=10 -n auto"
+# Estimated test times: 74s with auto (2), 76s with 6 workers, 113se with no workers.
 
 [tool.ruff]
 preview = true
@@ -130,3 +137,4 @@ twine = {version = "5.1.0"}
 
 [tool.custom.ci]
 python_versions = ["3.9", "3.10", "3.11", "3.12"]
+packaging_versions = ["22", "23", "24"]

{pydepinject-0.0.1.dev1 → pydepinject-0.0.2.dev0}/src/pydepinject/__init__.py

@@ -6,50 +6,71 @@ 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
+    from .backends import VenvBackend
 
+from .backends import VenvBackendRegistry
 
-VERSION = "0.0.1dev1"
+VERSION = "0.0.2dev0"
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 
-
-VENV_ROOT = pathlib.Path(tempfile.gettempdir()) / __name__.split(".")[0] / "venvs"
+VENV_ROOT = pathlib.Path(
+    os.environ.get("PYDEPINJECT_VENV_ROOT", None)
+    or pathlib.Path(tempfile.gettempdir()) / __name__.split(".")[0] / "venvs"
+)
 logger.debug("VENV_ROOT: %s", VENV_ROOT)
 
+VENV_BACKENDS = "|".join(VenvBackendRegistry.get_backends())
+logger.debug("VENV_BACKENDS: %s", VENV_BACKENDS)
+
 
 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
+        from importlib.metadata import PackageNotFoundError, distribution
+
+        from packaging.requirements import Requirement
     except ImportError:
-        logger.debug(
-            "pkg_resources not found. Cannot check if requirements are satisfied."
-        )
-        return None
+        try:
+            from importlib.metadata import PackageNotFoundError, distribution
+
+            from packaging.requirements import Requirement
+        except ImportError:
+            logger.warning(
+                "importlib.metadata and packaging 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)
+            req = Requirement(package)
+            try:
+                dist = distribution(req.name)
+                if dist.version not in req.specifier:
+                    logger.debug(
+                        "Requirement %s is not satisfied. Version conflict.", package
+                    )
+                    return False
+                logger.debug("Requirement %s is satisfied", package)
+            except PackageNotFoundError:
+                logger.debug(
+                    "Requirement %s is not satisfied. Distribution not found.", package
+                )
+                return False
         return True
-    except (pkg_resources.DistributionNotFound, pkg_resources.VersionConflict):
-        logger.debug("Requirements %s are not satisfied. Return False", packages)
-        return False
+    except Exception as e:
+        logger.warning("An error occurred while checking requirements: %s", str(e))
+        return None
 
 
 class RequirementManager:
@@ -60,6 +81,7 @@ class RequirementManager:
         *packages: str,
         venv_name: str | None = None,
         venv_root: pathlib.Path = VENV_ROOT,
+        venv_backend: str | None = None,
         recreate: bool = False,
         ephemeral: bool = False,
     ):
@@ -70,6 +92,7 @@ class RequirementManager:
             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.
+            venv_backend: The virtual environment backend to use. Defaults to $PYDEPINJECT_VENV_NAME or "uv|venv".
             recreate: If True, the virtual environment will be recreated if it exists.
             ephemeral: If True, the virtual environment will be deleted after use.
         """
@@ -80,10 +103,31 @@ class RequirementManager:
         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
+
+        venv_backend = (
+            venv_backend
+            or os.environ.get("PYDEPINJECT_VENV_BACKEND", None)
+            or VENV_BACKENDS
+        )
+        self._venv_backends = [item.strip() for item in venv_backend.split("|")]
+        invalid_backends = set(self._venv_backends) - set(VENV_BACKENDS.split("|"))
+        if invalid_backends:
+            raise ValueError(f"Invalid venv_backend: {','.join(invalid_backends)}")
+
         self.ephemeral = ephemeral
         self.recreate = recreate
         self._activated = False
 
+    @property
+    def venv_backend_cls(self) -> type[VenvBackend]:
+        """Returns the virtual environment backend class."""
+        supported_backends = VenvBackendRegistry.get_supported_backends()
+        for backend in self._venv_backends:
+            if backend not in supported_backends:
+                continue
+            return supported_backends[backend]
+        raise ValueError("No supported venv backend found")
+
     @property
     def venv_path(self):
         if self._venv_path:
@@ -101,21 +145,11 @@ class RequirementManager:
         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)
+        self.venv_backend_cls(self.venv_path).create(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)
+        self.venv_backend_cls(self.venv_path).install(*self.packages)
 
     def _activate_venv(self):
         if is_requirements_satisfied(*self.packages):
@@ -131,11 +165,10 @@ class RequirementManager:
 
         self._create_virtualenv()
 
-        venv_site_packages = (
-            pathlib.Path(self.venv_path)
-            / "lib"
-            / f"python{sys.version_info.major}.{sys.version_info.minor}"
-            / "site-packages"
+        venv_site_packages = pathlib.Path(self.venv_path).joinpath(
+            "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 ""
@@ -194,7 +227,6 @@ class RequirementManager:
         @functools.wraps(func)
         def wrapper(*args: Any, **kwargs: Any):
             with self:
-                print("returning func()")
                 return func(*args, **kwargs)
 
         return wrapper

pydepinject-0.0.2.dev0/src/pydepinject/backends.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import collections
+import logging
+import pathlib
+import shutil
+import subprocess
+import sys
+import typing
+from typing import Protocol
+
+if typing.TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
+_PYTHON_BIN = sys.executable
+
+logger = logging.getLogger(__name__)
+
+
+class VenvBackend(Protocol):
+    """Protocol for virtual environment backends."""
+
+    _path: pathlib.Path
+    _PRIORITY: int
+
+    def __init__(self, path: str | pathlib.Path): ...
+
+    @property
+    def name(self) -> str: ...
+
+    def create(self, clear: bool = False) -> None: ...
+
+    def install(self, *packages: str) -> None: ...
+
+    @classmethod
+    def is_supported(cls) -> bool: ...
+
+
+class VenvBackendRegistry:
+    """Registry of virtual environment backends."""
+
+    _registry: MutableMapping[str, type[VenvBackend]] = {}
+
+    @classmethod
+    def register_backend(cls, backend_cls: type[VenvBackend]) -> None:
+        instance = backend_cls(
+            pathlib.Path()
+        )  # Create an instance to access the name property
+        cls._registry[instance.name] = backend_cls
+
+    @classmethod
+    def get_backend(cls, name: str) -> type[VenvBackend] | None:
+        return cls._registry.get(name)
+
+    @classmethod
+    def has_backend(cls, name: str) -> bool:
+        return name in cls._registry
+
+    @classmethod
+    def get_backends(cls) -> MutableMapping[str, type[VenvBackend]]:
+        result: MutableMapping[str, type[VenvBackend]] = collections.OrderedDict()
+        for name in sorted(cls._registry, key=lambda x: cls._registry[x]._PRIORITY):  # pyright: ignore[reportPrivateUsage]
+            result[name] = cls._registry[name]
+        return result
+
+    @classmethod
+    def get_supported_backends(cls) -> dict[str, type[VenvBackend]]:
+        return {
+            name: backend_cls
+            for name, backend_cls in cls._registry.items()
+            if backend_cls.is_supported()
+        }
+
+
+class VenvBackendVenv:
+    """Virtual environment backend using the venv module."""
+
+    _NAME = "venv"
+    _PRIORITY: int = 0
+
+    def __init__(self, path: str | pathlib.Path):
+        self._path = pathlib.Path(path)
+
+    @property
+    def name(self) -> str:
+        return self._NAME
+
+    @classmethod
+    def is_supported(cls) -> bool:
+        return True
+
+    def create(self, clear: bool = False) -> None:
+        clear_opt = ["--clear"] if clear else []
+        venv_args = [_PYTHON_BIN, "-m", "venv"] + clear_opt + [str(self._path)]
+        logger.debug("Running command: %s", " ".join(venv_args))
+        subprocess.check_call(venv_args)
+
+    def install(self, *packages: str) -> None:
+        if not self._path.exists():
+            raise FileNotFoundError(f"Virtual environment not found: {self._path}")
+
+        pip_executable = self._path / "bin" / "pip"
+        if not pip_executable.exists():
+            raise FileNotFoundError(f"pip executable not found: {pip_executable}")
+
+        pip_args = [
+            str(pip_executable),
+            "install",
+            "--quiet",
+            "--no-python-version-warning",
+            "--disable-pip-version-check",
+            "--upgrade",
+            *packages,
+        ]
+        logger.debug("Running command: %s", " ".join(pip_args))
+        subprocess.check_call(pip_args)
+
+
+class VenvBackendUV:
+    """Virtual environment backend using the uv tool."""
+
+    _NAME = "uv"
+    _PRIORITY: int = 1
+    _CMD = "uv"
+
+    def __init__(self, path: str | pathlib.Path):
+        self._path = pathlib.Path(path)
+
+    @property
+    def name(self) -> str:
+        return self._NAME
+
+    @classmethod
+    def is_supported(cls) -> bool:
+        return bool(shutil.which(cls._CMD))
+
+    def create(self, clear: bool = False) -> None:
+        if clear and self._path.exists():
+            shutil.rmtree(self._path)
+        subprocess.check_call([
+            f"{self._CMD}",
+            "venv",
+            "--python",
+            _PYTHON_BIN,
+            self._path.as_posix(),
+        ])
+
+    def install(self, *packages: str) -> None:
+        if not self._path.exists():
+            raise FileNotFoundError(f"Virtual environment not found: {self._path}")
+        pip_args = [
+            f"{self._CMD}",
+            "pip",
+            "install",
+            "--python",
+            (self._path / "bin" / "python").as_posix(),
+            "--quiet",
+            "--upgrade",
+            *packages,
+        ]
+        logger.debug("Running command: %s", " ".join(pip_args))
+        subprocess.check_call(pip_args)
+
+
+# Register backends
+VenvBackendRegistry.register_backend(VenvBackendVenv)
+VenvBackendRegistry.register_backend(VenvBackendUV)

{pydepinject-0.0.1.dev1 → pydepinject-0.0.2.dev0/src/pydepinject.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pydepinject
-Version: 0.0.1.dev1
+Version: 0.0.2.dev0
 Summary: A package to dynamically inject requirements into a virtual environment.
 Author: pydepinject
 License: MIT
@@ -21,6 +21,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: packaging>=22.0
+Requires-Dist: typing_extensions
 Provides-Extra: lint
 Requires-Dist: ruff==0.4.7; extra == "lint"
 Requires-Dist: pyright==1.1.365; extra == "lint"
@@ -28,6 +30,7 @@ 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"
+Requires-Dist: pytest-xdist==3.6.1; extra == "test"
 Provides-Extra: build
 Requires-Dist: check-manifest==0.49; extra == "build"
 Requires-Dist: build==1.2.1; extra == "build"

{pydepinject-0.0.1.dev1 → pydepinject-0.0.2.dev0}/src/pydepinject.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ MANIFEST.in
 Readme.md
 pyproject.toml
 src/pydepinject/__init__.py
+src/pydepinject/backends.py
 src/pydepinject.egg-info/PKG-INFO
 src/pydepinject.egg-info/SOURCES.txt
 src/pydepinject.egg-info/dependency_links.txt
@@ -13,4 +14,5 @@ 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/conftest.py
 tests/test_pydepinject.py

{pydepinject-0.0.1.dev1 → pydepinject-0.0.2.dev0}/src/pydepinject.egg-info/requires.txt

@@ -1,3 +1,5 @@
+packaging>=22.0
+typing_extensions
 
 [build]
 check-manifest==0.49
@@ -13,3 +15,4 @@ isort==5.13.2
 [test]
 pytest==8.2.1
 pytest-cov==5.0.0
+pytest-xdist==3.6.1

pydepinject-0.0.2.dev0/tests/conftest.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import pathlib
+
+import pytest
+
+PROJECT_DIR = pathlib.Path(__file__).parent.parent
+
+
+@pytest.fixture(autouse=True)
+def check_test_leftovers():
+    """Checks if the test left any files in the project directory."""
+    items_before = list(PROJECT_DIR.iterdir())
+    yield
+    items_after = list(PROJECT_DIR.iterdir())
+    new_items = set(items_after) - set(items_before)
+    new_items = {item for item in new_items if not item.name.startswith(".coverage")}
+    if new_items:
+        pytest.fail(f"New items in the project directory: {new_items}")

{pydepinject-0.0.1.dev1 → pydepinject-0.0.2.dev0}/tests/test_pydepinject.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import functools
+
 import pytest
 
 from pydepinject import requires  # noqa: E402
@@ -13,14 +15,19 @@ def venv_root(tmp_path):
     return path
 
 
+@pytest.mark.parametrize("backend", ["uv", "venv"], ids=["uv", "venv"])
 @pytest.mark.parametrize("ephemeral", [True, False], ids=["ephemeral", "non-ephemeral"])
-def test_decorator(venv_root, ephemeral):
+def test_decorator(venv_root, ephemeral, backend):
     assert not list(venv_root.iterdir())
 
     with pytest.raises(ImportError):
         import six
 
-    @requires("six", venv_root=venv_root, ephemeral=ephemeral)
+    requires_ = functools.partial(
+        requires, venv_root=venv_root, ephemeral=ephemeral, venv_backend=backend
+    )
+
+    @requires_("six")
     def examplefn():
         print("examplefn")
         import six
@@ -37,15 +44,24 @@ def test_decorator(venv_root, ephemeral):
         assert len(list(venv_root.iterdir())) == 1
 
 
+@pytest.mark.parametrize("backend", ["uv", "venv"], ids=["uv", "venv"])
 @pytest.mark.parametrize("ephemeral", [True, False], ids=["ephemeral", "non-ephemeral"])
-def test_venv_name_predefined(venv_root, ephemeral):
+def test_venv_name_predefined(venv_root, ephemeral, backend):
     assert not list(venv_root.iterdir())
 
     venv_name = "test_venv_name_predefined"
     with pytest.raises(ImportError):
         import six
 
-    @requires("six", venv_root=venv_root, venv_name=venv_name, ephemeral=ephemeral)
+    requires_ = functools.partial(
+        requires,
+        venv_root=venv_root,
+        venv_name=venv_name,
+        ephemeral=ephemeral,
+        venv_backend=backend,
+    )
+
+    @requires_("six")
     def examplefn():
         print("examplefn")
         import six
@@ -60,7 +76,7 @@ def test_venv_name_predefined(venv_root, ephemeral):
     assert (venv_root / venv_name).exists() is (not ephemeral)
     assert len(list(venv_root.iterdir())) == (1 if not ephemeral else 0)
 
-    with requires("six", venv_root=venv_root, venv_name=venv_name, ephemeral=ephemeral):
+    with requires_("six"):
         import six
 
         assert six.__version__
@@ -73,8 +89,9 @@ def test_venv_name_predefined(venv_root, ephemeral):
     assert len(list(venv_root.iterdir())) == (1 if not ephemeral else 0)
 
 
+@pytest.mark.parametrize("backend", ["uv", "venv"], ids=["uv", "venv"])
 @pytest.mark.parametrize("ephemeral", [True, False], ids=["ephemeral", "non-ephemeral"])
-def test_venv_name_predefined_env(venv_root, monkeypatch, ephemeral):
+def test_venv_name_predefined_env(venv_root, monkeypatch, ephemeral, backend):
     assert not list(venv_root.iterdir())
 
     venv_name = "test_venv_name_predefined_env"
@@ -83,7 +100,11 @@ def test_venv_name_predefined_env(venv_root, monkeypatch, ephemeral):
     with pytest.raises(ImportError):
         import six
 
-    @requires("six", venv_root=venv_root, ephemeral=ephemeral)
+    requires_ = functools.partial(
+        requires, venv_root=venv_root, ephemeral=ephemeral, venv_backend=backend
+    )
+
+    @requires_("six")
     def examplefn():
         print("examplefn")
         import six
@@ -98,7 +119,7 @@ def test_venv_name_predefined_env(venv_root, monkeypatch, ephemeral):
     assert (venv_root / venv_name).exists() is (not ephemeral)
     assert len(list(venv_root.iterdir())) == (1 if not ephemeral else 0)
 
-    with requires("six", venv_root=venv_root, ephemeral=ephemeral):
+    with requires_("six"):
         import six
 
         assert six.__version__
@@ -111,14 +132,18 @@ def test_venv_name_predefined_env(venv_root, monkeypatch, ephemeral):
     assert len(list(venv_root.iterdir())) == (1 if not ephemeral else 0)
 
 
+@pytest.mark.parametrize("backend", ["uv", "venv"], ids=["uv", "venv"])
 @pytest.mark.parametrize("ephemeral", [True, False], ids=["ephemeral", "non-ephemeral"])
-def test_context_manager(venv_root, ephemeral):
+def test_context_manager(venv_root, ephemeral, backend):
     assert not list(venv_root.iterdir())
 
     with pytest.raises(ImportError):
         import six
 
-    with requires("six", venv_root=venv_root, ephemeral=ephemeral):
+    requires_ = functools.partial(
+        requires, venv_root=venv_root, ephemeral=ephemeral, venv_backend=backend
+    )
+    with requires_("six"):
         import six
 
         assert six.__version__
@@ -132,13 +157,14 @@ def test_context_manager(venv_root, ephemeral):
         assert len(list(venv_root.iterdir())) == 1
 
 
-def test_function_call(venv_root):
+@pytest.mark.parametrize("backend", ["uv", "venv"], ids=["uv", "venv"])
+def test_function_call(venv_root, backend):
     assert not list(venv_root.iterdir())
 
     with pytest.raises(ImportError):
         import six
 
-    requires_instance = requires("six", venv_root=venv_root)
+    requires_instance = requires("six", venv_root=venv_root, venv_backend=backend)
     requires_instance()
     import six
 
@@ -151,10 +177,11 @@ def test_function_call(venv_root):
     assert len(list(venv_root.iterdir())) == 1
 
 
-def test_no_installs(venv_root):
+@pytest.mark.parametrize("backend", ["uv", "venv"], ids=["uv", "venv"])
+def test_no_installs(venv_root, backend):
     assert not list(venv_root.iterdir())
 
-    @requires("pytest", venv_root=venv_root, ephemeral=False)
+    @requires("pytest", venv_root=venv_root, ephemeral=False, venv_backend=backend)
     def examplefn():
         print("examplefn")
 
@@ -162,17 +189,22 @@ def test_no_installs(venv_root):
     assert not list(venv_root.iterdir())
 
 
-def test_reuse_venv(venv_root):
+@pytest.mark.parametrize("backend", ["uv", "venv"], ids=["uv", "venv"])
+def test_reuse_venv(venv_root, backend):
     assert not list(venv_root.iterdir())
 
-    @requires("six", venv_root=venv_root, ephemeral=False)
+    requires_ = functools.partial(
+        requires, venv_root=venv_root, ephemeral=False, venv_backend=backend
+    )
+
+    @requires_("six")
     def examplea():
         import six
 
         assert six.__version__
         examplea.called = True
 
-    @requires("six", venv_root=venv_root, ephemeral=False)
+    @requires_("six")
     def exampleb():
         import six
 
@@ -192,19 +224,28 @@ def test_reuse_venv(venv_root):
     assert len(list(venv_root.iterdir())) == 1
 
 
-def test_one_venv_multiple_packages(venv_root):
+@pytest.mark.parametrize("backend", ["uv", "venv"], ids=["uv", "venv"])
+def test_one_venv_multiple_packages(venv_root, backend):
     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)
+    requires_ = functools.partial(
+        requires,
+        venv_root=venv_root,
+        venv_name=venv_name,
+        ephemeral=False,
+        venv_backend=backend,
+    )
+
+    @requires_("six")
     def examplefn():
         import six
 
         assert six.__version__
         assert (venv_root / venv_name).exists()
 
-    @requires("pyparsing", venv_root=venv_root, venv_name=venv_name, ephemeral=False)
+    @requires_("pyparsing")
     def examplefn2():
         import pyparsing
 

pydepinject-0.0.1.dev1/MANIFEST.in

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