def _populate_lockfile_repo(self, repo: LockfileRepository,
ops: Sequence[Operation]) -> None:
for op in ops:
if isinstance(op, Uninstall):
continue
elif isinstance(op, Update):
package = op.target_package
else:
package = op.package
if not repo.has_package(package):
repo.add_package(package)
def _do_refresh(self) -> int:
from poetry.puzzle.solver import Solver
# Checking extras
for extra in self._extras:
if extra not in self._package.extras:
raise ValueError(f"Extra [{extra}] is not specified.")
locked_repository = self._locker.locked_repository()
solver = Solver(
self._package,
self._pool,
locked_repository.packages,
locked_repository.packages,
self._io,
)
with solver.provider.use_source_root(
source_root=self._env.path.joinpath("src")):
ops = solver.solve(use_latest=[]).calculate_operations()
lockfile_repo = LockfileRepository()
self._populate_lockfile_repo(lockfile_repo, ops)
self._write_lock_file(lockfile_repo, force=True)
return 0
def test_has_package():
repo = LockfileRepository()
url_package = Package("a",
"1.0",
source_type="url",
source_url="https://example.org/a.whl")
assert not repo.has_package(url_package)
repo.add_package(url_package)
pypi_package = Package("a", "1.0")
assert not repo.has_package(pypi_package)
repo.add_package(pypi_package)
url_package_2 = Package("a",
"1.0",
source_type="url",
source_url="https://example.org/a-1.whl")
assert not repo.has_package(url_package_2)
repo.add_package(url_package_2)
assert len(repo.packages) == 3
assert repo.has_package(deepcopy(url_package))
assert repo.has_package(deepcopy(pypi_package))
assert repo.has_package(deepcopy(url_package_2))
def test_remove_package():
url_package = Package("a",
"1.0",
source_type="url",
source_url="https://example.org/a.whl")
pypi_package = Package("a", "1.0")
url_package_2 = Package("a",
"1.0",
source_type="url",
source_url="https://example.org/a-1.whl")
repo = LockfileRepository()
repo.add_package(url_package)
repo.add_package(pypi_package)
repo.add_package(url_package_2)
assert len(repo.packages) == 3
repo.remove_package(deepcopy(pypi_package))
assert len(repo.packages) == 2
repo.remove_package(pypi_package)
assert len(repo.packages) == 2
repo.remove_package(deepcopy(url_package_2))
assert len(repo.packages) == 1
assert repo.packages[0] == url_package
repo.remove_package(url_package_2)
assert len(repo.packages) == 1
def _do_install(self) -> int:
from poetry.puzzle.solver import Solver
locked_repository = Repository("poetry-locked")
if self._update:
if self._locker.is_locked() and not self._lock:
locked_repository = self._locker.locked_repository()
# If no packages have been whitelisted (The ones we want to update),
# we whitelist every package in the lock file.
if not self._whitelist:
for pkg in locked_repository.packages:
self._whitelist.append(pkg.name)
# Checking extras
for extra in self._extras:
if extra not in self._package.extras:
raise ValueError(f"Extra [{extra}] is not specified.")
self._io.write_line("<info>Updating dependencies</>")
solver = Solver(
self._package,
self._pool,
self._installed_repository.packages,
locked_repository.packages,
self._io,
)
with solver.provider.use_source_root(
source_root=self._env.path.joinpath("src")):
ops = solver.solve(
use_latest=self._whitelist).calculate_operations()
else:
self._io.write_line(
"<info>Installing dependencies from lock file</>")
locked_repository = self._locker.locked_repository()
if not self._locker.is_fresh():
self._io.write_error_line(
"<warning>"
"Warning: poetry.lock is not consistent with pyproject.toml. "
"You may be getting improper dependencies. "
"Run `poetry lock [--no-update]` to fix it."
"</warning>")
for extra in self._extras:
if extra not in self._locker.lock_data.get("extras", {}):
raise ValueError(f"Extra [{extra}] is not specified.")
# If we are installing from lock
# Filter the operations by comparing it with what is
# currently installed
ops = self._get_operations_from_lock(locked_repository)
lockfile_repo = LockfileRepository()
self._populate_lockfile_repo(lockfile_repo, ops)
if self._update:
self._write_lock_file(lockfile_repo)
if self._lock:
# If we are only in lock mode, no need to go any further
return 0
if self._groups is not None:
root = self._package.with_dependency_groups(list(self._groups),
only=True)
else:
root = self._package.without_optional_dependency_groups()
if self._io.is_verbose():
self._io.write_line("")
self._io.write_line(
"<info>Finding the necessary packages for the current system</>"
)
# We resolve again by only using the lock file
pool = Pool(ignore_repository_names=True)
# Making a new repo containing the packages
# newly resolved and the ones from the current lock file
repo = Repository("poetry-repo")
for package in lockfile_repo.packages + locked_repository.packages:
if not package.is_direct_origin() and not repo.has_package(
package):
repo.add_package(package)
pool.add_repository(repo)
solver = Solver(
root,
pool,
self._installed_repository.packages,
locked_repository.packages,
NullIO(),
)
# Everything is resolved at this point, so we no longer need
# to load deferred dependencies (i.e. VCS, URL and path dependencies)
solver.provider.load_deferred(False)
with solver.use_environment(self._env):
ops = solver.solve(
use_latest=self._whitelist).calculate_operations(
with_uninstalls=self._requires_synchronization,
synchronize=self._requires_synchronization,
)
if not self._requires_synchronization:
# If no packages synchronisation has been requested we need
# to calculate the uninstall operations
from poetry.puzzle.transaction import Transaction
transaction = Transaction(
locked_repository.packages,
[(package, 0) for package in lockfile_repo.packages],
installed_packages=self._installed_repository.packages,
root_package=root,
)
ops = [
op for op in transaction.calculate_operations(
with_uninstalls=True) if op.job_type == "uninstall"
] + ops
# We need to filter operations so that packages
# not compatible with the current system,
# or optional and not requested, are dropped
self._filter_operations(ops, lockfile_repo)
# Execute operations
return self._execute(ops)