virtualenv 21.2.3__tar.gz → 21.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtualenv
-Version: 21.2.3
+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.3 → 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.3 → 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.3 → 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.3 → 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.3 → virtualenv-21.3.0}/src/virtualenv/seed/embed/via_app_data/pip_install/base.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import logging
+import ntpath
 import os
+import posixpath
 import re
 import zipfile
 from abc import ABC, abstractmethod
@@ -21,6 +23,24 @@ if TYPE_CHECKING:
 LOGGER = logging.getLogger(__name__)
 
 
+def _safe_extract_zip(zip_ref: zipfile.ZipFile, target_dir: Path) -> None:
+    # Guard against zip slip: a wheel is a zip and a tampered entry name (absolute path or one containing ``..``)
+    # could escape ``target_dir``.
+    base = target_dir.resolve()
+    for info in zip_ref.infolist():
+        name = info.filename
+        if name.startswith(("/", "\\")) or ntpath.isabs(name) or posixpath.isabs(name):
+            msg = f"refusing to extract absolute path entry from wheel: {name!r}"
+            raise RuntimeError(msg)
+        candidate = (base / name).resolve()
+        try:
+            candidate.relative_to(base)
+        except ValueError as exc:
+            msg = f"refusing to extract entry escaping target directory: {name!r}"
+            raise RuntimeError(msg) from exc
+    zip_ref.extractall(str(target_dir))
+
+
 class PipInstall(ABC):
     def __init__(self, wheel: Path, creator: Creator, image_folder: Path) -> None:
         self._wheel = wheel
@@ -49,11 +69,19 @@ class PipInstall(ABC):
         LOGGER.debug("generated console scripts %s", " ".join(i.name for i in consoles))
 
     def build_image(self) -> None:
+        """Extract the seed wheel into the image directory and fix up its RECORD file.
+
+        Each archive entry is validated before extraction so a tampered wheel cannot escape the image directory via an
+        absolute path or ``..`` traversal.
+
+        :raises RuntimeError: if the wheel contains an entry that would land outside the image directory.
+
+        """
         # 1. first extract the wheel
         LOGGER.debug("build install image for %s to %s", self._wheel.name, self._image_dir)
         with zipfile.ZipFile(str(self._wheel)) as zip_ref:
             self._shorten_path_if_needed(zip_ref)
-            zip_ref.extractall(str(self._image_dir))
+            _safe_extract_zip(zip_ref, self._image_dir)
             self._extracted = True
         # 2. now add additional files not present in the distribution
         new_files = self._generate_new_files()

{virtualenv-21.2.3 → virtualenv-21.3.0}/src/virtualenv/seed/wheels/acquire.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import re
 import sys
 from operator import eq, lt
 from pathlib import Path
@@ -18,6 +19,34 @@ if TYPE_CHECKING:
 
 LOGGER = logging.getLogger(__name__)
 
