"""Tests for the Formatters."""

from math import pi

try:

import numpy

except:

numpy = None

import pytest

from IPython import get_ipython

from traitlets.config import Config

from IPython.core.formatters import (

PlainTextFormatter,

HTMLFormatter,

PDFFormatter,

_mod_name_key,

DisplayFormatter,

JSONFormatter,

)

from IPython.utils.io import capture_output

class A(object):

def __repr__(self):

return "A()"

class B(A):

def __repr__(self):

return "B()"

class C:

pass

class BadRepr(object):

def __repr__(self):

raise ValueError("bad repr")

class BadPretty(object):

_repr_pretty_ = None

class GoodPretty(object):

def _repr_pretty_(self, pp, cycle):

pp.text("foo")

def __repr__(self):

return "GoodPretty()"

def foo_printer(obj, pp, cycle):

pp.text("foo")

def test_display_formatter_active_types_config():

from IPython.terminal.interactiveshell import TerminalInteractiveShell

from IPython.core.history import HistoryManager

from traitlets.config import Config

# Clear HistoryManager instances to bypass singleton limit before creating new shell

prev_instances = HistoryManager._instances.copy()

HistoryManager._instances.clear()

try:

c = Config()

c.DisplayFormatter.active_types = ["text/plain", "image/png"]

# Disable history

c.HistoryManager.enabled = False

ip = TerminalInteractiveShell(config=c)

active_types = ip.display_formatter.active_types

assert "text/plain" in active_types

assert "image/png" in active_types

# Ensure only the expected types are active

assert set(active_types) == {"text/plain", "image/png"}

finally:

# Clean up the new instance and restore previous state

HistoryManager._instances.clear()

HistoryManager._instances.update(prev_instances)

def test_pretty():

f = PlainTextFormatter()

f.for_type(A, foo_printer)

assert f(A()) == "foo"

assert f(B()) == "B()"

assert f(GoodPretty()) == "foo"

# Just don't raise an exception for the following:

f(BadPretty())

f.pprint = False

assert f(A()) == "A()"

assert f(B()) == "B()"

assert f(GoodPretty()) == "GoodPretty()"

def test_deferred():

f = PlainTextFormatter()

def test_precision():

"""test various values for float_precision."""

f = PlainTextFormatter()

assert f(pi) == repr(pi)

f.float_precision = 0

if numpy:

po = numpy.get_printoptions()

assert po["precision"] == 0

assert f(pi) == "3"

f.float_precision = 2

if numpy:

po = numpy.get_printoptions()

assert po["precision"] == 2

assert f(pi) == "3.14"

f.float_precision = "%g"

if numpy:

po = numpy.get_printoptions()

assert po["precision"] == 2

assert f(pi) == "3.14159"

f.float_precision = "%e"

assert f(pi) == "3.141593e+00"

f.float_precision = ""

if numpy:

po = numpy.get_printoptions()

assert po["precision"] == 8

assert f(pi) == repr(pi)

def test_bad_precision():

"""test various invalid values for float_precision."""

f = PlainTextFormatter()

def set_fp(p):

f.float_precision = p

pytest.raises(ValueError, set_fp, "%")

pytest.raises(ValueError, set_fp, "%.3f%i")

pytest.raises(ValueError, set_fp, "foo")

pytest.raises(ValueError, set_fp, -1)

def test_for_type():

f = PlainTextFormatter()

# initial return, None

assert f.for_type(C, foo_printer) is None

# no func queries

assert f.for_type(C) is foo_printer

# shouldn't change anything

assert f.for_type(C) is foo_printer

# None should do the same

assert f.for_type(C, None) is foo_printer

assert f.for_type(C, None) is foo_printer

def test_for_type_string():

f = PlainTextFormatter()

type_str = "%s.%s" % (C.__module__, "C")

# initial return, None

assert f.for_type(type_str, foo_printer) is None

# no func queries

assert f.for_type(type_str) is foo_printer

assert _mod_name_key(C) in f.deferred_printers

assert f.for_type(C) is foo_printer

assert _mod_name_key(C) not in f.deferred_printers

assert C in f.type_printers

def test_for_type_by_name():

f = PlainTextFormatter()

mod = C.__module__

# initial return, None

assert f.for_type_by_name(mod, "C", foo_printer) is None

# no func queries

assert f.for_type_by_name(mod, "C") is foo_printer

# shouldn't change anything

assert f.for_type_by_name(mod, "C") is foo_printer

# None should do the same

assert f.for_type_by_name(mod, "C", None) is foo_printer

assert f.for_type_by_name(mod, "C", None) is foo_printer

def test_lookup():

f = PlainTextFormatter()

f.for_type(C, foo_printer)

assert f.lookup(C()) is foo_printer

with pytest.raises(KeyError):

f.lookup(A())

def test_lookup_string():

f = PlainTextFormatter()

type_str = "%s.%s" % (C.__module__, "C")

