def packages_path(self) -> Path:
"""The local packages path."""
version, is_64bit = get_python_version(self.python_executable, True, 2)
pypackages = (self.project.root / "__pypackages__" /
get_python_version_string(version, is_64bit))
if not pypackages.exists() and not is_64bit:
compatible_packages = pypackages.parent / get_python_version_string(
version, True)
if compatible_packages.exists():
pypackages = compatible_packages
scripts = "Scripts" if os.name == "nt" else "bin"
for subdir in [scripts, "include", "lib"]:
pypackages.joinpath(subdir).mkdir(exist_ok=True, parents=True)
return pypackages
def do_use(project: Project,
python: Optional[str] = "",
first: Optional[bool] = False) -> None:
"""Use the specified python version and save in project config.
The python can be a version string or interpreter path.
"""
def version_matcher(py_version):
return project.python_requires.contains(str(py_version.version))
python = python.strip()
found_interpreters = list(
dict.fromkeys(
filter(version_matcher, project.find_interpreters(python))))
if not found_interpreters:
raise NoPythonVersion("Python interpreter is not found on the system.")
if first or len(found_interpreters) == 1:
selected_python = found_interpreters[0]
else:
project.core.ui.echo("Please enter the Python interpreter to use")
for i, py_version in enumerate(found_interpreters):
python_version = str(py_version.version)
is_64bit = py_version.get_architecture() == "64bit"
version_string = get_python_version_string(python_version,
is_64bit)
project.core.ui.echo(
f"{i}. {termui.green(py_version.executable)} ({version_string})"
)
selection = click.prompt(
"Please select:",
type=click.Choice([str(i)
for i in range(len(found_interpreters))]),
default="0",
show_choices=False,
)
selected_python = found_interpreters[int(selection)]
old_path = project.config.get("python.path")
new_path = selected_python.executable
python_version = str(selected_python.version)
is_64bit = selected_python.get_architecture() == "64bit"
project.core.ui.echo("Using Python interpreter: {} ({})".format(
termui.green(str(new_path)),
get_python_version_string(python_version, is_64bit),
))
project.python_executable = new_path
if old_path and Path(old_path) != Path(new_path) and not project.is_global:
project.core.ui.echo(termui.cyan("Updating executable scripts..."))
project.environment.update_shebangs(new_path)
def do_use(project: Project, python: str, first: bool = False) -> None:
"""Use the specified python version and save in project config.
The python can be a version string or interpreter path.
"""
import pythonfinder
python = python.strip()
if python and not all(c.isdigit() for c in python.split(".")):
if Path(python).exists():
python_path = find_python_in_path(python)
else:
python_path = shutil.which(python)
if not python_path:
raise NoPythonVersion(f"{python} is not a valid Python.")
python_version, is_64bit = get_python_version(python_path, True)
else:
finder = pythonfinder.Finder()
pythons = []
args = [int(v) for v in python.split(".") if v != ""]
for i, entry in enumerate(finder.find_all_python_versions(*args)):
python_version, is_64bit = get_python_version(entry.path.as_posix(), True)
pythons.append((entry.path.as_posix(), python_version, is_64bit))
if not pythons:
raise NoPythonVersion(f"Python {python} is not available on the system.")
if not first and len(pythons) > 1:
for i, (path, python_version, is_64bit) in enumerate(pythons):
stream.echo(
f"{i}. {stream.green(path)} "
f"({get_python_version_string(python_version, is_64bit)})"
)
selection = click.prompt(
"Please select:",
type=click.Choice([str(i) for i in range(len(pythons))]),
default="0",
show_choices=False,
)
else:
selection = 0
python_path, python_version, is_64bit = pythons[int(selection)]
if not project.python_requires.contains(python_version):
raise NoPythonVersion(
"The target Python version {} doesn't satisfy "
"the Python requirement: {}".format(python_version, project.python_requires)
)
stream.echo(
"Using Python interpreter: {} ({})".format(
stream.green(python_path),
get_python_version_string(python_version, is_64bit),
)
)
old_path = project.config.get("python.path")
new_path = python_path
project.project_config["python.path"] = Path(new_path).as_posix()
if old_path and Path(old_path) != Path(new_path) and not project.is_global:
stream.echo(stream.cyan("Updating executable scripts..."))
project.environment.update_shebangs(new_path)