first commit
This commit is contained in:
commit
417e54da96
5696 changed files with 900003 additions and 0 deletions
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,225 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Callable
|
||||
|
||||
from virtualenv.info import IS_WIN, fs_path_id
|
||||
|
||||
from .discover import Discover
|
||||
from .py_info import PythonInfo
|
||||
from .py_spec import PythonSpec
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from argparse import ArgumentParser
|
||||
from collections.abc import Generator, Iterable, Mapping, Sequence
|
||||
|
||||
from virtualenv.app_data.base import AppData
|
||||
|
||||
|
||||
class Builtin(Discover):
|
||||
python_spec: Sequence[str]
|
||||
app_data: AppData
|
||||
try_first_with: Sequence[str]
|
||||
|
||||
def __init__(self, options) -> None:
|
||||
super().__init__(options)
|
||||
self.python_spec = options.python or [sys.executable]
|
||||
self.app_data = options.app_data
|
||||
self.try_first_with = options.try_first_with
|
||||
|
||||
@classmethod
|
||||
def add_parser_arguments(cls, parser: ArgumentParser) -> None:
|
||||
parser.add_argument(
|
||||
"-p",
|
||||
"--python",
|
||||
dest="python",
|
||||
metavar="py",
|
||||
type=str,
|
||||
action="append",
|
||||
default=[],
|
||||
help="interpreter based on what to create environment (path/identifier) "
|
||||
"- by default use the interpreter where the tool is installed - first found wins",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--try-first-with",
|
||||
dest="try_first_with",
|
||||
metavar="py_exe",
|
||||
type=str,
|
||||
action="append",
|
||||
default=[],
|
||||
help="try first these interpreters before starting the discovery",
|
||||
)
|
||||
|
||||
def run(self) -> PythonInfo | None:
|
||||
for python_spec in self.python_spec:
|
||||
result = get_interpreter(python_spec, self.try_first_with, self.app_data, self._env)
|
||||
if result is not None:
|
||||
return result
|
||||
return None
|
||||
|
||||
def __repr__(self) -> str:
|
||||
spec = self.python_spec[0] if len(self.python_spec) == 1 else self.python_spec
|
||||
return f"{self.__class__.__name__} discover of python_spec={spec!r}"
|
||||
|
||||
|
||||
def get_interpreter(
|
||||
key, try_first_with: Iterable[str], app_data: AppData | None = None, env: Mapping[str, str] | None = None
|
||||
) -> PythonInfo | None:
|
||||
spec = PythonSpec.from_string_spec(key)
|
||||
logging.info("find interpreter for spec %r", spec)
|
||||
proposed_paths = set()
|
||||
env = os.environ if env is None else env
|
||||
for interpreter, impl_must_match in propose_interpreters(spec, try_first_with, app_data, env):
|
||||
key = interpreter.system_executable, impl_must_match
|
||||
if key in proposed_paths:
|
||||
continue
|
||||
logging.info("proposed %s", interpreter)
|
||||
if interpreter.satisfies(spec, impl_must_match):
|
||||
logging.debug("accepted %s", interpreter)
|
||||
return interpreter
|
||||
proposed_paths.add(key)
|
||||
return None
|
||||
|
||||
|
||||
def propose_interpreters( # noqa: C901, PLR0912, PLR0915
|
||||
spec: PythonSpec,
|
||||
try_first_with: Iterable[str],
|
||||
app_data: AppData | None = None,
|
||||
env: Mapping[str, str] | None = None,
|
||||
) -> Generator[tuple[PythonInfo, bool], None, None]:
|
||||
# 0. try with first
|
||||
env = os.environ if env is None else env
|
||||
tested_exes: set[str] = set()
|
||||
for py_exe in try_first_with:
|
||||
path = os.path.abspath(py_exe)
|
||||
try:
|
||||
os.lstat(path) # Windows Store Python does not work with os.path.exists, but does for os.lstat
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
exe_raw = os.path.abspath(path)
|
||||
exe_id = fs_path_id(exe_raw)
|
||||
if exe_id in tested_exes:
|
||||
continue
|
||||
tested_exes.add(exe_id)
|
||||
yield PythonInfo.from_exe(exe_raw, app_data, env=env), True
|
||||
|
||||
# 1. if it's a path and exists
|
||||
if spec.path is not None:
|
||||
try:
|
||||
os.lstat(spec.path) # Windows Store Python does not work with os.path.exists, but does for os.lstat
|
||||
except OSError:
|
||||
if spec.is_abs:
|
||||
raise
|
||||
else:
|
||||
exe_raw = os.path.abspath(spec.path)
|
||||
exe_id = fs_path_id(exe_raw)
|
||||
if exe_id not in tested_exes:
|
||||
tested_exes.add(exe_id)
|
||||
yield PythonInfo.from_exe(exe_raw, app_data, env=env), True
|
||||
if spec.is_abs:
|
||||
return
|
||||
else:
|
||||
# 2. otherwise try with the current
|
||||
current_python = PythonInfo.current_system(app_data)
|
||||
exe_raw = str(current_python.executable)
|
||||
exe_id = fs_path_id(exe_raw)
|
||||
if exe_id not in tested_exes:
|
||||
tested_exes.add(exe_id)
|
||||
yield current_python, True
|
||||
|
||||
# 3. otherwise fallback to platform default logic
|
||||
if IS_WIN:
|
||||
from .windows import propose_interpreters # noqa: PLC0415
|
||||
|
||||
for interpreter in propose_interpreters(spec, app_data, env):
|
||||
exe_raw = str(interpreter.executable)
|
||||
exe_id = fs_path_id(exe_raw)
|
||||
if exe_id in tested_exes:
|
||||
continue
|
||||
tested_exes.add(exe_id)
|
||||
yield interpreter, True
|
||||
# finally just find on path, the path order matters (as the candidates are less easy to control by end user)
|
||||
find_candidates = path_exe_finder(spec)
|
||||
for pos, path in enumerate(get_paths(env)):
|
||||
logging.debug(LazyPathDump(pos, path, env))
|
||||
for exe, impl_must_match in find_candidates(path):
|
||||
exe_raw = str(exe)
|
||||
exe_id = fs_path_id(exe_raw)
|
||||
if exe_id in tested_exes:
|
||||
continue
|
||||
tested_exes.add(exe_id)
|
||||
interpreter = PathPythonInfo.from_exe(exe_raw, app_data, raise_on_error=False, env=env)
|
||||
if interpreter is not None:
|
||||
yield interpreter, impl_must_match
|
||||
|
||||
|
||||
def get_paths(env: Mapping[str, str]) -> Generator[Path, None, None]:
|
||||
path = env.get("PATH", None)
|
||||
if path is None:
|
||||
try:
|
||||
path = os.confstr("CS_PATH")
|
||||
except (AttributeError, ValueError):
|
||||
path = os.defpath
|
||||
if path:
|
||||
for p in map(Path, path.split(os.pathsep)):
|
||||
if p.exists():
|
||||
yield p
|
||||
|
||||
|
||||
class LazyPathDump:
|
||||
def __init__(self, pos: int, path: Path, env: Mapping[str, str]) -> None:
|
||||
self.pos = pos
|
||||
self.path = path
|
||||
self.env = env
|
||||
|
||||
def __repr__(self) -> str:
|
||||
content = f"discover PATH[{self.pos}]={self.path}"
|
||||
if self.env.get("_VIRTUALENV_DEBUG"): # this is the over the board debug
|
||||
content += " with =>"
|
||||
for file_path in self.path.iterdir():
|
||||
try:
|
||||
if file_path.is_dir() or not (file_path.stat().st_mode & os.X_OK):
|
||||
continue
|
||||
except OSError:
|
||||
pass
|
||||
content += " "
|
||||
content += file_path.name
|
||||
return content
|
||||
|
||||
|
||||
def path_exe_finder(spec: PythonSpec) -> Callable[[Path], Generator[tuple[Path, bool], None, None]]:
|
||||
"""Given a spec, return a function that can be called on a path to find all matching files in it."""
|
||||
pat = spec.generate_re(windows=sys.platform == "win32")
|
||||
direct = spec.str_spec
|
||||
if sys.platform == "win32":
|
||||
direct = f"{direct}.exe"
|
||||
|
||||
def path_exes(path: Path) -> Generator[tuple[Path, bool], None, None]:
|
||||
# 4. then maybe it's something exact on PATH - if it was direct lookup implementation no longer counts
|
||||
direct_path = path / direct
|
||||
if direct_path.exists():
|
||||
yield direct_path, False
|
||||
|
||||
# 5. or from the spec we can deduce if a name on path matches
|
||||
for exe in path.iterdir():
|
||||
match = pat.fullmatch(exe.name)
|
||||
if match:
|
||||
# the implementation must match when we find “python[ver]”
|
||||
yield exe.absolute(), match["impl"] == "python"
|
||||
|
||||
return path_exes
|
||||
|
||||
|
||||
class PathPythonInfo(PythonInfo):
|
||||
"""python info from path."""
|
||||
|
||||
|
||||
__all__ = [
|
||||
"Builtin",
|
||||
"PathPythonInfo",
|
||||
"get_interpreter",
|
||||
]
|
||||
|
|
@ -0,0 +1,178 @@
|
|||
"""
|
||||
|
||||
We acquire the python information by running an interrogation script via subprocess trigger. This operation is not
|
||||
cheap, especially not on Windows. To not have to pay this hefty cost every time we apply multiple levels of
|
||||
caching.
|
||||
""" # noqa: D205
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import os
|
||||
import random
|
||||
import sys
|
||||
from collections import OrderedDict
|
||||
from pathlib import Path
|
||||
from shlex import quote
|
||||
from string import ascii_lowercase, ascii_uppercase, digits
|
||||
from subprocess import Popen
|
||||
|
||||
from virtualenv.app_data import AppDataDisabled
|
||||
from virtualenv.discovery.py_info import PythonInfo
|
||||
from virtualenv.util.subprocess import subprocess
|
||||
|
||||
_CACHE = OrderedDict()
|
||||
_CACHE[Path(sys.executable)] = PythonInfo()
|
||||
|
||||
|
||||
def from_exe(cls, app_data, exe, env=None, raise_on_error=True, ignore_cache=False): # noqa: FBT002, PLR0913
|
||||
env = os.environ if env is None else env
|
||||
result = _get_from_cache(cls, app_data, exe, env, ignore_cache=ignore_cache)
|
||||
if isinstance(result, Exception):
|
||||
if raise_on_error:
|
||||
raise result
|
||||
logging.info("%s", result)
|
||||
result = None
|
||||
return result
|
||||
|
||||
|
||||
def _get_from_cache(cls, app_data, exe, env, ignore_cache=True): # noqa: FBT002
|
||||
# note here we cannot resolve symlinks, as the symlink may trigger different prefix information if there's a
|
||||
# pyenv.cfg somewhere alongside on python3.5+
|
||||
exe_path = Path(exe)
|
||||
if not ignore_cache and exe_path in _CACHE: # check in the in-memory cache
|
||||
result = _CACHE[exe_path]
|
||||
else: # otherwise go through the app data cache
|
||||
py_info = _get_via_file_cache(cls, app_data, exe_path, exe, env)
|
||||
result = _CACHE[exe_path] = py_info
|
||||
# independent if it was from the file or in-memory cache fix the original executable location
|
||||
if isinstance(result, PythonInfo):
|
||||
result.executable = exe
|
||||
return result
|
||||
|
||||
|
||||
def _get_via_file_cache(cls, app_data, path, exe, env):
|
||||
path_text = str(path)
|
||||
try:
|
||||
path_modified = path.stat().st_mtime
|
||||
except OSError:
|
||||
path_modified = -1
|
||||
if app_data is None:
|
||||
app_data = AppDataDisabled()
|
||||
py_info, py_info_store = None, app_data.py_info(path)
|
||||
with py_info_store.locked():
|
||||
if py_info_store.exists(): # if exists and matches load
|
||||
data = py_info_store.read()
|
||||
of_path, of_st_mtime, of_content = data["path"], data["st_mtime"], data["content"]
|
||||
if of_path == path_text and of_st_mtime == path_modified:
|
||||
py_info = cls._from_dict(of_content.copy())
|
||||
sys_exe = py_info.system_executable
|
||||
if sys_exe is not None and not os.path.exists(sys_exe):
|
||||
py_info_store.remove()
|
||||
py_info = None
|
||||
else:
|
||||
py_info_store.remove()
|
||||
if py_info is None: # if not loaded run and save
|
||||
failure, py_info = _run_subprocess(cls, exe, app_data, env)
|
||||
if failure is None:
|
||||
data = {"st_mtime": path_modified, "path": path_text, "content": py_info._to_dict()} # noqa: SLF001
|
||||
py_info_store.write(data)
|
||||
else:
|
||||
py_info = failure
|
||||
return py_info
|
||||
|
||||
|
||||
COOKIE_LENGTH: int = 32
|
||||
|
||||
|
||||
def gen_cookie():
|
||||
return "".join(
|
||||
random.choice(f"{ascii_lowercase}{ascii_uppercase}{digits}") # noqa: S311
|
||||
for _ in range(COOKIE_LENGTH)
|
||||
)
|
||||
|
||||
|
||||
def _run_subprocess(cls, exe, app_data, env):
|
||||
py_info_script = Path(os.path.abspath(__file__)).parent / "py_info.py"
|
||||
# Cookies allow to split the serialized stdout output generated by the script collecting the info from the output
|
||||
# generated by something else. The right way to deal with it is to create an anonymous pipe and pass its descriptor
|
||||
# to the child and output to it. But AFAIK all of them are either not cross-platform or too big to implement and are
|
||||
# not in the stdlib. So the easiest and the shortest way I could mind is just using the cookies.
|
||||
# We generate pseudorandom cookies because it easy to implement and avoids breakage from outputting modules source
|
||||
# code, i.e. by debug output libraries. We reverse the cookies to avoid breakages resulting from variable values
|
||||
# appearing in debug output.
|
||||
|
||||
start_cookie = gen_cookie()
|
||||
end_cookie = gen_cookie()
|
||||
with app_data.ensure_extracted(py_info_script) as py_info_script:
|
||||
cmd = [exe, str(py_info_script), start_cookie, end_cookie]
|
||||
# prevent sys.prefix from leaking into the child process - see https://bugs.python.org/issue22490
|
||||
env = env.copy()
|
||||
env.pop("__PYVENV_LAUNCHER__", None)
|
||||
logging.debug("get interpreter info via cmd: %s", LogCmd(cmd))
|
||||
try:
|
||||
process = Popen(
|
||||
cmd,
|
||||
universal_newlines=True,
|
||||
stdin=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE,
|
||||
stdout=subprocess.PIPE,
|
||||
env=env,
|
||||
encoding="utf-8",
|
||||
)
|
||||
out, err = process.communicate()
|
||||
code = process.returncode
|
||||
except OSError as os_error:
|
||||
out, err, code = "", os_error.strerror, os_error.errno
|
||||
result, failure = None, None
|
||||
if code == 0:
|
||||
out_starts = out.find(start_cookie[::-1])
|
||||
|
||||
if out_starts > -1:
|
||||
pre_cookie = out[:out_starts]
|
||||
|
||||
if pre_cookie:
|
||||
sys.stdout.write(pre_cookie)
|
||||
|
||||
out = out[out_starts + COOKIE_LENGTH :]
|
||||
|
||||
out_ends = out.find(end_cookie[::-1])
|
||||
|
||||
if out_ends > -1:
|
||||
post_cookie = out[out_ends + COOKIE_LENGTH :]
|
||||
|
||||
if post_cookie:
|
||||
sys.stdout.write(post_cookie)
|
||||
|
||||
out = out[:out_ends]
|
||||
|
||||
result = cls._from_json(out)
|
||||
result.executable = exe # keep original executable as this may contain initialization code
|
||||
else:
|
||||
msg = f"{exe} with code {code}{f' out: {out!r}' if out else ''}{f' err: {err!r}' if err else ''}"
|
||||
failure = RuntimeError(f"failed to query {msg}")
|
||||
return failure, result
|
||||
|
||||
|
||||
class LogCmd:
|
||||
def __init__(self, cmd, env=None) -> None:
|
||||
self.cmd = cmd
|
||||
self.env = env
|
||||
|
||||
def __repr__(self) -> str:
|
||||
cmd_repr = " ".join(quote(str(c)) for c in self.cmd)
|
||||
if self.env is not None:
|
||||
cmd_repr = f"{cmd_repr} env of {self.env!r}"
|
||||
return cmd_repr
|
||||
|
||||
|
||||
def clear(app_data):
|
||||
app_data.py_info_clear()
|
||||
_CACHE.clear()
|
||||
|
||||
|
||||
___all___ = [
|
||||
"from_exe",
|
||||
"clear",
|
||||
"LogCmd",
|
||||
]
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
from __future__ import annotations
|
||||
|
||||
from abc import ABC, abstractmethod
|
||||
|
||||
|
||||
class Discover(ABC):
|
||||
"""Discover and provide the requested Python interpreter."""
|
||||
|
||||
@classmethod
|
||||
def add_parser_arguments(cls, parser):
|
||||
"""
|
||||
Add CLI arguments for this discovery mechanisms.
|
||||
|
||||
:param parser: the CLI parser
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
def __init__(self, options) -> None:
|
||||
"""
|
||||
Create a new discovery mechanism.
|
||||
|
||||
:param options: the parsed options as defined within :meth:`add_parser_arguments`
|
||||
"""
|
||||
self._has_run = False
|
||||
self._interpreter = None
|
||||
self._env = options.env
|
||||
|
||||
@abstractmethod
|
||||
def run(self):
|
||||
"""
|
||||
Discovers an interpreter.
|
||||
|
||||
:return: the interpreter ready to use for virtual environment creation
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
@property
|
||||
def interpreter(self):
|
||||
""":return: the interpreter as returned by :meth:`run`, cached"""
|
||||
if self._has_run is False:
|
||||
self._interpreter = self.run()
|
||||
self._has_run = True
|
||||
return self._interpreter
|
||||
|
||||
|
||||
__all__ = [
|
||||
"Discover",
|
||||
]
|
||||
|
|
@ -0,0 +1,572 @@
|
|||
"""
|
||||
The PythonInfo contains information about a concrete instance of a Python interpreter.
|
||||
|
||||
Note: this file is also used to query target interpreters, so can only use standard library methods
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import platform
|
||||
import re
|
||||
import sys
|
||||
import sysconfig
|
||||
import warnings
|
||||
from collections import OrderedDict, namedtuple
|
||||
from string import digits
|
||||
|
||||
VersionInfo = namedtuple("VersionInfo", ["major", "minor", "micro", "releaselevel", "serial"]) # noqa: PYI024
|
||||
|
||||
|
||||
def _get_path_extensions():
|
||||
return list(OrderedDict.fromkeys(["", *os.environ.get("PATHEXT", "").lower().split(os.pathsep)]))
|
||||
|
||||
|
||||
EXTENSIONS = _get_path_extensions()
|
||||
_CONF_VAR_RE = re.compile(r"\{\w+\}")
|
||||
|
||||
|
||||
class PythonInfo: # noqa: PLR0904
|
||||
"""Contains information for a Python interpreter."""
|
||||
|
||||
def __init__(self) -> None: # noqa: PLR0915
|
||||
def abs_path(v):
|
||||
return None if v is None else os.path.abspath(v) # unroll relative elements from path (e.g. ..)
|
||||
|
||||
# qualifies the python
|
||||
self.platform = sys.platform
|
||||
self.implementation = platform.python_implementation()
|
||||
if self.implementation == "PyPy":
|
||||
self.pypy_version_info = tuple(sys.pypy_version_info)
|
||||
|
||||
# this is a tuple in earlier, struct later, unify to our own named tuple
|
||||
self.version_info = VersionInfo(*sys.version_info)
|
||||
self.architecture = 64 if sys.maxsize > 2**32 else 32
|
||||
|
||||
# Used to determine some file names.
|
||||
# See `CPython3Windows.python_zip()`.
|
||||
self.version_nodot = sysconfig.get_config_var("py_version_nodot")
|
||||
|
||||
self.version = sys.version
|
||||
self.os = os.name
|
||||
|
||||
# information about the prefix - determines python home
|
||||
self.prefix = abs_path(getattr(sys, "prefix", None)) # prefix we think
|
||||
self.base_prefix = abs_path(getattr(sys, "base_prefix", None)) # venv
|
||||
self.real_prefix = abs_path(getattr(sys, "real_prefix", None)) # old virtualenv
|
||||
|
||||
# information about the exec prefix - dynamic stdlib modules
|
||||
self.base_exec_prefix = abs_path(getattr(sys, "base_exec_prefix", None))
|
||||
self.exec_prefix = abs_path(getattr(sys, "exec_prefix", None))
|
||||
|
||||
self.executable = abs_path(sys.executable) # the executable we were invoked via
|
||||
self.original_executable = abs_path(self.executable) # the executable as known by the interpreter
|
||||
self.system_executable = self._fast_get_system_executable() # the executable we are based of (if available)
|
||||
|
||||
try:
|
||||
__import__("venv")
|
||||
has = True
|
||||
except ImportError:
|
||||
has = False
|
||||
self.has_venv = has
|
||||
self.path = sys.path
|
||||
self.file_system_encoding = sys.getfilesystemencoding()
|
||||
self.stdout_encoding = getattr(sys.stdout, "encoding", None)
|
||||
|
||||
scheme_names = sysconfig.get_scheme_names()
|
||||
|
||||
if "venv" in scheme_names:
|
||||
self.sysconfig_scheme = "venv"
|
||||
self.sysconfig_paths = {
|
||||
i: sysconfig.get_path(i, expand=False, scheme=self.sysconfig_scheme) for i in sysconfig.get_path_names()
|
||||
}
|
||||
# we cannot use distutils at all if "venv" exists, distutils don't know it
|
||||
self.distutils_install = {}
|
||||
# debian / ubuntu python 3.10 without `python3-distutils` will report
|
||||
# mangled `local/bin` / etc. names for the default prefix
|
||||
# intentionally select `posix_prefix` which is the unaltered posix-like paths
|
||||
elif sys.version_info[:2] == (3, 10) and "deb_system" in scheme_names:
|
||||
self.sysconfig_scheme = "posix_prefix"
|
||||
self.sysconfig_paths = {
|
||||
i: sysconfig.get_path(i, expand=False, scheme=self.sysconfig_scheme) for i in sysconfig.get_path_names()
|
||||
}
|
||||
# we cannot use distutils at all if "venv" exists, distutils don't know it
|
||||
self.distutils_install = {}
|
||||
else:
|
||||
self.sysconfig_scheme = None
|
||||
self.sysconfig_paths = {i: sysconfig.get_path(i, expand=False) for i in sysconfig.get_path_names()}
|
||||
self.distutils_install = self._distutils_install().copy()
|
||||
|
||||
# https://bugs.python.org/issue22199
|
||||
makefile = getattr(sysconfig, "get_makefile_filename", getattr(sysconfig, "_get_makefile_filename", None))
|
||||
self.sysconfig = {
|
||||
k: v
|
||||
for k, v in [
|
||||
# a list of content to store from sysconfig
|
||||
("makefile_filename", makefile()),
|
||||
]
|
||||
if k is not None
|
||||
}
|
||||
|
||||
config_var_keys = set()
|
||||
for element in self.sysconfig_paths.values():
|
||||
config_var_keys.update(k[1:-1] for k in _CONF_VAR_RE.findall(element))
|
||||
config_var_keys.add("PYTHONFRAMEWORK")
|
||||
|
||||
self.sysconfig_vars = {i: sysconfig.get_config_var(i or "") for i in config_var_keys}
|
||||
|
||||
confs = {
|
||||
k: (self.system_prefix if v is not None and v.startswith(self.prefix) else v)
|
||||
for k, v in self.sysconfig_vars.items()
|
||||
}
|
||||
self.system_stdlib = self.sysconfig_path("stdlib", confs)
|
||||
self.system_stdlib_platform = self.sysconfig_path("platstdlib", confs)
|
||||
self.max_size = getattr(sys, "maxsize", getattr(sys, "maxint", None))
|
||||
self._creators = None
|
||||
|
||||
def _fast_get_system_executable(self):
|
||||
"""Try to get the system executable by just looking at properties."""
|
||||
if self.real_prefix or ( # noqa: PLR1702
|
||||
self.base_prefix is not None and self.base_prefix != self.prefix
|
||||
): # if this is a virtual environment
|
||||
if self.real_prefix is None:
|
||||
base_executable = getattr(sys, "_base_executable", None) # some platforms may set this to help us
|
||||
if base_executable is not None: # noqa: SIM102 # use the saved system executable if present
|
||||
if sys.executable != base_executable: # we know we're in a virtual environment, cannot be us
|
||||
if os.path.exists(base_executable):
|
||||
return base_executable
|
||||
# Python may return "python" because it was invoked from the POSIX virtual environment
|
||||
# however some installs/distributions do not provide a version-less "python" binary in
|
||||
# the system install location (see PEP 394) so try to fallback to a versioned binary.
|
||||
#
|
||||
# Gate this to Python 3.11 as `sys._base_executable` path resolution is now relative to
|
||||
# the 'home' key from pyvenv.cfg which often points to the system install location.
|
||||
major, minor = self.version_info.major, self.version_info.minor
|
||||
if self.os == "posix" and (major, minor) >= (3, 11):
|
||||
# search relative to the directory of sys._base_executable
|
||||
base_dir = os.path.dirname(base_executable)
|
||||
for base_executable in [
|
||||
os.path.join(base_dir, exe) for exe in (f"python{major}", f"python{major}.{minor}")
|
||||
]:
|
||||
if os.path.exists(base_executable):
|
||||
return base_executable
|
||||
return None # in this case we just can't tell easily without poking around FS and calling them, bail
|
||||
# if we're not in a virtual environment, this is already a system python, so return the original executable
|
||||
# note we must choose the original and not the pure executable as shim scripts might throw us off
|
||||
return self.original_executable
|
||||
|
||||
def install_path(self, key):
|
||||
result = self.distutils_install.get(key)
|
||||
if result is None: # use sysconfig if sysconfig_scheme is set or distutils is unavailable
|
||||
# set prefixes to empty => result is relative from cwd
|
||||
prefixes = self.prefix, self.exec_prefix, self.base_prefix, self.base_exec_prefix
|
||||
config_var = {k: "" if v in prefixes else v for k, v in self.sysconfig_vars.items()}
|
||||
result = self.sysconfig_path(key, config_var=config_var).lstrip(os.sep)
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def _distutils_install():
|
||||
# use distutils primarily because that's what pip does
|
||||
# https://github.com/pypa/pip/blob/main/src/pip/_internal/locations.py#L95
|
||||
# note here we don't import Distribution directly to allow setuptools to patch it
|
||||
with warnings.catch_warnings(): # disable warning for PEP-632
|
||||
warnings.simplefilter("ignore")
|
||||
try:
|
||||
from distutils import dist # noqa: PLC0415
|
||||
from distutils.command.install import SCHEME_KEYS # noqa: PLC0415
|
||||
except ImportError: # if removed or not installed ignore
|
||||
return {}
|
||||
|
||||
d = dist.Distribution({"script_args": "--no-user-cfg"}) # conf files not parsed so they do not hijack paths
|
||||
if hasattr(sys, "_framework"):
|
||||
sys._framework = None # disable macOS static paths for framework # noqa: SLF001
|
||||
|
||||
with warnings.catch_warnings(): # disable warning for PEP-632
|
||||
warnings.simplefilter("ignore")
|
||||
i = d.get_command_obj("install", create=True)
|
||||
|
||||
i.prefix = os.sep # paths generated are relative to prefix that contains the path sep, this makes it relative
|
||||
i.finalize_options()
|
||||
return {key: (getattr(i, f"install_{key}")[1:]).lstrip(os.sep) for key in SCHEME_KEYS}
|
||||
|
||||
@property
|
||||
def version_str(self):
|
||||
return ".".join(str(i) for i in self.version_info[0:3])
|
||||
|
||||
@property
|
||||
def version_release_str(self):
|
||||
return ".".join(str(i) for i in self.version_info[0:2])
|
||||
|
||||
@property
|
||||
def python_name(self):
|
||||
version_info = self.version_info
|
||||
return f"python{version_info.major}.{version_info.minor}"
|
||||
|
||||
@property
|
||||
def is_old_virtualenv(self):
|
||||
return self.real_prefix is not None
|
||||
|
||||
@property
|
||||
def is_venv(self):
|
||||
return self.base_prefix is not None
|
||||
|
||||
def sysconfig_path(self, key, config_var=None, sep=os.sep):
|
||||
pattern = self.sysconfig_paths[key]
|
||||
if config_var is None:
|
||||
config_var = self.sysconfig_vars
|
||||
else:
|
||||
base = self.sysconfig_vars.copy()
|
||||
base.update(config_var)
|
||||
config_var = base
|
||||
return pattern.format(**config_var).replace("/", sep)
|
||||
|
||||
def creators(self, refresh=False): # noqa: FBT002
|
||||
if self._creators is None or refresh is True:
|
||||
from virtualenv.run.plugin.creators import CreatorSelector # noqa: PLC0415
|
||||
|
||||
self._creators = CreatorSelector.for_interpreter(self)
|
||||
return self._creators
|
||||
|
||||
@property
|
||||
def system_include(self):
|
||||
path = self.sysconfig_path(
|
||||
"include",
|
||||
{
|
||||
k: (self.system_prefix if v is not None and v.startswith(self.prefix) else v)
|
||||
for k, v in self.sysconfig_vars.items()
|
||||
},
|
||||
)
|
||||
if not os.path.exists(path): # some broken packaging don't respect the sysconfig, fallback to distutils path
|
||||
# the pattern include the distribution name too at the end, remove that via the parent call
|
||||
fallback = os.path.join(self.prefix, os.path.dirname(self.install_path("headers")))
|
||||
if os.path.exists(fallback):
|
||||
path = fallback
|
||||
return path
|
||||
|
||||
@property
|
||||
def system_prefix(self):
|
||||
return self.real_prefix or self.base_prefix or self.prefix
|
||||
|
||||
@property
|
||||
def system_exec_prefix(self):
|
||||
return self.real_prefix or self.base_exec_prefix or self.exec_prefix
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return "{}({!r})".format(
|
||||
self.__class__.__name__,
|
||||
{k: v for k, v in self.__dict__.items() if not k.startswith("_")},
|
||||
)
|
||||
|
||||
def __str__(self) -> str:
|
||||
return "{}({})".format(
|
||||
self.__class__.__name__,
|
||||
", ".join(
|
||||
f"{k}={v}"
|
||||
for k, v in (
|
||||
("spec", self.spec),
|
||||
(
|
||||
"system"
|
||||
if self.system_executable is not None and self.system_executable != self.executable
|
||||
else None,
|
||||
self.system_executable,
|
||||
),
|
||||
(
|
||||
"original"
|
||||
if self.original_executable not in {self.system_executable, self.executable}
|
||||
else None,
|
||||
self.original_executable,
|
||||
),
|
||||
("exe", self.executable),
|
||||
("platform", self.platform),
|
||||
("version", repr(self.version)),
|
||||
("encoding_fs_io", f"{self.file_system_encoding}-{self.stdout_encoding}"),
|
||||
)
|
||||
if k is not None
|
||||
),
|
||||
)
|
||||
|
||||
@property
|
||||
def spec(self):
|
||||
return "{}{}-{}".format(self.implementation, ".".join(str(i) for i in self.version_info), self.architecture)
|
||||
|
||||
@classmethod
|
||||
def clear_cache(cls, app_data):
|
||||
# this method is not used by itself, so here and called functions can import stuff locally
|
||||
from virtualenv.discovery.cached_py_info import clear # noqa: PLC0415
|
||||
|
||||
clear(app_data)
|
||||
cls._cache_exe_discovery.clear()
|
||||
|
||||
def satisfies(self, spec, impl_must_match): # noqa: C901
|
||||
"""Check if a given specification can be satisfied by the this python interpreter instance."""
|
||||
if spec.path:
|
||||
if self.executable == os.path.abspath(spec.path):
|
||||
return True # if the path is a our own executable path we're done
|
||||
if not spec.is_abs:
|
||||
# if path set, and is not our original executable name, this does not match
|
||||
basename = os.path.basename(self.original_executable)
|
||||
spec_path = spec.path
|
||||
if sys.platform == "win32":
|
||||
basename, suffix = os.path.splitext(basename)
|
||||
if spec_path.endswith(suffix):
|
||||
spec_path = spec_path[: -len(suffix)]
|
||||
if basename != spec_path:
|
||||
return False
|
||||
|
||||
if (
|
||||
impl_must_match
|
||||
and spec.implementation is not None
|
||||
and spec.implementation.lower() != self.implementation.lower()
|
||||
):
|
||||
return False
|
||||
|
||||
if spec.architecture is not None and spec.architecture != self.architecture:
|
||||
return False
|
||||
|
||||
for our, req in zip(self.version_info[0:3], (spec.major, spec.minor, spec.micro)):
|
||||
if req is not None and our is not None and our != req:
|
||||
return False
|
||||
return True
|
||||
|
||||
_current_system = None
|
||||
_current = None
|
||||
|
||||
@classmethod
|
||||
def current(cls, app_data=None):
|
||||
"""
|
||||
This locates the current host interpreter information. This might be different than what we run into in case
|
||||
the host python has been upgraded from underneath us.
|
||||
""" # noqa: D205
|
||||
if cls._current is None:
|
||||
cls._current = cls.from_exe(sys.executable, app_data, raise_on_error=True, resolve_to_host=False)
|
||||
return cls._current
|
||||
|
||||
@classmethod
|
||||
def current_system(cls, app_data=None) -> PythonInfo:
|
||||
"""
|
||||
This locates the current host interpreter information. This might be different than what we run into in case
|
||||
the host python has been upgraded from underneath us.
|
||||
""" # noqa: D205
|
||||
if cls._current_system is None:
|
||||
cls._current_system = cls.from_exe(sys.executable, app_data, raise_on_error=True, resolve_to_host=True)
|
||||
return cls._current_system
|
||||
|
||||
def _to_json(self):
|
||||
# don't save calculated paths, as these are non primitive types
|
||||
return json.dumps(self._to_dict(), indent=2)
|
||||
|
||||
def _to_dict(self):
|
||||
data = {var: (getattr(self, var) if var != "_creators" else None) for var in vars(self)}
|
||||
|
||||
data["version_info"] = data["version_info"]._asdict() # namedtuple to dictionary
|
||||
return data
|
||||
|
||||
@classmethod
|
||||
def from_exe( # noqa: PLR0913
|
||||
cls,
|
||||
exe,
|
||||
app_data=None,
|
||||
raise_on_error=True, # noqa: FBT002
|
||||
ignore_cache=False, # noqa: FBT002
|
||||
resolve_to_host=True, # noqa: FBT002
|
||||
env=None,
|
||||
):
|
||||
"""Given a path to an executable get the python information."""
|
||||
# this method is not used by itself, so here and called functions can import stuff locally
|
||||
from virtualenv.discovery.cached_py_info import from_exe # noqa: PLC0415
|
||||
|
||||
env = os.environ if env is None else env
|
||||
proposed = from_exe(cls, app_data, exe, env=env, raise_on_error=raise_on_error, ignore_cache=ignore_cache)
|
||||
|
||||
if isinstance(proposed, PythonInfo) and resolve_to_host:
|
||||
try:
|
||||
proposed = proposed._resolve_to_system(app_data, proposed) # noqa: SLF001
|
||||
except Exception as exception:
|
||||
if raise_on_error:
|
||||
raise
|
||||
logging.info("ignore %s due cannot resolve system due to %r", proposed.original_executable, exception)
|
||||
proposed = None
|
||||
return proposed
|
||||
|
||||
@classmethod
|
||||
def _from_json(cls, payload):
|
||||
# the dictionary unroll here is to protect against pypy bug of interpreter crashing
|
||||
raw = json.loads(payload)
|
||||
return cls._from_dict(raw.copy())
|
||||
|
||||
@classmethod
|
||||
def _from_dict(cls, data):
|
||||
data["version_info"] = VersionInfo(**data["version_info"]) # restore this to a named tuple structure
|
||||
result = cls()
|
||||
result.__dict__ = data.copy()
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def _resolve_to_system(cls, app_data, target):
|
||||
start_executable = target.executable
|
||||
prefixes = OrderedDict()
|
||||
while target.system_executable is None:
|
||||
prefix = target.real_prefix or target.base_prefix or target.prefix
|
||||
if prefix in prefixes:
|
||||
if len(prefixes) == 1:
|
||||
# if we're linking back to ourselves accept ourselves with a WARNING
|
||||
logging.info("%r links back to itself via prefixes", target)
|
||||
target.system_executable = target.executable
|
||||
break
|
||||
for at, (p, t) in enumerate(prefixes.items(), start=1):
|
||||
logging.error("%d: prefix=%s, info=%r", at, p, t)
|
||||
logging.error("%d: prefix=%s, info=%r", len(prefixes) + 1, prefix, target)
|
||||
msg = "prefixes are causing a circle {}".format("|".join(prefixes.keys()))
|
||||
raise RuntimeError(msg)
|
||||
prefixes[prefix] = target
|
||||
target = target.discover_exe(app_data, prefix=prefix, exact=False)
|
||||
if target.executable != target.system_executable:
|
||||
target = cls.from_exe(target.system_executable, app_data)
|
||||
target.executable = start_executable
|
||||
return target
|
||||
|
||||
_cache_exe_discovery = {} # noqa: RUF012
|
||||
|
||||
def discover_exe(self, app_data, prefix, exact=True, env=None): # noqa: FBT002
|
||||
key = prefix, exact
|
||||
if key in self._cache_exe_discovery and prefix:
|
||||
logging.debug("discover exe from cache %s - exact %s: %r", prefix, exact, self._cache_exe_discovery[key])
|
||||
return self._cache_exe_discovery[key]
|
||||
logging.debug("discover exe for %s in %s", self, prefix)
|
||||
# we don't know explicitly here, do some guess work - our executable name should tell
|
||||
possible_names = self._find_possible_exe_names()
|
||||
possible_folders = self._find_possible_folders(prefix)
|
||||
discovered = []
|
||||
env = os.environ if env is None else env
|
||||
for folder in possible_folders:
|
||||
for name in possible_names:
|
||||
info = self._check_exe(app_data, folder, name, exact, discovered, env)
|
||||
if info is not None:
|
||||
self._cache_exe_discovery[key] = info
|
||||
return info
|
||||
if exact is False and discovered:
|
||||
info = self._select_most_likely(discovered, self)
|
||||
folders = os.pathsep.join(possible_folders)
|
||||
self._cache_exe_discovery[key] = info
|
||||
logging.debug("no exact match found, chosen most similar of %s within base folders %s", info, folders)
|
||||
return info
|
||||
msg = "failed to detect {} in {}".format("|".join(possible_names), os.pathsep.join(possible_folders))
|
||||
raise RuntimeError(msg)
|
||||
|
||||
def _check_exe(self, app_data, folder, name, exact, discovered, env): # noqa: PLR0913
|
||||
exe_path = os.path.join(folder, name)
|
||||
if not os.path.exists(exe_path):
|
||||
return None
|
||||
info = self.from_exe(exe_path, app_data, resolve_to_host=False, raise_on_error=False, env=env)
|
||||
if info is None: # ignore if for some reason we can't query
|
||||
return None
|
||||
for item in ["implementation", "architecture", "version_info"]:
|
||||
found = getattr(info, item)
|
||||
searched = getattr(self, item)
|
||||
if found != searched:
|
||||
if item == "version_info":
|
||||
found, searched = ".".join(str(i) for i in found), ".".join(str(i) for i in searched)
|
||||
executable = info.executable
|
||||
logging.debug("refused interpreter %s because %s differs %s != %s", executable, item, found, searched)
|
||||
if exact is False:
|
||||
discovered.append(info)
|
||||
break
|
||||
else:
|
||||
return info
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def _select_most_likely(discovered, target):
|
||||
# no exact match found, start relaxing our requirements then to facilitate system package upgrades that
|
||||
# could cause this (when using copy strategy of the host python)
|
||||
def sort_by(info):
|
||||
# we need to setup some priority of traits, this is as follows:
|
||||
# implementation, major, minor, micro, architecture, tag, serial
|
||||
matches = [
|
||||
info.implementation == target.implementation,
|
||||
info.version_info.major == target.version_info.major,
|
||||
info.version_info.minor == target.version_info.minor,
|
||||
info.architecture == target.architecture,
|
||||
info.version_info.micro == target.version_info.micro,
|
||||
info.version_info.releaselevel == target.version_info.releaselevel,
|
||||
info.version_info.serial == target.version_info.serial,
|
||||
]
|
||||
return sum((1 << pos if match else 0) for pos, match in enumerate(reversed(matches)))
|
||||
|
||||
sorted_discovered = sorted(discovered, key=sort_by, reverse=True) # sort by priority in decreasing order
|
||||
return sorted_discovered[0]
|
||||
|
||||
def _find_possible_folders(self, inside_folder):
|
||||
candidate_folder = OrderedDict()
|
||||
executables = OrderedDict()
|
||||
executables[os.path.realpath(self.executable)] = None
|
||||
executables[self.executable] = None
|
||||
executables[os.path.realpath(self.original_executable)] = None
|
||||
executables[self.original_executable] = None
|
||||
for exe in executables:
|
||||
base = os.path.dirname(exe)
|
||||
# following path pattern of the current
|
||||
if base.startswith(self.prefix):
|
||||
relative = base[len(self.prefix) :]
|
||||
candidate_folder[f"{inside_folder}{relative}"] = None
|
||||
|
||||
# or at root level
|
||||
candidate_folder[inside_folder] = None
|
||||
return [i for i in candidate_folder if os.path.exists(i)]
|
||||
|
||||
def _find_possible_exe_names(self):
|
||||
name_candidate = OrderedDict()
|
||||
for name in self._possible_base():
|
||||
for at in (3, 2, 1, 0):
|
||||
version = ".".join(str(i) for i in self.version_info[:at])
|
||||
for arch in [f"-{self.architecture}", ""]:
|
||||
for ext in EXTENSIONS:
|
||||
candidate = f"{name}{version}{arch}{ext}"
|
||||
name_candidate[candidate] = None
|
||||
return list(name_candidate.keys())
|
||||
|
||||
def _possible_base(self):
|
||||
possible_base = OrderedDict()
|
||||
basename = os.path.splitext(os.path.basename(self.executable))[0].rstrip(digits)
|
||||
possible_base[basename] = None
|
||||
possible_base[self.implementation] = None
|
||||
# python is always the final option as in practice is used by multiple implementation as exe name
|
||||
if "python" in possible_base:
|
||||
del possible_base["python"]
|
||||
possible_base["python"] = None
|
||||
for base in possible_base:
|
||||
lower = base.lower()
|
||||
yield lower
|
||||
from virtualenv.info import fs_is_case_sensitive # noqa: PLC0415
|
||||
|
||||
if fs_is_case_sensitive():
|
||||
if base != lower:
|
||||
yield base
|
||||
upper = base.upper()
|
||||
if upper != base:
|
||||
yield upper
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# dump a JSON representation of the current python
|
||||
|
||||
argv = sys.argv[1:]
|
||||
|
||||
if len(argv) >= 1:
|
||||
start_cookie = argv[0]
|
||||
argv = argv[1:]
|
||||
else:
|
||||
start_cookie = ""
|
||||
|
||||
if len(argv) >= 1:
|
||||
end_cookie = argv[0]
|
||||
argv = argv[1:]
|
||||
else:
|
||||
end_cookie = ""
|
||||
|
||||
sys.argv = sys.argv[:1] + argv
|
||||
|
||||
info = PythonInfo()._to_json() # noqa: SLF001
|
||||
sys.stdout.write("".join((start_cookie[::-1], info, end_cookie[::-1])))
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
"""A Python specification is an abstract requirement definition of an interpreter."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import re
|
||||
|
||||
PATTERN = re.compile(r"^(?P<impl>[a-zA-Z]+)?(?P<version>[0-9.]+)?(?:-(?P<arch>32|64))?$")
|
||||
|
||||
|
||||
class PythonSpec:
|
||||
"""Contains specification about a Python Interpreter."""
|
||||
|
||||
def __init__( # noqa: PLR0913
|
||||
self,
|
||||
str_spec: str,
|
||||
implementation: str | None,
|
||||
major: int | None,
|
||||
minor: int | None,
|
||||
micro: int | None,
|
||||
architecture: int | None,
|
||||
path: str | None,
|
||||
) -> None:
|
||||
self.str_spec = str_spec
|
||||
self.implementation = implementation
|
||||
self.major = major
|
||||
self.minor = minor
|
||||
self.micro = micro
|
||||
self.architecture = architecture
|
||||
self.path = path
|
||||
|
||||
@classmethod
|
||||
def from_string_spec(cls, string_spec: str): # noqa: C901, PLR0912
|
||||
impl, major, minor, micro, arch, path = None, None, None, None, None, None
|
||||
if os.path.isabs(string_spec): # noqa: PLR1702
|
||||
path = string_spec
|
||||
else:
|
||||
ok = False
|
||||
match = re.match(PATTERN, string_spec)
|
||||
if match:
|
||||
|
||||
def _int_or_none(val):
|
||||
return None if val is None else int(val)
|
||||
|
||||
try:
|
||||
groups = match.groupdict()
|
||||
version = groups["version"]
|
||||
if version is not None:
|
||||
versions = tuple(int(i) for i in version.split(".") if i)
|
||||
if len(versions) > 3: # noqa: PLR2004
|
||||
raise ValueError # noqa: TRY301
|
||||
if len(versions) == 3: # noqa: PLR2004
|
||||
major, minor, micro = versions
|
||||
elif len(versions) == 2: # noqa: PLR2004
|
||||
major, minor = versions
|
||||
elif len(versions) == 1:
|
||||
version_data = versions[0]
|
||||
major = int(str(version_data)[0]) # first digit major
|
||||
if version_data > 9: # noqa: PLR2004
|
||||
minor = int(str(version_data)[1:])
|
||||
ok = True
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
impl = groups["impl"]
|
||||
if impl in {"py", "python"}:
|
||||
impl = None
|
||||
arch = _int_or_none(groups["arch"])
|
||||
|
||||
if not ok:
|
||||
path = string_spec
|
||||
|
||||
return cls(string_spec, impl, major, minor, micro, arch, path)
|
||||
|
||||
def generate_re(self, *, windows: bool) -> re.Pattern:
|
||||
"""Generate a regular expression for matching against a filename."""
|
||||
version = r"{}(\.{}(\.{})?)?".format(
|
||||
*(r"\d+" if v is None else v for v in (self.major, self.minor, self.micro))
|
||||
)
|
||||
impl = "python" if self.implementation is None else f"python|{re.escape(self.implementation)}"
|
||||
suffix = r"\.exe" if windows else ""
|
||||
version_conditional = (
|
||||
"?"
|
||||
# Windows Python executables are almost always unversioned
|
||||
if windows
|
||||
# Spec is an empty string
|
||||
or self.major is None
|
||||
else ""
|
||||
)
|
||||
# Try matching `direct` first, so the `direct` group is filled when possible.
|
||||
return re.compile(
|
||||
rf"(?P<impl>{impl})(?P<v>{version}){version_conditional}{suffix}$",
|
||||
flags=re.IGNORECASE,
|
||||
)
|
||||
|
||||
@property
|
||||
def is_abs(self):
|
||||
return self.path is not None and os.path.isabs(self.path)
|
||||
|
||||
def satisfies(self, spec):
|
||||
"""Called when there's a candidate metadata spec to see if compatible - e.g. PEP-514 on Windows."""
|
||||
if spec.is_abs and self.is_abs and self.path != spec.path:
|
||||
return False
|
||||
if spec.implementation is not None and spec.implementation.lower() != self.implementation.lower():
|
||||
return False
|
||||
if spec.architecture is not None and spec.architecture != self.architecture:
|
||||
return False
|
||||
|
||||
for our, req in zip((self.major, self.minor, self.micro), (spec.major, spec.minor, spec.micro)):
|
||||
if req is not None and our is not None and our != req:
|
||||
return False
|
||||
return True
|
||||
|
||||
def __repr__(self) -> str:
|
||||
name = type(self).__name__
|
||||
params = "implementation", "major", "minor", "micro", "architecture", "path"
|
||||
return f"{name}({', '.join(f'{k}={getattr(self, k)}' for k in params if getattr(self, k) is not None)})"
|
||||
|
||||
|
||||
__all__ = [
|
||||
"PythonSpec",
|
||||
]
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
from __future__ import annotations
|
||||
|
||||
from virtualenv.discovery.py_info import PythonInfo
|
||||
from virtualenv.discovery.py_spec import PythonSpec
|
||||
|
||||
from .pep514 import discover_pythons
|
||||
|
||||
# Map of well-known organizations (as per PEP 514 Company Windows Registry key part) versus Python implementation
|
||||
_IMPLEMENTATION_BY_ORG = {
|
||||
"ContinuumAnalytics": "CPython",
|
||||
"PythonCore": "CPython",
|
||||
}
|
||||
|
||||
|
||||
class Pep514PythonInfo(PythonInfo):
|
||||
"""A Python information acquired from PEP-514."""
|
||||
|
||||
|
||||
def propose_interpreters(spec, cache_dir, env):
|
||||
# see if PEP-514 entries are good
|
||||
|
||||
# start with higher python versions in an effort to use the latest version available
|
||||
# and prefer PythonCore over conda pythons (as virtualenv is mostly used by non conda tools)
|
||||
existing = list(discover_pythons())
|
||||
existing.sort(
|
||||
key=lambda i: (*tuple(-1 if j is None else j for j in i[1:4]), 1 if i[0] == "PythonCore" else 0),
|
||||
reverse=True,
|
||||
)
|
||||
|
||||
for name, major, minor, arch, exe, _ in existing:
|
||||
# Map well-known/most common organizations to a Python implementation, use the org name as a fallback for
|
||||
# backwards compatibility.
|
||||
implementation = _IMPLEMENTATION_BY_ORG.get(name, name)
|
||||
|
||||
# Pre-filtering based on Windows Registry metadata, for CPython only
|
||||
skip_pre_filter = implementation.lower() != "cpython"
|
||||
registry_spec = PythonSpec(None, implementation, major, minor, None, arch, exe)
|
||||
if skip_pre_filter or registry_spec.satisfies(spec):
|
||||
interpreter = Pep514PythonInfo.from_exe(exe, cache_dir, env=env, raise_on_error=False)
|
||||
if interpreter is not None and interpreter.satisfies(spec, impl_must_match=True):
|
||||
yield interpreter # Final filtering/matching using interpreter metadata
|
||||
|
||||
|
||||
__all__ = [
|
||||
"Pep514PythonInfo",
|
||||
"propose_interpreters",
|
||||
]
|
||||
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,152 @@
|
|||
"""Implement https://www.python.org/dev/peps/pep-0514/ to discover interpreters - Windows only."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import re
|
||||
import winreg
|
||||
from logging import basicConfig, getLogger
|
||||
|
||||
LOGGER = getLogger(__name__)
|
||||
|
||||
|
||||
def enum_keys(key):
|
||||
at = 0
|
||||
while True:
|
||||
try:
|
||||
yield winreg.EnumKey(key, at)
|
||||
except OSError:
|
||||
break
|
||||
at += 1
|
||||
|
||||
|
||||
def get_value(key, value_name):
|
||||
try:
|
||||
return winreg.QueryValueEx(key, value_name)[0]
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
def discover_pythons():
|
||||
for hive, hive_name, key, flags, default_arch in [
|
||||
(winreg.HKEY_CURRENT_USER, "HKEY_CURRENT_USER", r"Software\Python", 0, 64),
|
||||
(winreg.HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE", r"Software\Python", winreg.KEY_WOW64_64KEY, 64),
|
||||
(winreg.HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE", r"Software\Python", winreg.KEY_WOW64_32KEY, 32),
|
||||
]:
|
||||
yield from process_set(hive, hive_name, key, flags, default_arch)
|
||||
|
||||
|
||||
def process_set(hive, hive_name, key, flags, default_arch):
|
||||
try:
|
||||
with winreg.OpenKeyEx(hive, key, 0, winreg.KEY_READ | flags) as root_key:
|
||||
for company in enum_keys(root_key):
|
||||
if company == "PyLauncher": # reserved
|
||||
continue
|
||||
yield from process_company(hive_name, company, root_key, default_arch)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
def process_company(hive_name, company, root_key, default_arch):
|
||||
with winreg.OpenKeyEx(root_key, company) as company_key:
|
||||
for tag in enum_keys(company_key):
|
||||
spec = process_tag(hive_name, company, company_key, tag, default_arch)
|
||||
if spec is not None:
|
||||
yield spec
|
||||
|
||||
|
||||
def process_tag(hive_name, company, company_key, tag, default_arch):
|
||||
with winreg.OpenKeyEx(company_key, tag) as tag_key:
|
||||
version = load_version_data(hive_name, company, tag, tag_key)
|
||||
if version is not None: # if failed to get version bail
|
||||
major, minor, _ = version
|
||||
arch = load_arch_data(hive_name, company, tag, tag_key, default_arch)
|
||||
if arch is not None:
|
||||
exe_data = load_exe(hive_name, company, company_key, tag)
|
||||
if exe_data is not None:
|
||||
exe, args = exe_data
|
||||
return company, major, minor, arch, exe, args
|
||||
return None
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def load_exe(hive_name, company, company_key, tag):
|
||||
key_path = f"{hive_name}/{company}/{tag}"
|
||||
try:
|
||||
with winreg.OpenKeyEx(company_key, rf"{tag}\InstallPath") as ip_key, ip_key:
|
||||
exe = get_value(ip_key, "ExecutablePath")
|
||||
if exe is None:
|
||||
ip = get_value(ip_key, None)
|
||||
if ip is None:
|
||||
msg(key_path, "no ExecutablePath or default for it")
|
||||
|
||||
else:
|
||||
exe = os.path.join(ip, "python.exe")
|
||||
if exe is not None and os.path.exists(exe):
|
||||
args = get_value(ip_key, "ExecutableArguments")
|
||||
return exe, args
|
||||
msg(key_path, f"could not load exe with value {exe}")
|
||||
except OSError:
|
||||
msg(f"{key_path}/InstallPath", "missing")
|
||||
return None
|
||||
|
||||
|
||||
def load_arch_data(hive_name, company, tag, tag_key, default_arch):
|
||||
arch_str = get_value(tag_key, "SysArchitecture")
|
||||
if arch_str is not None:
|
||||
key_path = f"{hive_name}/{company}/{tag}/SysArchitecture"
|
||||
try:
|
||||
return parse_arch(arch_str)
|
||||
except ValueError as sys_arch:
|
||||
msg(key_path, sys_arch)
|
||||
return default_arch
|
||||
|
||||
|
||||
def parse_arch(arch_str):
|
||||
if isinstance(arch_str, str):
|
||||
match = re.match(r"^(\d+)bit$", arch_str)
|
||||
if match:
|
||||
return int(next(iter(match.groups())))
|
||||
error = f"invalid format {arch_str}"
|
||||
else:
|
||||
error = f"arch is not string: {arch_str!r}"
|
||||
raise ValueError(error)
|
||||
|
||||
|
||||
def load_version_data(hive_name, company, tag, tag_key):
|
||||
for candidate, key_path in [
|
||||
(get_value(tag_key, "SysVersion"), f"{hive_name}/{company}/{tag}/SysVersion"),
|
||||
(tag, f"{hive_name}/{company}/{tag}"),
|
||||
]:
|
||||
if candidate is not None:
|
||||
try:
|
||||
return parse_version(candidate)
|
||||
except ValueError as sys_version:
|
||||
msg(key_path, sys_version)
|
||||
return None
|
||||
|
||||
|
||||
def parse_version(version_str):
|
||||
if isinstance(version_str, str):
|
||||
match = re.match(r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?$", version_str)
|
||||
if match:
|
||||
return tuple(int(i) if i is not None else None for i in match.groups())
|
||||
error = f"invalid format {version_str}"
|
||||
else:
|
||||
error = f"version is not string: {version_str!r}"
|
||||
raise ValueError(error)
|
||||
|
||||
|
||||
def msg(path, what):
|
||||
LOGGER.warning("PEP-514 violation in Windows Registry at %s error: %s", path, what)
|
||||
|
||||
|
||||
def _run():
|
||||
basicConfig()
|
||||
interpreters = [repr(spec) for spec in discover_pythons()]
|
||||
print("\n".join(sorted(interpreters))) # noqa: T201
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
_run()
|
||||
Loading…
Add table
Add a link
Reference in a new issue