f.for_type(type_str, foo_printer)

assert f.lookup(C()) is foo_printer

# should move from deferred to imported dict

assert _mod_name_key(C) not in f.deferred_printers

assert C in f.type_printers

def test_lookup_by_type():

f = PlainTextFormatter()

f.for_type(C, foo_printer)

assert f.lookup_by_type(C) is foo_printer

with pytest.raises(KeyError):

f.lookup_by_type(A)

def test_lookup_by_type_string():

f = PlainTextFormatter()

type_str = "%s.%s" % (C.__module__, "C")

f.for_type(type_str, foo_printer)

# verify insertion

assert _mod_name_key(C) in f.deferred_printers

assert C not in f.type_printers

assert f.lookup_by_type(type_str) is foo_printer

# lookup by string doesn't cause import

assert _mod_name_key(C) in f.deferred_printers

assert C not in f.type_printers

assert f.lookup_by_type(C) is foo_printer

# should move from deferred to imported dict

assert _mod_name_key(C) not in f.deferred_printers

assert C in f.type_printers

def test_in_formatter():

f = PlainTextFormatter()

f.for_type(C, foo_printer)

type_str = "%s.%s" % (C.__module__, "C")

assert C in f

assert type_str in f

def test_string_in_formatter():

f = PlainTextFormatter()

type_str = "%s.%s" % (C.__module__, "C")

f.for_type(type_str, foo_printer)

assert type_str in f

assert C in f

def test_pop():

f = PlainTextFormatter()

f.for_type(C, foo_printer)

assert f.lookup_by_type(C) is foo_printer

assert f.pop(C, None) is foo_printer

f.for_type(C, foo_printer)

assert f.pop(C) is foo_printer

with pytest.raises(KeyError):

f.lookup_by_type(C)

with pytest.raises(KeyError):

f.pop(C)

with pytest.raises(KeyError):

f.pop(A)

assert f.pop(A, None) is None

def test_pop_string():

f = PlainTextFormatter()

type_str = "%s.%s" % (C.__module__, "C")

with pytest.raises(KeyError):

f.pop(type_str)

f.for_type(type_str, foo_printer)

f.pop(type_str)

with pytest.raises(KeyError):

f.lookup_by_type(C)

with pytest.raises(KeyError):

f.pop(type_str)

f.for_type(C, foo_printer)

assert f.pop(type_str, None) is foo_printer

with pytest.raises(KeyError):

f.lookup_by_type(C)

with pytest.raises(KeyError):

f.pop(type_str)

assert f.pop(type_str, None) is None

def test_error_method():

f = HTMLFormatter()

class BadHTML(object):

def _repr_html_(self):

raise ValueError("Bad HTML")

bad = BadHTML()

with capture_output() as captured:

result = f(bad)

assert result is None

assert "Traceback" in captured.stdout

assert "Bad HTML" in captured.stdout

assert "_repr_html_" in captured.stdout

def test_nowarn_notimplemented():

f = HTMLFormatter()

class HTMLNotImplemented(object):

def _repr_html_(self):

raise NotImplementedError

h = HTMLNotImplemented()

with capture_output() as captured:

result = f(h)

assert result is None

assert "" == captured.stderr

assert "" == captured.stdout

def test_warn_error_for_type():

f = HTMLFormatter()

f.for_type(int, lambda i: name_error)

with capture_output() as captured:

result = f(5)

assert result is None

assert "Traceback" in captured.stdout

assert "NameError" in captured.stdout

assert "name_error" in captured.stdout

def test_error_pretty_method():

f = PlainTextFormatter()

class BadPretty(object):

def _repr_pretty_(self):

return "hello"

bad = BadPretty()

with capture_output() as captured:

result = f(bad)

assert result is None

assert "Traceback" in captured.stdout

assert "_repr_pretty_" in captured.stdout

assert "given" in captured.stdout

assert "argument" in captured.stdout

def test_bad_repr_traceback():

f = PlainTextFormatter()

bad = BadRepr()

with capture_output() as captured:

result = f(bad)

# catches error, returns None

assert result is None

assert "Traceback" in captured.stdout

assert "__repr__" in captured.stdout

assert "ValueError" in captured.stdout

class MakePDF(object):

def _repr_pdf_(self):

return "PDF"

def test_pdf_formatter():

pdf = MakePDF()

f = PDFFormatter()

assert f(pdf) == "PDF"

def test_print_method_bound():

f = HTMLFormatter()

class MyHTML(object):

def _repr_html_(self):

return "hello"

with capture_output() as captured:

result = f(MyHTML)

assert result is None

assert "FormatterWarning" not in captured.stderr

with capture_output() as captured:

result = f(MyHTML())

assert result == "hello"

assert captured.stderr == ""

def test_print_method_weird():

class TextMagicHat(object):

def __getattr__(self, key):

return key

f = HTMLFormatter()

text_hat = TextMagicHat()