+# PEP 503 normalized distribution name. Anything outside this character set on the way to ``pip download`` means
+# somebody is smuggling pip options or extras, so reject it before we build the command line.
+_DISTRIBUTION_RE = re.compile(
+    r"""
+    ^
+    (?P<name>
+        [A-Za-z0-9]                 # must start with an alnum
+        (?:[A-Za-z0-9._-]*           # inner chars: alnum plus . _ -
+           [A-Za-z0-9])?             # must also end with an alnum (unless length is 1)
+    )
+    $
+    """,
+    re.VERBOSE,
+)
+
+# Version specifier that matches what ``Version.as_version_spec`` emits: either empty, ``==<ver>`` or ``<<ver>`` where
+# ``<ver>`` is a subset of PEP 440 public versions. Kept deliberately strict so a crafted version cannot inject pip
+# flags.
+_VERSION_SPEC_RE = re.compile(
+    r"""
+    ^
+    (?P<operator>==|<)              # only the operators Version.as_version_spec can emit
+    (?P<version>[A-Za-z0-9._+!-]+)  # PEP 440 public-version character set, no whitespace
+    $
+    """,
+    re.VERBOSE,
+)
+
 
 def get_wheel(  # noqa: PLR0913
     distribution: str,
@@ -63,6 +92,26 @@ def download_wheel(  # noqa: PLR0913
     to_folder: Path,
     env: dict[str, str],
 ) -> Wheel:
+    """Invoke ``pip download`` in a subprocess to fetch a seed wheel.
+
+    :param distribution: PEP 503 normalized project name; rejected if it contains anything other than
+        ``[A-Za-z0-9._-]``.
+    :param version_spec: optional version specifier of the form ``==<ver>`` or ``<<ver>`` as emitted by
+        :func:`Version.as_version_spec`, or ``None``/empty for the latest compatible release.
+    :param for_py_version: major.minor Python version to pass through to ``pip --python-version``.
+    :param search_dirs: additional directories to treat as a local wheel index when bootstrapping pip.
+    :param app_data: application data store used to locate the embedded pip wheel.
+    :param to_folder: directory the downloaded wheel is written into.
+    :param env: environment mapping passed through to the subprocess.
+
+    :returns: the downloaded :class:`Wheel`.
+
+    :raises ValueError: if ``distribution`` or ``version_spec`` fail the strict allow-list check.
+    :raises CalledProcessError: if ``pip download`` exits with a non-zero status.
+
+    """
+    _check_distribution(distribution)
+    _check_version_spec(version_spec)
     to_download = f"{distribution}{version_spec or ''}"
     LOGGER.debug("download wheel %s %s to %s", to_download, for_py_version, to_folder)
     cmd = [
@@ -143,6 +192,20 @@ def pip_wheel_env_run(search_dirs: list[Path], app_data: AppData, env: dict[str,
     return env
 
 
+def _check_distribution(distribution: str) -> None:
+    if not _DISTRIBUTION_RE.fullmatch(distribution):
+        msg = f"refusing to download wheel for suspicious distribution name: {distribution!r}"
+        raise ValueError(msg)
+
+
+def _check_version_spec(version_spec: str | None) -> None:
+    if not version_spec:
+        return
+    if not _VERSION_SPEC_RE.fullmatch(version_spec):
+        msg = f"refusing to download wheel with suspicious version spec: {version_spec!r}"
+        raise ValueError(msg)
+
+
 __all__ = [
     "download_wheel",
     "get_wheel",

virtualenv-21.3.0/src/virtualenv/seed/wheels/embed/__init__.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import hashlib
+import zipfile
+from pathlib import Path
+
+from virtualenv.info import IS_ZIPAPP, ROOT
+from virtualenv.seed.wheels.util import Wheel
+
+BUNDLE_FOLDER = Path(__file__).absolute().parent
+BUNDLE_SUPPORT = {
+    "3.8": {
+        "pip": "pip-25.0.1-py3-none-any.whl",
+        "setuptools": "setuptools-75.3.4-py3-none-any.whl",
+        "wheel": "wheel-0.45.1-py3-none-any.whl",
+    },
+    "3.9": {
+        "pip": "pip-26.0.1-py3-none-any.whl",
+        "setuptools": "setuptools-82.0.1-py3-none-any.whl",
+    },
+    "3.10": {
+        "pip": "pip-26.1-py3-none-any.whl",
+        "setuptools": "setuptools-82.0.1-py3-none-any.whl",
+    },
+    "3.11": {
+        "pip": "pip-26.1-py3-none-any.whl",
+        "setuptools": "setuptools-82.0.1-py3-none-any.whl",
+    },
+    "3.12": {
+        "pip": "pip-26.1-py3-none-any.whl",
+        "setuptools": "setuptools-82.0.1-py3-none-any.whl",
+    },
+    "3.13": {
+        "pip": "pip-26.1-py3-none-any.whl",
+        "setuptools": "setuptools-82.0.1-py3-none-any.whl",
+    },
+    "3.14": {
+        "pip": "pip-26.1-py3-none-any.whl",
+        "setuptools": "setuptools-82.0.1-py3-none-any.whl",
+    },
+    "3.15": {
+        "pip": "pip-26.1-py3-none-any.whl",
+        "setuptools": "setuptools-82.0.1-py3-none-any.whl",
+    },
+}
+MAX = "3.8"
+
+# SHA-256 of every bundled wheel. Verified on load so a corrupted or tampered wheel on disk fails loud instead of
+# being handed to pip. Generated together with ``BUNDLE_SUPPORT`` by ``tasks/upgrade_wheels.py``.
+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",
+}
+
+_VERIFIED_WHEELS: set[str] = set()
+
+
+def get_embed_wheel(distribution: str, for_py_version: str) -> Wheel | None:
+    """Return the bundled wheel that ships with virtualenv for a given distribution and Python version.
+
+    :param distribution: project name of the seed package, for example ``pip`` or ``setuptools``.
+    :param for_py_version: major.minor Python version string the environment will be created for.
+
+    :returns: a :class:`Wheel` pointing at the verified bundled file, or ``None`` when no wheel is bundled for the
+        requested combination.
+
+    :raises RuntimeError: if the bundled wheel on disk fails SHA-256 verification.
+
+    """
+    mapping = BUNDLE_SUPPORT.get(for_py_version, {}) or BUNDLE_SUPPORT[MAX]
+    wheel_file = mapping.get(distribution)
+    if wheel_file is None:
+        return None
+    path = BUNDLE_FOLDER / wheel_file
+    _verify_bundled_wheel(path)
+    return Wheel.from_path(path)
+
+
+def _verify_bundled_wheel(path: Path) -> None:
+    name = path.name
+    if name in _VERIFIED_WHEELS:
+        return
+    expected = BUNDLE_SHA256.get(name)
+    if expected is None:
+        msg = f"bundled wheel {name} has no recorded sha256 in BUNDLE_SHA256"
+        raise RuntimeError(msg)
+    actual = _hash_bundled_wheel(path)
+    if actual != expected:
+        msg = f"bundled wheel {name} sha256 mismatch: expected {expected}, got {actual}"
+        raise RuntimeError(msg)
+    _VERIFIED_WHEELS.add(name)
+
+
+def _hash_bundled_wheel(path: Path) -> str:
+    # ``path`` is under the package directory; when virtualenv runs from a zipapp the wheel lives inside the
+    # archive and cannot be opened as a regular file, so read the bytes straight from the zipapp entry.
+    digest = hashlib.sha256()
+    if IS_ZIPAPP:
+        entry = path.resolve().relative_to(Path(ROOT).resolve()).as_posix()
+        with zipfile.ZipFile(ROOT, "r") as archive, archive.open(entry) as stream:
+            for chunk in iter(lambda: stream.read(1 << 20), b""):
+                digest.update(chunk)
+    else:
+        with path.open("rb") as stream:
+            for chunk in iter(lambda: stream.read(1 << 20), b""):
+                digest.update(chunk)
+    return digest.hexdigest()
+
+
+__all__ = [
+    "BUNDLE_FOLDER",
+    "BUNDLE_SHA256",
+    "BUNDLE_SUPPORT",
+    "MAX",
+    "get_embed_wheel",
+]

{virtualenv-21.2.3 → virtualenv-21.3.0}/src/virtualenv/seed/wheels/periodic_update.py

@@ -360,10 +360,20 @@ def release_date_for_wheel_path(dest: Path) -> datetime | None:
     return None
 
 
+#: Opt-in escape hatch to restore the pre-2026 behavior of falling back to an unverified HTTPS context when the
+#: verified request fails. Off by default: a failed TLS handshake on the PyPI metadata lookup now aborts the update
+#: instead of silently downgrading, because the response drives which wheel version virtualenv thinks is up to date.
+_INSECURE_FALLBACK_ENV = "VIRTUALENV_PERIODIC_UPDATE_INSECURE"
+
+
 def _request_context() -> Generator[ssl.SSLContext | None, None, None]:
     yield None
-    # fallback to non verified HTTPS (the information we request is not sensitive, so fallback)
-    yield ssl._create_unverified_context()  # noqa: S323, SLF001
+    if os.environ.get(_INSECURE_FALLBACK_ENV):
+        LOGGER.warning(
+            "falling back to unverified HTTPS for PyPI metadata because %s is set",
+            _INSECURE_FALLBACK_ENV,
+        )
+        yield ssl._create_unverified_context()  # noqa: S323, SLF001
 
 
 _PYPI_CACHE = {}

{virtualenv-21.2.3 → virtualenv-21.3.0}/src/virtualenv/util/zipapp.py

@@ -1,14 +1,10 @@
 from __future__ import annotations
 
 import logging
-import os
 import zipfile
-from typing import TYPE_CHECKING
+from pathlib import Path
 
-from virtualenv.info import IS_WIN, ROOT
-
-if TYPE_CHECKING:
-    from pathlib import Path
+from virtualenv.info import ROOT
 
 LOGGER = logging.getLogger(__name__)
 
@@ -29,16 +25,18 @@ def extract(full_path: str | Path, dest: Path) -> None:
 
 
 def _get_path_within_zip(full_path: str | Path) -> str:
-    full_path = os.path.realpath(os.path.abspath(str(full_path)))
-    prefix = f"{ROOT}{os.sep}"
-    if not full_path.startswith(prefix):
-        msg = f"full_path={full_path} should start with prefix={prefix}."
-        raise RuntimeError(msg)
-    sub_file = full_path[len(prefix) :]
-    if IS_WIN:
-        # paths are always UNIX separators, even on Windows, though __file__ still follows platform default
-        sub_file = sub_file.replace(os.sep, "/")
-    return sub_file
+    # Use Path.relative_to so symlinks and ``..`` segments cannot slip through a string ``startswith`` check. The zipapp
+    # root is a real file we own so ``resolve`` is safe; anything that does not resolve under ROOT is a bug or an
+    # attempt to escape the archive and we refuse it.
+    resolved = Path(full_path).resolve()
+    root = Path(ROOT).resolve()
+    try:
+        relative = resolved.relative_to(root)
+    except ValueError as exc:
+        msg = f"full_path={resolved} should be within ROOT={root}"
+        raise RuntimeError(msg) from exc
+    # Zip entries always use forward slashes regardless of platform.
+    return relative.as_posix()
 
 
 __all__ = [

{virtualenv-21.2.3 → 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.3'
-__version_tuple__ = version_tuple = (21, 2, 3)
+__version__ = version = '21.3.0'
+__version_tuple__ = version_tuple = (21, 3, 0)
 
 __commit_id__ = commit_id = None