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)