YzwW. / %'-$"+qV죣 O8 ~%࿔9ҵ]+,@p&Lpn9'hwg@ز6ҮNt`¥b^t5 lC E 1v(hw@io.=mO9 ǣ gD-]r#g#w";di눼T's9gݘh&Yʹ Ű}>5qF`[
gk ~#5Hw vd} @{M0ՅlčG1~N_wr+=GXHaer-]f^
f#]
&(((((((((((((((((((J ,k IENDB` pipx-0.12.3.1/makefile 0000664 0000000 0000000 00000000465 13435016624 0014425 0 ustar 00root root 0000000 0000000 .PHONY: build publish docs test
test:
python setup.py test
build: clean
python -m pip install --upgrade --quiet setuptools wheel twine
python setup.py --quiet sdist bdist_wheel
publish: build
python -m twine upload dist/*
clean:
rm -r build dist *.egg-info || true
docs:
python generate_readme.py
pipx-0.12.3.1/pipx/ 0000775 0000000 0000000 00000000000 13435016624 0013700 5 ustar 00root root 0000000 0000000 pipx-0.12.3.1/pipx/Venv.py 0000664 0000000 0000000 00000011136 13435016624 0015172 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import json
import logging
import pkgutil
import subprocess
from pathlib import Path
from typing import Dict, List, NamedTuple, Sequence, Union
from pipx.animate import animate
from pipx.constants import DEFAULT_PYTHON
from pipx.util import WINDOWS, PipxError, rmdir
class PipxVenvMetadata(NamedTuple):
binaries: List[str]
binary_paths: List[Path]
binaries_of_dependencies: List[str]
binary_paths_of_dependencies: Dict[str, List[Path]]
package_version: str
python_version: str
venv_metadata_inspector_raw = pkgutil.get_data("pipx", "venv_metadata_inspector.py")
assert venv_metadata_inspector_raw is not None, (
"pipx could not find required file venv_metadata_inspector.py. "
"Please report this error at https://github.com/pipxproject/pipx. Exiting."
)
VENV_METADATA_INSPECTOR = venv_metadata_inspector_raw.decode("utf-8")
class Venv:
"""Abstraction for a virtual environment with various useful methods for pipx"""
def __init__(
self, path: Path, *, verbose: bool = False, python: str = DEFAULT_PYTHON
) -> None:
self.root = path
self._python = python
self.bin_path = path / "bin" if not WINDOWS else path / "Scripts"
self.python_path = self.bin_path / ("python" if not WINDOWS else "python.exe")
self.verbose = verbose
self.do_animation = not verbose
def create_venv(self, venv_args: List[str], pip_args: List[str]) -> None:
with animate("creating virtual environment", self.do_animation):
_run([self._python, "-m", "venv"] + venv_args + [str(self.root)])
ignored_args = ["--editable"]
_pip_args = [arg for arg in pip_args if arg not in ignored_args]
self.upgrade_package("pip", _pip_args)
def remove_venv(self) -> None:
rmdir(self.root)
def install_package(self, package_or_url: str, pip_args: List[str]) -> None:
with animate(f"installing package {package_or_url!r}", self.do_animation):
if pip_args is None:
pip_args = []
cmd = ["install"] + pip_args + [package_or_url]
self._run_pip(cmd)
def get_venv_metadata_for_package(self, package: str) -> PipxVenvMetadata:
data = json.loads(
subprocess.run(
[
str(self.python_path),
"-c",
VENV_METADATA_INSPECTOR,
package,
str(self.bin_path),
],
stdout=subprocess.PIPE,
).stdout.decode(),
encoding="utf-8",
)
data["binary_paths"] = [Path(p) for p in data["binary_paths"]]
data["binaries_of_dependencies"] = []
for dep, raw_paths in data["binary_paths_of_dependencies"].items():
paths = [Path(raw_path) for raw_path in raw_paths]
data["binary_paths_of_dependencies"][dep] = paths
data["binaries_of_dependencies"] += [path.name for path in paths]
if WINDOWS:
windows_bin_paths = set()
for binary in data["binary_paths"]:
# windows has additional files staring with the same name that are required
# to run the binary
for win_exec in binary.parent.glob(f"{binary.name}*"):
windows_bin_paths.add(win_exec)
data["binary_paths"] = windows_bin_paths
return PipxVenvMetadata(**data)
def get_python_version(self) -> str:
return (
subprocess.run([str(self.python_path), "--version"], stdout=subprocess.PIPE)
.stdout.decode()
.strip()
)
def run_binary(self, binary: str, binary_args: List[str]):
cmd = [str(self.bin_path / binary)] + binary_args
try:
return _run(cmd, check=False)
except KeyboardInterrupt:
pass
def upgrade_package(self, package_or_url: str, pip_args: List[str]):
self._run_pip(["install"] + pip_args + ["--upgrade", package_or_url])
def _run_pip(self, cmd):
cmd = [self.python_path, "-m", "pip"] + cmd
if not self.verbose:
cmd.append("-q")
return _run(cmd)
def _run(cmd: Sequence[Union[str, Path]], check=True) -> int:
"""Run arbitrary command as subprocess"""
cmd_str = " ".join(str(c) for c in cmd)
logging.info(f"running {cmd_str}")
# windows cannot take Path objects, only strings
cmd_str_list = [str(c) for c in cmd]
returncode = subprocess.run(cmd_str_list).returncode
if check and returncode:
raise PipxError(f"{cmd_str!r} failed")
return returncode
pipx-0.12.3.1/pipx/__init__.py 0000664 0000000 0000000 00000000242 13435016624 0016007 0 ustar 00root root 0000000 0000000 import sys
assert sys.version_info >= (3, 6, 0), (
"Python 3.6+ is required. See https://github.com/pipxproject/pipx "
"for installation instructions"
)
pipx-0.12.3.1/pipx/__main__.py 0000664 0000000 0000000 00000000075 13435016624 0015774 0 ustar 00root root 0000000 0000000 from .main import cli
if __name__ == "__main__":
cli()
pipx-0.12.3.1/pipx/animate.py 0000664 0000000 0000000 00000002164 13435016624 0015673 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
from contextlib import contextmanager
import sys
from typing import Dict
from threading import Thread
from time import sleep
@contextmanager
def animate(message: str, do_animation: bool):
animate = {"do_animation": do_animation, "message": message}
t = Thread(target=print_animation, args=(animate,))
t.start()
try:
yield
finally:
animate["do_animation"] = False
t.join(0)
def print_animation(meta: Dict[str, bool]):
if not sys.stdout.isatty():
return
cur = "."
longest_len = 0
sleep(1)
while meta["do_animation"]:
if cur == "":
cur = "."
elif cur == ".":
cur = ".."
elif cur == "..":
cur = "..."
else:
cur = ""
message = f"{meta['message']}{cur}"
longest_len = max(len(message), longest_len)
sys.stdout.write(" " * longest_len)
sys.stdout.write("\r")
sys.stdout.write(message)
sys.stdout.write("\r")
sleep(0.5)
sys.stdout.write(" " * longest_len)
sys.stdout.write("\r")
pipx-0.12.3.1/pipx/colors.py 0000664 0000000 0000000 00000001217 13435016624 0015554 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
USING_WINDOWS = os.name == "nt"
PRINT_COLOR = not USING_WINDOWS and sys.stdout.isatty()
class c:
header = "\033[95m"
blue = "\033[94m"
green = "\033[92m"
yellow = "\033[93m"
red = "\033[91m"
bold = "\033[1m"
cyan = "\033[96m"
underline = "\033[4m"
end = "\033[0m"
def mkcolorfunc(style):
def stylize_text(x):
if PRINT_COLOR:
return f"{style}{x}{c.end}"
else:
return x
return stylize_text
bold = mkcolorfunc(c.bold)
red = mkcolorfunc(c.red)
cyan = mkcolorfunc(c.cyan)
green = mkcolorfunc(c.green)
pipx-0.12.3.1/pipx/commands.py 0000664 0000000 0000000 00000051601 13435016624 0016056 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import datetime
import distutils.spawn
import hashlib
import http.client
import logging
import multiprocessing
import os
import shlex
import shutil
import subprocess
import textwrap
import time
import urllib.parse
from pathlib import Path
from shutil import which
from typing import List, Optional
from .animate import animate
from .colors import bold, red
from .constants import (
LOCAL_BIN_DIR,
PIPX_PACKAGE_NAME,
PIPX_VENV_CACHEDIR,
TEMP_VENV_EXPIRATION_THRESHOLD_DAYS,
)
from .emojies import hazard, sleep, stars
from .util import (
WINDOWS,
PipxError,
get_pypackage_bin_path,
mkdir,
rmdir,
run_pypackage_bin,
)
from .Venv import Venv
def run(
binary: str,
package_or_url: str,
binary_args: List[str],
python: str,
pip_args: List[str],
venv_args: List[str],
pypackages: bool,
verbose: bool,
use_cache: bool,
):
"""Installs venv to temporary dir (or reuses cache), then runs binary from
package
"""
if urllib.parse.urlparse(binary).scheme:
if not binary.endswith(".py"):
exit(
"pipx will only execute binaries from the internet directly if "
"they end with '.py'. To run from an SVN, try pipx --spec URL BINARY"
)
logging.info("Detected url. Downloading and executing as a Python file.")
content = _http_get_request(binary)
try:
exit(subprocess.run([str(python), "-c", content]).returncode)
except KeyboardInterrupt:
pass
exit(0)
elif which(binary):
logging.warning(
f"{hazard} {binary} is already on your PATH and installed at "
f"{which(binary)}. Downloading and "
"running anyway."
)
if WINDOWS and not binary.endswith(".exe"):
binary = f"{binary}.exe"
logging.warning(f"Assuming binary is {binary!r} (Windows only)")
pypackage_bin_path = get_pypackage_bin_path(binary)
if pypackage_bin_path.exists():
logging.info(
f"Using binary in local __pypackages__ directory at {str(pypackage_bin_path)}"
)
return run_pypackage_bin(pypackage_bin_path, binary_args)
if pypackages:
raise PipxError(
f"'--pypackages' flag was passed, but {str(pypackage_bin_path)!r} was "
"not found. See https://github.com/cs01/pythonloc to learn how to "
"install here, or omit the flag."
)
venv_dir = _get_temporary_venv_path(package_or_url, python, pip_args, venv_args)
venv = Venv(venv_dir)
bin_path = venv.bin_path / binary
_prepare_venv_cache(venv, bin_path, use_cache)
if bin_path.exists():
logging.info(f"Reusing cached venv {venv_dir}")
retval = venv.run_binary(binary, binary_args)
else:
logging.info(f"venv location is {venv_dir}")
retval = _download_and_run(
Path(venv_dir),
package_or_url,
binary,
binary_args,
python,
pip_args,
venv_args,
verbose,
)
if not use_cache:
rmdir(venv_dir)
return retval
def _download_and_run(
venv_dir: Path,
package: str,
binary: str,
binary_args: List[str],
python: str,
pip_args: List[str],
venv_args: List[str],
verbose: bool,
):
venv = Venv(venv_dir, python=python, verbose=verbose)
venv.create_venv(venv_args, pip_args)
venv.install_package(package, pip_args)
if not (venv.bin_path / binary).exists():
binaries = venv.get_venv_metadata_for_package(package).binaries
raise PipxError(
f"{binary} not found in package {package}. Available binaries: "
f"{', '.join(b for b in binaries)}"
)
return venv.run_binary(binary, binary_args)
def _get_temporary_venv_path(
package_or_url: str, python: str, pip_args: List[str], venv_args: List[str]
):
"""Computes deterministic path using hashing function on arguments relevant
to virtual environment's end state. Arguments used should result in idempotent
virtual environment. (i.e. args passed to binary aren't relevant, but args
passed to venv creation are.)
"""
m = hashlib.sha256()
m.update(package_or_url.encode())
m.update(python.encode())
m.update("".join(pip_args).encode())
m.update("".join(venv_args).encode())
venv_folder_name = m.hexdigest()[0:15] # 15 chosen arbitrarily
return Path(PIPX_VENV_CACHEDIR) / venv_folder_name
def _is_temporary_venv_expired(venv_dir: Path):
created_time_sec = venv_dir.stat().st_ctime
current_time_sec = time.mktime(datetime.datetime.now().timetuple())
age = current_time_sec - created_time_sec
expiration_threshold_sec = 60 * 60 * 24 * TEMP_VENV_EXPIRATION_THRESHOLD_DAYS
return age > expiration_threshold_sec
def _prepare_venv_cache(venv: Venv, bin_path: Path, use_cache: bool):
venv_dir = venv.root
if not use_cache and bin_path.exists():
logging.info(f"Removing cached venv {str(venv_dir)}")
rmdir(venv_dir)
_remove_all_expired_venvs()
def _remove_all_expired_venvs():
for venv_dir in Path(PIPX_VENV_CACHEDIR).iterdir():
if _is_temporary_venv_expired(venv_dir):
logging.info(f"Removing expired venv {str(venv_dir)}")
rmdir(venv_dir)
def _http_get_request(url: str):
parts = urllib.parse.urlparse(url)
conn = http.client.HTTPSConnection(parts.hostname)
conn.request("GET", parts.path)
response = conn.getresponse()
if response.status != 200:
raise PipxError(response.reason)
return response.read().decode("utf-8")
def upgrade(
venv_dir: Path,
package: str,
package_or_url: str,
pip_args: List[str],
verbose: bool,
*,
upgrading_all: bool,
include_deps: bool,
) -> int:
"""Returns nonzero if package was upgraded, 0 if version did not change"""
if not venv_dir.is_dir():
raise PipxError(
f"Package is not installed. Expected to find {str(venv_dir)}, "
"but it does not exist."
)
venv = Venv(venv_dir, verbose=verbose)
old_version = venv.get_venv_metadata_for_package(package).package_version
do_animation = not verbose
try:
with animate(f"upgrading pip for package {package_or_url!r}", do_animation):
venv.upgrade_package("pip", pip_args)
except Exception:
logging.error("Failed to upgrade pip", exc_info=True)
with animate(f"upgrading package {package_or_url!r}", do_animation):
venv.upgrade_package(package_or_url, pip_args)
new_version = venv.get_venv_metadata_for_package(package).package_version
metadata = venv.get_venv_metadata_for_package(package)
_expose_binaries_globally(LOCAL_BIN_DIR, metadata.binary_paths, package)
if include_deps:
for _, binary_paths in metadata.binary_paths_of_dependencies.items():
_expose_binaries_globally(LOCAL_BIN_DIR, binary_paths, package)
if old_version == new_version:
if upgrading_all:
pass
else:
print(
f"{package} is already at latest version {old_version} (location: {str(venv_dir)})"
)
return 0
else:
print(
f"upgraded package {package} from {old_version} to {new_version} (location: {str(venv_dir)})"
)
return 1
def upgrade_all(
pipx_local_venvs: Path, pip_args: List[str], verbose: bool, *, include_deps: bool
):
packages_upgraded = 0
num_packages = 0
for venv_dir in pipx_local_venvs.iterdir():
num_packages += 1
package = venv_dir.name
if package == "pipx":
package_or_url = PIPX_PACKAGE_NAME
else:
package_or_url = package
try:
packages_upgraded += upgrade(
venv_dir,
package,
package_or_url,
pip_args,
verbose,
upgrading_all=True,
include_deps=include_deps,
)
except Exception:
logging.error(f"Error encountered when upgrading {package}")
if packages_upgraded == 0:
print(
f"Versions did not change after running 'pip upgrade' for each package {sleep}"
)
def install(
venv_dir: Path,
package: str,
package_or_url: str,
local_bin_dir: Path,
python: str,
pip_args: List[str],
venv_args: List[str],
verbose: bool,
*,
force: bool,
include_deps: bool,
):
try:
exists = venv_dir.exists() and next(venv_dir.iterdir())
except StopIteration:
exists = False
if exists:
if force:
print(f"Installing to existing directory {str(venv_dir)!r}")
else:
raise PipxError(
f"Not installing to existing directory {str(venv_dir)!r}. "
"Pass '--force' to force installation"
)
venv = Venv(venv_dir, python=python, verbose=verbose)
venv.create_venv(venv_args, pip_args)
try:
venv.install_package(package_or_url, pip_args)
except PipxError:
venv.remove_venv()
raise
if venv.get_venv_metadata_for_package(package).package_version is None:
venv.remove_venv()
raise PipxError(f"Could not find package {package}. Is the name correct?")
_run_post_install_actions(venv, package, local_bin_dir, venv_dir, include_deps)
def _run_post_install_actions(
venv: Venv, package: str, local_bin_dir: Path, venv_dir: Path, include_deps: bool
):
metadata = venv.get_venv_metadata_for_package(package)
if not include_deps and not metadata.binary_paths:
for dep, dependent_binaries in metadata.binary_paths_of_dependencies.items():
print(
f"Note: Dependent package '{dep}' contains {len(dependent_binaries)} binaries"
)
for binary in dependent_binaries:
print(f" - {binary.name}")
venv.remove_venv()
if len(metadata.binary_paths_of_dependencies.keys()):
raise PipxError(
f"No binaries associated with package {package}. "
"Try again with '--include-deps' to include binaries of dependent packages."
)
else:
raise PipxError(f"No binaries associated with package {package}. ")
_expose_binaries_globally(local_bin_dir, metadata.binary_paths, package)
if include_deps:
for _, binary_paths in metadata.binary_paths_of_dependencies.items():
_expose_binaries_globally(local_bin_dir, binary_paths, package)
print(_get_package_summary(venv_dir, package=package, new_install=True))
random_binary_name: str
if metadata.binaries:
random_binary_name = metadata.binaries[0]
else:
random_binary_name = metadata.binaries_of_dependencies[0]
_warn_if_not_on_path(local_bin_dir, random_binary_name)
print(f"done! {stars}")
def _warn_if_not_on_path(local_bin_dir: Path, binary: str):
if not distutils.spawn.find_executable(binary):
logging.warning(
f"{hazard} Note: {str(local_bin_dir)!r} is not on your PATH environment "
"variable. These binaries will not be globally accessible until "
"your PATH is updated. Run `pipx ensurepath` to automatically add it, "
"or manually modify your PATH in your shell's config file (i.e. ~/.bashrc)."
)
def inject(
venv_dir: Path,
package: str,
pip_args: List[str],
*,
verbose: bool,
include_binaries: bool,
include_deps: bool,
):
if not venv_dir.exists() or not next(venv_dir.iterdir()):
raise PipxError(
textwrap.dedent(
f"""\
Can't inject {package!r} into nonexistent Virtual Environment {str(venv_dir)!r}.
Be sure to install the package first with pipx install {venv_dir.name!r}
before injecting into it."""
)
)
venv = Venv(venv_dir, verbose=verbose)
venv.install_package(package, pip_args)
if venv.get_venv_metadata_for_package(package).package_version is None:
raise PipxError(f"Could not find package {package}. Is the name correct?")
if include_binaries:
_run_post_install_actions(venv, package, LOCAL_BIN_DIR, venv_dir, include_deps)
print(f"done! {stars}")
def uninstall(venv_dir: Path, package: str, local_bin_dir: Path, verbose: bool):
if not venv_dir.exists():
print(f"Nothing to uninstall for {package} 😴")
binary = which(package)
if binary:
print(
f"{hazard} Note: '{binary}' still exists on your system and is on your PATH"
)
return
venv = Venv(venv_dir, verbose=verbose)
metadata = venv.get_venv_metadata_for_package(package)
binary_paths = metadata.binary_paths
for dep_paths in metadata.binary_paths_of_dependencies.values():
binary_paths += dep_paths
for file in local_bin_dir.iterdir():
if WINDOWS:
for b in binary_paths:
if file.name == b.name:
file.unlink()
else:
symlink = file
for b in binary_paths:
if symlink.exists() and b.exists() and symlink.samefile(b):
logging.info(f"removing symlink {str(symlink)}")
symlink.unlink()
rmdir(venv_dir)
print(f"uninstalled {package}! {stars}")
def uninstall_all(pipx_local_venvs: Path, local_bin_dir: Path, verbose: bool):
for venv_dir in pipx_local_venvs.iterdir():
package = venv_dir.name
uninstall(venv_dir, package, local_bin_dir, verbose)
def reinstall_all(
pipx_local_venvs: Path,
local_bin_dir: Path,
python: str,
pip_args: List[str],
venv_args: List[str],
verbose: bool,
include_deps: bool,
):
for venv_dir in pipx_local_venvs.iterdir():
package = venv_dir.name
uninstall(venv_dir, package, local_bin_dir, verbose)
package_or_url = package
install(
venv_dir,
package,
package_or_url,
local_bin_dir,
python,
pip_args,
venv_args,
verbose,
force=True,
include_deps=include_deps,
)
def _expose_binaries_globally(
local_bin_dir: Path, binary_paths: List[Path], package: str
):
if WINDOWS:
_copy_package_binaries(local_bin_dir, binary_paths, package)
else:
_symlink_package_binaries(local_bin_dir, binary_paths, package)
def _copy_package_binaries(local_bin_dir: Path, binary_paths: List[Path], package: str):
for src_unresolved in binary_paths:
src = src_unresolved.resolve()
binary = src.name
dest = Path(local_bin_dir / binary)
if not dest.parent.is_dir():
mkdir(dest.parent)
if dest.exists():
logging.warning(f"{hazard} Overwriting file {str(dest)} with {str(src)}")
dest.unlink()
shutil.copy(src, dest)
def _symlink_package_binaries(
local_bin_dir: Path, binary_paths: List[Path], package: str
):
for b in binary_paths:
binary = b.name
symlink_path = Path(local_bin_dir / binary)
if not symlink_path.parent.is_dir():
mkdir(symlink_path.parent)
if symlink_path.exists():
if symlink_path.samefile(b):
pass
else:
logging.warning(
f"{hazard} File exists at {str(symlink_path)} and points "
f"to {symlink_path.resolve()}. Not modifying."
)
else:
shadow = which(binary)
try:
symlink_path.symlink_to(b)
except FileExistsError:
pass
if shadow:
logging.warning(
f"{hazard} Note: {binary} was already on your PATH at " f"{shadow}"
)
def _get_package_summary(
path: Path, *, package: str = None, new_install: bool = False
) -> str:
venv = Venv(path)
python_path = venv.python_path.resolve()
if package is None:
package = path.name
metadata = venv.get_venv_metadata_for_package(package)
if metadata.package_version is None:
not_installed = red("is not installed")
return f" package {bold(package)} {not_installed} in the venv {str(path)}"
binaries = metadata.binaries + metadata.binaries_of_dependencies
exposed_binary_paths = _get_exposed_binary_paths_for_package(
venv.bin_path, binaries, LOCAL_BIN_DIR
)
exposed_binary_names = sorted(p.name for p in exposed_binary_paths)
unavailable_binary_names = sorted(
set(metadata.binaries) - set(exposed_binary_names)
)
return _get_list_output(
metadata.python_version,
python_path,
metadata.package_version,
package,
new_install,
exposed_binary_names,
unavailable_binary_names,
)
def _get_list_output(
python_version: str,
python_path: Path,
package_version: str,
package: str,
new_install: bool,
exposed_binary_names: List[str],
unavailable_binary_names: List[str],
) -> str:
output = []
output.append(
f" {'installed' if new_install else ''} package {bold(shlex.quote(package))} {bold(package_version)}, {python_version}"
)
if not python_path.exists():
output.append(f" associated python path {str(python_path)} does not exist!")
if new_install and exposed_binary_names:
output.append(" These binaries are now globally available")
for name in exposed_binary_names:
output.append(f" - {name}")
for name in unavailable_binary_names:
output.append(f" - {red(name)} (symlink not installed)")
return "\n".join(output)
def list_packages(pipx_local_venvs: Path):
dirs = list(sorted(pipx_local_venvs.iterdir()))
if not dirs:
print(f"nothing has been installed with pipx {sleep}")
return
print(f"venvs are in {bold(str(pipx_local_venvs))}")
print(f"binaries are exposed on your $PATH at {bold(str(LOCAL_BIN_DIR))}")
with multiprocessing.Pool() as p:
for package_summary in p.map(_get_package_summary, dirs):
print(package_summary)
def _get_exposed_binary_paths_for_package(
bin_path: Path, package_binary_names: List[str], local_bin_dir: Path
):
bin_symlinks = set()
for b in local_bin_dir.iterdir():
try:
# sometimes symlinks can resolve to a file of a different name
# (in the case of ansible for example) so checking the resolved paths
# is not a reliable way to determine if the symlink exists.
# windows doesn't use symlinks, so the check is less strict.
if WINDOWS and b.name in package_binary_names:
is_same_file = True
else:
is_same_file = b.resolve().parent.samefile(bin_path)
if is_same_file:
bin_symlinks.add(b)
except FileNotFoundError:
pass
return bin_symlinks
def ensurepath(bin_dir: Path):
shell = os.environ.get("SHELL", "")
config_file: Optional[str]
if "bash" in shell:
config_file = "~/.bashrc"
elif "zsh" in shell:
config_file = "~/.zshrc"
elif "fish" in shell:
config_file = "~/.config/fish/config.fish"
else:
config_file = None
if config_file:
config_file = os.path.expanduser(config_file)
if config_file and os.path.exists(config_file):
with open(config_file, "a") as f:
f.write("\n# added by pipx (https://github.com/pipxproject/pipx)\n")
if "fish" in shell:
f.write(f"set -x PATH {str(bin_dir)} $PATH\n\n")
else:
f.write(f'export PATH="{str(bin_dir)}{os.pathsep}$PATH"\n')
print(f"Added {str(bin_dir)} to the PATH environment variable in {config_file}")
print("")
print(f"Open a new terminal to use pipx {stars}")
else:
if WINDOWS:
print(
textwrap.dedent(
f"""
Note {hazard}:
To finish installation, {str(bin_dir)!r} must be added to your PATH
environment variable.
To do this, go to settings and type "Environment Variables".
In the Environment Variables window edit the PATH variable
by adding the following to the end of the value, then open a new
terminal.
;{str(bin_dir)}
"""
)
)
else:
print(
textwrap.dedent(
f"""
Note:
To finish installation, {str(bin_dir)!r} must be added to your PATH
environemnt variable.
To do this, add the following line to your shell
config file (such as ~/.bashrc if using bash):
export PATH={str(bin_dir)}:$PATH
"""
)
)
pipx-0.12.3.1/pipx/constants.py 0000664 0000000 0000000 00000001024 13435016624 0016263 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from pathlib import Path
DEFAULT_PYTHON = sys.executable
DEFAULT_PIPX_HOME = Path.home() / ".local/pipx"
DEFAULT_PIPX_BIN_DIR = Path.home() / ".local/bin"
PIPX_HOME = Path(os.environ.get("PIPX_HOME", DEFAULT_PIPX_HOME)).resolve()
PIPX_LOCAL_VENVS = PIPX_HOME / "venvs"
LOCAL_BIN_DIR = Path(os.environ.get("PIPX_BIN_DIR", DEFAULT_PIPX_BIN_DIR)).resolve()
PIPX_VENV_CACHEDIR = PIPX_HOME / ".cache"
PIPX_PACKAGE_NAME = "pipx"
TEMP_VENV_EXPIRATION_THRESHOLD_DAYS = 2
pipx-0.12.3.1/pipx/emojies.py 0000664 0000000 0000000 00000000322 13435016624 0015702 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
# -*- coding: utf-8 -*-
from pipx.util import WINDOWS
if WINDOWS:
stars = ""
hazard = ""
sleep = ""
else:
stars = "✨ 🌟 ✨"
hazard = "⚠️"
sleep = "😴"
pipx-0.12.3.1/pipx/main.py 0000664 0000000 0000000 00000040220 13435016624 0015174 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import argparse
import logging
import os
import shlex
import sys
import textwrap
import urllib.parse
from typing import Dict, List, Tuple
from . import commands
from .constants import (
DEFAULT_PYTHON,
LOCAL_BIN_DIR,
DEFAULT_PIPX_HOME,
DEFAULT_PIPX_BIN_DIR,
PIPX_LOCAL_VENVS,
PIPX_VENV_CACHEDIR,
TEMP_VENV_EXPIRATION_THRESHOLD_DAYS,
)
from .util import PipxError, mkdir
__version__ = "0.12.3.1"
def print_version() -> None:
print(__version__)
SPEC_HELP = textwrap.dedent(
"""The package name or specific installation source passed to pip.
Runs `pip install -U SPEC`.
For example `--spec mypackage==2.0.0` or `--spec git+https://github.com/user/repo.git@branch`
"""
)
PIPX_DESCRIPTION = textwrap.dedent(
f"""
Install and execute binaries from Python packages.
Binaries can either be installed globally into isolated Virtual Environments
or run directly in an temporary Virtual Environment.
Virtual Envrionment location is {str(PIPX_LOCAL_VENVS)}.
Symlinks to binaries are placed in {str(LOCAL_BIN_DIR)}.
These locations can be overridden with the environment variables
PIPX_HOME and PIPX_BIN_DIR, respectively. (Virtual Environments will
be installed to $PIPX_HOME/venvs)
"""
)
INSTALL_DESCRIPTION = f"""
The install command is the preferred way to globally install binaries
from python packages on your system. It creates an isolated virtual
environment for the package, then ensures the package's binaries are
accessible on your $PATH.
The result: binaries you can run from anywhere, located in packages
you can cleanly upgrade or uninstall. Guaranteed to not have
dependency version conflicts or interfere with your OS's python
packages. 'sudo' is not required to do this.
pipx install PACKAGE
pipx install --python PYTHON PACKAGE
pipx install --spec VCS_URL PACKAGE
pipx install --spec ZIP_FILE PACKAGE
pipx install --spec TAR_GZ_FILE PACKAGE
The argument to `--spec` is passed directly to `pip install`.
The default virtual environment location is {DEFAULT_PIPX_HOME}
and can be overridden by setting the environment variable `PIPX_HOME`
(Virtual Environments will be installed to `$PIPX_HOME/venvs`).
The default binary location is {DEFAULT_PIPX_BIN_DIR} and can be
overridden by setting the environment variable `PIPX_BIN_DIR`.
"""
class LineWrapRawTextHelpFormatter(argparse.RawDescriptionHelpFormatter):
def _split_lines(self, text, width):
text = self._whitespace_matcher.sub(" ", text).strip()
return textwrap.wrap(text, width)
def get_pip_args(parsed_args: Dict):
pip_args: List[str] = []
if parsed_args.get("index_url"):
pip_args += ["--index-url", parsed_args["index_url"]]
if parsed_args.get("editable"):
pip_args += ["--editable"]
if parsed_args.get("pip_args"):
pip_args += shlex.split(parsed_args.get("pip_args", ""))
return pip_args
def get_venv_args(parsed_args: Dict):
venv_args: List[str] = []
if parsed_args.get("system_site_packages"):
venv_args += ["--system-site-packages"]
return venv_args
def run_pipx_command(args, binary_args: List[str]):
setup(args)
verbose = args.verbose if "verbose" in args else False
pip_args = get_pip_args(vars(args))
venv_args = get_venv_args(vars(args))
if "package" in args:
package = args.package
if urllib.parse.urlparse(package).scheme:
raise PipxError("Package cannot be a url")
if "spec" in args and args.spec is not None:
if urllib.parse.urlparse(args.spec).scheme:
if "#egg=" not in args.spec:
args.spec = args.spec + f"#egg={package}"
venv_dir = PIPX_LOCAL_VENVS / package
logging.info(f"Virtual Environment location is {venv_dir}")
if args.command == "run":
package_or_url = (
args.spec if ("spec" in args and args.spec is not None) else args.binary
)
use_cache = not args.no_cache
return commands.run(
args.binary,
package_or_url,
binary_args,
args.python,
pip_args,
venv_args,
args.pypackages,
verbose,
use_cache,
)
elif args.command == "install":
package_or_url = (
args.spec if ("spec" in args and args.spec is not None) else package
)
commands.install(
venv_dir,
package,
package_or_url,
LOCAL_BIN_DIR,
args.python,
pip_args,
venv_args,
verbose,
force=args.force,
include_deps=args.include_deps,
)
elif args.command == "inject":
if not args.include_binaries and args.include_deps:
raise PipxError(
"Cannot pass --include-deps if --use_binaries is not passed as well"
)
for dep in args.dependencies:
commands.inject(
venv_dir,
dep,
pip_args,
verbose=verbose,
include_binaries=args.include_binaries,
include_deps=args.include_deps,
)
elif args.command == "upgrade":
package_or_url = (
args.spec if ("spec" in args and args.spec is not None) else package
)
commands.upgrade(
venv_dir,
package,
package_or_url,
pip_args,
verbose,
upgrading_all=False,
include_deps=args.include_deps,
)
elif args.command == "list":
commands.list_packages(PIPX_LOCAL_VENVS)
elif args.command == "uninstall":
commands.uninstall(venv_dir, package, LOCAL_BIN_DIR, verbose)
elif args.command == "uninstall-all":
commands.uninstall_all(PIPX_LOCAL_VENVS, LOCAL_BIN_DIR, verbose)
elif args.command == "upgrade-all":
commands.upgrade_all(
PIPX_LOCAL_VENVS, pip_args, verbose, include_deps=args.include_deps
)
elif args.command == "reinstall-all":
commands.reinstall_all(
PIPX_LOCAL_VENVS,
LOCAL_BIN_DIR,
args.python,
pip_args,
venv_args,
verbose,
args.include_deps,
)
elif args.command == "ensurepath":
paths = os.getenv("PATH", "").split(os.pathsep)
path_good = str(LOCAL_BIN_DIR) in paths
if not path_good or args.force:
commands.ensurepath(LOCAL_BIN_DIR)
else:
print(
"Your PATH looks like it already is set up for pipx. Pass `--force` to modify the PATH."
)
else:
raise PipxError(f"Unknown command {args.command}")
def add_pip_venv_args(parser):
parser.add_argument(
"--system-site-packages",
action="store_true",
help="Give the virtual environment access to the system site-packages dir.",
)
parser.add_argument("--index-url", "-i", help="Base URL of Python Package Index")
parser.add_argument(
"--editable",
"-e",
help="Install a project in editable mode",
action="store_true",
)
parser.add_argument(
"--pip-args",
help="Arbitrary pip arguments to pass directly to pip install/upgrade commands",
)
def add_include_deps(parser):
parser.add_argument(
"--include-deps",
help="Include binaries of dependent packages",
action="store_true",
)
def get_command_parser():
parser = argparse.ArgumentParser(
formatter_class=LineWrapRawTextHelpFormatter, description=PIPX_DESCRIPTION
)
subparsers = parser.add_subparsers(
dest="command", description="Get help for commands with pipx COMMAND --help"
)
p = subparsers.add_parser(
"install",
help="Install a package",
formatter_class=LineWrapRawTextHelpFormatter,
description=INSTALL_DESCRIPTION,
)
p.add_argument("package", help="package name")
p.add_argument("--spec", help=SPEC_HELP)
add_include_deps(p)
p.add_argument("--verbose", action="store_true")
p.add_argument(
"--force",
action="store_true",
help="Install even when the package has already been installed",
)
p.add_argument(
"--python",
default=DEFAULT_PYTHON,
help=(
"The Python executable used to create the Virtual Environment and run the "
"associated binary/binaries. Must be v3.3+."
),
)
add_pip_venv_args(p)
p = subparsers.add_parser(
"inject",
help="Install packages into an existing Virtual Environment",
description="Installs packages to an existing pipx-managed virtual environment.",
)
p.add_argument(
"package",
help="Name of the existing pipx-managed Virtual Environment to inject into",
)
p.add_argument(
"dependencies",
nargs="+",
help="the packages to inject into the Virtual Environment",
)
p.add_argument(
"--include-binaries",
action="store_true",
help="Add binaries from the injected packages onto your PATH",
)
add_include_deps(p)
add_pip_venv_args(p)
p.add_argument("--verbose", action="store_true")
p = subparsers.add_parser(
"upgrade",
help="Upgrade a package",
description="Upgrade a package in a pipx-managed Virtual Environment by running 'pip install --upgrade PACKAGE'",
)
p.add_argument("package")
p.add_argument("--spec", help=SPEC_HELP)
add_include_deps(p)
add_pip_venv_args(p)
p.add_argument("--verbose", action="store_true")
p = subparsers.add_parser(
"upgrade-all",
help="Upgrade all packages. "
"Runs `pip install -U &q* ɓ#c+w3mÈ1т %Ļ<6
n= cna++Y0<։g*V?=Diٳ;+rԻ{RPFCql5F[FfA +DobT R B6І $&Lr`͂ni>̓ =O>-"TQ 4sQFS D҇ e2PG4Qc5JPM5(Q"!@ttVZ褈&p\ ڰøӜ25HĬuYf$RhK041&mA
Yr,2`@'RM ;cŢ3L,l3&ҿ^-L+`߬0肫b;xceղxdK6dSVye[vecyfkfsy&yz蕷}JGVze複ezjuZjT0ꪻzL6°oqijv[>7N߶n*oO.mp3 6q#b &r%|s;sC}tK7tSW}u[wuc}vkvs}w{w~x7xW~ywy裗~zz~{{vH rhwe N4(yA%P;cʁz0aP<9vRZ(|rD$E`PpP2 A ,^hX} Fn G* 4H xE bEłtQ_¦D 0$ĈBjE8F (C$Ћ8,)ģ^ h@ (l >?iH$wR*o#PlALH^ #QW/ TaqjהAV -wG-Z< ;bLKd&q fFV5yMlfSf7Mp_4IzȡX%\ ;ѩNDA儧8w?" ,L9~)D h>q30XKjhJ I8Ϣ&hK) pdM KFqÓ٫ d@jKJ@
f
.'1.(DA;9HQTejDA>$ F-`Ԃd 3}Jl)5"X%-o]*NQ(ᣣP+a@GլV:NO4ҺTQC6ze0X
ZO8[06gYA!h Q(6b E8*#pb fp\%# @Gw .R>7 ]y{܂"}Sd;NEp; Q6QQC eopKv Cůq>tad[(m,΄Ba'~< 7 kTȊ" GH/BѾx#؉D
*`_ NDh *V 裏(A>7G#'EF` I> 6@xOr )9˅h>sDyBKܲΠjn ؊Rf`Ų1&OK#@ƨ );'.um.EVC" pG:$^;0u. WwF30Vw(a Hp/]m5 ]b/{{EHpW/-6) n/m(Jԓ֒ I!qIq 0PKe+w"ܞH^ $ohNH$!繞qsUN~!7%"Q }hnWnV/ςFb)1,ňX֞}4 M`
|7E̼|2zQ,, (y
=g7~7ġf(rbP 4x_ ~A!LMjmh4~R5=L>g+ r\7\vR E@ߋ}89|\0q oEvA{2X92;cp{;{Cp#?|s? ~@y՚93AqA;9
!x"8&A '8 xӋ&AB[B*Ԉ8 W+B,B0 C1 C2,C3 @B:DZFzHJLڤNPR:TZVzXZ\ڥ^`bʀHpGf
ejjizozGl0vzxz|ڧ~:Zzڨ*r9 쨩 'bcH/ٓ a 7_0º8:}b g , g%)fsG`2{" &6L (B >'υe5ZOq&! lx]1a+PDMZ.Ԡ`qĞyfB^Zָεw^%lq \'T#;HZ44"U/>hWh}!,vPؒ%B!?`"$@ #I%j]ެ`ois 4CT CCk!
HbFLGED5~X H*4ZLsH@xR Ш f 0F-V.u+'0+dӓ=EUI7Y\lk h\̈́q34 v䋡w ӠٴE=T 8݂f?n l|x=Rm$\uG
"# F`ҽH~qv x`r&3}`B7ҝtk9# :iT<#'W9jX@!] O ; >/zӫ^gWvOySF>~4}ܗ7?s?0
e=-GPPDU$ +r
@ `%
DDF
2#!;2 %"#LC/ Bm\%1CEDLA#6H
#`DcT MGPdG`HVO$U]JbDF\E5OknNprDGtGyFK(EHHtm]DD B
"#W
)WΔKJ Py>{q@ bTOK Lng`LRrLɴL'ĉ8K w KK0M ˰OMRHR 5NQFQOFUOuOEMMUPZPP&O 2I %!W.6 < x H`偲 qn97g% y
"*ǐ`ST!V C ;s ia S
QUjTsbJMUUWUAuXLjd%dVmWiVRHoUWV,dfHF
(@!!x & rFz n%HKuZKI q9nu ZbZ\Y\(Y6ܕ[)[Ǔ_ \T\ G\e8^6]ny!l]dT]ݕ_]\U#`Bp = Ən$ I R:0(Ͱ,&y"#9!aN@aXI 6 v` a0a&V
ЛG)sH bad!d[+W.] 0c5HnWЉD?AfVCd GҹM+d&vPt"ePGϸb49R$Qg g3 ) xzG
FbFZvivh r %j.c& /JbYX3$p-p:1;:kƠADZFzHJflSg iA Z
q i) 2PHL
'rt _= @1p nsq C
]:i lp M7?#_z㰔Њ"r$ FGq u
n cPb1iSbs 1s61 Q9S8rBCP$?tY ? < *7S(3sZFXz
W '& HW:$@
X@N 7|њ|3' |y@ E `@%` = =@G@vc`)$N0&*"WPW9 0;0${0C
l iNyq *҃& C"'P W9ꠗϘ4ϐseJSez0L#~;$ e3TK(8Jѳ.G H
'+b `3x h+_Lbn
YB !@Pd(/7ṖplD
Zd } J9M*P2AZ7u@
{+( 9zСS#L[U4pWP`@I@Y_őZF4ouNc=j? 8i`3 |1 Nva1Q+nU?a9! E?'tRbZ0 f9 "ZE$# k_uY>oSW# IS
v:I*2 vISJHΰ<2EMw"D6tH Y$W)Ǡ\ara ׃JXN\IUQf g/5SFT^>Tp۩E@cP$§(0Zp ( a+pdSP89zj$Z* .3T)iyr Z` ya:2 $Dfq l@Q#H +L 5*զ6#q iAq
"=$]&}0=b `=R '#:(+J `8j`!"R61y{ӯP !2[p
;GW۷dR]&U 0ta+7P3{ȹTpg}+;$ q Sp 61|L/[0 r"U6z
jl oq˭yM1#ʴ 9@ӣ]+ӜgZ|M
}ȝʽ}V-V1o#
Anm+5G`}
n})Npv+ ̶ⵯ~}N@ ! , {
+,+0//444;::KKKTTSZZZaaakkkttt||| $qe;Xv.3]$I8=- @!a*Ò8
J r` *#HD" &($#
k B#
2 6 Sn16'
" f(?@L 0F/ 2"m{J 0* ! ! ,% {
/0/555@@@NNNgfgwww||| v UQQXemyau%F1 jQH4a1CT,>@*8pLDAUm #>C? R?C"e '9u$&C'<^{Bt*! ! ,, { "!"***444<<<@AAHHHTTTYYXnmnsss{z{ s vgFbm1^ڙ. h0LP,
Z*Q:^Ѹn0
HPA@/mBD( /.
;50 , >1( 9[.9.! ! ,3 { )))444;;;CCCRRR___bcbonosst $MפNe;꺕U5:YRvIb#
M*7$ R0\ʅ8e[51Se0d p@idx";8*K#h.>+"\3=EA*
Wc)G#'1*! ! ,A {
###)))545@@@JJJTST___jjkstt||{ l @4UU$EF5 GTEplT&7!0
&IJh( jE\bM,GH#h
Mi+(]՛Ei.j>jNj^jmj.jj6VQT5( k`9SŹ֡tUruF}TWfk3\Jf @ HXz?m* ؑ<Juռ\숯LKϦDˌiH\]˥SxS5+>=5Vs>6RܾL[bZEL:nNIǔ-a9`rgrRL*_ L0O_&m4Nc(a&9Hac!baT'hBAM>BaDM VdoBC/ yR6C
KE%5U^?vNd1~<FNq Idg5]qf>2(eQ\ggTn.[>FFSg'G_Kmie0,)O*7h1'j>Ns8s9s:s;s
