def frame(
message: str,
char1: Optional[str] = None,
num_chars: Optional[int] = None,
char2: Optional[str] = None,
thickness: int = 1,
) -> str:
"""Print a frame around a message."""
# Fill in the default values.
if char1 is None:
# User didn't specify any char.
char1 = char2 = "#"
elif char1 is not None and char2 is None:
# User specified only one char.
char2 = char1
elif char1 is None and char2 is not None:
# User specified the second char, but not the first.
dbg.dfatal("Invalid char1='%s' char2='%s'" % (char1, char2))
else:
# User specified both chars. Nothing to do.
pass
num_chars = 80 if num_chars is None else num_chars
# Sanity check.
dbg.dassert_lte(1, thickness)
dbg.dassert_eq(len(char1), 1)
dbg.dassert_eq(len(char2), 1)
dbg.dassert_lte(1, num_chars)
# Build the return value.
ret = ((line(char1, num_chars) + "\n") * thickness + message + "\n" +
(line(char2, num_chars) + "\n") * thickness).rstrip("\n")
return ret
def format_list(
list_: List[Any],
sep: str = " ",
max_n: Optional[int] = None,
tag: Optional[str] = None,
) -> str:
sep = " "
# sep = ", "
if max_n is None:
max_n = 10
max_n = cast(int, max_n)
dbg.dassert_lte(1, max_n)
n = len(list_)
txt = ""
if tag is not None:
txt += "%s: " % tag
txt += "(%s) " % n
if n < max_n:
txt += sep.join(map(str, list_))
else:
num_elems = int(max_n / 2)
dbg.dassert_lte(1, num_elems)
txt += sep.join(map(str, list_[:num_elems]))
txt += " ... "
# pylint: disable=invalid-unary-operand-type
txt += sep.join(map(str, list_[-num_elems:]))
return txt
def get_hash(git_hash: str, short_hash: bool, num_digits: int = 8) -> str:
dbg.dassert_lte(1, num_digits)
if short_hash:
ret = git_hash[:num_digits]
else:
ret = git_hash
return ret
def print_set_diff(
obj1: Iterable,
obj2: Iterable,
obj1_name: str = "obj1",
obj2_name: str = "obj2",
add_space: bool = False,
) -> None:
def _to_string(obj: Iterable) -> str:
return " ".join(map(str, obj))
print("# %s vs %s" % (obj1_name, obj2_name))
obj1 = set(obj1)
dbg.dassert_lte(1, len(obj1))
print("* %s: (%s) %s" % (obj1_name, len(obj1), _to_string(obj1)))
if add_space:
print()
#
obj2 = set(obj2)
dbg.dassert_lte(1, len(obj2))
print("* %s: (%s) %s" % (obj2_name, len(obj2), _to_string(obj2)))
if add_space:
print()
#
intersection = obj1.intersection(obj2)
print("* intersect=(%s) %s" %
(len(intersection), _to_string(intersection)))
if add_space:
print()
#
diff = obj1 - obj2
print("* %s-%s=(%s) %s" %
(obj1_name, obj2_name, len(diff), _to_string(diff)))
if add_space:
print()
#
diff = obj2 - obj1
print("* %s-%s=(%s) %s" %
(obj2_name, obj1_name, len(diff), _to_string(diff)))
if add_space:
print()
def filter_text(regex: str, txt: str) -> str:
"""Remove lines in `txt` that match the regex `regex`."""
_LOG.debug("Filtering with '%s'", regex)
if regex is None:
return txt
txt_out = []
txt_as_arr = txt.split("\n")
for line in txt_as_arr:
if re.search(regex, line):
_LOG.debug("Skipping line='%s'", line)
continue
txt_out.append(line)
# We can only remove lines.
dbg.dassert_lte(
len(txt_out),
len(txt_as_arr),
"txt_out=\n'''%s'''\ntxt=\n'''%s'''",
"\n".join(txt_out),
"\n".join(txt_as_arr),
)
txt = "\n".join(txt_out)
return txt
def perc(
a: float,
b: float,
only_perc: bool = False,
invert: bool = False,
num_digits: int = 2,
use_thousands_separator: bool = False,
) -> str:
"""Calculate percentage a / b as a string.
Asserts 0 <= a <= b. If true, returns a/b to `num_digits` decimal places.
:param a: numerator
:param b: denominator
:param only_perc: return only the percentage, without the original numbers
:param invert: assume the fraction is (b - a) / b
This is useful when we want to compute the complement of a count.
:param use_thousands_separator: report the numbers using thousands separator
:return: string with a/b
"""
dbg.dassert_lte(0, a)
dbg.dassert_lte(a, b)
if use_thousands_separator:
a_str = str("{0:,}".format(a))
b_str = str("{0:,}".format(b))
else:
a_str = str(a)
b_str = str(b)
if invert:
a = b - a
dbg.dassert_lte(0, num_digits)
if only_perc:
fmt = "%." + str(num_digits) + "f%%"
ret = fmt % (float(a) / b * 100.0)
else:
fmt = "%s / %s = %." + str(num_digits) + "f%%"
ret = fmt % (a_str, b_str, float(a) / b * 100.0)
return ret