assert text_hat._repr_html_ == "_repr_html_"

with capture_output() as captured:

result = f(text_hat)

assert result is None

assert "FormatterWarning" not in captured.stderr

class CallableMagicHat(object):

def __getattr__(self, key):

return lambda: key

call_hat = CallableMagicHat()

with capture_output() as captured:

result = f(call_hat)

assert result is None

class BadReprArgs(object):

def _repr_html_(self, extra, args):

return "html"

bad = BadReprArgs()

with capture_output() as captured:

result = f(bad)

assert result is None

assert "FormatterWarning" not in captured.stderr

def test_format_config():

"""config objects don't pretend to support fancy reprs with lazy attrs"""

f = HTMLFormatter()

cfg = Config()

with capture_output() as captured:

result = f(cfg)

assert result is None

assert captured.stderr == ""

with capture_output() as captured:

result = f(Config)

assert result is None

assert captured.stderr == ""

def test_pretty_max_seq_length():

f = PlainTextFormatter(max_seq_length=1)

lis = list(range(3))

text = f(lis)

assert text == "[0, ...]"

f.max_seq_length = 0

text = f(lis)

assert text == "[0, 1, 2]"

text = f(list(range(1024)))

lines = text.splitlines()

assert len(lines) == 1024

def test_ipython_display_formatter():

"""Objects with _ipython_display_ defined bypass other formatters"""

f = get_ipython().display_formatter

catcher = []

class SelfDisplaying(object):

def _ipython_display_(self):

catcher.append(self)

class NotSelfDisplaying(object):

def __repr__(self):

return "NotSelfDisplaying"

def _ipython_display_(self):

raise NotImplementedError

save_enabled = f.ipython_display_formatter.enabled

f.ipython_display_formatter.enabled = True

yes = SelfDisplaying()

no = NotSelfDisplaying()

d, md = f.format(no)

assert d == {"text/plain": repr(no)}

assert md == {}

assert catcher == []

d, md = f.format(yes)

assert d == {}

assert md == {}

assert catcher == [yes]

f.ipython_display_formatter.enabled = save_enabled

def test_repr_mime():

class HasReprMime(object):

def _repr_mimebundle_(self, include=None, exclude=None):

return {

"application/json+test.v2": {"x": "y"},

"plain/text": "<HasReprMime>",

"image/png": "i-overwrite",

}

def _repr_png_(self):

return "should-be-overwritten"

def _repr_html_(self):

return "<b>hi!</b>"

f = get_ipython().display_formatter

html_f = f.formatters["text/html"]

save_enabled = html_f.enabled

html_f.enabled = True

obj = HasReprMime()

d, md = f.format(obj)

html_f.enabled = save_enabled

assert sorted(d) == [

"application/json+test.v2",

"image/png",

"plain/text",

"text/html",

"text/plain",

]

assert md == {}

d, md = f.format(obj, include={"image/png"})

assert list(d.keys()) == [

"image/png"

], "Include should filter out even things from repr_mimebundle"

assert d["image/png"] == "i-overwrite", "_repr_mimebundle_ take precedence"

def test_pass_correct_include_exclude():

class Tester(object):

def __init__(self, include=None, exclude=None):

self.include = include

self.exclude = exclude

def _repr_mimebundle_(self, include, exclude, **kwargs):

if include and (include != self.include):

raise ValueError("include got modified: display() may be broken.")

if exclude and (exclude != self.exclude):

raise ValueError("exclude got modified: display() may be broken.")

return None

include = {"a", "b", "c"}

exclude = {"c", "e", "f"}

f = get_ipython().display_formatter

f.format(Tester(include=include, exclude=exclude), include=include, exclude=exclude)

f.format(Tester(exclude=exclude), exclude=exclude)

f.format(Tester(include=include), include=include)

def test_repr_mime_meta():

class HasReprMimeMeta(object):

def _repr_mimebundle_(self, include=None, exclude=None):

data = {

"image/png": "base64-image-data",

}

metadata = {

"image/png": {

"width": 5,

"height": 10,

}

}

return (data, metadata)

f = get_ipython().display_formatter

obj = HasReprMimeMeta()

d, md = f.format(obj)

assert sorted(d) == ["image/png", "text/plain"]

assert md == {

"image/png": {

"width": 5,

"height": 10,

}

}

def test_repr_mime_failure():

class BadReprMime(object):

def _repr_mimebundle_(self, include=None, exclude=None):

raise RuntimeError

f = get_ipython().display_formatter

obj = BadReprMime()

d, md = f.format(obj)

assert "text/plain" in d

def test_custom_repr_namedtuple_partialmethod():

from functools import partialmethod

from typing import NamedTuple

class Foo(NamedTuple):

...

Foo.__repr__ = partialmethod(lambda obj: "Hello World")

foo = Foo()

f = PlainTextFormatter()

assert f.pprint

assert f(foo) == "Hello World"