Replace venv_path with venv_python_executable

Author: mgorny

tests/plugins/test_loader.py

@@ -474,7 +474,9 @@ def test_plugin_in_venv(test_plugin_package_req: str) -> None:
 
     with DefaultIsolatedEnv() as venv:
         venv.install([test_plugin_package_req])
-        with PluginLoader(variant_info, venv_path=Path(venv.path)) as loader:
+        with PluginLoader(
+            variant_info, venv_python_executable=Path(venv.python_executable)
+        ) as loader:
             assert set(loader.namespaces) == {"installable_plugin"}
 
 

tests/plugins/test_py_envs.py

@@ -203,9 +203,6 @@ def get_or_skip_combinations() -> Generator[VariantDescription]:
             f"Did not conform the `VariantsJsonDict` format: {variants_json}"
         )
 
-    mocker.patch(
-        "variantlib.plugins.loader.BasePluginLoader._load_all_plugins_from_tuple"
-    ).return_value = None
     mocker.patch(
         "variantlib.plugins.loader.BasePluginLoader.get_supported_configs"
     ).return_value = {provider_cfg.namespace: provider_cfg for provider_cfg in configs}

tests/test_api.py

@@ -47,18 +47,22 @@
 def get_variant_hashes_by_priority(
     *,
     variants_json: VariantsJsonDict | VariantsJson,
-    venv_path: str | pathlib.Path | None = None,
+    venv_python_executable: str | pathlib.Path | None = None,
     enable_optional_plugins: bool | list[VariantNamespace] = False,
 ) -> list[str]:
     supported_vprops = []
     if not isinstance(variants_json, VariantsJson):
         variants_json = VariantsJson(variants_json)
 
