def resolve_requirements(
repository,
lines,
requires_python="",
allow_prereleases=None,
strategy="all",
preferred_pins=None,
tracked_names=None,
):
requirements = []
for line in lines:
if line.startswith("-e "):
requirements.append(parse_requirement(line[3:], True))
else:
requirements.append(parse_requirement(line))
requires_python = PySpecSet(requires_python)
if not preferred_pins:
provider = BaseProvider(repository, requires_python, allow_prereleases)
else:
provider_class = (ReusePinProvider
if strategy == "reuse" else EagerUpdateProvider)
provider = provider_class(
preferred_pins,
tracked_names or (),
repository,
requires_python,
allow_prereleases,
)
ui = termui.UI()
with ui.open_spinner("Resolving dependencies") as spin, ui.logging("lock"):
reporter = SpinnerReporter(spin, requirements)
resolver = Resolver(provider, reporter)
mapping, *_ = resolve(resolver, requirements, requires_python)
return mapping
def resolve_func(
lines,
requires_python="",
allow_prereleases=None,
strategy="all",
tracked_names=None,
):
repository.environment.python_requires = PySpecSet(requires_python)
if allow_prereleases is not None:
project.tool_settings["allow_prereleases"] = allow_prereleases
requirements = []
for line in lines:
if line.startswith("-e "):
requirements.append(parse_requirement(line[3:], True))
else:
requirements.append(parse_requirement(line))
provider = project.get_provider(strategy, tracked_names)
ui = project.core.ui
with ui.open_spinner("Resolving dependencies") as spin, ui.logging(
"lock"):
reporter = SpinnerReporter(spin, requirements)
resolver = Resolver(provider, reporter)
mapping, *_ = _resolve(resolver, requirements,
repository.environment.python_requires)
return mapping
def get_reporter(
self,
requirements: Dict[str, Dict[str, Requirement]],
tracked_names: Optional[Iterable[str]] = None,
spinner: Optional[halo.Halo] = None,
) -> SpinnerReporter:
"""Return the reporter object to construct a resolver.
:param requirements: requirements to resolve
:param tracked_names: the names of packages that needs to update
:param spinner: optional spinner object
:returns: a reporter
"""
return SpinnerReporter(spinner)
def get_reporter(
self,
requirements: List[Requirement],
tracked_names: Optional[Iterable[str]] = None,
spinner: Optional[halo.Halo] = None,
) -> BaseReporter:
"""Return the reporter object to construct a resolver.
:param requirements: requirements to resolve
:param tracked_names: the names of packages that needs to update
:param spinner: optional spinner object
:returns: a reporter
"""
from pdm.resolver.reporters import SpinnerReporter
return SpinnerReporter(spinner, requirements)
def do_lock(
project: Project,
strategy: str = "all",
tracked_names: Optional[Iterable[str]] = None,
requirements: Optional[Dict[str, Dict[str, Requirement]]] = None,
) -> Dict[str, Candidate]:
"""Performs the locking process and update lockfile.
:param project: the project instance
:param strategy: update stratege: reuse/eager/all
:param tracked_names: required when using eager strategy
:param requirements: An optional dictionary of requirements, read from pyproject
if not given.
"""
check_project_file(project)
# TODO: multiple dependency definitions for the same package.
repository = project.get_repository()
requirements = requirements or project.all_dependencies
allow_prereleases = project.allow_prereleases
requires_python = project.python_requires
if strategy == "all":
provider = BaseProvider(repository, requires_python, allow_prereleases)
else:
provider_class = (ReusePinProvider
if strategy == "reuse" else EagerUpdateProvider)
preferred_pins = project.get_locked_candidates("__all__")
provider = provider_class(
preferred_pins,
tracked_names or (),
repository,
requires_python,
allow_prereleases,
)
flat_reqs = list(
itertools.chain(*[deps.values() for _, deps in requirements.items()]))
# TODO: switch reporter at io level.
with halo.Halo(text="Resolving dependencies", spinner="dots") as spin:
reporter = SpinnerReporter(flat_reqs, spin)
mapping, dependencies, summaries = resolve(provider, reporter,
requirements,
requires_python)
data = format_lockfile(mapping, dependencies, summaries)
spin.succeed("Resolution success")
project.write_lockfile(data)
return mapping