def uninstall(all, packages):
"""Uninstall packages"""
if packages and all:
abort("Either specify packages to uninstall, or --all (but not both)")
if not packages and not all:
abort("Specify packages to uninstall, or --all")
if packages and PICKLEY in packages:
abort(
"Run 'uninstall --all' if you wish to uninstall pickley itself (and everything it installed)"
)
setup_audit_log()
for pspec in CFG.package_specs(packages):
manifest = pspec.get_manifest()
if not manifest or not manifest.version:
abort("%s was not installed with pickley" %
runez.bold(pspec.dashed))
if manifest.entrypoints:
for ep in manifest.entrypoints:
runez.delete(pspec.exe_path(ep))
runez.delete(pspec.meta_path)
action = "Would uninstall" if runez.DRYRUN else "Uninstalled"
inform("%s %s" % (action, pspec.dashed))
if all:
runez.delete(CFG.base.full_path(PICKLEY))
runez.delete(CFG.meta.path)
inform("pickley is now %s" % runez.red("uninstalled"))
def apply(self, exe):
dest = os.path.join(self.target, os.path.basename(exe))
if os.path.exists(exe):
r = runez.symlink(exe, dest, must_exist=False)
if r > 0:
inform("Symlinked %s -> %s" %
(runez.short(dest), runez.short(exe)))
else:
LOG.debug("'%s' does not exist, skipping symlink" % exe)
def upgrade(packages):
"""Upgrade an installed package"""
packages = CFG.package_specs(packages)
if not packages:
inform("No packages installed, nothing to upgrade")
sys.exit(0)
setup_audit_log()
for pspec in packages:
perform_install(pspec, is_upgrade=True, force=False, quiet=False)
def perform_install(pspec, is_upgrade=False, force=False, quiet=False):
"""
Args:
pspec (PackageSpec): Package spec to install
is_upgrade (bool): If True, intent is an upgrade (not a new install)
force (bool): If True, check latest version even if recently checked
quiet (bool): If True, don't chatter
Returns:
(pickley.TrackedManifest): Manifest is successfully installed (or was already up-to-date)
"""
with SoftLock(pspec):
started = time.time()
pspec.resolve()
skip_reason = pspec.skip_reason(force)
if skip_reason:
inform("Skipping installation of %s: %s" %
(pspec.dashed, runez.bold(skip_reason)))
return None
manifest = pspec.get_manifest()
if is_upgrade and not manifest and not quiet:
abort("'%s' is not installed" % runez.red(pspec))
if not pspec.version:
desired = pspec.get_desired_version_info(force=force)
if desired.problem:
action = "upgrade" if is_upgrade else "install"
abort("Can't %s %s: %s" %
(action, pspec, runez.red(desired.problem)))
pspec.version = desired.version
if not force and manifest and manifest.version == pspec.version and pspec.is_healthily_installed(
):
if not quiet:
status = "up-to-date" if is_upgrade else "installed"
inform("%s v%s is already %s" %
(pspec.dashed, runez.bold(pspec.version), status))
pspec.groom_installation()
return manifest
setup_audit_log()
manifest = PACKAGER.install(pspec)
if manifest and not quiet:
note = " in %s" % runez.represented_duration(time.time() - started)
action = "Upgraded" if is_upgrade else "Installed"
if runez.DRYRUN:
action = "Would state: %s" % action
inform("%s %s v%s%s" %
(action, pspec.dashed, runez.bold(
pspec.version), runez.dim(note)))
if not pspec._pickley_dev_mode:
pspec.groom_installation()
return manifest
def package(build, dist, symlink, no_compile, sanity_check, project,
requirement):
"""Package a project from source checkout"""
started = time.time()
runez.log.spec.default_logger = LOG.info
CFG.set_base(runez.resolved_path(build))
finalizer = PackageFinalizer(project, dist, symlink)
finalizer.sanity_check = sanity_check
finalizer.requirements = requirement
finalizer.compile = not no_compile
finalizer.resolve()
report = finalizer.finalize()
if report:
inform("")
inform(report)
inform("")
elapsed = "in %s" % runez.represented_duration(time.time() - started)
inform("Packaged %s successfully %s" %
(runez.bold(runez.short(project)), runez.dim(elapsed)))