def get_upgrade_requirements(
self, pkgs: List[FlatpakApplication], root_password: str,
watcher: ProcessWatcher) -> UpgradeRequirements:
flatpak_version = flatpak.get_version()
user_pkgs, system_pkgs = [], []
for pkg in pkgs:
if pkg.installation == 'user':
user_pkgs.append(pkg)
else:
system_pkgs.append(pkg)
for apps_by_install in ((user_pkgs, 'user'), (system_pkgs, 'system')):
if apps_by_install[0]:
sizes = flatpak.map_update_download_size(
[str(p.id) for p in apps_by_install[0]],
apps_by_install[1], flatpak_version)
if sizes:
for p in apps_by_install[0]:
p.size = sizes.get(str(p.id))
to_update = [
UpgradeRequirement(pkg=p, extra_size=p.size, required_size=p.size)
for p in self.sort_update_order(pkgs)
]
return UpgradeRequirements(None, None, to_update, [])
def update_file(self, pkg: AppImage, root_password: Optional[str], watcher: ProcessWatcher):
max_width = 350
file_chooser = FileChooserComponent(label=self.i18n['file'].capitalize(),
allowed_extensions={'AppImage', '*'},
search_path=get_default_manual_installation_file_dir(),
max_width=max_width)
input_version = TextInputComponent(label=self.i18n['version'].capitalize(), max_width=max_width)
file_chooser.observers.append(ManualInstallationFileObserver(None, input_version))
while True:
if watcher.request_confirmation(title=self.i18n['appimage.custom_action.manual_update.details'], body=None,
components=[FormComponent(label='', components=[file_chooser, input_version], spaces=False)],
confirmation_label=self.i18n['proceed'].capitalize(),
deny_label=self.i18n['cancel'].capitalize(),
min_height=100, max_width=max_width + 150):
if not file_chooser.file_path or not os.path.isfile(file_chooser.file_path) or not file_chooser.file_path.lower().strip().endswith('.appimage'):
watcher.request_confirmation(title=self.i18n['error'].capitalize(),
body=self.i18n['appimage.custom_action.install_file.invalid_file'],
deny_button=False)
else:
break
else:
return False
pkg.local_file_path = file_chooser.file_path
pkg.version = input_version.get_value()
reqs = UpgradeRequirements(to_install=None, to_remove=None, to_upgrade=[UpgradeRequirement(pkg=pkg)], cannot_upgrade=None)
return self.upgrade(reqs, root_password=root_password, watcher=watcher)
def get_upgrade_requirements(self, pkgs: List[AppImage], root_password: Optional[str], watcher: ProcessWatcher) -> UpgradeRequirements:
to_update = []
for pkg in pkgs:
requirement = UpgradeRequirement(pkg)
installed_size = self.http_client.get_content_length_in_bytes(pkg.url_download)
upgrade_size = self.http_client.get_content_length_in_bytes(pkg.url_download_latest_version)
requirement.required_size = upgrade_size
if upgrade_size and installed_size:
requirement.extra_size = upgrade_size - installed_size
to_update.append(requirement)
return UpgradeRequirements([], [], to_update, [])
def update_file(self, pkg: AppImage, root_password: str,
watcher: ProcessWatcher):
file_chooser = FileChooserComponent(
label=self.i18n['file'].capitalize(),
allowed_extensions={'AppImage'})
input_version = TextInputComponent(
label=self.i18n['version'].capitalize())
while True:
if watcher.request_confirmation(
title=self.
i18n['appimage.custom_action.manual_update.details'],
body=None,
components=[
FormComponent(label='',
components=[file_chooser, input_version],
spaces=False)
],
confirmation_label=self.i18n['proceed'].capitalize(),
deny_label=self.i18n['cancel'].capitalize()):
if not file_chooser.file_path or not os.path.isfile(
file_chooser.file_path):
watcher.request_confirmation(
title=self.i18n['error'].capitalize(),
body=self.i18n[
'appimage.custom_action.install_file.invalid_file'],
deny_button=False)
else:
break
else:
return False
pkg.local_file_path = file_chooser.file_path
pkg.version = input_version.get_value()
reqs = UpgradeRequirements(to_install=None,
to_remove=None,
to_upgrade=[UpgradeRequirement(pkg=pkg)],
cannot_upgrade=None)
return self.upgrade(reqs, root_password=root_password, watcher=watcher)
def summarize(self, pkgs: List[ArchPackage], root_password: str, arch_config: dict) -> UpgradeRequirements:
res = UpgradeRequirements([], [], [], [])
remote_provided_map = pacman.map_provided(remote=True)
remote_repo_map = pacman.map_repositories()
context = UpdateRequirementsContext(to_update={}, repo_to_update={}, aur_to_update={}, repo_to_install={},
aur_to_install={}, to_install={}, pkgs_data={}, cannot_upgrade={},
to_remove={}, installed_names=set(), provided_map={}, aur_index=set(),
arch_config=arch_config, root_password=root_password,
remote_provided_map=remote_provided_map, remote_repo_map=remote_repo_map)
self.__fill_aur_index(context)
aur_data = {}
aur_srcinfo_threads = []
for p in pkgs:
context.to_update[p.name] = p
if p.repository == 'aur':
context.aur_to_update[p.name] = p
t = Thread(target=self._fill_aur_pkg_update_data, args=(p, aur_data), daemon=True)
t.start()
aur_srcinfo_threads.append(t)
else:
context.repo_to_update[p.name] = p
if context.aur_to_update:
for t in aur_srcinfo_threads:
t.join()
self.logger.info("Filling updates data")
if context.repo_to_update:
context.pkgs_data.update(pacman.map_updates_data(context.repo_to_update.keys()))
if aur_data:
context.pkgs_data.update(aur_data)
self.__fill_provided_map(context)
if context.pkgs_data:
self._fill_conflicts(context)
try:
if not self._fill_to_install(context):
self.logger.info("The operation was cancelled by the user")
return
except PackageNotFoundException as e:
self.logger.error("Package '{}' not found".format(e.name))
return
if context.to_update:
installed_sizes = pacman.get_installed_size(list(context.to_update.keys()))
sorted_pkgs = []
if context.repo_to_update: # only sorting by name ( pacman already knows the best order to perform the upgrade )
sorted_pkgs.extend(context.repo_to_update.values())
sorted_pkgs.sort(key=lambda pkg: pkg.name)
if context.aur_to_update: # adding AUR packages in the end
sorted_aur = sorting.sort(context.aur_to_update.keys(), context.pkgs_data, context.provided_map)
for aur_pkg in sorted_aur:
sorted_pkgs.append(context.aur_to_update[aur_pkg[0]])
res.to_upgrade = [self._map_requirement(pkg, context, installed_sizes) for pkg in sorted_pkgs]
if context.to_remove:
res.to_remove = [p for p in context.to_remove.values()]
if context.cannot_upgrade:
res.cannot_upgrade = [d for d in context.cannot_upgrade.values()]
if context.to_install:
res.to_install = [self._map_requirement(p, context) for p in context.to_install.values()]
return res
def get_upgrade_requirements(self, pkgs: List[DebianPackage], root_password: str, watcher: ProcessWatcher) \
-> UpgradeRequirements:
transaction = self.aptitude.simulate_upgrade((p.name for p in pkgs))
if transaction:
size_to_query = (f'{p.name}={p.latest_version}' for p in (*transaction.to_upgrade,
*transaction.to_install,
*transaction.to_remove))
update_extra_attrs = ('compressed size', *(('depends', 'predepends') if transaction.to_install else ()))
update_data = self.aptitude.show(pkgs=size_to_query, attrs=update_extra_attrs)
to_install = None
if transaction.to_install:
dependents = self._map_dependents(update_data)
to_install = []
for p in transaction.to_install:
p_data = update_data.get(p.name) if update_data else None
req_size = p_data.get('compressed size') if p_data else None
reason = None
if dependents:
p_dependents = dependents.get(p.name)
if p_dependents:
deps_str = ', '.join((bold(d) for d in p_dependents))
reason = self._i18n['debian.transaction.dependency_of'].format(pkgs=deps_str)
to_install.append(UpgradeRequirement(pkg=p, reason=reason, required_size=req_size,
extra_size=p.transaction_size))
to_install.sort(key=attrgetter('pkg.name'))
to_install = tuple(to_install)
to_remove = None
if transaction.to_remove:
to_remove = []
for p in transaction.to_remove:
to_remove.append(UpgradeRequirement(pkg=p, required_size=0, extra_size=p.transaction_size))
to_remove.sort(key=attrgetter('pkg.name'))
to_remove = tuple(to_remove)
to_upgrade = None
if transaction.to_upgrade:
to_upgrade = []
for p in transaction.to_upgrade:
p_data = update_data.get(p.name) if update_data else None
if p_data:
req_size = p_data.get('compressed size')
else:
req_size = None
to_upgrade.append(UpgradeRequirement(pkg=p, required_size=req_size, extra_size=p.transaction_size))
to_upgrade.sort(key=attrgetter('pkg.name'))
to_upgrade = tuple(to_upgrade)
return UpgradeRequirements(to_install=to_install, to_upgrade=to_upgrade,
to_remove=to_remove, cannot_upgrade=None)
else:
cannot_upgrade = [UpgradeRequirement(pkg=p, reason=self._i18n['error']) for p in pkgs]
cannot_upgrade.sort(key=attrgetter('pkg.name'))
return UpgradeRequirements(cannot_upgrade=cannot_upgrade, to_install=None, to_remove=None,
to_upgrade=[])