-    venv_path = venv_path if venv_path is None else pathlib.Path(venv_path)
+    venv_python_executable = (
+        venv_python_executable
+        if venv_python_executable is None
+        else pathlib.Path(venv_python_executable)
+    )
 
     with PluginLoader(
         variant_info=variants_json,
-        venv_path=venv_path,
+        venv_python_executable=venv_python_executable,
         enable_optional_plugins=enable_optional_plugins,
     ) as plugin_loader:
         supported_vprops = list(
@@ -94,7 +98,7 @@ def get_variant_hashes_by_priority(
 def validate_variant(
     variant_desc: VariantDescription,
     variant_info: VariantInfo,
-    venv_path: str | pathlib.Path | None = None,
+    venv_python_executable: str | pathlib.Path | None = None,
 ) -> VariantValidationResult:
     """
     Validate all metas in the variant description
@@ -106,11 +110,15 @@ def validate_variant(
     be verified.
     """
 
-    venv_path = venv_path if venv_path is None else pathlib.Path(venv_path)
+    venv_python_executable = (
+        venv_python_executable
+        if venv_python_executable is None
+        else pathlib.Path(venv_python_executable)
+    )
 
     with PluginLoader(
         variant_info=variant_info,
-        venv_path=venv_path,
+        venv_python_executable=venv_python_executable,
         enable_optional_plugins=True,
         filter_plugins=list({vprop.namespace for vprop in variant_desc.properties}),
     ) as plugin_loader:
@@ -150,7 +158,7 @@ def check_variant_supported(
     *,
     vdesc: VariantDescription | None = None,
     variant_info: VariantInfo,
-    venv_path: str | pathlib.Path | None = None,
+    venv_python_executable: str | pathlib.Path | None = None,
     enable_optional_plugins: bool | list[VariantNamespace] = False,
 ) -> bool:
     """Check if variant description is supported
@@ -170,11 +178,15 @@ def check_variant_supported(
             )
         vdesc = next(iter(variant_info.variants.values()))
 
-    venv_path = venv_path if venv_path is None else pathlib.Path(venv_path)
+    venv_python_executable = (
+        venv_python_executable
+        if venv_python_executable is None
+        else pathlib.Path(venv_python_executable)
+    )
 
     with PluginLoader(
         variant_info=variant_info,
-        venv_path=venv_path,
+        venv_python_executable=venv_python_executable,
         enable_optional_plugins=enable_optional_plugins,
     ) as plugin_loader:
         supported_vprops = list(

variantlib/api.py

@@ -188,7 +188,9 @@ def _make_variant(
                 vdesc_valid = validate_variant(
                     vdesc,
                     variant_info=variant_info,
-                    venv_path=venv.path if venv is not None else None,
+                    venv_python_executable=venv.python_executable
+                    if venv is not None
+                    else None,
                 )
                 if vdesc_valid.invalid_properties:
                     invalid_str = ", ".join(

variantlib/commands/make_variant.py

@@ -9,7 +9,6 @@
 import sys
 from abc import abstractmethod
 from collections.abc import Sequence
-from functools import partial
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import TYPE_CHECKING
@@ -24,17 +23,14 @@
 from variantlib.errors import PluginMissingError
 from variantlib.models.provider import ProviderConfig
 from variantlib.models.provider import VariantFeatureConfig
-from variantlib.plugins.py_envs import python_env
 from variantlib.validators.base import validate_matches_re
 
 if TYPE_CHECKING:
-    from contextlib import AbstractContextManager
     from types import TracebackType
 
     from variantlib.models.variant import VariantDescription
     from variantlib.models.variant_info import ProviderInfo
     from variantlib.models.variant_info import VariantInfo
-    from variantlib.plugins.py_envs import PythonEnv
     from variantlib.protocols import VariantNamespace
 
 if sys.version_info >= (3, 10):
@@ -56,29 +52,22 @@ class BasePluginLoader:
     """Load and query plugins"""
 
     _namespace_map: dict[str, str] | None = None
-    _python_ctx_manager: AbstractContextManager[PythonEnv] | None = None
-    _python_ctx: PythonEnv | None = None
+    _python_executable: Path
 
     def __init__(
         self,
-        venv_path: Path | None = None,
+        venv_python_executable: Path | None = None,
     ) -> None:
-        self._python_ctx_factory = partial(python_env, venv_path=venv_path)
+        self._python_executable = (
+            venv_python_executable
+            if venv_python_executable is not None
+            else Path(sys.executable)
+        )
 
     def __enter__(self) -> Self:
-        if self._python_ctx is not None:
+        if self._namespace_map is not None:
             raise RuntimeError("Already inside the context manager!")
-
-        self._python_ctx_manager = self._python_ctx_factory()
-        self._python_ctx = self._python_ctx_manager.__enter__()
-        try:
-            self._load_all_plugins()
-        except Exception:
-            self._python_ctx_manager.__exit__(*sys.exc_info())
-            self._python_ctx = None
-            self._python_ctx_manager = None
-            raise
-
+        self._load_all_plugins()
         return self
 
     def __exit__(
@@ -87,19 +76,13 @@ def __exit__(
         exc_value: BaseException | None,
         traceback: TracebackType | None,
     ) -> None:
-        if self._python_ctx is None:
+        if self._namespace_map is None:
             raise RuntimeError("Context manager not entered!")
-        assert self._python_ctx_manager is not None
-
         self._namespace_map = None
-        self._python_ctx = None
-        self._python_ctx_manager.__exit__(exc_type, exc_value, traceback)
 
     def _call_subprocess(
         self, plugin_apis: list[str], commands: dict[str, Any]
     ) -> dict[str, dict[str, Any]]:
-        assert self._python_ctx is not None
-
         with TemporaryDirectory(prefix="variantlib") as temp_dir:
             script = Path(temp_dir) / "loader.py"
             script.write_bytes(
@@ -125,7 +108,7 @@ def _call_subprocess(
                 args += ["-p", plugin_api]
 
             process = subprocess.run(  # noqa: S603
-                [self._python_ctx.python_executable, script, *args],
+                [self._python_executable, script, *args],
                 input=json.dumps(commands).encode("utf8"),
                 capture_output=True,
                 check=False,
@@ -140,8 +123,6 @@ def _call_subprocess(
     def _load_all_plugins(self) -> None: ...
 
     def _load_all_plugins_from_tuple(self, plugin_apis: list[str]) -> None:
-        if self._python_ctx is None:
-            raise RuntimeError("Context manager not entered!")
         if self._namespace_map is not None:
             raise RuntimeError(
                 "Impossible to load plugins - `self._namespace_map` is not None"
@@ -189,8 +170,6 @@ def _load_all_plugins_from_tuple(self, plugin_apis: list[str]) -> None:
             )
 
     def _check_plugins_loaded(self) -> None:
-        if self._python_ctx is None:
-            raise RuntimeError("Context manager not entered!")
         if self._namespace_map is None:
             raise NoPluginFoundError("No plugin has been loaded in the environment.")
 
@@ -285,15 +264,15 @@ class PluginLoader(BasePluginLoader):
     def __init__(
         self,
         variant_info: VariantInfo,
-        venv_path: Path | None = None,
+        venv_python_executable: Path | None = None,
         enable_optional_plugins: bool | list[VariantNamespace] = False,
         filter_plugins: list[VariantNamespace] | None = None,
     ) -> None:
         self._variant_info = variant_info
         self._enable_optional_plugins = enable_optional_plugins
         self._filter_plugins = filter_plugins
         self._environment = cast("dict[str, str]", default_environment())
-        super().__init__(venv_path=venv_path)
+        super().__init__(venv_python_executable=venv_python_executable)
 
     def _optional_provider_enabled(self, namespace: str) -> bool:
         # if enable_optional_plugins is a bool, it controls all plugins
@@ -348,9 +327,9 @@ class EntryPointPluginLoader(BasePluginLoader):
 
     def __init__(
         self,
-        venv_path: Path | None = None,
+        venv_python_executable: Path | None = None,
     ) -> None:
-        super().__init__(venv_path=venv_path)
+        super().__init__(venv_python_executable=venv_python_executable)
 
     def _load_all_plugins(self) -> None:
         if self._namespace_map is not None:
@@ -396,10 +375,10 @@ class ListPluginLoader(BasePluginLoader):
     def __init__(
         self,
         plugin_apis: list[str],
-        venv_path: Path | None = None,
+        venv_python_executable: Path | None = None,
     ) -> None:
         self._plugin_apis = list(plugin_apis)
-        super().__init__(venv_path=venv_path)
+        super().__init__(venv_python_executable=venv_python_executable)
 
     def _load_all_plugins(self) -> None:
         if self._namespace_map is not None: