def test_pretty_namedtuple_fields_invalid_type(): class LooksLikeANamedTupleButIsnt(tuple): _fields = "blah" instance = LooksLikeANamedTupleButIsnt() result = pretty_repr(instance) assert result == "()" # Treated as tuple
def test_user_dict(): class D1(UserDict): pass class D2(UserDict): def __repr__(self): return "FOO" d1 = D1({"foo": "bar"}) d2 = D2({"foo": "bar"}) result = pretty_repr(d1, expand_all=True) print(repr(result)) assert result == "{\n 'foo': 'bar'\n}" result = pretty_repr(d2, expand_all=True) print(repr(result)) assert result == "FOO"
def test_broken_repr(): class BrokenRepr: def __repr__(self): 1 / 0 test = [BrokenRepr()] result = pretty_repr(test) expected = "[<error in repr: division by zero>]" assert result.plain == expected
def test_attrs_empty(): @attr.define class Nada: pass result = pretty_repr(Nada()) print(repr(result)) expected = "Nada()" assert result == expected
def test_lying_attribute(): """Test getattr doesn't break rich repr protocol""" class Foo: def __getattr__(self, attr): return "foo" foo = Foo() result = pretty_repr(foo) assert "Foo" in result
def test_broken_repr(): class BrokenRepr: def __repr__(self): 1 / 0 test = [BrokenRepr()] result = pretty_repr(test) expected = "[<repr-error 'division by zero'>]" assert result == expected
def test_pretty_dataclass(): dc = ExampleDataclass(1000, "Hello, World", 999, ["foo", "bar", "baz"]) result = pretty_repr(dc, max_width=80) print(repr(result)) assert ( result == "ExampleDataclass(foo=1000, bar='Hello, World', baz=['foo', 'bar', 'baz'])" ) result = pretty_repr(dc, max_width=16) print(repr(result)) assert ( result == "ExampleDataclass(\n foo=1000,\n bar='Hello, World',\n baz=[\n 'foo',\n 'bar',\n 'baz'\n ]\n)" ) dc.bar = dc result = pretty_repr(dc, max_width=80) print(repr(result)) assert result == "ExampleDataclass(foo=1000, bar=..., baz=['foo', 'bar', 'baz'])"
def test_max_depth_dataclass(): @dataclass class Foo: foo: object @dataclass class Bar: bar: object assert (pretty_repr(Foo(foo=Bar(bar=Foo(foo=[]))), max_depth=2) == "Foo(foo=Bar(bar=...))")
def test_pretty(): test = { "foo": [1, 2, 3, {4, 5, 6, (7, 8, 9)}, {}], False: "foo", True: "", "text": ("Hello World", "foo bar baz egg"), } result = pretty_repr(test) expected = "{\n 'foo': [1, 2, 3, {(7, 8, 9), 4, 5, 6}, {}], \n False: 'foo', \n True: '', \n 'text': ('Hello World', 'foo bar baz egg')\n}" assert result.plain == expected
def test_max_depth_attrs(): @attr.define class Foo: foo = attr.field() @attr.define class Bar: bar = attr.field() assert (pretty_repr(Foo(foo=Bar(bar=Foo(foo=[]))), max_depth=2) == "Foo(foo=Bar(bar=...))")
def test_broken_getattr(): class BrokenAttr: def __getattr__(self, name): 1 / 0 def __repr__(self): return "BrokenAttr()" test = BrokenAttr() result = pretty_repr(test) assert result == "BrokenAttr()"
def test_attrs_broken(): @attr.define class Foo: bar: int foo = Foo(1) del foo.bar result = pretty_repr(foo) print(repr(result)) expected = "Foo(bar=AttributeError('bar'))" assert result == expected
def test_attrs_broken_310(): @attr.define class Foo: bar: int foo = Foo(1) del foo.bar result = pretty_repr(foo) print(repr(result)) expected = "Foo(bar=AttributeError(\"'Foo' object has no attribute 'bar'\"))" assert result == expected
def test_attrs(): @attr.define class Point: x: int y: int foo: str = attr.field(repr=str.upper) z: int = 0 result = pretty_repr(Point(1, 2, foo="bar")) print(repr(result)) expected = "Point(x=1, y=2, foo=BAR, z=0)" assert result == expected
def test_pretty(): test = { "foo": [1, 2, 3, (4, 5, {6}, 7, 8, {9}), {}], "bar": {"egg": "baz", "words": ["Hello World"] * 10}, False: "foo", True: "", "text": ("Hello World", "foo bar baz egg"), } result = pretty_repr(test, max_width=80) print(result) expected = "{\n 'foo': [1, 2, 3, (4, 5, {6}, 7, 8, {9}), {}],\n 'bar': {\n 'egg': 'baz',\n 'words': [\n 'Hello World',\n 'Hello World',\n 'Hello World',\n 'Hello World',\n 'Hello World',\n 'Hello World',\n 'Hello World',\n 'Hello World',\n 'Hello World',\n 'Hello World'\n ]\n },\n False: 'foo',\n True: '',\n 'text': ('Hello World', 'foo bar baz egg')\n}" print(expected) assert result == expected
def test_max_depth_rich_repr(): class Foo: def __init__(self, foo): self.foo = foo def __rich_repr__(self): yield "foo", self.foo class Bar: def __init__(self, bar): self.bar = bar def __rich_repr__(self): yield "bar", self.bar assert (pretty_repr(Foo(foo=Bar(bar=Foo(foo=[]))), max_depth=2) == "Foo(foo=Bar(bar=...))")
def test_max_depth(): d = {} d["foo"] = {"fob": {"a": [1, 2, 3], "b": {"z": "x", "y": ["a", "b", "c"]}}} assert pretty_repr(d, max_depth=0) == "..." assert pretty_repr(d, max_depth=1) == "{'foo': ...}" assert pretty_repr(d, max_depth=2) == "{'foo': {'fob': ...}}" assert pretty_repr(d, max_depth=3) == "{'foo': {'fob': {'a': ..., 'b': ...}}}" assert (pretty_repr(d, max_width=100, max_depth=4) == "{'foo': {'fob': {'a': [1, 2, 3], 'b': {'z': 'x', 'y': ...}}}}") assert ( pretty_repr(d, max_width=100, max_depth=5) == "{'foo': {'fob': {'a': [1, 2, 3], 'b': {'z': 'x', 'y': ['a', 'b', 'c']}}}}" ) assert ( pretty_repr(d, max_width=100, max_depth=None) == "{'foo': {'fob': {'a': [1, 2, 3], 'b': {'z': 'x', 'y': ['a', 'b', 'c']}}}}" )
def test_pretty_namedtuple(): console = Console(color_system=None) console.begin_capture() example_namedtuple = StockKeepingUnit( "Sparkling British Spring Water", "Carbonated spring water", 0.9, "water", ["its amazing!", "its terrible!"], ) result = pretty_repr(example_namedtuple) print(result) assert (result == """StockKeepingUnit( name='Sparkling British Spring Water', description='Carbonated spring water', price=0.9, category='water', reviews=['its amazing!', 'its terrible!'] )""")
def test_recursive(): test = [] test.append(test) result = pretty_repr(test) expected = "[...]" assert result == expected
def test_small_width(): test = ["Hello world! 12345"] result = pretty_repr(test, max_width=10) expected = "[\n 'Hello world! 12345'\n]" assert result == expected
def test_empty_repr(): class Foo: def __repr__(self): return "" assert pretty_repr(Foo()) == ""
def test_tuple_of_one(): assert pretty_repr((1, )) == "(1,)"
def test_pretty_namedtuple_empty(): instance = collections.namedtuple("Thing", [])() assert pretty_repr(instance) == "Thing()"
def test_pretty_namedtuple_custom_repr(): class Thing(NamedTuple): def __repr__(self): return "XX" assert pretty_repr(Thing()) == "XX"
def test_defaultdict(): test_dict = defaultdict(int, {"foo": 2}) result = pretty_repr(test_dict) assert result == "defaultdict(<class 'int'>, {'foo': 2})"
def test_array(): test_array = array("I", [1, 2, 3]) result = pretty_repr(test_array) assert result == "array('I', [1, 2, 3])"
def test_pretty_namedtuple_length_one_no_trailing_comma(): instance = collections.namedtuple("Thing", ["name"])(name="Bob") assert pretty_repr(instance) == "Thing(name='Bob')"
def test_node(): node = Node("abc") assert pretty_repr(node) == "abc: "
def test_pretty_namedtuple_max_depth(): instance = {"unit": StockKeepingUnit("a", "b", 1.0, "c", ["d", "e"])} result = pretty_repr(instance, max_depth=1) assert result == "{'unit': ...}"