def actually_resolve_deps(
deps,
index_lookup,
markers_lookup,
project,
sources,
clear,
pre,
req_dir=None,
):
from pipenv.vendor.vistir.path import create_tracked_tempdir
if not req_dir:
req_dir = create_tracked_tempdir(suffix="-requirements",
prefix="pipenv-")
constraints = get_resolver_metadata(
deps,
index_lookup,
markers_lookup,
project,
sources,
)
resolver = Resolver(constraints,
req_dir,
project,
sources,
clear=clear,
pre=pre)
resolved_tree = resolver.resolve()
hashes = resolver.resolve_hashes()
return (resolved_tree, hashes, markers_lookup, resolver)
def actually_resolve_deps(
deps,
index_lookup,
markers_lookup,
project,
sources,
clear,
pre,
req_dir=None,
):
from .patched.notpip._internal import basecommand
from .patched.notpip._internal.req import parse_requirements
from .patched.notpip._internal.exceptions import DistributionNotFound
from .patched.notpip._vendor.requests.exceptions import HTTPError
from pipenv.patched.piptools.resolver import Resolver
from pipenv.patched.piptools.repositories.pypi import PyPIRepository
from pipenv.patched.piptools.scripts.compile import get_pip_command
from pipenv.patched.piptools import logging as piptools_logging
from pipenv.patched.piptools.exceptions import NoCandidateFound
from .vendor.requirementslib.models.requirements import Requirement
from ._compat import TemporaryDirectory, NamedTemporaryFile
class PipCommand(basecommand.Command):
"""Needed for pip-tools."""
name = "PipCommand"
constraints = []
cleanup_req_dir = False
if not req_dir:
req_dir = TemporaryDirectory(suffix="-requirements", prefix="pipenv-")
cleanup_req_dir = True
for dep in deps:
if not dep:
continue
url = None
indexes, trusted_hosts, remainder = parse_indexes(dep)
if indexes:
url = indexes[0]
dep = " ".join(remainder)
req = Requirement.from_line(dep)
# extra_constraints = []
if url:
index_lookup[req.name] = project.get_source(url=url).get("name")
# strip the marker and re-add it later after resolution
# but we will need a fallback in case resolution fails
# eg pypiwin32
if req.markers:
markers_lookup[req.name] = req.markers.replace('"', "'")
constraints.append(req.constraint_line)
pip_command = get_pip_command()
constraints_file = None
pip_args = []
if sources:
pip_args = prepare_pip_source_args(sources, pip_args)
if environments.is_verbose():
print("Using pip: {0}".format(" ".join(pip_args)))
with NamedTemporaryFile(
mode="w",
prefix="pipenv-",
suffix="-constraints.txt",
dir=req_dir.name,
delete=False,
) as f:
if sources:
requirementstxt_sources = " ".join(pip_args) if pip_args else ""
requirementstxt_sources = requirementstxt_sources.replace(
" --", "\n--")
f.write(u"{0}\n".format(requirementstxt_sources))
f.write(u"\n".join([_constraint for _constraint in constraints]))
constraints_file = f.name
pip_options, _ = pip_command.parser.parse_args(pip_args)
pip_options.cache_dir = environments.PIPENV_CACHE_DIR
session = pip_command._build_session(pip_options)
pypi = PyPIRepository(pip_options=pip_options,
use_json=False,
session=session)
constraints = parse_requirements(constraints_file,
finder=pypi.finder,
session=pypi.session,
options=pip_options)
constraints = [c for c in constraints]
if environments.is_verbose():
logging.log.verbose = True
piptools_logging.log.verbose = True
resolved_tree = set()
resolver = Resolver(constraints=constraints,
repository=pypi,
clear_caches=clear,
prereleases=pre)
# pre-resolve instead of iterating to avoid asking pypi for hashes of editable packages
hashes = None
try:
results = resolver.resolve(max_rounds=environments.PIPENV_MAX_ROUNDS)
hashes = resolver.resolve_hashes(results)
resolved_tree.update(results)
except (NoCandidateFound, DistributionNotFound, HTTPError) as e:
click_echo(
"{0}: Your dependencies could not be resolved. You likely have a "
"mismatch in your sub-dependencies.\n "
"First try clearing your dependency cache with {1}, then try the original command again.\n "
"Alternatively, you can use {2} to bypass this mechanism, then run "
"{3} to inspect the situation.\n "
"Hint: try {4} if it is a pre-release dependency."
"".format(
crayons.red("Warning", bold=True),
crayons.red("$ pipenv lock --clear"),
crayons.red("$ pipenv install --skip-lock"),
crayons.red("$ pipenv graph"),
crayons.red("$ pipenv lock --pre"),
),
err=True,
)
click_echo(crayons.blue(str(e)), err=True)
if "no version found at all" in str(e):
click_echo(
crayons.blue(
"Please check your version specifier and version number. See PEP440 for more information."
))
if cleanup_req_dir:
req_dir.cleanup()
raise RuntimeError
if cleanup_req_dir:
req_dir.cleanup()
return (resolved_tree, hashes, markers_lookup, resolver)
def actually_resolve_deps(
deps,
index_lookup,
markers_lookup,
project,
sources,
verbose,
clear,
pre,
req_dir=None,
):
from .vendor.packaging.markers import default_environment
from .patched.notpip._internal import basecommand
from .patched.notpip._internal.cmdoptions import no_binary, only_binary
from .patched.notpip._internal.req import parse_requirements
from .patched.notpip._internal.exceptions import DistributionNotFound
from .patched.notpip._vendor.requests.exceptions import HTTPError
from pipenv.patched.piptools.resolver import Resolver
from pipenv.patched.piptools.repositories.pypi import PyPIRepository
from pipenv.patched.piptools.scripts.compile import get_pip_command
from pipenv.patched.piptools import logging as piptools_logging
from pipenv.patched.piptools.exceptions import NoCandidateFound
from .vendor.requirementslib import Requirement
from ._compat import TemporaryDirectory, NamedTemporaryFile
class PipCommand(basecommand.Command):
"""Needed for pip-tools."""
name = "PipCommand"
constraints = []
cleanup_req_dir = False
if not req_dir:
req_dir = TemporaryDirectory(suffix="-requirements", prefix="pipenv-")
cleanup_req_dir = True
for dep in deps:
if not dep:
continue
url = None
if " -i " in dep:
dep, url = dep.split(" -i ")
req = Requirement.from_line(dep)
# extra_constraints = []
if url:
index_lookup[req.name] = project.get_source(url=url).get("name")
# strip the marker and re-add it later after resolution
# but we will need a fallback in case resolution fails
# eg pypiwin32
if req.markers:
markers_lookup[req.name] = req.markers.replace('"', "'")
constraints.append(req.constraint_line)
pip_command = get_pip_command()
constraints_file = None
pip_args = []
if sources:
pip_args = prepare_pip_source_args(sources, pip_args)
if verbose:
print("Using pip: {0}".format(" ".join(pip_args)))
with NamedTemporaryFile(
mode="w",
prefix="pipenv-",
suffix="-constraints.txt",
dir=req_dir.name,
delete=False,
) as f:
if sources:
requirementstxt_sources = " ".join(pip_args) if pip_args else ""
requirementstxt_sources = requirementstxt_sources.replace(" --", "\n--")
f.write(u"{0}\n".format(requirementstxt_sources))
f.write(u"\n".join([_constraint for _constraint in constraints]))
constraints_file = f.name
pip_options, _ = pip_command.parser.parse_args(pip_args)
pip_options.cache_dir = PIPENV_CACHE_DIR
session = pip_command._build_session(pip_options)
pypi = PyPIRepository(pip_options=pip_options, use_json=False, session=session)
constraints = parse_requirements(
constraints_file, finder=pypi.finder, session=pypi.session, options=pip_options
)
constraints = [c for c in constraints]
if verbose:
logging.log.verbose = True
piptools_logging.log.verbose = True
resolved_tree = set()
resolver = Resolver(
constraints=constraints, repository=pypi, clear_caches=clear, prereleases=pre
)
# pre-resolve instead of iterating to avoid asking pypi for hashes of editable packages
hashes = None
try:
results = resolver.resolve(max_rounds=PIPENV_MAX_ROUNDS)
hashes = resolver.resolve_hashes(results)
resolved_tree.update(results)
except (NoCandidateFound, DistributionNotFound, HTTPError) as e:
click_echo(
"{0}: Your dependencies could not be resolved. You likely have a "
"mismatch in your sub-dependencies.\n "
"You can use {1} to bypass this mechanism, then run {2} to inspect "
"the situation.\n "
"Hint: try {3} if it is a pre-release dependency."
"".format(
crayons.red("Warning", bold=True),
crayons.red("$ pipenv install --skip-lock"),
crayons.red("$ pipenv graph"),
crayons.red("$ pipenv lock --pre"),
),
err=True,
)
click_echo(crayons.blue(str(e)), err=True)
if "no version found at all" in str(e):
click_echo(
crayons.blue(
"Please check your version specifier and version number. See PEP440 for more information."
)
)
if cleanup_req_dir:
req_dir.cleanup()
raise RuntimeError
if cleanup_req_dir:
req_dir.cleanup()
return (resolved_tree, hashes, markers_lookup, resolver)
def actually_resolve_deps(deps,
index_lookup,
markers_lookup,
project,
sources,
verbose,
clear,
pre,
req_dir=None):
from .vendor.packaging.markers import default_environment
from .patched.notpip._internal import basecommand
from .patched.notpip._internal.cmdoptions import no_binary, only_binary
from .patched.notpip._internal.req import parse_requirements
from .patched.notpip._internal.exceptions import DistributionNotFound
from .patched.notpip._vendor.requests.exceptions import HTTPError
from pipenv.patched.piptools.resolver import Resolver
from pipenv.patched.piptools.repositories.pypi import PyPIRepository
from pipenv.patched.piptools.scripts.compile import get_pip_command
from pipenv.patched.piptools import logging as piptools_logging
from pipenv.patched.piptools.exceptions import NoCandidateFound
from .vendor.requirementslib import Requirement
from ._compat import TemporaryDirectory, NamedTemporaryFile
class PipCommand(basecommand.Command):
"""Needed for pip-tools."""
name = 'PipCommand'
constraints = []
cleanup_req_dir = False
if not req_dir:
req_dir = TemporaryDirectory(suffix='-requirements', prefix='pipenv-')
cleanup_req_dir = True
for dep in deps:
if not dep:
continue
url = None
if ' -i ' in dep:
dep, url = dep.split(' -i ')
req = Requirement.from_line(dep)
# extra_constraints = []
if url:
index_lookup[req.name] = project.get_source(url=url).get('name')
# strip the marker and re-add it later after resolution
# but we will need a fallback in case resolution fails
# eg pypiwin32
if req.markers:
markers_lookup[req.name] = req.markers.replace('"', "'")
constraints.append(req.constraint_line)
pip_command = get_pip_command()
constraints_file = None
pip_args = []
if sources:
pip_args = prepare_pip_source_args(sources, pip_args)
if verbose:
print('Using pip: {0}'.format(' '.join(pip_args)))
with NamedTemporaryFile(mode='w',
prefix='pipenv-',
suffix='-constraints.txt',
dir=req_dir.name,
delete=False) as f:
if sources:
requirementstxt_sources = ' '.join(pip_args) if pip_args else ''
requirementstxt_sources = requirementstxt_sources.replace(
' --', '\n--')
f.write(u'{0}\n'.format(requirementstxt_sources))
f.write(u'\n'.join([_constraint for _constraint in constraints]))
constraints_file = f.name
pip_options, _ = pip_command.parser.parse_args(pip_args)
pip_options.cache_dir = PIPENV_CACHE_DIR
session = pip_command._build_session(pip_options)
pypi = PyPIRepository(pip_options=pip_options,
use_json=False,
session=session)
constraints = parse_requirements(constraints_file,
finder=pypi.finder,
session=pypi.session,
options=pip_options)
constraints = [c for c in constraints]
if verbose:
logging.log.verbose = True
piptools_logging.log.verbose = True
resolved_tree = set()
resolver = Resolver(constraints=constraints,
repository=pypi,
clear_caches=clear,
prereleases=pre)
# pre-resolve instead of iterating to avoid asking pypi for hashes of editable packages
hashes = None
try:
results = resolver.resolve(max_rounds=PIPENV_MAX_ROUNDS)
hashes = resolver.resolve_hashes(results)
resolved_tree.update(results)
except (NoCandidateFound, DistributionNotFound, HTTPError) as e:
click_echo(
'{0}: Your dependencies could not be resolved. You likely have a '
'mismatch in your sub-dependencies.\n '
'You can use {1} to bypass this mechanism, then run {2} to inspect '
'the situation.\n '
'Hint: try {3} if it is a pre-release dependency.'
''.format(
crayons.red('Warning', bold=True),
crayons.red('$ pipenv install --skip-lock'),
crayons.red('$ pipenv graph'),
crayons.red('$ pipenv lock --pre'),
),
err=True,
)
click_echo(crayons.blue(str(e)), err=True)
if 'no version found at all' in str(e):
click_echo(
crayons.blue(
'Please check your version specifier and version number. See PEP440 for more information.'
))
if cleanup_req_dir:
req_dir.cleanup()
raise RuntimeError
if cleanup_req_dir:
req_dir.cleanup()
return (resolved_tree, hashes, markers_lookup, resolver)
def actually_resolve_deps(
deps,
index_lookup,
markers_lookup,
project,
sources,
clear,
pre,
req_dir=None,
):
from .vendor.pip_shims.shims import (
Command, parse_requirements, DistributionNotFound
)
from .vendor.requests.exceptions import HTTPError
from pipenv.patched.piptools.resolver import Resolver
from pipenv.patched.piptools.repositories.pypi import PyPIRepository
from pipenv.patched.piptools.scripts.compile import get_pip_command
from pipenv.patched.piptools import logging as piptools_logging
from pipenv.patched.piptools.exceptions import NoCandidateFound
from .vendor.requirementslib.models.requirements import Requirement
from .vendor.vistir.path import (
create_tracked_tempdir, create_tracked_tempfile, url_to_path,
)
from .vendor.vistir.compat import Path, to_native_string
class PipCommand(Command):
"""Needed for pip-tools."""
name = "PipCommand"
constraints = []
needs_hash = []
if not req_dir:
req_dir = create_tracked_tempdir(suffix="-requirements", prefix="pipenv-")
for dep in deps:
if not dep:
continue
url = None
indexes, trusted_hosts, remainder = parse_indexes(dep)
if indexes:
url = indexes[0]
dep = " ".join(remainder)
req = Requirement.from_line(dep)
new_ireq = req.as_ireq()
if getattr(new_ireq, "link", None) and new_ireq.link.is_wheel and new_ireq.link.scheme == 'file':
needs_hash.append(new_ireq)
# extra_constraints = []
if url:
index_lookup[req.name] = project.get_source(url=url).get("name")
# strip the marker and re-add it later after resolution
# but we will need a fallback in case resolution fails
# eg pypiwin32
if req.markers:
markers_lookup[req.name] = req.markers.replace('"', "'")
constraints.append(req.constraint_line)
pip_command = get_pip_command()
constraints_file = None
pip_args = []
if sources:
pip_args = prepare_pip_source_args(sources, pip_args)
if environments.is_verbose():
click_echo(crayons.blue("Using pip: {0}".format(" ".join(pip_args))), err=True)
constraints_file = create_tracked_tempfile(
mode="w",
prefix="pipenv-",
suffix="-constraints.txt",
dir=req_dir,
delete=False,
)
if sources:
requirementstxt_sources = " ".join(pip_args) if pip_args else ""
requirementstxt_sources = requirementstxt_sources.replace(" --", "\n--")
constraints_file.write(u"{0}\n".format(requirementstxt_sources))
constraints_file.write(u"\n".join([_constraint for _constraint in constraints]))
constraints_file.close()
pip_options, _ = pip_command.parser.parse_args(pip_args)
pip_options.cache_dir = environments.PIPENV_CACHE_DIR
session = pip_command._build_session(pip_options)
pypi = PyPIRepository(pip_options=pip_options, use_json=False, session=session)
constraints = parse_requirements(
constraints_file.name, finder=pypi.finder, session=pypi.session, options=pip_options
)
constraints = [c for c in constraints]
if environments.is_verbose():
logging.log.verbose = True
piptools_logging.log.verbose = True
resolved_tree = set()
resolver = Resolver(
constraints=constraints, repository=pypi, clear_caches=clear, prereleases=pre
)
# pre-resolve instead of iterating to avoid asking pypi for hashes of editable packages
hashes = {
ireq: pypi._hash_cache.get_hash(ireq.link)
for ireq in constraints if (getattr(ireq, "link", None)
# We can only hash artifacts, but we don't want normal pypi artifcats since the
# normal resolver handles those
and ireq.link.is_artifact and not (is_pypi_url(ireq.link.url) or
# We also don't want to try to hash directories as this will fail (editable deps)
(ireq.link.scheme == "file" and Path(to_native_string(url_to_path(ireq.link.url))).is_dir())))
}
try:
results = resolver.resolve(max_rounds=environments.PIPENV_MAX_ROUNDS)
resolved_tree.update(results)
except (NoCandidateFound, DistributionNotFound, HTTPError) as e:
click_echo(
"{0}: Your dependencies could not be resolved. You likely have a "
"mismatch in your sub-dependencies.\n "
"First try clearing your dependency cache with {1}, then try the original command again.\n "
"Alternatively, you can use {2} to bypass this mechanism, then run "
"{3} to inspect the situation.\n "
"Hint: try {4} if it is a pre-release dependency."
"".format(
crayons.red("Warning", bold=True),
crayons.red("$ pipenv lock --clear"),
crayons.red("$ pipenv install --skip-lock"),
crayons.red("$ pipenv graph"),
crayons.red("$ pipenv lock --pre"),
),
err=True,
)
click_echo(crayons.blue(str(e)), err=True)
if "no version found at all" in str(e):
click_echo(
crayons.blue(
"Please check your version specifier and version number. See PEP440 for more information."
), err=True
)
raise RuntimeError
else:
resolved_hashes = resolver.resolve_hashes(results)
for ireq, ireq_hashes in resolved_hashes.items():
if ireq not in hashes:
hashes[ireq] = ireq_hashes
return (resolved_tree, hashes, markers_lookup, resolver)