def parse_requirements(
filename, session, finder=None, options=None, constraint=False, isolated=False
):
for parsed_req in _parse_requirements(
filename, session, finder=finder, options=options, constraint=constraint
):
yield install_req_from_parsed_requirement(parsed_req, isolated=isolated)
def run(self, options, args):
session = self.get_default_session(options)
reqs_to_uninstall = {}
for name in args:
req = install_req_from_line(
name,
isolated=options.isolated_mode,
)
if req.name:
reqs_to_uninstall[canonicalize_name(req.name)] = req
for filename in options.requirements:
for parsed_req in parse_requirements(filename,
options=options,
session=session):
req = install_req_from_parsed_requirement(
parsed_req, isolated=options.isolated_mode)
if req.name:
reqs_to_uninstall[canonicalize_name(req.name)] = req
if not reqs_to_uninstall:
raise InstallationError(
'You must give at least one requirement to {self.name} (see '
'"pip help {self.name}")'.format(**locals()))
protect_pip_from_modification_on_windows(
modifying_pip="pip" in reqs_to_uninstall)
for req in reqs_to_uninstall.values():
uninstall_pathset = req.uninstall(
auto_confirm=options.yes,
verbose=self.verbosity > 0,
)
if uninstall_pathset:
uninstall_pathset.commit()
def parse_requirements(requirement_file):
requirements = []
for req in pip_parse_requirements(requirement_file, session=PipSession()):
install_req = install_req_from_parsed_requirement(req)
if install_req.markers and not pkg_resources.evaluate_marker(str(install_req.markers)):
continue
requirements.append(pkg_resources.Requirement.parse(str(install_req.req)))
return requirements
def parse_requirement_file(filename):
from pip._internal.req.constructors import install_req_from_parsed_requirement
finder = get_finder([])
ireqs = [
install_req_from_parsed_requirement(pr)
for pr in parse_requirements(filename, finder.session, finder)
]
return ireqs, finder
def parse_requirements(
filename: str,
session: PipSession,
finder: Optional[PackageFinder] = None,
options: Optional[optparse.Values] = None,
constraint: bool = False,
isolated: bool = False,
) -> Iterator[InstallRequirement]:
for parsed_req in _parse_requirements(
filename, session, finder=finder, options=options, constraint=constraint
):
yield install_req_from_parsed_requirement(parsed_req, isolated=isolated)
def parse_requirements(requirement_file):
requirements = []
for req in pip_parse_requirements(requirement_file, session=PipSession()):
install_req = install_req_from_parsed_requirement(req)
if install_req.markers and not pkg_resources.evaluate_marker(
str(install_req.markers)):
# req should not installed due to env markers
continue
elif install_req.editable:
# skip editable req as they are failing in the resolve phase
continue
requirements.append(
pkg_resources.Requirement.parse(str(install_req.req)))
return requirements
def get_processed_req_from_line(line, fname='file', lineno=1):
line_parser = get_line_parser(None)
args_str, opts = line_parser(line)
parsed_line = ParsedLine(
fname,
lineno,
args_str,
opts,
False,
)
parsed_req = handle_requirement_line(parsed_line)
assert parsed_req is not None
req = install_req_from_parsed_requirement(parsed_req)
req.user_supplied = True
return req
def as_tuple(preq):
"""
Pulls out the (name: str, version:str, extras:(str)) tuple from
the pinned ParsedRequirement.
"""
req = install_req_from_parsed_requirement(preq)
if not is_pinned_requirement(req, preq.is_editable):
raise TypeError((
"Expected a pinned requirement, got {}, "
"either pre-compile the requirements, or set compile=True in pip_import"
).format(req))
name = req.name
version = next(iter(req.specifier._specs))._spec[1]
extras = tuple(sorted(req.extras))
return name, version, extras
def run(self, options: Values, args: List[str]) -> int:
session = self.get_default_session(options)
reqs_to_uninstall = {}
for name in args:
req = install_req_from_line(
name,
isolated=options.isolated_mode,
)
if req.name:
reqs_to_uninstall[canonicalize_name(req.name)] = req
else:
logger.warning(
"Invalid requirement: %r ignored -"
" the uninstall command expects named"
" requirements.",
name,
)
for filename in options.requirements:
for parsed_req in parse_requirements(
filename, options=options, session=session
):
req = install_req_from_parsed_requirement(
parsed_req, isolated=options.isolated_mode
)
if req.name:
reqs_to_uninstall[canonicalize_name(req.name)] = req
if not reqs_to_uninstall:
raise InstallationError(
f"You must give at least one requirement to {self.name} (see "
f'"pip help {self.name}")'
)
protect_pip_from_modification_on_windows(
modifying_pip="pip" in reqs_to_uninstall
)
for req in reqs_to_uninstall.values():
uninstall_pathset = req.uninstall(
auto_confirm=options.yes,
verbose=self.verbosity > 0,
)
if uninstall_pathset:
uninstall_pathset.commit()
if options.warn_about_root_user:
warn_if_run_as_root()
return SUCCESS
def parse_requirements(directory):
# Parse the requirements.txt
requirement_packages = []
requirement_files = glob.glob(os.path.join(directory, '*.txt')) \
+ glob.glob(os.path.join(directory, '**', '*.txt'))
pip_compile_files = glob.glob(os.path.join(directory, '*.in')) \
+ glob.glob(os.path.join(directory, '**', '*.in'))
def version_from_install_req(install_req):
if install_req.is_pinned:
return next(iter(install_req.specifier)).version
for reqs_file in requirement_files + pip_compile_files:
try:
requirements = pip._internal.req.req_file.parse_requirements(
reqs_file, session=PipSession())
for parsed_req in requirements:
install_req = install_req_from_parsed_requirement(parsed_req)
if install_req.original_link:
continue
pattern = r"-[cr] (.*) \(line \d+\)"
abs_path = re.search(pattern, install_req.comes_from).group(1)
rel_path = os.path.relpath(abs_path, directory)
requirement_packages.append({
"name":
install_req.req.name,
"version":
version_from_install_req(install_req),
"markers":
str(install_req.markers) or None,
"file":
rel_path,
"requirement":
str(install_req.specifier) or None,
"extras":
sorted(list(install_req.extras))
})
except Exception as e:
print(json.dumps({"error": repr(e)}))
exit(1)
return json.dumps({"result": requirement_packages})
def parse_reqfile(
filename,
session,
finder=None,
options=None,
constraint=False,
isolated=False,
):
# Wrap parse_requirements/install_req_from_parsed_requirement to
# avoid having to write the same chunk of code in lots of tests.
for parsed_req in parse_requirements(
filename, session, finder=finder,
options=options, constraint=constraint,
):
yield install_req_from_parsed_requirement(
parsed_req,
isolated=isolated
)
def parse_reqfile(
filename: Union[Path, str],
session: PipSession,
finder: PackageFinder = None,
options: Values = None,
constraint: bool = False,
isolated: bool = False,
) -> Iterator[InstallRequirement]:
# Wrap parse_requirements/install_req_from_parsed_requirement to
# avoid having to write the same chunk of code in lots of tests.
for parsed_req in parse_requirements(
os.fspath(filename),
session,
finder=finder,
options=options,
constraint=constraint,
):
yield install_req_from_parsed_requirement(parsed_req,
isolated=isolated)
def merge_requirements(files):
requirements = defaultdict(lambda: Requirement())
links = set()
for filename in files:
f_requirements = parse_requirements(str(filename),
session=PipSession())
for parsed_requirement in f_requirements:
requirement = install_req_from_parsed_requirement(
parsed_requirement)
if requirement.markers and not requirement.markers.evaluate():
continue
if not hasattr(requirement.req, 'name'):
links.add(requirement.link.url)
break
name = requirement.req.name
specifiers = requirement.req.specifier
extras = requirement.req.extras
requirements[name].extras |= set(extras)
requirements[name].specifiers |= set(specifiers)
if requirement.link:
requirements[name].links |= {requirement.link.url}
requirements[name].editable |= requirement.editable
result = []
for key, value in requirements.items():
if value.links:
result.append("%s" % value.links.pop())
elif not value.extras:
result.append("%s %s" %
(key, ",".join(map(str, value.specifiers))))
else:
result.append("%s [%s] %s" % (key, ",".join(map(
str, value.extras)), ",".join(map(str, value.specifiers))))
for link in links:
result.append(link)
return "\n".join(result)
def get_requirements(
self,
args: List[str],
options: Values,
finder: PackageFinder,
session: PipSession,
) -> List[InstallRequirement]:
"""
Parse command-line arguments into the corresponding requirements.
"""
requirements: List[InstallRequirement] = []
for filename in options.constraints:
for parsed_req in parse_requirements(
filename,
constraint=True,
finder=finder,
options=options,
session=session,
):
req_to_add = install_req_from_parsed_requirement(
parsed_req,
isolated=options.isolated_mode,
user_supplied=False,
)
requirements.append(req_to_add)
for req in args:
req_to_add = install_req_from_line(
req,
None,
isolated=options.isolated_mode,
use_pep517=options.use_pep517,
user_supplied=True,
)
requirements.append(req_to_add)
for req in options.editables:
req_to_add = install_req_from_editable(
req,
user_supplied=True,
isolated=options.isolated_mode,
use_pep517=options.use_pep517,
)
requirements.append(req_to_add)
# NOTE: options.require_hashes may be set if --require-hashes is True
for filename in options.requirements:
for parsed_req in parse_requirements(
filename, finder=finder, options=options, session=session
):
req_to_add = install_req_from_parsed_requirement(
parsed_req,
isolated=options.isolated_mode,
use_pep517=options.use_pep517,
user_supplied=True,
)
requirements.append(req_to_add)
# If any requirement has hash options, enable hash checking.
if any(req.has_hash_options for req in requirements):
options.require_hashes = True
if not (args or options.editables or options.requirements):
opts = {"name": self.name}
if options.find_links:
raise CommandError(
"You must give at least one requirement to {name} "
'(maybe you meant "pip {name} {links}"?)'.format(
**dict(opts, links=" ".join(options.find_links))
)
)
else:
raise CommandError(
"You must give at least one requirement to {name} "
'(see "pip help {name}")'.format(**opts)
)
return requirements
finder, # type: PackageFinder
session, # type: PipSession
):
# type: (...) -> List[InstallRequirement]
"""
Parse command-line arguments into the corresponding requirements.
"""
requirements = [] # type: List[InstallRequirement]
for filename in options.constraints:
for parsed_req in parse_requirements(
filename,
constraint=True, finder=finder, options=options,
session=session):
req_to_add = install_req_from_parsed_requirement(
parsed_req,
isolated=options.isolated_mode,
user_supplied=False,
)
requirements.append(req_to_add)
for req in args:
req_to_add = install_req_from_line(
req, None, isolated=options.isolated_mode,
use_pep517=options.use_pep517,
user_supplied=True,
)
requirements.append(req_to_add)
for req in options.editables:
req_to_add = install_req_from_editable(
req,
def get_requirements(
self,
args, # type: List[str]
options, # type: Values
finder, # type: PackageFinder
session, # type: PipSession
check_supported_wheels=True, # type: bool
):
# type: (...) -> List[InstallRequirement]
"""
Parse command-line arguments into the corresponding requirements.
"""
requirement_set = RequirementSet(
check_supported_wheels=check_supported_wheels)
for filename in options.constraints:
for parsed_req in parse_requirements(filename,
constraint=True,
finder=finder,
options=options,
session=session):
req_to_add = install_req_from_parsed_requirement(
parsed_req,
isolated=options.isolated_mode,
)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
for req in args:
req_to_add = install_req_from_line(
req,
None,
isolated=options.isolated_mode,
use_pep517=options.use_pep517,
)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
for req in options.editables:
req_to_add = install_req_from_editable(
req,
isolated=options.isolated_mode,
use_pep517=options.use_pep517,
)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
# NOTE: options.require_hashes may be set if --require-hashes is True
for filename in options.requirements:
for parsed_req in parse_requirements(filename,
finder=finder,
options=options,
session=session):
req_to_add = install_req_from_parsed_requirement(
parsed_req,
isolated=options.isolated_mode,
use_pep517=options.use_pep517)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
# If any requirement has hash options, enable hash checking.
requirements = requirement_set.all_requirements
if any(req.has_hash_options for req in requirements):
options.require_hashes = True
if not (args or options.editables or options.requirements):
opts = {'name': self.name}
if options.find_links:
raise CommandError(
'You must give at least one requirement to {name} '
'(maybe you meant "pip {name} {links}"?)'.format(
**dict(opts, links=' '.join(options.find_links))))
else:
raise CommandError(
'You must give at least one requirement to {name} '
'(see "pip help {name}")'.format(**opts))
return requirements
def parse_install_requirements(
requirements_lock: str) -> List[InstallRequirement]:
return [
constructors.install_req_from_parsed_requirement(pr)
for pr in parse_requirements(requirements_lock, session=PipSession())
]
Parse command-line arguments into the corresponding requirements.
"""
<<<<<<< HEAD
requirements = [] # type: List[InstallRequirement]
=======
requirement_set = RequirementSet(
check_supported_wheels=check_supported_wheels
)
>>>>>>> b66a76afa15ab74019740676a52a071b85ed8f71
for filename in options.constraints:
for parsed_req in parse_requirements(
filename,
constraint=True, finder=finder, options=options,
session=session):
req_to_add = install_req_from_parsed_requirement(
parsed_req,
isolated=options.isolated_mode,
<<<<<<< HEAD
user_supplied=False,
)
requirements.append(req_to_add)
=======
)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
>>>>>>> b66a76afa15ab74019740676a52a071b85ed8f71
for req in args:
req_to_add = install_req_from_line(
req, None, isolated=options.isolated_mode,
use_pep517=options.use_pep517,
