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 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_is_registered():
class MyClass:
pass
assert not is_registered(MyClass)
# object is not counted as a subclass
assert not is_registered(MyClass, check_superclasses=True)
@register_pretty(MyClass)
def pretty_myclass(instance, ctx):
return '...'
assert is_registered(MyClass)
assert is_registered(MyClass, check_superclasses=True)
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_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_is_registered_subclass():
class MyList(list):
pass
assert not is_registered(MyList)
assert is_registered(MyList, check_superclasses=True)
def test_exception():
exc = ValueError(1)
assert is_registered(ValueError, check_superclasses=True)
assert pformat(exc) == 'ValueError(1)'
if not check_deferred and register_deferred:
raise ValueError(
"register_deferred may not be True when check_deferred is False")
if type in pretty_dispatch.registry:
return True
if not check_superclasses:
return False
return pretty_dispatch.dispatch(type) is not _BASE_DISPATCH
# Resolve deferred names and prevent them being used again.
prettyprinter.is_registered(type(_T),
check_superclasses=True,
check_deferred=True,
register_deferred=True)
prettyprinter.is_registered = is_registered
sys.modules[
"prettyprinter.prettyprinter"].is_registered = is_registered # type: ignore
@register_pretty(enum.EnumMeta)
@register_pretty(enum.Enum)
@register_pretty(enum.IntEnum)
@register_pretty(enum.Flag)
@register_pretty(enum.IntFlag)
def pretty_enum(value, ctx) -> str:
r"""
Pretty-prints the given :class:`~enum.Enum`.
"""
