def do_sync(
project: Project,
sections: Sequence[str] = (),
dev: bool = False,
default: bool = True,
dry_run: bool = False,
clean: Optional[bool] = None,
) -> None:
"""Synchronize project
:param project: The project instance.
:param sections: A tuple of optional sections to be synced.
:param dev: whether to include dev-dependecies.
:param default: whether to include default dependencies.
:param dry_run: Print actions without actually running them.
:param clean: whether to remove unneeded packages.
"""
if not project.lockfile_file.exists():
raise ProjectError("Lock file does not exist, nothing to sync.")
clean = default if clean is None else clean
candidates = {}
for section in sections:
candidates.update(project.get_locked_candidates(section))
if dev:
candidates.update(project.get_locked_candidates("dev"))
if default:
candidates.update(project.get_locked_candidates())
handler = Synchronizer(candidates, project.environment)
handler.synchronize(clean=clean, dry_run=dry_run)
def do_sync(
project: Project,
sections: Sequence[str] = (),
dev: bool = False,
default: bool = True,
dry_run: bool = False,
clean: Optional[bool] = None,
tracked_names: Optional[Sequence[str]] = None,
) -> None:
"""Synchronize project"""
if not project.lockfile_file.exists():
raise ProjectError("Lock file does not exist, nothing to sync")
clean = default if clean is None else clean
if tracked_names and dry_run:
candidates = {
name: c
for name, c in project.get_locked_candidates("__all__").items()
if name in tracked_names
}
else:
candidates = {}
sections = translate_sections(project, default, dev, sections or ())
valid_sections = list(project.iter_sections())
for section in sections:
if section not in valid_sections:
raise PdmUsageError(
f"Section {termui.green(repr(section))} doesn't exist "
"in the pyproject.toml")
candidates.update(project.get_locked_candidates(section))
handler = project.core.synchronizer_class(candidates, project.environment,
clean, dry_run)
handler.synchronize()
def handle(self, project: Project, options: argparse.Namespace) -> None:
candidates = []
if options.pyproject:
options.hashes = False
if options.default:
# Don't include self candidate
if options.pyproject:
temp = project.dependencies
else:
temp = project.get_locked_candidates()
temp.pop(project.meta.name, None)
candidates.extend(temp.values())
if options.dev:
if options.pyproject:
candidates.extend(project.dev_dependencies.values())
else:
candidates.extend(project.get_locked_candidates("dev").values())
for section in options.sections:
if options.pyproject:
candidates.extend(project.get_dependencies(section).values())
else:
candidates.extend(project.get_locked_candidates(section).values())
content = FORMATS[options.format].export(project, candidates, options)
if options.output:
Path(options.output).write_text(content)
else:
stream.echo(content)
def handle(self, project: Project, options: argparse.Namespace) -> None:
candidates = {}
sections = list(options.sections)
if options.pyproject:
options.hashes = False
if not sections and options.dev:
sections.append(":all")
if ":all" in sections:
if options.dev:
sections = list(
project.tool_settings.get("dev-dependencies", []))
else:
sections = list(project.meta.optional_dependencies or [])
if options.default:
sections.append("default")
for section in sections:
if options.pyproject:
candidates.update(project.get_dependencies(section))
else:
candidates.update(project.get_locked_candidates(section))
candidates.pop(project.meta.name and project.meta.project_name, None)
content = FORMATS[options.format].export(project, candidates.values(),
options)
if options.output:
Path(options.output).write_text(content)
else:
project.core.ui.echo(content)
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
def handle(self, project: Project, options: argparse.Namespace) -> None:
candidates = {}
sections = list(options.sections)
if options.pyproject:
options.hashes = False
sections = translate_sections(
project,
options.default,
compatible_dev_flag(project, options.dev),
options.sections or (),
)
for section in sections:
if options.pyproject:
candidates.update(project.get_dependencies(section))
else:
candidates.update(project.get_locked_candidates(section))
candidates.pop(project.meta.name and project.meta.project_name, None)
content = FORMATS[options.format].export(project, candidates.values(), options)
if options.output:
Path(options.output).write_text(content)
else:
project.core.ui.echo(content)
