def test_expand_env_variables():
with temp_environ():
os.environ["FOO"] = "foo"
assert expand_env_variables("echo ${FOO} ${BAR}") == "echo foo ${BAR}"
assert expand_env_variables("echo %FOO%") == "echo %FOO%"
assert expand_env_variables("echo $FOO") == "echo $FOO"
def get_dependencies_from_index(dep,
sources=None,
pip_options=None,
wheel_cache=None):
"""Retrieves dependencies for the given install requirement from the pip resolver.
:param dep: A single InstallRequirement
:type dep: :class:`~pip._internal.req.req_install.InstallRequirement`
:param sources: Pipfile-formatted sources, defaults to None
:type sources: list[dict], optional
:return: A set of dependency lines for generating new InstallRequirements.
:rtype: set(str) or None
"""
session, finder = get_finder(sources=sources, pip_options=pip_options)
if not wheel_cache:
wheel_cache = WHEEL_CACHE
dep.is_direct = True
requirements = None
setup_requires = {}
with temp_environ():
os.environ["PIP_EXISTS_ACTION"] = "i"
if dep.editable and not dep.prepared and not dep.req:
setup_info = SetupInfo.from_ireq(dep)
results = setup_info.get_info()
setup_requires.update(results["setup_requires"])
requirements = set(results["requires"].values())
else:
results = pip_shims.shims.resolve(dep)
requirements = [v for v in results.values() if v.name != dep.name]
requirements = set([format_requirement(r) for r in requirements])
if not dep.editable and is_pinned_requirement(
dep) and requirements is not None:
DEPENDENCY_CACHE[dep] = list(requirements)
return requirements
def __init__(self, src_path):
# Grab current terminal dimensions to replace the hardcoded default
# dimensions of pexpect.
self.src_path = src_path
dims = get_terminal_size()
name, executable = get_shell()
self.reset_buffer()
with temp_environ():
self.c = pexpect.spawn(executable, ["-i"],
dimensions=(dims.lines, dims.columns))
# Handler for terminal resizing events
# Must be defined here to have the shell process in its context, since
# we can't pass it as an argument
def sigwinch_passthrough(sig, data):
dims = get_terminal_size()
self.c.setwinsize(dims.lines, dims.columns)
signal.signal(signal.SIGWINCH, sigwinch_passthrough)
# Interact with the new shell.
self.c.interact(
escape_character=None,
input_filter=self.in_intercept,
)
self.c.close()
sys.exit(self.c.exitstatus)
def activate(self):
"""Activate the environment. Manipulate the ``PYTHONPATH`` and patches ``pip``
to be aware of local packages. This method acts like a context manager.
"""
paths = self.get_paths()
with temp_environ():
old_paths = os.getenv("PYTHONPATH")
if old_paths:
new_paths = os.pathsep.join([paths["purelib"], old_paths])
else:
new_paths = paths["purelib"]
os.environ["PYTHONPATH"] = new_paths
python_root = os.path.dirname(self.python_executable)
os.environ["PATH"] = os.pathsep.join(
[python_root, paths["scripts"], os.environ["PATH"]])
working_set = self.get_working_set()
_old_ws = pkg_resources.working_set
pkg_resources.working_set = working_set.pkg_ws
# HACK: Replace the is_local with environment version so that packages can
# be removed correctly.
_old_sitepackages = misc.site_packages
_is_local = misc.is_local
_evaluate_marker = pkg_resources.evaluate_marker
pkg_resources.evaluate_marker = self.evaluate_marker
misc.is_local = req_uninstall.is_local = self.is_local
misc.site_packages = paths["purelib"]
yield
misc.is_local = req_uninstall.is_local = _is_local
pkg_resources.working_set = _old_ws
pkg_resources.evaluate_marker = _evaluate_marker
misc.site_packages = _old_sitepackages
def test_lockfile(tmpdir):
with temp_environ():
os.environ["PIPENV_CACHE_DIR"] = tmpdir.strpath
lockfile = Lockfile.create(".")
requires = lockfile.as_requirements(dev=False)
assert requires == []
requires = lockfile.as_requirements(dev=True)
assert any(req.startswith("attrs") for req in requires)
def test_lockfile(tmpdir):
with temp_environ():
os.environ['PIPENV_CACHE_DIR'] = tmpdir.strpath
from requirementslib import Lockfile
lockfile = Lockfile.create('.')
requires = lockfile.as_requirements(dev=False)
assert requires == []
requires = lockfile.as_requirements(dev=True)
assert any(req.startswith("attrs") for req in requires)
def PipenvInstance():
with temp_environ():
original_umask = os.umask(0o007)
os.environ["PIPENV_NOSPIN"] = fs_str("1")
os.environ["CI"] = fs_str("1")
os.environ['PIPENV_DONT_USE_PYENV'] = fs_str('1')
warnings.simplefilter("ignore", category=ResourceWarning)
warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*<ssl.SSLSocket.*>")
try:
yield _PipenvInstance
finally:
os.umask(original_umask)
def PipenvInstance(monkeypatch):
with temp_environ(), monkeypatch.context() as m:
m.setattr(shutil, "rmtree", _rmtree_func)
original_umask = os.umask(0o007)
os.environ["PIPENV_NOSPIN"] = fs_str("1")
os.environ["CI"] = fs_str("1")
os.environ['PIPENV_DONT_USE_PYENV'] = fs_str('1')
warnings.simplefilter("ignore", category=ResourceWarning)
warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*<ssl.SSLSocket.*>")
try:
yield _PipenvInstance
finally:
os.umask(original_umask)
def test_vcs_requirement_with_env_vars():
with temp_environ():
os.environ["GIT_URL"] = "github.com"
r = Requirement.from_pipfile("click", {
"git": "https://${GIT_URL}/pallets/click.git",
"ref": "6.7"
})
assert (r.as_ireq().link.url_without_fragment ==
"git+https://github.com/pallets/[email protected]")
assert r.as_line(
) == "git+https://${GIT_URL}/pallets/[email protected]#egg=click"
assert r.as_pipfile(
)["click"]["git"] == "https://${GIT_URL}/pallets/click.git"
assert r.commit_hash == "df0e37dd890d36fc997986ae6d2b6c255f3ed1dc"
def test_config_env_var_shadowing(project, invoke):
with temp_environ():
os.environ["PDM_PYPI_URL"] = "https://example.org/simple"
result = invoke(["config", "get", "pypi.url"], obj=project)
assert result.output.strip() == "https://example.org/simple"
result = invoke(
["config", "set", "pypi.url", "https://testpypi.org/pypi"],
obj=project)
assert "config is shadowed by env var 'PDM_PYPI_URL'" in result.output
result = invoke(["config", "get", "pypi.url"], obj=project)
assert result.output.strip() == "https://example.org/simple"
del os.environ["PDM_PYPI_URL"]
result = invoke(["config", "get", "pypi.url"], obj=project)
assert result.output.strip() == "https://testpypi.org/pypi"
def test_remote_requirement_with_env_vars():
with temp_environ():
os.environ["USERNAME"] = "******"
os.environ["PASSWORD"] = "******"
r = Requirement.from_line(
"https://${USERNAME}:${PASSWORD}@codeload.github.com/jazzband/tablib/zip/v0.12.1#egg=tablib"
)
assert (
r.as_ireq().link.url_without_fragment ==
"https://*****:*****@codeload.github.com/jazzband/tablib/zip/v0.12.1")
assert (
r.as_line() ==
"https://${USERNAME}:${PASSWORD}@codeload.github.com/jazzband/tablib/zip/v0.12.1#egg=tablib"
)
assert (
r.as_pipfile()["tablib"]["file"] ==
"https://${USERNAME}:${PASSWORD}@codeload.github.com/jazzband/tablib/zip/v0.12.1"
)
def get_dependencies_from_index(dep,
sources=None,
pip_options=None,
wheel_cache=None):
"""Retrieves dependencies for the given install requirement from the pip resolver.
:param dep: A single InstallRequirement
:type dep: :class:`~pip._internal.req.req_install.InstallRequirement`
:param sources: Pipfile-formatted sources, defaults to None
:type sources: list[dict], optional
:return: A set of dependency lines for generating new InstallRequirements.
:rtype: set(str) or None
"""
finder = get_finder(sources=sources, pip_options=pip_options)
if not wheel_cache:
wheel_cache = WHEEL_CACHE
dep.is_direct = True
reqset = RequirementSet()
reqset.add_requirement(dep)
requirements = None
setup_requires = {}
with temp_environ(), start_resolver(finder=finder,
wheel_cache=wheel_cache) as resolver:
os.environ['PIP_EXISTS_ACTION'] = 'i'
dist = None
if dep.editable and not dep.prepared and not dep.req:
with cd(dep.setup_py_dir):
from setuptools.dist import distutils
try:
dist = distutils.core.run_setup(dep.setup_py)
except (ImportError, TypeError, AttributeError):
dist = None
else:
setup_requires[dist.get_name()] = dist.setup_requires
if not dist:
try:
dist = dep.get_dist()
except (TypeError, ValueError, AttributeError):
pass
else:
setup_requires[dist.get_name()] = dist.setup_requires
resolver.require_hashes = False
try:
results = resolver._resolve_one(reqset, dep)
except Exception:
# FIXME: Needs to bubble the exception somehow to the user.
results = []
finally:
try:
wheel_cache.cleanup()
except AttributeError:
pass
resolver_requires_python = getattr(resolver, "requires_python", None)
requires_python = getattr(reqset, "requires_python",
resolver_requires_python)
if requires_python:
add_marker = fix_requires_python_marker(requires_python)
reqset.remove(dep)
if dep.req.marker:
dep.req.marker._markers.extend([
'and',
].extend(add_marker._markers))
else:
dep.req.marker = add_marker
reqset.add(dep)
requirements = set()
for r in results:
if requires_python:
if r.req.marker:
r.req.marker._markers.extend([
'and',
].extend(add_marker._markers))
else:
r.req.marker = add_marker
requirements.add(format_requirement(r))
for section in setup_requires:
python_version = section
not_python = not is_python(section)
# This is for cleaning up :extras: formatted markers
# by adding them to the results of the resolver
# since any such extra would have been returned as a result anyway
for value in setup_requires[section]:
# This is a marker.
if is_python(section):
python_version = value[1:-1]
else:
not_python = True
if ':' not in value and not_python:
try:
requirement_str = "{0}{1}".format(
value, python_version).replace(":", ";")
requirements.add(
format_requirement(
make_install_requirement(
requirement_str).ireq))
# Anything could go wrong here -- can't be too careful.
except Exception:
pass
if not dep.editable and is_pinned_requirement(
dep) and requirements is not None:
DEPENDENCY_CACHE[dep] = list(requirements)
return requirements
def virtualenv(vistir_tmpdir):
with temp_environ(), VirtualEnv(base_dir=vistir_tmpdir) as venv:
yield venv
