def resolve_latest(motif_list, pm):
out = []
grouped_packages = {}
group_package_identifiers_by_name(pm.list_installed_packages().keys(),
pkgmap=grouped_packages)
group_package_identifiers_by_name(pm.list_available_packages().keys(),
pkgmap=grouped_packages)
for motif in motif_list:
pi = None
if PackageIdentifier.is_valid_identifier(motif):
pi = PackageIdentifier.parse(motif)
if pi.name not in grouped_packages or pi not in grouped_packages[
pi.name]:
# Unknwon package
pi = None
elif motif in grouped_packages:
# Get latest of the sorted list
pi = grouped_packages[motif][-1]
# Check if package identifier has been found
if pi is None:
raise InvalidPackageNameException(motif)
out.append(pi)
return out
def find_manifest(pi, mfmap, ignore_unknown=False):
"""
Return the Manifest from the given map from its PackageIdentifier.
If the given PackageIdentifier is *latest*, then return the highest version of the package.
"""
if not isinstance(mfmap, dict):
raise ValueError()
if is_latest_package(pi):
pi = find_latest_version(pi, mfmap.keys(), ignore_unknown=True)
if pi in mfmap:
return mfmap[pi]
if not ignore_unknown:
raise InvalidPackageNameException(pi)
def find_latest_version(pi_or_name, pilist, ignore_unknown=False):
"""
Use given package name to return the PackageIdentifier with the highest version
"""
out = None
piname = pi_or_name.name if isinstance(
pi_or_name, PackageIdentifier) else str(pi_or_name)
for pi in [pi for pi in pilist if pi.name == piname]:
if out is None or pi > out:
out = pi
if out is None and not ignore_unknown:
raise InvalidPackageNameException(pi_or_name)
return out
def execute(self, args, uargs):
wm = self.get_workspacemanager()
logger = wm.logger
pfname = wm.current_profile_name
profile = wm.get_profile(pfname)
profile_pkg_map = profile.pkg_map
grouped_packagesmap = group_package_identifiers_by_name(wm.list_installed_packages())
grouped_packagesmap = group_package_identifiers_by_name(wm.list_available_packages(), pkgmap=grouped_packagesmap)
update_pilist = []
motiflist = args.packages if args.packages is not None else profile_pkg_map.keys()
for motif in motiflist:
pi = None
if PackageIdentifier.is_valid_identifier(motif):
# User force specific version
candidate = PackageIdentifier.parse(motif)
if candidate.name in grouped_packagesmap:
if candidate in grouped_packagesmap[candidate.name]:
pi = candidate
elif motif in grouped_packagesmap:
# Get latest version
pi = grouped_packagesmap[motif][-1]
if pi is None:
# Unknown package identifier
raise InvalidPackageNameException(motif)
if pi is not None and pi not in update_pilist:
# Get PI in profile
previous_pi = PackageIdentifier(pi.name, profile_pkg_map[pi.name]) if pi.name in profile_pkg_map else None
if previous_pi is None:
# Package not in profile yet, add it
if wm.print_with_confirm("Do you want to add package {pi}?".format(pi=pi)):
update_pilist.append(pi)
elif previous_pi != pi:
# Package already in profile with a different version, update it
if wm.print_with_confirm("Do you want to update package {pi.name} from {oldpi.version} to {pi.version}?".format(pi=pi, oldpi=previous_pi)):
update_pilist.append(pi)
else:
# Package already in profile with same version, do nothing
pass
if len(update_pilist) == 0:
logger.print_default("Nothing to do")
else:
profile.add_packages(update_pilist)
wm.update_profile(profile)
wm.provision_profile(profile)
def build_packages_environment(self, items: list, ipmap=None):
"""
Get the env vars declared by given packages
@param items: a list of InstalledPackage or PackageIdentifier
"""
ipmap = ipmap or self.list_installed_packages()
out = Environment()
for item in items:
ip = None
if isinstance(item, InstalledPackage):
ip = item
elif isinstance(item, PackageIdentifier):
ip = None
if is_latest_package(item):
ip = find_manifest(item, ipmap)
else:
ip = ipmap.get(item)
if ip is None:
raise InvalidPackageNameException(item)
else:
raise InvalidPackageNameException(item)
vr = VariableResolver(ip, ipmap.values())
out.append(ip.build_environment(vr=vr.resolve))
return out
def parse(pis: str):
if not PackageIdentifier.is_valid_identifier(pis):
raise InvalidPackageNameException(pis)
split = pis.partition(PackageIdentifier.SEPARATOR)
return PackageIdentifier(split[0], split[2])