def replay(existing, tokens, samples):
"""Rerun samples and compare them with their current baseline"""
kinds = []
if tokens:
kinds.append(TestSamples.K_TOKEN)
skipped = 0
for sample in samples:
report = sample.replay(*kinds)
if report is runez.UNSET:
skipped += 1
report = None if existing else " %s" % runez.yellow("skipped")
elif report:
report = "\n%s" % "\n".join(" %s" % s
for s in report.splitlines())
else:
report = " %s" % runez.green("OK")
if report is not None:
print("** %s:%s" % (runez.bold(sample.name), report))
if skipped:
print(runez.dim("-- %s skipped" % runez.plural(skipped, "sample")))
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 cmd_passthrough():
"""
Capture pass-through test
Run a program, capture its output as well as let it pass-through to stdout/stderr
"""
parser = runez.cli.parser()
args, unknown = parser.parse_known_args()
unknown = runez.flattened(unknown, split=" ")
if not unknown:
sys.exit("Provide command to run")
print("-- Running: %s\n" % unknown)
r = runez.run(*unknown, fatal=False, passthrough=True)
print("\n---- Captured: (exit code %s) ----" % r.exit_code)
print("\nstdout:\n%s" % (r.output or runez.dim("-empty-")))
print("\nstderr:\n%s" % (r.error or runez.dim("-empty-")))
def represented(self):
"""str: Human readable representation of this configuration"""
result = ["%s:" % runez.bold(runez.short(self.source))]
if self.values:
self._add_dict_representation(result, self.values)
else:
result[0] += runez.dim(" # empty")
result.append("")
return "\n".join(result)
def show_result(self, data, tokens=False):
rtype = "tokens" if tokens else data.__class__.__name__ if data is not None else "None"
rep = data
if not tokens or isinstance(data, Exception):
rep = TestSettings.represented(data)
message = "---- %s: %s" % (runez.bold(self.name), runez.dim(rtype))
if isinstance(data, NotImplementedError):
print("%s - %s" % (message, rep))
return
print(message)
print(rep)
def check(force, verbose, packages):
"""Check whether specified packages need an upgrade"""
code = 0
packages = CFG.package_specs(packages)
if not packages:
print("No packages installed")
sys.exit(0)
for pspec in packages:
skip_reason = pspec.skip_reason(force)
if skip_reason:
print(
"%s: %s, %s" %
(pspec.dashed, runez.bold("skipped"), runez.dim(skip_reason)))
continue
desired = pspec.get_desired_version_info(force=force)
dv = runez.bold(desired and desired.version)
manifest = pspec.get_manifest()
if desired.problem:
msg = desired.problem
code = 1
elif not manifest or not manifest.version:
msg = "v%s is not installed" % dv
code = 1
elif manifest.version == desired.version:
msg = "v%s is installed" % dv
else:
action = "upgraded to" if desired.source == "latest" else "caught up to %s" % desired.source
msg = "v%s installed, can be %s v%s" % (runez.dim(
manifest.version), action, dv)
print("%s: %s" % (pspec.dashed, msg))
sys.exit(code)
def colored_key(key, indent):
if (key in K_CLI or key in K_LEAVES) and indent in (1, 3):
return runez.teal(key)
if key in K_DIRECTIVES and indent == 1:
return runez.dim(key)
if key in K_GROUPS and indent == 1:
return runez.purple(key)
if indent == 2:
return runez.bold(key)
return runez.red(key)
def show_lines(cls, content, header=None):
if hasattr(content, "path"):
header = header or str(content)
content = runez.readlines(content.path)
elif hasattr(content, "splitlines"):
content = content.splitlines()
result = []
for n, line in enumerate(content, start=1):
line = line.rstrip("\n")
result.append("%s%s" % (runez.dim("%3s: " % n) if cls.line_numbers else "", line))
if header:
print("======== %s ========" % header)
print("\n".join(result))
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)))
def report(self, fastest=None, indent=""):
message = "%s%s: " % (indent, self.name)
if self.error:
return "%s%s" % (message, TestSettings.represented(self.error, size=-len(message)))
if self.seconds is None:
return "%s%s" % (message, runez.red("no result"))
info = ""
if fastest and self.seconds and fastest.seconds and self.seconds != fastest.seconds:
info = runez.dim(" [x %.1f]" % (self.seconds / fastest.seconds))
unit = u"μ"
x = self.seconds / self.iterations * 1000000
if x >= 999:
x = x / 1000
unit = "m"
if x >= 999:
x = x / 1000
unit = "s"
return "%s%s: %.3f %ss/i%s" % (indent, self.name, x, unit, info)
def _unknown(self):
return runez.dim("-unknown-")
def test_colors():
dim = runez.color.style.dim
assert runez.color.cast_style(dim) is dim
assert runez.color.cast_style(runez.dim) is runez.dim
assert runez.color.cast_style("dim") is dim
assert runez.color.cast_color(dim) is dim
assert runez.color.cast_color("dim") is dim
assert runez.color.cast_color("blue") is runez.color.fg.blue
msg1 = dim("hi")
msg2 = runez.colored("hi", "dim")
assert msg1 == msg2
with pytest.raises(ValueError):
runez.color.cast_style("foo")
assert not runez.color.is_coloring()
with runez.ActivateColors(terminal.Ansi16Backend):
# Check that backend can be passed as class (flavor auto-determined in that case)
assert runez.color.is_coloring()
assert "ansi16" in runez.color.backend.name
msg1 = runez.dim("hi")
msg2 = runez.colored("hi", "dim")
assert msg1 == msg2
assert not runez.color.is_coloring()
with runez.ActivateColors(terminal.Ansi16Backend(flavor="neutral")):
assert runez.color.is_coloring()
assert runez.red(None) == "\x1b[31mNone\x1b[39m"
assert runez.blue("") == ""
assert runez.plain("hello") == "hello"
assert runez.yellow("hello") == "\x1b[33mhello\x1b[39m"
assert runez.yellow("hello", size=4) == "\x1b[33mh...\x1b[39m"
assert runez.bold(1) == "\x1b[1m1\x1b[22m"
assert runez.color.bg.get(None) is None
assert runez.color.bg.get("blue") is runez.color.bg.blue
assert runez.dim("") == ""
assert runez.dim("hello", size=4) == "\x1b[2mh...\x1b[22m"
# Verify unicode char 'μ' from represented_duration() works
assert "foo: %s" % runez.dim(runez.represented_duration(0.010049)) == "foo: \x1b[2m10 ms 49 μs\x1b[22m"
assert "foo: %s" % runez.blue(runez.represented_duration(0.010049)) == "foo: \x1b[34m10 ms 49 μs\x1b[39m"
assert not runez.color.is_coloring()
assert runez.black("") == ""
assert runez.blue("") == ""
assert runez.brown("") == ""
assert runez.gray("") == ""
assert runez.green("") == ""
assert runez.orange("") == ""
assert runez.plain("hello") == "hello"
assert runez.purple("") == ""
assert runez.red(None) == "None"
assert runez.teal("") == ""
assert runez.white("") == ""
assert runez.yellow("hello") == "hello"
assert runez.blink("hello") == "hello"
assert runez.bold(1) == "1"
assert runez.dim("") == ""
assert runez.invert("") == ""
assert runez.italic("") == ""
assert runez.strikethrough("") == ""
assert runez.underline("") == ""
assert str(runez.color.fg.black) == "black"