def test_deferred_registration_subclass():
"""Registering a printer for BaseTestDeferredType should be resolved
when using the subclass ConcreteTestDeferredType"""
expected = 'Deferred type works.'
@register_pretty('tests.test_prettyprinter.BaseTestDeferredType')
def pretty_testdeferredtype(value, ctx):
return expected
assert not is_registered(
ConcreteTestDeferredType,
check_superclasses=False,
register_deferred=False
)
assert is_registered(
ConcreteTestDeferredType,
check_superclasses=True,
register_deferred=False
)
assert pformat(ConcreteTestDeferredType()) == expected
assert is_registered(
ConcreteTestDeferredType,
check_superclasses=True,
check_deferred=False,
register_deferred=False
)
assert pformat(ConcreteTestDeferredType()) == expected
def __repr__(self):
simple_fields = ["method", "src_path"]
rich_fields = list()
if self.method == DAVMethod.PROPFIND:
simple_fields += [
"body_is_parsed_success",
"depth",
"propfind_only_fetch_property_name",
"propfind_fetch_all_property",
"propfind_only_fetch_basic",
"propfind_basic_keys",
]
rich_fields += [
"propfind_extra_keys",
]
elif self.method == DAVMethod.PROPPATCH:
simple_fields += ["body_is_parsed_success", "depth"]
rich_fields += [
"proppatch_entries",
]
elif self.method == DAVMethod.PUT:
simple_fields += [
"lock_token",
"lock_token_path",
"lock_token_is_parsed_success",
]
elif self.method in (DAVMethod.COPY, DAVMethod.MOVE):
simple_fields += ["dst_path", "depth", "overwrite"]
elif self.method in (DAVMethod.LOCK, DAVMethod.UNLOCK):
simple_fields += [
"body_is_parsed_success",
"depth",
"timeout",
"lock_scope",
"lock_owner",
"lock_token",
"lock_token_path",
"lock_token_is_parsed_success",
]
simple = "|".join(
[str(self.__getattribute__(name)) for name in simple_fields])
try:
from prettyprinter import pformat
scope = pformat(self.scope)
rich = "\n".join(
[pformat(self.__getattribute__(name)) for name in rich_fields])
s = "{}\n{}\n{}".format(simple, scope, rich)
except ImportError:
s = simple
return s
def test_counter():
value = Counter({'a': 1, 'b': 200})
expected = "collections.Counter({'a': 1, 'b': 200})"
assert pformat(value, width=999, sort_dict_keys=True) == expected
if sys.version_info >= (3, 6):
expected = "collections.Counter({'b': 200, 'a': 1})"
assert pformat(value, width=999, sort_dict_keys=False) == expected
def assert_equal_programs(actual: Program, expected: Program):
assert pformat(actual) == pformat(
expected
), "The given program instances do not pretty print to the same string"
assert (
actual == expected
), "The given program instances pretty print to the same value, but object equality differs"
def pretty_compare(config, op, left, right):
very_verbose = config.option.verbose >= 2
if not very_verbose:
return None
if op != "==":
return None
try:
if abs(left + right) < 100:
return None
except TypeError:
pass
try:
pretty_left = pformat(left, indent=4, width=80,
sort_dict_keys=True).splitlines()
pretty_right = pformat(right, indent=4, width=80,
sort_dict_keys=True).splitlines()
differ = icdiff.ConsoleDiff(cols=160, tabsize=4)
icdiff_lines = list(
differ.make_table(pretty_left, pretty_right, context=False))
return (["equals failed"] +
["<left>".center(79) + "|" + "<right>".center(80)] +
["-" * 160] +
[icdiff.color_codes["none"] + l for l in icdiff_lines])
except Exception:
return None
def test_compat():
class MyClass:
def _repr_pretty_(self, p, cycle):
with p.group(0, '{', '}'):
with p.indent(4):
p.breakable(sep='')
p.text("'a': ")
p.pretty(1)
p.text(',')
p.breakable(sep=' ')
p.text("'b': ")
p.pretty(2)
p.breakable(sep='')
result = pformat(MyClass())
expected = """{'a': 1, 'b': 2}"""
assert result == expected
result = pformat(MyClass(), width=12)
expected = """\
{
'a': 1,
'b': 2
}"""
assert result == expected
def test_chainmap():
empty = ChainMap()
assert pformat(empty, width=999) == 'collections.ChainMap()'
value = ChainMap({'a': 1}, {'b': 2}, {'a': 1})
assert pformat(
value,
width=999) == "collections.ChainMap({'a': 1}, {'b': 2}, {'a': 1})"
def test_purepath(typ, name, args, pathstr):
path = typ(*args)
assert is_registered(typ, check_superclasses=True)
assert pformat(path) == 'pathlib.{}({})'.format(name, pathstr)
assert pformat(path, width=20) == """\
pathlib.{}(
{}
)""".format(name, pathstr)
def test_array():
assert pformat(np.array([0, 1])) == "numpy.ndarray([0, 1])"
assert pformat(np.array([0., 1.])) == "numpy.ndarray([0.0, 1.0])"
assert pformat(np.array(
[0, 1], dtype=np.uint8)) == "numpy.ndarray([0, 1], dtype='uint8')"
assert pformat(np.array(["a",
"b"])) == "numpy.ndarray(['a', 'b'], dtype='<U1')"
assert pformat(np.array([("a", 1)], [("field1", str), ("field2", int)])) \
== "numpy.ndarray([('', 1)], dtype=[('field1', '<U'), ('field2', '<i8')])"
def test_purelongpath(typ, name):
as_str = "/a-b" * 10
path = typ(as_str)
assert pformat(path) == 'pathlib.{}({!r})'.format(name, as_str)
assert pformat(path, width=20) == """\
pathlib.{}(
'/a-b/a-b/a-b/'
'a-b/a-b/a-b/'
'a-b/a-b/a-b/'
'a-b'
)""".format(name)
def format(self, record):
"""Automatically called when logging a record"""
# Allows modification of the record attributes
record_dict = vars(record)
# Checks for message format in order: from message, self.fmt, self.schema
style = record_dict.get("fmt") or self.fmt
if not style:
style = self.schema.get(record.levelname, self.schema["default"])
# Prepare a pretty version of the message
curr_conf = config.get(record.levelname, config["default"])
if isinstance(record_dict["msg"], (dict, list, tuple)):
pretty = pprint.pformat(record_dict["msg"]).strip("'\"")
elif dataclasses.is_dataclass(record_dict["msg"]):
pretty = pprint.pformat(record_dict["msg"])
else:
pretty = str(record_dict["msg"])
total_lines = pretty.count("\n")
if total_lines > curr_conf["max_lines"]:
lines = pretty.splitlines()
# TODO Abstract away the lines left after truncation (e.g. the 2's and 4)
trunc = total_lines - 6
pretty = "\n".join(lines[:3] + [f"...truncated {trunc} lines"] +
lines[-3:])
record_dict["level_str"] = self.level_fmt(record.levelname)
record_dict["msg"] = pretty
# --- Logging macros for doing some special operations ---
# Uses purple to draw extra attention to the text of the line
if record_dict["msg"].startswith("#!"):
record_dict["msg"] = (
self.color_text(record_dict["msg"][2:], "purple") + "\n")
# Doesn't add a newline, allowing line continuation
elif record_dict["msg"].startswith("#^"):
record_dict["msg"] = record_dict["msg"][2:]
# Next two Continue previous line by using a logformat with message text only
# First with green, indicating a desirable result
elif record_dict["msg"].startswith("#$+"):
record_dict["msg"] = self.color_text(record_dict["msg"][3:],
"green") + "\n"
style = "msg"
# Seconde with red, indicating a problem
elif record_dict["msg"].startswith("#$-"):
record_dict["msg"] = self.color_text(record_dict["msg"][3:],
"red") + "\n"
style = "msg"
else:
record_dict["msg"] += "\n"
message = formats[style].format(**record_dict)
return message
def test_list_subclass():
class MyList(list):
pass
empty = MyList()
constructor_str = 'tests.test_prettyprinter.test_list_subclass.<locals>.MyList'
assert pformat(empty) == constructor_str + '()'
value = MyList([1, 2])
assert pformat(value) == constructor_str + "([1, 2])"
truncated = MyList([1, 2])
assert pformat(truncated, max_seq_len=1) == constructor_str + """\
def test_dict_subclass():
class MyDict(dict):
pass
empty = MyDict()
constructor_str = 'tests.test_prettyprinter.test_dict_subclass.<locals>.MyDict'
assert pformat(empty) == constructor_str + '()'
value = MyDict({'a': 1})
assert pformat(value) == constructor_str + "({'a': 1})"
truncated = MyDict({'a': 1, 'b': 2})
assert pformat(truncated, max_seq_len=1) == constructor_str + """\
def __repr__(self):
try:
from prettyprinter import pformat
s = "{}\n{}".format(pformat(self.path2token_map),
pformat(self.lock_map))
except ImportError:
s = "{}\n{}".format(
",".join(self.path2token_map.keys().__str__()),
",".join(self.lock_map.keys().__str__()),
)
return s
def test_numpy_numeric_types(nptype):
val = nptype(1)
py_val = val.item()
if type(py_val) in (int, float):
inner_printed = pformat(py_val)
else:
# numpy renders types such as float128,
# that are not representable in native Python
# types, with Python syntax
inner_printed = repr(py_val)
expected = "numpy.{}({})".format(nptype.__name__, inner_printed)
assert pformat(val) == expected
def test_sort_dict_keys():
value = {
'x': 1,
'a': 2
}
expected = """{'a': 2, 'x': 1}"""
assert pformat(value, sort_dict_keys=True) == expected
def test_deferred_registration():
expected = 'Deferred type works.'
assert not is_registered(TestDeferredType, register_deferred=False)
@register_pretty('tests.test_prettyprinter.TestDeferredType')
def pretty_testdeferredtype(value, ctx):
return expected
assert not is_registered(
TestDeferredType,
check_deferred=False,
register_deferred=False
)
assert is_registered(
TestDeferredType,
register_deferred=False
)
assert pformat(TestDeferredType()) == expected
# Printer should have been moved to non-deferred registry
assert is_registered(
TestDeferredType,
check_deferred=False,
register_deferred=False
)
def test_bytes_pprint_equals_repr(bytestr):
reprd = repr(bytestr)
pformatted = pformat(bytestr)
# This is not always the case. E.g.:
# >>> print(repr(b"\"''"))
# >>> b'"\'\''
#
# Where as prettyprinter chooses
# >>> print(pformat(b"\"''""))
# >>> b"\"''"
# For fewer escapes.
used_same_quote_type = reprd[-1] == pformatted[-1]
if used_same_quote_type:
assert pformat(bytestr) == repr(bytestr)
def auto_repr(obj):
try:
class_name = obj.__class__.__name__
part_1 = f'<{class_name}: '
items = []
_d = obj.__dict__
d = {k: v for k, v in _d.items() if not (k.startswith('_'))}
for k, v in d.items():
try:
if is_class(v): nv = auto_repr(v)
elif isinstance(v, dict): nv = pformat(v)
else: nv = repr(v)
s = f'{k} = {nv}'
items.append(s)
except:
with open('auto_repr.log', 'w') as f:
f.write(f"{obj}")
raise SystemExit
secondary_indent = ' ' * len(part_1)
part_2 = f',{secondary_indent}'.join(items)
return f'{part_1}{part_2}>'
except AttributeError:
with open('auto_repr.log', 'w') as f:
f.write(f"{obj}")
raise SystemExit
def report(
click_ctx,
log: str,
ceph_document_id: str = None,
limit: int = 5,
report_output: str = "-",
handler: str = None,
colorize: bool = False,
pretty: bool = False,
) -> str:
"""Analyze raw build log and produce a report."""
start_time = time.monotonic()
if ceph_document_id:
_get_document(ceph_document_id, log)
with open(log, "r") as f:
build_log: str = f.read()
result: dict = build_breaker_report(log=build_log, handler=handler, top=limit, colorize=colorize)
if ceph_document_id:
print_command_result(
click_ctx=click_ctx,
result=result,
analyzer=analyzer_name,
analyzer_version=analyzer_version,
output=report_output,
duration=time.monotonic() - start_time,
pretty=pretty,
)
else:
if pretty:
result: str = pformat(result)
click.echo(result)
sys.exit(0)
def test_dict_sorted_by_insertion():
"""dict keys should be printed
in insertion order."""
if sys.version_info >= (3, 6):
value = {'x': 1, 'a': 2}
expected = """{'x': 1, 'a': 2}"""
assert pformat(value, sort_dict_keys=False) == expected
def test_mappingproxytype():
assert is_registered(MappingProxyType,
check_deferred=True,
register_deferred=False)
value = MappingProxyType({'a': 1, 'b': 2})
expected = "mappingproxy({'a': 1, 'b': 2})"
assert pformat(value, sort_dict_keys=True) == expected
def test_partial(typ):
value = typ(sorted, [2, 3, 1], reverse=True)
assert pformat(value) == """\
functools.{}(
sorted, # built-in function
[2, 3, 1],
reverse=True
)""".format(typ.__name__)
def test_recursive():
d = {}
d['self_recursion'] = d
rendered = pformat(d)
expected = "{{'self_recursion': <Recursion on dict with id={}>}}".format(
id(d))
assert rendered == expected
def test_top_level_str():
"""Tests that top level strings are not indented or surrounded with parentheses"""
pprint('ab' * 50)
expected = (
"'ababababababababababababababababababababababababababababababababababa'"
"\n'bababababababababababababababab'")
assert pformat('ab' * 50) == expected
def test_queryset():
for i in range(11):
MyModel.objects.create(name='Name{}'.format(i),
version=1,
slug='slug-{}'.format(i))
qs = MyModel.objects.all()
assert pformat(qs, width=999) == """\
def test_enum():
class TestEnum(Enum):
ONE = 1
TWO = 2
value = TestEnum.ONE
expected = 'tests.test_stdlib_definitions.test_enum.<locals>.TestEnum.ONE'
assert pformat(value) == expected
def test_request():
request = Request('GET',
'https://example.com/pages/1',
data={'ok': True},
headers={
'Content-Type': 'application/json',
})
assert pformat(request, width=999) == """\
def test_str_bug():
data = 'lorem ipsum dolor sit amet ' * 10
expected = """\
'lorem ipsum dolor sit amet lorem ipsum dolor sit amet lorem ipsum '
'dolor sit amet lorem ipsum dolor sit amet lorem ipsum dolor sit amet '
'lorem ipsum dolor sit amet lorem ipsum dolor sit amet lorem ipsum '
'dolor sit amet lorem ipsum dolor sit amet lorem ipsum dolor sit amet '"""
res = pformat(data)
assert res == expected
def test_pretty_repr():
class MyClass:
__repr__ = pretty_repr
@register_pretty(MyClass)
def pretty_myclass(value, ctx):
return pretty_call_alt(ctx, MyClass)
assert repr(MyClass()) == pformat(MyClass())
