def add_package(key: str, dist: Distribution | None) -> Package:
name, extras = strip_extras(key)
extras = extras or ()
reqs: dict[str, Requirement] = {}
if dist:
requirements = (parse_requirement(r)
for r in filter_requirements_with_extras(
dist.requires or [], extras))
for req in requirements:
if not req.marker or req.marker.evaluate(marker_env):
reqs[req.identify()] = req
version: str | None = dist.version
else:
version = None
node = Package(key, version, reqs)
if node not in graph:
if extras:
node_with_extras.add(name)
graph.add(node)
for k in reqs:
child = add_package(k, working_set.get(strip_extras(k)[0]))
graph.connect(node, child)
return node
def _get_dependencies_from_json(self,
candidate: Candidate) -> CandidateInfo:
if not candidate.name or not candidate.version:
# Only look for json api for named requirements.
raise CandidateInfoNotFound(candidate)
sources = self.get_filtered_sources(candidate.req)
url_prefixes = [
proc_url[:-7] # Strip "/simple".
for proc_url in (raw_url.rstrip("/")
for raw_url in (source.get("url", "")
for source in sources))
if proc_url.endswith("/simple")
]
with self.environment.get_finder(sources) as finder:
session = finder.session
for prefix in url_prefixes:
json_url = f"{prefix}/pypi/{candidate.name}/{candidate.version}/json"
resp = session.get(json_url)
if not resp.ok:
continue
info = resp.json()["info"]
requires_python = info["requires_python"] or ""
summary = info["summary"] or ""
try:
requirement_lines = info["requires_dist"] or []
except KeyError:
requirement_lines = info["requires"] or []
requirements = filter_requirements_with_extras(
requirement_lines, candidate.req.extras or ())
return requirements, requires_python, summary
raise CandidateInfoNotFound(candidate)
def get_dependencies_from_metadata(self) -> list[str]:
"""Get the dependencies of a candidate from metadata."""
extras = self.req.extras or ()
metadata = self.get_metadata()
if self.req.editable:
if not metadata:
return []
return get_requirements_from_dist(self.ireq.get_dist(), extras)
elif hasattr(metadata, "install_requires"):
requires = metadata.install_requires or [] # type: ignore
extras_not_found = set()
for extra in extras:
try:
requires.extend(
(metadata.extras_require or {})[extra] # type: ignore
)
except KeyError:
extras_not_found.add(extra)
if extras_not_found:
warnings.warn(ExtrasError(sorted(extras_not_found)))
return sorted(set(requires))
else:
return filter_requirements_with_extras(
metadata.run_requires, extras # type: ignore
)
def get_dependencies_from_metadata(self) -> list[str]:
"""Get the dependencies of a candidate from metadata."""
extras = self.req.extras or ()
return filter_requirements_with_extras(
self.metadata.requires or [],
extras # type: ignore
)
def _get_dependencies_from_fixture(
self, candidate: Candidate
) -> Tuple[List[str], str, str]:
try:
pypi_data = self._pypi_data[candidate.req.key][candidate.version]
except KeyError:
raise CandidateInfoNotFound(candidate)
deps = pypi_data.get("dependencies", [])
deps = filter_requirements_with_extras(deps, candidate.req.extras or ())
return deps, pypi_data.get("requires_python", ""), ""
def get_dependencies_from_metadata(self) -> List[str]:
"""Get the dependencies of a candidate from metadata."""
extras = self.req.extras or ()
metadata = self.get_metadata()
if self.req.editable:
if not metadata:
return []
return get_requirements_from_dist(self.ireq.get_dist(), extras)
else:
return filter_requirements_with_extras(metadata.run_requires, extras)
def test_project_with_combined_extras(fixture_project):
project = fixture_project("demo-combined-extras")
(project.root / "build").mkdir(exist_ok=True)
with cd(project.root.as_posix()):
wheel_name = build_wheel(str(project.root / "build"))
wheel = distlib.wheel.Wheel(str(project.root / "build" / wheel_name))
all_requires = filter_requirements_with_extras(wheel.metadata.run_requires,
("all", ))
for dep in ("urllib3", "chardet", "idna"):
assert dep in all_requires
def get_dependencies_from_metadata(self) -> List[str]:
"""Get the dependencies of a candidate from metadata."""
extras = self.req.extras or ()
metadata = self.get_metadata()
if self.req.editable:
if not metadata:
return []
return get_requirements_from_dist(self.ireq.get_dist(), extras)
elif getattr(metadata, "install_requires", None):
requires = metadata.install_requires
for extra in extras:
requires.extend(metadata.extras_require.get(extra, []))
return sorted(set(requires))
else:
return filter_requirements_with_extras(metadata.run_requires, extras)
