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())