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': ...}"
