virtualenv 21.2.4__tar.gz → 21.3.0__tar.gz

{virtualenv-21.2.4 → virtualenv-21.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtualenv
-Version: 21.2.4
+Version: 21.3.0
 Summary: Virtual Python Environment builder
 Project-URL: Documentation, https://virtualenv.pypa.io
 Project-URL: Homepage, https://github.com/pypa/virtualenv

{virtualenv-21.2.4 → virtualenv-21.3.0}/pyproject.toml

@@ -65,6 +65,7 @@ entry-points."virtualenv.activate".fish = "virtualenv.activation.fish:FishActiva
 entry-points."virtualenv.activate".nushell = "virtualenv.activation.nushell:NushellActivator"
 entry-points."virtualenv.activate".powershell = "virtualenv.activation.powershell:PowerShellActivator"
 entry-points."virtualenv.activate".python = "virtualenv.activation.python:PythonActivator"
+entry-points."virtualenv.activate".xonsh = "virtualenv.activation.xonsh:XonshActivator"
 entry-points."virtualenv.create".cpython3-mac-brew = "virtualenv.create.via_global_ref.builtin.cpython.mac_os:CPython3macOsBrew"
 entry-points."virtualenv.create".cpython3-mac-framework = "virtualenv.create.via_global_ref.builtin.cpython.mac_os:CPython3macOsFramework"
 entry-points."virtualenv.create".cpython3-posix = "virtualenv.create.via_global_ref.builtin.cpython.cpython3:CPython3Posix"

{virtualenv-21.2.4 → virtualenv-21.3.0}/src/virtualenv/activation/__init__.py

@@ -7,6 +7,7 @@ from .fish import FishActivator
 from .nushell import NushellActivator
 from .powershell import PowerShellActivator
 from .python import PythonActivator
+from .xonsh import XonshActivator
 
 __all__ = [
     "BashActivator",
@@ -16,4 +17,5 @@ __all__ = [
     "NushellActivator",
     "PowerShellActivator",
     "PythonActivator",
+    "XonshActivator",
 ]

virtualenv-21.3.0/src/virtualenv/activation/xonsh/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from virtualenv.activation.via_template import ViaTemplateActivator
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from pathlib import Path
+
+    from virtualenv.create.creator import Creator
+
+
+class XonshActivator(ViaTemplateActivator):
+    def templates(self) -> Iterator[str]:
+        yield "activate.xsh"
+
+    @staticmethod
+    def quote(string: str) -> str:
+        """Quote as a Python literal — xonsh parses the activation script as Python."""
+        return repr(string)
+
+    def replacements(self, creator: Creator, dest_folder: Path) -> dict[str, str]:
+        data = super().replacements(creator, dest_folder)
+        data.update({
+            "__TCL_LIBRARY__": getattr(creator.interpreter, "tcl_lib", None) or "",
+            "__TK_LIBRARY__": getattr(creator.interpreter, "tk_lib", None) or "",
+        })
+        return data
+
+
+__all__ = [
+    "XonshActivator",
+]

virtualenv-21.3.0/src/virtualenv/activation/xonsh/activate.xsh

@@ -0,0 +1,101 @@
+# This file must be used with "source bin/activate.xsh" *from xonsh*.
+# You cannot run it directly.
+
+
+class _VirtualEnvActivator:
+    """xonsh activation for virtualenv.
+
+    Rendered into ``<venv>/bin/activate.xsh`` by the template in
+    ``src/virtualenv/activation/xonsh/`` at generate-time.
+
+    - Project: https://github.com/pypa/virtualenv
+    - Template source: https://github.com/pypa/virtualenv/tree/main/src/virtualenv/activation/xonsh
+    """
+
+    # Stashed in _OLD_VIRTUAL_{name} when the variable was not set before
+    # activation. deactivate treats this as "unset" rather than "restore to
+    # this string". Chosen to be vanishingly unlikely as a real value.
+    _UNSET_SENTINEL = "__virtualenv_was_not_set__"
+
+    def __init__(self):
+        self.env = __xonsh__.env
+        try:
+            # Values substituted by virtualenv's XonshActivator at generate-time.
+            # If this file was sourced before template rendering, the bare
+            # identifiers below resolve to NameError.
+            self.embedded_virtual_env = __VIRTUAL_ENV__
+            self.embedded_virtual_prompt = __VIRTUAL_PROMPT__
+            self.embedded_bin_name = __BIN_NAME__
+            self.embedded_tcl_library = __TCL_LIBRARY__
+            self.embedded_tk_library = __TK_LIBRARY__
+        except NameError:
+            print("virtualenv activate.xsh: template was not rendered")
+            raise
+        # Variables this activator may save+override; deactivate walks this list.
+        self.managed_vars = ("PATH", "PYTHONHOME", "TCL_LIBRARY", "TK_LIBRARY")
+
+    def _backup_name(self, name):
+        return f"_OLD_VIRTUAL_{name}"
+
+    def _save(self, name):
+        """Stash the current value (or sentinel if unset) so deactivate can undo."""
+        backup = self._backup_name(name)
+        self.env[backup] = self.env[name] if name in self.env else self._UNSET_SENTINEL
+
+    def _override(self, name, value):
+        self._save(name)
+        self.env[name] = value
+
+    def _drop(self, name):
+        self._save(name)
+        self.env.pop(name, None)
+
+    def register_pydoc(self):
+        aliases["pydoc"] = ["python", "-m", "pydoc"]
+
+    def unregister_pydoc(self):
+        aliases.pop("pydoc", None)
+
+    def activate(self):
+        from os.path import join, basename
+
+        aliases["deactivate"] = self.deactivate
+        self.deactivate(["nondestructive"])  # wipe any stale state from a prior activation
+
+        $VIRTUAL_ENV = self.embedded_virtual_env
+        $VIRTUAL_ENV_PROMPT = self.embedded_virtual_prompt or basename($VIRTUAL_ENV)
+
+        self._override("PATH", [join($VIRTUAL_ENV, self.embedded_bin_name), *$PATH])
+        self._drop("PYTHONHOME")
+        for name, value in (("TCL_LIBRARY", self.embedded_tcl_library), ("TK_LIBRARY", self.embedded_tk_library)):
+            if value:
+                self._override(name, value)
+
+        self.register_pydoc()
+
+    def deactivate(self, args=None):
+        for name in self.managed_vars:
+            backup = self._backup_name(name)
+            if backup not in self.env:
+                continue
+            previous = self.env[backup]
+            del self.env[backup]
+            if previous == self._UNSET_SENTINEL:
+                self.env.pop(name, None)
+            else:
+                self.env[name] = previous
+        for name in ("VIRTUAL_ENV", "VIRTUAL_ENV_PROMPT"):
+            self.env.pop(name, None)
+        self.unregister_pydoc()
+        if args is None or "nondestructive" not in args:
+            del aliases["deactivate"]
+            try:
+                del __xonsh__.xontrib.virtualenv
+            except AttributeError:
+                pass
+
+
+if not hasattr(__xonsh__, "xontrib"):
+    __xonsh__.xontrib = __xonsh__.imp.types.SimpleNamespace()
+__xonsh__.xontrib.virtualenv = _VirtualEnvActivator()
+__xonsh__.xontrib.virtualenv.activate()

{virtualenv-21.2.4 → virtualenv-21.3.0}/src/virtualenv/config/cli/parser.py

@@ -113,7 +113,8 @@ class VirtualEnvConfigParser(ArgumentParser):
                     if outcome is not None:
                         break
             if outcome is not None:
-                action.default, action.default_source = outcome
+                action.default, default_source = outcome
+                vars(action)["default_source"] = default_source
             else:
                 outcome = action.default, "default"
             self.options.set_src(action.dest, *outcome)
@@ -122,7 +123,7 @@ class VirtualEnvConfigParser(ArgumentParser):
         self._fix_defaults()
         self.add_argument("-h", "--help", action="help", default=SUPPRESS, help="show this help message and exit")
 
-    def parse_known_args(
+    def parse_known_args(  # ty: ignore[invalid-method-override]
         self, args: Sequence[str] | None = None, namespace: VirtualEnvOptions | None = None
     ) -> tuple[VirtualEnvOptions, list[str]]:
         if namespace is None:

{virtualenv-21.2.4 → virtualenv-21.3.0}/src/virtualenv/run/plugin/base.py

@@ -22,8 +22,14 @@ class PluginLoader:
     @classmethod
     def entry_points_for(cls, key: str) -> OrderedDict[str, type]:
         if sys.version_info >= (3, 10) or importlib_metadata_version >= (3, 6):
-            return OrderedDict((e.name, e.load()) for e in cls.entry_points().select(group=key))  # ty: ignore[unresolved-attribute]
-        return OrderedDict((e.name, e.load()) for e in cls.entry_points().get(key, {}))  # ty: ignore[unresolved-attribute]
+            selected = list(cls.entry_points().select(group=key))  # ty: ignore[unresolved-attribute]
+        else:
+            selected = list(cls.entry_points().get(key, []))  # ty: ignore[unresolved-attribute]
+        # Third-party packages may register entry points with the same name as virtualenv's
+        # built-ins (e.g. xonsh's own `virtualenv.activate.xonsh`). Sort so built-ins are
+        # inserted last into the OrderedDict, making them win on name collision.
+        selected.sort(key=lambda e: e.value.startswith("virtualenv."))
+        return OrderedDict((e.name, e.load()) for e in selected)
 
     @staticmethod
     def entry_points() -> object:

{virtualenv-21.2.4 → virtualenv-21.3.0}/src/virtualenv/seed/wheels/embed/__init__.py

@@ -19,27 +19,27 @@ BUNDLE_SUPPORT = {
         "setuptools": "setuptools-82.0.1-py3-none-any.whl",
     },
     "3.10": {
-        "pip": "pip-26.0.1-py3-none-any.whl",
+        "pip": "pip-26.1-py3-none-any.whl",
         "setuptools": "setuptools-82.0.1-py3-none-any.whl",
     },
     "3.11": {
-        "pip": "pip-26.0.1-py3-none-any.whl",
+        "pip": "pip-26.1-py3-none-any.whl",
         "setuptools": "setuptools-82.0.1-py3-none-any.whl",
     },
     "3.12": {
-        "pip": "pip-26.0.1-py3-none-any.whl",
+        "pip": "pip-26.1-py3-none-any.whl",
         "setuptools": "setuptools-82.0.1-py3-none-any.whl",
     },
     "3.13": {
-        "pip": "pip-26.0.1-py3-none-any.whl",
+        "pip": "pip-26.1-py3-none-any.whl",
         "setuptools": "setuptools-82.0.1-py3-none-any.whl",
     },
     "3.14": {
-        "pip": "pip-26.0.1-py3-none-any.whl",
+        "pip": "pip-26.1-py3-none-any.whl",
         "setuptools": "setuptools-82.0.1-py3-none-any.whl",
     },
     "3.15": {
-        "pip": "pip-26.0.1-py3-none-any.whl",
+        "pip": "pip-26.1-py3-none-any.whl",
         "setuptools": "setuptools-82.0.1-py3-none-any.whl",
     },
 }
@@ -50,6 +50,7 @@ MAX = "3.8"
 BUNDLE_SHA256 = {
     "pip-25.0.1-py3-none-any.whl": "c46efd13b6aa8279f33f2864459c8ce587ea6a1a59ee20de055868d8f7688f7f",
     "pip-26.0.1-py3-none-any.whl": "bdb1b08f4274833d62c1aa29e20907365a2ceb950410df15fc9521bad440122b",
+    "pip-26.1-py3-none-any.whl": "4e8486d821d814b77319acb7b9e8bf5a4ee7590a643e7cb21029f209be8573c1",
     "setuptools-75.3.4-py3-none-any.whl": "2dd50a7f42dddfa1d02a36f275dbe716f38ed250224f609d35fb60a09593d93e",
     "setuptools-82.0.1-py3-none-any.whl": "a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb",
     "wheel-0.45.1-py3-none-any.whl": "708e7481cc80179af0e556bbf0cc00b8444c7321e2700b8d8580231d13017248",

{virtualenv-21.2.4 → virtualenv-21.3.0}/src/virtualenv/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '21.2.4'
-__version_tuple__ = version_tuple = (21, 2, 4)
+__version__ = version = '21.3.0'
+__version_tuple__ = version_tuple = (21, 3, 0)
 
 __commit_id__ = commit_id = None

{virtualenv-21.2.4 → virtualenv-21.3.0}/tests/unit/activation/conftest.py

@@ -34,12 +34,13 @@ class ActivationTester:
             try:
                 process = Popen(
                     self._version_cmd,
+                    stdin=subprocess.DEVNULL,
                     universal_newlines=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     encoding="utf-8",
                 )
-                out, err = process.communicate()
+                out, err = process.communicate(timeout=30)
             except Exception as exception:
                 self._version = exception
                 if raise_on_fail:
@@ -75,12 +76,15 @@ class ActivationTester:
         invoke, env = [*self._invoke_script, str(test_script)], self.env(tmp_path)
 
         try:
-            process = Popen(invoke, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env)
-            raw_, _ = process.communicate(timeout=120)
-        except subprocess.TimeoutExpired:
+            process = Popen(invoke, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env)
+            raw_, _ = process.communicate(timeout=60)
+        except subprocess.TimeoutExpired as exc:
             process.kill()
-            process.communicate()
-            pytest.fail(f"Activation script timed out: {invoke}")
+            remaining, _ = process.communicate(timeout=5)
+            partial = (exc.stdout or b"") + (remaining or b"")
+            pytest.fail(
+                f"Activation script timed out:\nPartial output:\n{partial.decode(errors='replace')}\nCommand: {invoke}"
+            )
         except subprocess.CalledProcessError as exception:
             output = exception.output + exception.stderr
             assert not exception.returncode, output  # noqa: PT017
@@ -103,7 +107,7 @@ class ActivationTester:
         env["PYTHONIOENCODING"] = "utf-8"
         env["PATH"] = os.pathsep.join([dirname(sys.executable), *env.get("PATH", "").split(os.pathsep)])
         # clear up some environment variables so they don't affect the tests
-        for key in [k for k in env if k.startswith(("_OLD", "VIRTUALENV_"))]:
+        for key in [k for k in env if k.startswith(("_OLD", "VIRTUALENV_", "COVERAGE_"))]:
             del env[key]
         return env
 
@@ -116,7 +120,7 @@ class ActivationTester:
         return test_script
 
     def _get_test_lines(self, activate_script):
-        return [
+        steps = [
             self.print_python_exe(),
             self.print_os_env_var("VIRTUAL_ENV"),
             self.print_os_env_var("VIRTUAL_ENV_PROMPT"),
@@ -133,9 +137,17 @@ class ActivationTester:
             self.print_os_env_var("VIRTUAL_ENV_PROMPT"),
             "",  # just finish with an empty new line
         ]
+        result = []
+        for index, step in enumerate(steps):
+            result.extend((self.print_marker(index), step))
+        return result
+
+    def print_marker(self, step) -> str:
+        return f'echo "__STEP_{step}__"'
 
     def assert_output(self, out, raw, tmp_path) -> None:
         """Compare _get_test_lines() with the expected values."""
+        out = [line for line in out if not line.strip('"').startswith("__STEP_")]
         assert out[0], raw
         assert out[1] == "None", raw
         assert out[2] == "None", raw
@@ -213,11 +225,12 @@ class RaiseOnNonSourceCall(ActivationTester):
         env, activate_script = super().__call__(monkeypatch, tmp_path)
         process = Popen(
             self.non_source_activate(activate_script),
+            stdin=subprocess.DEVNULL,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             env=env,
         )
-        _out, err_ = process.communicate()
+        _out, err_ = process.communicate(timeout=60)
         err = err_.decode("utf-8")
         assert process.returncode
         assert self.non_source_fail_message in err

{virtualenv-21.2.4 → virtualenv-21.3.0}/tests/unit/activation/test_activation_support.py

@@ -12,12 +12,13 @@ from virtualenv.activation import (
     FishActivator,
     PowerShellActivator,
     PythonActivator,
+    XonshActivator,
 )
 
 
 @pytest.mark.parametrize(
     "activator_class",
-    [BatchActivator, PowerShellActivator, PythonActivator, BashActivator, FishActivator],
+    [BatchActivator, PowerShellActivator, PythonActivator, BashActivator, FishActivator, XonshActivator],
 )
 def test_activator_support_windows(mocker, activator_class) -> None:
     activator = activator_class(Namespace(prompt=None))
@@ -38,7 +39,7 @@ def test_activator_no_support_windows(mocker, activator_class) -> None:
 
 @pytest.mark.parametrize(
     "activator_class",
-    [BashActivator, CShellActivator, FishActivator, PowerShellActivator, PythonActivator],
+    [BashActivator, CShellActivator, FishActivator, PowerShellActivator, PythonActivator, XonshActivator],
 )
 def test_activator_support_posix(mocker, activator_class) -> None:
     activator = activator_class(Namespace(prompt=None))

{virtualenv-21.2.4 → virtualenv-21.3.0}/tests/unit/activation/test_powershell.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import shutil
 import sys
 from argparse import Namespace
 
@@ -101,7 +102,7 @@ def test_powershell(activation_tester_class, activation_tester, monkeypatch) ->
 
     class PowerShell(activation_tester_class):
         def __init__(self, session) -> None:
-            cmd = "powershell.exe" if sys.platform == "win32" else "pwsh"
+            cmd = "pwsh" if shutil.which("pwsh") else "powershell.exe" if sys.platform == "win32" else "pwsh"
             super().__init__(PowerShellActivator, session, cmd, "activate.ps1", "ps1")
             self._version_cmd = [cmd, "-c", "$PSVersionTable"]
             self._invoke_script = [cmd, "-NonInteractive", "-NoProfile", "-ExecutionPolicy", "ByPass", "-File"]

virtualenv-21.3.0/tests/unit/activation/test_xonsh.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from argparse import Namespace
+from shutil import which
+from unittest.mock import create_autospec
+
+import pytest
+from python_discovery import PythonInfo
+
+from virtualenv.activation import XonshActivator
+from virtualenv.create.creator import Creator
+
+
+@pytest.mark.parametrize(
+    ("tcl_lib", "tk_lib", "present"),
+    [
+        ("/path/to/tcl", "/path/to/tk", True),
+        (None, None, False),
+    ],
+)
+def test_xonsh_tkinter_generation(tmp_path, tcl_lib, tk_lib, present) -> None:
+    # GIVEN
+    interpreter = create_autospec(PythonInfo, instance=True)
+    interpreter.tcl_lib = tcl_lib
+    interpreter.tk_lib = tk_lib
+
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+
+    creator = create_autospec(Creator, instance=True)
+    creator.dest = tmp_path
+    creator.bin_dir = bin_dir
+    creator.interpreter = interpreter
+    creator.pyenv_cfg = {}
+    creator.env_name = "my-env"
+
+    activator = XonshActivator(Namespace(prompt=None))
+
+    # WHEN
+    activator.generate(creator)
+    content = (bin_dir / "activate.xsh").read_text(encoding="utf-8")
+
+    # THEN
+    # `managed_vars` always lists TCL_LIBRARY/TK_LIBRARY so deactivate can clean up
+    # whatever activation introduced — regardless of whether the interpreter reported
+    # tcl_lib/tk_lib.
+    assert '"TCL_LIBRARY"' in content
+    assert '"TK_LIBRARY"' in content
+
+    if present:
+        # Paths are embedded in __init__ as Python string literals and used
+        # from self.embedded_* attributes during activate().
+        assert "self.embedded_tcl_library = '/path/to/tcl'" in content
+        assert "self.embedded_tk_library = '/path/to/tk'" in content
+    else:
+        # Empty strings are falsy, so the override loop is skipped at runtime.
+        assert "self.embedded_tcl_library = ''" in content
+        assert "self.embedded_tk_library = ''" in content
+
+
+def test_xonsh_quote() -> None:
+    # XonshActivator.quote uses repr() so the template substitution produces valid
+    # Python literals — this is what the rest of the tests rely on.
+    assert XonshActivator.quote("hello") == "'hello'"
+    assert XonshActivator.quote("it's") == '"it\'s"'
+    assert XonshActivator.quote("") == "''"
+
+
+@pytest.mark.skipif(which("xonsh") is None, reason="xonsh is not installed")
+def test_xonsh(activation_tester_class, activation_tester) -> None:
+    class Xonsh(activation_tester_class):
+        def __init__(self, session) -> None:
+            super().__init__(XonshActivator, session, "xonsh", "activate.xsh", "xsh")
+            self._invoke_script.append("--no-rc")
+
+        def env(self, tmp_path):
+            env = super().env(tmp_path)
+            # Keep the subprocess hermetic: skip auto-loaded xontribs that a dev may
+            # have installed locally, and surface tracebacks so test failures are
+            # actionable.
+            env["XONTRIBS_AUTOLOAD_DISABLED"] = "1"
+            env["XONSH_SHOW_TRACEBACK"] = "1"
+            return env
+
+        def print_prompt(self):
+            return 'echo @("(" + $VIRTUAL_ENV_PROMPT + ") ")'
+
+        def activate_call(self, script):
+            return f"source {self.quote(str(script))}"
+
+    activation_tester(Xonsh)

{virtualenv-21.2.4 → virtualenv-21.3.0}/tests/unit/seed/embed/test_bootstrap_link_via_app_data.py

@@ -122,7 +122,12 @@ def test_seed_link_via_app_data(tmp_path, coverage_env, current_fastest, copies,
         purelib = result.creator.purelib
         patch_files = {purelib / f"{'_virtualenv'}.{i}" for i in ("py", "pyc", "pth")}
         patch_files.add(purelib / "__pycache__")
-        post_run = set(site_package.iterdir()) - patch_files
+
+        # pip 26.1+ leaves empty parent directories on uninstall (pypa/pip#13725)
+        def _has_files(path: Path) -> bool:
+            return path.is_file() or (path.is_dir() and any(_has_files(child) for child in path.iterdir()))
+
+        post_run = {p for p in set(site_package.iterdir()) - patch_files if _has_files(p)}
         assert not post_run, "\n".join(str(i) for i in post_run)