def execute(self, **kwargs):
pm = PackageManager()
ipmap = None
apmap = None
if "skipInstalled" not in kwargs or not kwargs["skipInstalled"]:
ipmap = pm.list_installed_packages()
if "skipAvailable" not in kwargs or not kwargs["skipAvailable"]:
apmap = pm.list_available_packages()
# if we have install & available packages, tag packages:
if ipmap is not None and apmap is not None:
mflist = list(ipmap.values()) + list(apmap.values())
TagUtils.tag_latest(mflist)
TagUtils.tag_installed(apmap.values(), ipmap.keys())
out = {}
# Build the output list
if ipmap is not None:
out["installedPackages"] = {}
for pi, ip in ipmap.items():
data = ip.json
data["folder"] = str(ip.folder)
data["info"]["customTags"] = ip.custom_tags
out["installedPackages"][str(pi)] = data
if apmap is not None:
out["availablePackages"] = {}
for pi, ap in apmap.items():
data = ap.json
data["remoteUrl"] = ap.url
data["info"]["customTags"] = ap.custom_tags
out["availablePackages"][str(pi)] = data
return out
def execute(self, args, uargs):
pm = PackageManager()
metafilter = MetaPackageFilter()
if args.only_master_packages:
metafilter.only_master_packages()
if args.tags is not None:
for t in args.tags:
metafilter.with_tag(t)
if args.keywords is not None and len(args.keywords) > 0:
for kw in args.keywords:
metafilter.with_keyword(kw)
# Pkg list
mflist = sorted(pm.list_available_packages().values(), key=IDENTIFIER_GETTER)
# manage tags
TagUtils.tag_latest(mflist)
TagUtils.tag_installed(mflist, pm.list_installed_packages().keys())
# Print filtered packages
rend = ManifestListRenderer(metafilter)
rend.extend(filter(metafilter.matches, mflist))
pm.print_renderer(rend)
def test_environment(self):
pm = PackageManager()
env = Environment.build(pm.build_builtin_environment(),
pm.build_user_environment(),
Environment("test", {"FOO": "BAR"}))
rend = EnvironmentRenderer(env)
with self.assertStdout(template_out="env.out"):
self.loggerManager.print_renderer(rend)
def setUp(self):
super().setUp()
pm = PackageManager()
pm.create_remote("default", self.remote_url1, insecure=True)
pm.create_remote("default2", self.remote_url2, insecure=True)
pm.fetch_remotes()
self.content = pm.list_available_packages().values()
self.assertTrue(len(self.content) > 0)
def execute(self, **kwargs):
out = {}
pm = PackageManager()
out["version"] = __version__
out["configFolder"] = str(pm.configuration_folder)
out["cacheFolder"] = str(pm.cache_folder)
out["packageFolder"] = str(pm.install_folder)
return out
def execute(self, args, uargs):
pm = PackageManager()
complete_available_packages()
try:
items = pm.install_packages(
args.packages, keep_folder_on_error=args.keep_on_error)
except Exception as e:
raise PackageInstallInterruptedException(args.packages, e)
if len(items) > 0:
pm.logger.print_quiet("Packages installed:",
" ".join([str(p.identifier) for p in items]))
def execute(self, args, uargs):
pm = PackageManager()
tmp_install_folder = args.tmp_install_folder
if tmp_install_folder is None:
tmp_install_folder = mkdir_tmp_leaf_dir()
pm.logger.print_quiet(
"Prereq root folder: {folder}".format(folder=tmp_install_folder))
errors = pm.install_prereq(PackageIdentifier.parse_list(args.packages),
tmp_install_folder,
raise_on_error=False)
pm.logger.print_quiet(
"Prereq installed with {count} error(s)".format(count=errors))
return errors
def execute(self, args, uargs):
pm = PackageManager()
metafilter = MetaPackageFilter()
if not get_optional_arg(args, "show_all_packages", False):
metafilter.only_master_packages()
for t in get_optional_arg(args, "tags", []):
metafilter.with_tag(t)
for kw in get_optional_arg(args, "keywords", []):
metafilter.with_keyword(kw)
# Print filtered packages
rend = ManifestListRenderer(metafilter)
mflist = pm.list_installed_packages().values()
rend.extend(filter(metafilter.matches, mflist))
pm.print_renderer(rend)
def setUp(self):
super().setUp()
self.pm = PackageManager()
with self.assertRaises(NoRemoteException):
self.pm.list_available_packages()
self.assertEqual(0, len(self.pm.list_installed_packages()))
with self.assertRaises(NoRemoteException):
self.pm.list_remotes()
self.assertEqual(0, len(self.pm.read_user_configuration().remotes))
self.pm.create_remote("default", self.remote_url1, insecure=True)
self.pm.create_remote("other", self.remote_url2, insecure=True)
self.assertEqual(2, len(self.pm.read_user_configuration().remotes))
self.pm.fetch_remotes(True)
self.assertEqual(2, len(self.pm.list_remotes()))
self.assertTrue(self.pm.list_remotes()["default"].is_fetched)
self.assertTrue(self.pm.list_remotes()["other"].is_fetched)
self.assertNotEqual(0, len(self.pm.list_available_packages()))
def execute(self, args, uargs):
pm = PackageManager()
env = Environment.build(pm.build_builtin_environment(),
pm.build_user_environment())
install_list, uninstall_list = DependencyUtils.upgrade(
None if len(args.packages) == 0 else args.packages,
pm.list_available_packages(),
pm.list_installed_packages(),
env=env)
pm.logger.print_verbose(
"{count} package(s) to be upgraded: {text}".format(
count=len(install_list),
text=" ".join([str(ap.identifier) for ap in install_list])))
if args.clean:
pm.logger.print_verbose(
"{count} package(s) to be removed: {text}".format(
count=len(uninstall_list),
text=" ".join(
[str(ip.identifier) for ip in uninstall_list])))
if len(install_list) == 0:
pm.logger.print_default("No package to upgrade")
else:
pm.install_packages(map(IDENTIFIER_GETTER, install_list), env=env)
if len(uninstall_list) > 0:
if args.clean:
pm.uninstall_packages(
map(IDENTIFIER_GETTER, uninstall_list))
else:
pm.logger.print_default(
"These packages can be removed:",
" ".join([str(ip.identifier)
for ip in uninstall_list]))
def complete_help(*args, **kwargs):
out = []
for ip in PackageManager().list_installed_packages().values():
for t in ip.help_topics.values():
out += [t.full_name, t.name]
return out
def complete_available_packages(*args, **kwargs):
return list(map(str, PackageManager().list_available_packages().keys()))
def complete_installed_packages(*args, **kwargs):
return list(map(str, PackageManager().list_installed_packages().keys()))
def execute(self, args, uargs):
pm = PackageManager()
pm.sync_packages(PackageIdentifier.parse_list(args.packages))
def execute(self, args, uargs):
pm = PackageManager()
env = None
# If the user specified env values, build a complete env
if args.custom_envlist is not None:
env = Environment.build(
pm.build_builtin_environment(), pm.build_user_environment(),
Environment("Custom env",
env_list_to_map(args.custom_envlist)))
items = None
if args.dependency_type == "available":
items = DependencyUtils.install(PackageIdentifier.parse_list(
args.packages),
pm.list_available_packages(), {},
env=env)
elif args.dependency_type == "install":
items = DependencyUtils.install(PackageIdentifier.parse_list(
args.packages),
pm.list_available_packages(),
pm.list_installed_packages(),
env=env)
elif args.dependency_type == "installed":
items = DependencyUtils.installed(PackageIdentifier.parse_list(
args.packages),
pm.list_installed_packages(),
env=env,
ignore_unknown=True)
elif args.dependency_type == "uninstall":
items = DependencyUtils.uninstall(PackageIdentifier.parse_list(
args.packages),
pm.list_installed_packages(),
env=env)
elif args.dependency_type == "prereq":
items = DependencyUtils.prereq(PackageIdentifier.parse_list(
args.packages),
pm.list_available_packages(),
pm.list_installed_packages(),
env=env)
elif args.dependency_type == "upgrade":
items, _ = DependencyUtils.upgrade(
None if len(args.packages) == 0 else args.packages,
pm.list_available_packages(),
pm.list_installed_packages(),
env=env)
elif args.dependency_type == "rdepends":
mfmap = OrderedDict()
mfmap.update(
DependencyUtils.rdepends(PackageIdentifier.parse_list(
args.packages),
pm.list_available_packages(),
env=env))
mfmap.update(
DependencyUtils.rdepends(PackageIdentifier.parse_list(
args.packages),
pm.list_installed_packages(),
env=env))
items = mfmap.values()
else:
raise ValueError()
rend = ManifestListRenderer()
rend.extend(items)
pm.print_renderer(rend)
def complete_installed_packages_tags(*args, **kwargs):
out = {TagUtils.LATEST}
for ip in PackageManager().list_installed_packages().values():
out.update(set(ip.all_tags))
return out
def complete_available_packages_tags(*args, **kwargs):
out = {TagUtils.LATEST, TagUtils.INSTALLED}
for ip in PackageManager().list_available_packages().values():
out.update(set(ip.all_tags))
return out
def execute(self, args, uargs):
pm = PackageManager()
wm = self.get_workspacemanager()
profilename = wm.current_profile_name
profile = wm.get_profile(profilename)
env = Environment.build(pm.build_builtin_environment(),
pm.build_user_environment())
install_list, upgraded_list = DependencyUtils.upgrade(
None if len(args.packages) == 0 else args.packages,
pm.list_available_packages(),
pm.list_installed_packages(),
env=env)
pm.logger.print_verbose(
"{count} package(s) to be upgraded: {text}".format(
count=len(install_list),
text=" ".join([str(ap.identifier) for ap in install_list])))
if args.clean:
pm.logger.print_verbose(
"{count} package(s) to be removed: {text}".format(
count=len(upgraded_list),
text=" ".join([str(ip.identifier)
for ip in upgraded_list])))
if len(install_list) == 0:
pm.logger.print_default("No package to upgrade")
else:
pm.install_packages(map(IDENTIFIER_GETTER, install_list), env=env)
if len(upgraded_list) > 0:
if args.clean:
pm.uninstall_packages(map(IDENTIFIER_GETTER,
upgraded_list))
else:
pm.logger.print_default(
"Packages upgraded:",
" ".join([str(ip.identifier) for ip in upgraded_list]))
pm.logger.print_default(
'Hint: Use "leaf profile config -p {PACKAGENAME}" to add these packages to your workspace profile'
)
update_pilist = install_list
profile_pkg_map = profile.pkg_map
installed_packages = group_package_identifiers_by_name(
wm.list_installed_packages())
pkg_list = args.packages if args.packages else profile_pkg_map.keys()
for pkg in pkg_list:
pi = None
if pkg in installed_packages.keys():
# Get latest version
pi = installed_packages[pkg][-1]
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 is not in profile yet, add it
update_pilist.append(pi)
elif previous_pi != pi:
# Package is already in profile with a different version, update it
update_pilist.append(pi)
else:
# Package is already in profile with same version, do nothing
pass
if len(update_pilist) == 0:
pm.logger.print_default(
"Packages are already in profile with same version")
else:
pm.logger.print_default(
"Packages to be updated in profile:",
" ".join([str(pi) for pi in update_pilist]))
profile.add_packages(update_pilist)
wm.update_profile(profile)
def complete_binaries(*args, **kwargs):
out = []
for ip in PackageManager().list_installed_packages().values():
for e in ip.binaries.values():
out.append(e.name)
return out