formatters.py
972 lines
| 32.0 KiB
| text/x-python
|
PythonLexer
|
r3209 | # -*- coding: utf-8 -*- | ||
|
r3278 | """Display formatters. | ||
|
r8795 | Inheritance diagram: | ||
.. inheritance-diagram:: IPython.core.formatters | ||||
:parts: 3 | ||||
|
r3209 | """ | ||
|
r18025 | # Copyright (c) IPython Development Team. | ||
# Distributed under the terms of the Modified BSD License. | ||||
|
r3279 | |||
|
r3209 | import abc | ||
|
r15225 | import inspect | ||
|
r19557 | import json | ||
|
r3352 | import sys | ||
|
r19105 | import traceback | ||
|
r9813 | import warnings | ||
|
r3209 | |||
|
r20813 | from decorator import decorator | ||
|
r13977 | |||
|
r21253 | from traitlets.config.configurable import Configurable | ||
|
r18025 | from IPython.core.getipython import get_ipython | ||
|
r21078 | from IPython.utils.sentinel import Sentinel | ||
|
r3413 | from IPython.lib import pretty | ||
|
r21253 | from traitlets import ( | ||
|
r9811 | Bool, Dict, Integer, Unicode, CUnicode, ObjectName, List, | ||
|
r19382 | ForwardDeclaredInstance, | ||
|
r9811 | ) | ||
|
r13781 | from IPython.utils.py3compat import ( | ||
|
r20486 | with_metaclass, string_types, unicode_type, | ||
|
r13781 | ) | ||
|
r13366 | |||
|
r3209 | |||
|
r3222 | #----------------------------------------------------------------------------- | ||
|
r3278 | # The main DisplayFormatter class | ||
|
r3222 | #----------------------------------------------------------------------------- | ||
|
r15217 | |||
|
r19128 | def _safe_get_formatter_method(obj, name): | ||
"""Safely get a formatter method | ||||
|
r15217 | |||
|
r19128 | - Classes cannot have formatter methods, only instance | ||
- protect against proxy objects that claim to have everything | ||||
|
r15217 | """ | ||
|
r19026 | if inspect.isclass(obj): | ||
# repr methods only make sense on instances, not classes | ||||
return None | ||||
|
r15486 | method = pretty._safe_getattr(obj, name, None) | ||
|
r19128 | if callable(method): | ||
# obj claims to have repr method... | ||||
if callable(pretty._safe_getattr(obj, '_ipython_canary_method_should_not_exist_', None)): | ||||
# ...but don't trust proxy objects that claim to have everything | ||||
return None | ||||
|
r15486 | return method | ||
|
r3278 | class DisplayFormatter(Configurable): | ||
|
r3280 | # When set to true only the default plain text formatter will be used. | ||
plain_text_only = Bool(False, config=True) | ||||
|
r9811 | def _plain_text_only_changed(self, name, old, new): | ||
warnings.warn("""DisplayFormatter.plain_text_only is deprecated. | ||||
Use DisplayFormatter.active_types = ['text/plain'] | ||||
for the same effect. | ||||
""", DeprecationWarning) | ||||
if new: | ||||
self.active_types = ['text/plain'] | ||||
else: | ||||
self.active_types = self.format_types | ||||
active_types = List(Unicode, config=True, | ||||
|
r10182 | help="""List of currently active mime-types to display. | ||
You can use this to set a white-list for formats to display. | ||||
Most users will not need to change this value. | ||||
""") | ||||
|
r9811 | def _active_types_default(self): | ||
return self.format_types | ||||
|
r10128 | |||
def _active_types_changed(self, name, old, new): | ||||
|
r10130 | for key, formatter in self.formatters.items(): | ||
|
r10128 | if key in new: | ||
formatter.enabled = True | ||||
else: | ||||
formatter.enabled = False | ||||
|
r19382 | ipython_display_formatter = ForwardDeclaredInstance('FormatterABC') | ||
def _ipython_display_formatter_default(self): | ||||
return IPythonDisplayFormatter(parent=self) | ||||
|
r19381 | |||
|
r3278 | # A dict of formatter whose keys are format types (MIME types) and whose | ||
# values are subclasses of BaseFormatter. | ||||
|
r5228 | formatters = Dict() | ||
|
r3278 | def _formatters_default(self): | ||
"""Activate the default formatters.""" | ||||
formatter_classes = [ | ||||
PlainTextFormatter, | ||||
HTMLFormatter, | ||||
|
r16364 | MarkdownFormatter, | ||
|
r3278 | SVGFormatter, | ||
PNGFormatter, | ||||
|
r15121 | PDFFormatter, | ||
|
r4528 | JPEGFormatter, | ||
|
r3278 | LatexFormatter, | ||
|
r3878 | JSONFormatter, | ||
JavascriptFormatter | ||||
|
r3278 | ] | ||
d = {} | ||||
for cls in formatter_classes: | ||||
|
r11064 | f = cls(parent=self) | ||
|
r3278 | d[f.format_type] = f | ||
return d | ||||
def format(self, obj, include=None, exclude=None): | ||||
"""Return a format data dict for an object. | ||||
By default all format types will be computed. | ||||
The following MIME types are currently implemented: | ||||
* text/plain | ||||
* text/html | ||||
|
r16364 | * text/markdown | ||
|
r3278 | * text/latex | ||
* application/json | ||||
|
r4526 | * application/javascript | ||
|
r15121 | * application/pdf | ||
|
r3278 | * image/png | ||
|
r4528 | * image/jpeg | ||
|
r4526 | * image/svg+xml | ||
|
r3278 | |||
Parameters | ||||
---------- | ||||
obj : object | ||||
The Python object whose format data will be computed. | ||||
|
r3282 | include : list or tuple, optional | ||
A list of format type strings (MIME types) to include in the | ||||
format data dict. If this is set *only* the format types included | ||||
in this list will be computed. | ||||
exclude : list or tuple, optional | ||||
|
r9811 | A list of format type string (MIME types) to exclude in the format | ||
|
r3282 | data dict. If this is set all format types will be computed, | ||
except for those included in this argument. | ||||
|
r3278 | |||
Returns | ||||
------- | ||||
|
r10446 | (format_dict, metadata_dict) : tuple of two dicts | ||
format_dict is a dictionary of key/value pairs, one of each format that was | ||||
|
r3278 | generated for the object. The keys are the format types, which | ||
will usually be MIME type strings and the values and JSON'able | ||||
data structure containing the raw data for the representation in | ||||
that format. | ||||
|
r10446 | |||
metadata_dict is a dictionary of metadata about each mime-type output. | ||||
Its keys will be a strict subset of the keys in format_dict. | ||||
|
r3278 | """ | ||
format_dict = {} | ||||
|
r10443 | md_dict = {} | ||
|
r19381 | |||
|
r19382 | if self.ipython_display_formatter(obj): | ||
|
r19381 | # object handled itself, don't proceed | ||
return {}, {} | ||||
|
r3278 | for format_type, formatter in self.formatters.items(): | ||
|
r10129 | if include and format_type not in include: | ||
continue | ||||
if exclude and format_type in exclude: | ||||
|
r9811 | continue | ||
|
r10443 | |||
md = None | ||||
|
r3278 | try: | ||
data = formatter(obj) | ||||
except: | ||||
# FIXME: log the exception | ||||
raise | ||||
|
r10443 | |||
# formatters can return raw data or (data, metadata) | ||||
if isinstance(data, tuple) and len(data) == 2: | ||||
data, md = data | ||||
|
r3278 | if data is not None: | ||
format_dict[format_type] = data | ||||
|
r10443 | if md is not None: | ||
md_dict[format_type] = md | ||||
return format_dict, md_dict | ||||
|
r3278 | |||
@property | ||||
def format_types(self): | ||||
"""Return the format types (MIME types) of the active formatters.""" | ||||
|
r13364 | return list(self.formatters.keys()) | ||
|
r3278 | |||
#----------------------------------------------------------------------------- | ||||
# Formatters for specific format types (text, html, svg, etc.) | ||||
#----------------------------------------------------------------------------- | ||||
|
r18025 | |||
def _safe_repr(obj): | ||||
"""Try to return a repr of an object | ||||
always returns a string, at least. | ||||
""" | ||||
try: | ||||
return repr(obj) | ||||
except Exception as e: | ||||
return "un-repr-able object (%r)" % e | ||||
|
r14637 | class FormatterWarning(UserWarning): | ||
"""Warning class for errors in formatters""" | ||||
|
r13977 | @decorator | ||
|
r19929 | def catch_format_error(method, self, *args, **kwargs): | ||
"""show traceback on failed format call""" | ||||
|
r13977 | try: | ||
|
r14152 | r = method(self, *args, **kwargs) | ||
|
r19105 | except NotImplementedError: | ||
|
r14635 | # don't warn on NotImplementedErrors | ||
return None | ||||
|
r18025 | except Exception: | ||
exc_info = sys.exc_info() | ||||
ip = get_ipython() | ||||
if ip is not None: | ||||
ip.showtraceback(exc_info) | ||||
else: | ||||
traceback.print_exception(*exc_info) | ||||
|
r13977 | return None | ||
|
r19557 | return self._check_return(r, args[0]) | ||
|
r13977 | |||
|
r13359 | class FormatterABC(with_metaclass(abc.ABCMeta, object)): | ||
|
r3278 | """ Abstract base class for Formatters. | ||
A formatter is a callable class that is responsible for computing the | ||||
raw format data for a particular format type (MIME type). For example, | ||||
an HTML formatter would have a format type of `text/html` and would return | ||||
the HTML representation of the object when called. | ||||
|
r3209 | """ | ||
|
r3278 | # The format type of the data returned, usually a MIME type. | ||
format_type = 'text/plain' | ||||
|
r3209 | |||
|
r3280 | # Is the formatter enabled... | ||
enabled = True | ||||
|
r13977 | |||
|
r3278 | @abc.abstractmethod | ||
def __call__(self, obj): | ||||
"""Return a JSON'able representation of the object. | ||||
|
r13977 | If the object cannot be formatted by this formatter, | ||
warn and return None. | ||||
|
r3278 | """ | ||
|
r13977 | return repr(obj) | ||
|
r3278 | |||
|
r13781 | def _mod_name_key(typ): | ||
|
r13788 | """Return a (__module__, __name__) tuple for a type. | ||
Used as key in Formatter.deferred_printers. | ||||
""" | ||||
|
r13781 | module = getattr(typ, '__module__', None) | ||
name = getattr(typ, '__name__', None) | ||||
return (module, name) | ||||
def _get_type(obj): | ||||
"""Return the type of an instance (old and new-style)""" | ||||
return getattr(obj, '__class__', None) or type(obj) | ||||
|
r21045 | |||
_raise_key_error = Sentinel('_raise_key_error', __name__, | ||||
""" | ||||
Special value to raise a KeyError | ||||
Raise KeyError in `BaseFormatter.pop` if passed as the default value to `pop` | ||||
""") | ||||
|
r13781 | |||
|
r13977 | |||
|
r3278 | class BaseFormatter(Configurable): | ||
"""A base formatter class that is configurable. | ||||
This formatter should usually be used as the base class of all formatters. | ||||
It is a traited :class:`Configurable` class and includes an extensible | ||||
API for users to determine how their objects are formatted. The following | ||||
logic is used to find a function to format an given object. | ||||
1. The object is introspected to see if it has a method with the name | ||||
:attr:`print_method`. If is does, that object is passed to that method | ||||
for formatting. | ||||
2. If no print method is found, three internal dictionaries are consulted | ||||
to find print method: :attr:`singleton_printers`, :attr:`type_printers` | ||||
and :attr:`deferred_printers`. | ||||
|
r3288 | Users should use these dictionaries to register functions that will be | ||
used to compute the format data for their objects (if those objects don't | ||||
have the special print methods). The easiest way of using these | ||||
dictionaries is through the :meth:`for_type` and :meth:`for_type_by_name` | ||||
methods. | ||||
|
r3278 | |||
If no function/callable is found to compute the format data, ``None`` is | ||||
returned and this format type is not used. | ||||
""" | ||||
|
r4046 | format_type = Unicode('text/plain') | ||
|
r14152 | _return_type = string_types | ||
|
r3278 | |||
|
r3280 | enabled = Bool(True, config=True) | ||
|
r4047 | print_method = ObjectName('__repr__') | ||
|
r3278 | |||
# The singleton printers. | ||||
# Maps the IDs of the builtin singleton objects to the format functions. | ||||
singleton_printers = Dict(config=True) | ||||
# The type-specific printers. | ||||
# Map type objects to the format functions. | ||||
type_printers = Dict(config=True) | ||||
# The deferred-import type-specific printers. | ||||
# Map (modulename, classname) pairs to the format functions. | ||||
deferred_printers = Dict(config=True) | ||||
|
r14152 | |||
|
r19929 | @catch_format_error | ||
|
r3278 | def __call__(self, obj): | ||
"""Compute the format for an object.""" | ||||
|
r3280 | if self.enabled: | ||
|
r13977 | # lookup registered printer | ||
|
r3278 | try: | ||
|
r13977 | printer = self.lookup(obj) | ||
except KeyError: | ||||
|
r3280 | pass | ||
|
r13977 | else: | ||
return printer(obj) | ||||
# Finally look for special method names | ||||
|
r15486 | method = _safe_get_formatter_method(obj, self.print_method) | ||
if method is not None: | ||||
|
r13977 | return method() | ||
return None | ||||
|
r3280 | else: | ||
|
r3278 | return None | ||
|
r13781 | |||
|
r13788 | def __contains__(self, typ): | ||
"""map in to lookup_by_type""" | ||||
try: | ||||
self.lookup_by_type(typ) | ||||
except KeyError: | ||||
return False | ||||
else: | ||||
return True | ||||
|
r19557 | def _check_return(self, r, obj): | ||
"""Check that a return value is appropriate | ||||
Return the value if so, None otherwise, warning if invalid. | ||||
""" | ||||
if r is None or isinstance(r, self._return_type) or \ | ||||
(isinstance(r, tuple) and r and isinstance(r[0], self._return_type)): | ||||
return r | ||||
else: | ||||
warnings.warn( | ||||
"%s formatter returned invalid type %s (expected %s) for object: %s" % \ | ||||
(self.format_type, type(r), self._return_type, _safe_repr(obj)), | ||||
FormatterWarning | ||||
) | ||||
|
r13781 | def lookup(self, obj): | ||
"""Look up the formatter for a given instance. | ||||
Parameters | ||||
---------- | ||||
obj : object instance | ||||
Returns | ||||
------- | ||||
f : callable | ||||
|
r13788 | The registered formatting callable for the type. | ||
|
r13781 | |||
Raises | ||||
------ | ||||
KeyError if the type has not been registered. | ||||
""" | ||||
# look for singleton first | ||||
obj_id = id(obj) | ||||
if obj_id in self.singleton_printers: | ||||
return self.singleton_printers[obj_id] | ||||
# then lookup by type | ||||
return self.lookup_by_type(_get_type(obj)) | ||||
def lookup_by_type(self, typ): | ||||
|
r13788 | """Look up the registered formatter for a type. | ||
|
r13781 | |||
Parameters | ||||
---------- | ||||
|
r13790 | typ : type or '__module__.__name__' string for a type | ||
|
r13781 | |||
Returns | ||||
------- | ||||
f : callable | ||||
|
r13788 | The registered formatting callable for the type. | ||
|
r3278 | |||
|
r13781 | Raises | ||
------ | ||||
KeyError if the type has not been registered. | ||||
""" | ||||
|
r13788 | if isinstance(typ, string_types): | ||
typ_key = tuple(typ.rsplit('.',1)) | ||||
if typ_key not in self.deferred_printers: | ||||
# We may have it cached in the type map. We will have to | ||||
# iterate over all of the types to check. | ||||
for cls in self.type_printers: | ||||
if _mod_name_key(cls) == typ_key: | ||||
return self.type_printers[cls] | ||||
else: | ||||
return self.deferred_printers[typ_key] | ||||
else: | ||||
for cls in pretty._get_mro(typ): | ||||
if cls in self.type_printers or self._in_deferred_types(cls): | ||||
return self.type_printers[cls] | ||||
|
r13781 | |||
# If we have reached here, the lookup failed. | ||||
raise KeyError("No registered printer for {0!r}".format(typ)) | ||||
def for_type(self, typ, func=None): | ||||
|
r3278 | """Add a format function for a given type. | ||
|
r13654 | |||
|
r3288 | Parameters | ||
|
r3278 | ----------- | ||
|
r13790 | typ : type or '__module__.__name__' string for a type | ||
|
r3278 | The class of the object that will be formatted using `func`. | ||
func : callable | ||||
|
r13654 | A callable for computing the format data. | ||
`func` will be called with the object to be formatted, | ||||
and will return the raw data in this formatter's format. | ||||
Subclasses may use a different call signature for the | ||||
|
r3278 | `func` argument. | ||
|
r13654 | |||
|
r13781 | If `func` is None or not specified, there will be no change, | ||
|
r13654 | only returning the current value. | ||
Returns | ||||
------- | ||||
oldfunc : callable | ||||
The currently registered callable. | ||||
If you are registering a new formatter, | ||||
this will be the previous value (to enable restoring later). | ||||
|
r3278 | """ | ||
|
r13781 | # if string given, interpret as 'pkg.module.class_name' | ||
if isinstance(typ, string_types): | ||||
type_module, type_name = typ.rsplit('.', 1) | ||||
return self.for_type_by_name(type_module, type_name, func) | ||||
try: | ||||
oldfunc = self.lookup_by_type(typ) | ||||
except KeyError: | ||||
oldfunc = None | ||||
if func is not None: | ||||
|
r3278 | self.type_printers[typ] = func | ||
|
r13781 | |||
|
r3278 | return oldfunc | ||
|
r13781 | def for_type_by_name(self, type_module, type_name, func=None): | ||
|
r3278 | """Add a format function for a type specified by the full dotted | ||
module and name of the type, rather than the type of the object. | ||||
Parameters | ||||
---------- | ||||
type_module : str | ||||
The full dotted name of the module the type is defined in, like | ||||
``numpy``. | ||||
type_name : str | ||||
The name of the type (the class name), like ``dtype`` | ||||
func : callable | ||||
|
r13654 | A callable for computing the format data. | ||
`func` will be called with the object to be formatted, | ||||
and will return the raw data in this formatter's format. | ||||
Subclasses may use a different call signature for the | ||||
|
r3278 | `func` argument. | ||
|
r13654 | |||
|
r13781 | If `func` is None or unspecified, there will be no change, | ||
|
r13654 | only returning the current value. | ||
Returns | ||||
------- | ||||
oldfunc : callable | ||||
The currently registered callable. | ||||
If you are registering a new formatter, | ||||
this will be the previous value (to enable restoring later). | ||||
|
r3278 | """ | ||
key = (type_module, type_name) | ||||
|
r13781 | |||
|
r13788 | try: | ||
oldfunc = self.lookup_by_type("%s.%s" % key) | ||||
except KeyError: | ||||
oldfunc = None | ||||
|
r13781 | if func is not None: | ||
|
r3278 | self.deferred_printers[key] = func | ||
return oldfunc | ||||
|
r13781 | |||
|
r13788 | def pop(self, typ, default=_raise_key_error): | ||
"""Pop a formatter for the given type. | ||||
|
r13781 | |||
Parameters | ||||
---------- | ||||
typ : type or '__module__.__name__' string for a type | ||||
|
r13788 | default : object | ||
value to be returned if no formatter is registered for typ. | ||||
|
r13781 | |||
Returns | ||||
------- | ||||
obj : object | ||||
The last registered object for the type. | ||||
Raises | ||||
------ | ||||
|
r13788 | KeyError if the type is not registered and default is not specified. | ||
|
r13781 | """ | ||
|
r13788 | |||
|
r13781 | if isinstance(typ, string_types): | ||
typ_key = tuple(typ.rsplit('.',1)) | ||||
if typ_key not in self.deferred_printers: | ||||
# We may have it cached in the type map. We will have to | ||||
# iterate over all of the types to check. | ||||
for cls in self.type_printers: | ||||
if _mod_name_key(cls) == typ_key: | ||||
old = self.type_printers.pop(cls) | ||||
break | ||||
else: | ||||
|
r13788 | old = default | ||
|
r13781 | else: | ||
|
r13783 | old = self.deferred_printers.pop(typ_key) | ||
|
r13781 | else: | ||
if typ in self.type_printers: | ||||
old = self.type_printers.pop(typ) | ||||
else: | ||||
|
r13788 | old = self.deferred_printers.pop(_mod_name_key(typ), default) | ||
if old is _raise_key_error: | ||||
raise KeyError("No registered value for {0!r}".format(typ)) | ||||
|
r13781 | return old | ||
|
r3278 | |||
|
r3279 | def _in_deferred_types(self, cls): | ||
""" | ||||
Check if the given class is specified in the deferred type registry. | ||||
|
r13781 | Successful matches will be moved to the regular type registry for future use. | ||
|
r3279 | """ | ||
mod = getattr(cls, '__module__', None) | ||||
name = getattr(cls, '__name__', None) | ||||
key = (mod, name) | ||||
if key in self.deferred_printers: | ||||
# Move the printer over to the regular registry. | ||||
printer = self.deferred_printers.pop(key) | ||||
self.type_printers[cls] = printer | ||||
|
r13781 | return True | ||
return False | ||||
|
r3278 | |||
|
r3280 | |||
|
r3278 | class PlainTextFormatter(BaseFormatter): | ||
"""The default pretty-printer. | ||||
|
r6292 | This uses :mod:`IPython.lib.pretty` to compute the format data of | ||
|
r3278 | the object. If the object cannot be pretty printed, :func:`repr` is used. | ||
|
r6292 | See the documentation of :mod:`IPython.lib.pretty` for details on | ||
|
r3278 | how to write pretty printers. Here is a simple example:: | ||
def dtype_pprinter(obj, p, cycle): | ||||
if cycle: | ||||
return p.text('dtype(...)') | ||||
if hasattr(obj, 'fields'): | ||||
if obj.fields is None: | ||||
p.text(repr(obj)) | ||||
else: | ||||
p.begin_group(7, 'dtype([') | ||||
for i, field in enumerate(obj.descr): | ||||
if i > 0: | ||||
p.text(',') | ||||
p.breakable() | ||||
p.pretty(field) | ||||
p.end_group(7, '])') | ||||
""" | ||||
# The format type of data returned. | ||||
|
r4046 | format_type = Unicode('text/plain') | ||
|
r3278 | |||
|
r3280 | # This subclass ignores this attribute as it always need to return | ||
# something. | ||||
enabled = Bool(True, config=False) | ||||
|
r18518 | |||
max_seq_length = Integer(pretty.MAX_SEQ_LENGTH, config=True, | ||||
help="""Truncate large collections (lists, dicts, tuples, sets) to this size. | ||||
Set to 0 to disable truncation. | ||||
""" | ||||
) | ||||
|
r3879 | # Look for a _repr_pretty_ methods to use for pretty printing. | ||
|
r4047 | print_method = ObjectName('_repr_pretty_') | ||
|
r3209 | |||
# Whether to pretty-print or not. | ||||
|
r3210 | pprint = Bool(True, config=True) | ||
|
r3209 | |||
# Whether to be verbose or not. | ||||
|
r3210 | verbose = Bool(False, config=True) | ||
|
r3209 | |||
# The maximum width. | ||||
|
r5344 | max_width = Integer(79, config=True) | ||
|
r3209 | |||
# The newline character. | ||||
|
r4046 | newline = Unicode('\n', config=True) | ||
|
r4872 | |||
|
r3350 | # format-string for pprinting floats | ||
|
r4046 | float_format = Unicode('%r') | ||
|
r3350 | # setter for float precision, either int or direct format-string | ||
|
r4046 | float_precision = CUnicode('', config=True) | ||
|
r4872 | |||
|
r3350 | def _float_precision_changed(self, name, old, new): | ||
"""float_precision changed, set float_format accordingly. | ||||
|
r4872 | |||
|
r3350 | float_precision can be set by int or str. | ||
This will set float_format, after interpreting input. | ||||
If numpy has been imported, numpy print precision will also be set. | ||||
|
r4872 | |||
|
r3350 | integer `n` sets format to '%.nf', otherwise, format set directly. | ||
|
r4872 | |||
|
r3350 | An empty string returns to defaults (repr for float, 8 for numpy). | ||
|
r4872 | |||
|
r3350 | This parameter can be set via the '%precision' magic. | ||
""" | ||||
|
r4872 | |||
|
r3350 | if '%' in new: | ||
# got explicit format string | ||||
fmt = new | ||||
try: | ||||
fmt%3.14159 | ||||
except Exception: | ||||
raise ValueError("Precision must be int or format string, not %r"%new) | ||||
elif new: | ||||
# otherwise, should be an int | ||||
try: | ||||
i = int(new) | ||||
assert i >= 0 | ||||
except ValueError: | ||||
raise ValueError("Precision must be int or format string, not %r"%new) | ||||
except AssertionError: | ||||
raise ValueError("int precision must be non-negative, not %r"%i) | ||||
|
r4872 | |||
|
r3350 | fmt = '%%.%if'%i | ||
if 'numpy' in sys.modules: | ||||
# set numpy precision if it has been imported | ||||
import numpy | ||||
numpy.set_printoptions(precision=i) | ||||
else: | ||||
# default back to repr | ||||
fmt = '%r' | ||||
if 'numpy' in sys.modules: | ||||
import numpy | ||||
# numpy default is 8 | ||||
numpy.set_printoptions(precision=8) | ||||
self.float_format = fmt | ||||
|
r3209 | |||
|
r6292 | # Use the default pretty printers from IPython.lib.pretty. | ||
|
r3278 | def _singleton_printers_default(self): | ||
|
r3209 | return pretty._singleton_pprinters.copy() | ||
|
r3278 | def _type_printers_default(self): | ||
|
r3350 | d = pretty._type_pprinters.copy() | ||
d[float] = lambda obj,p,cycle: p.text(self.float_format%obj) | ||||
return d | ||||
|
r3209 | |||
|
r3278 | def _deferred_printers_default(self): | ||
|
r3209 | return pretty._deferred_type_pprinters.copy() | ||
#### FormatterABC interface #### | ||||
|
r19929 | @catch_format_error | ||
|
r3209 | def __call__(self, obj): | ||
|
r3278 | """Compute the pretty representation of the object.""" | ||
|
r3209 | if not self.pprint: | ||
|
r18025 | return repr(obj) | ||
|
r3209 | else: | ||
|
r20486 | # handle str and unicode on Python 2 | ||
# io.StringIO only accepts unicode, | ||||
# cStringIO doesn't handle unicode on py2, | ||||
# StringIO allows str, unicode but only ascii str | ||||
stream = pretty.CUnicodeIO() | ||||
|
r3209 | printer = pretty.RepresentationPrinter(stream, self.verbose, | ||
|
r20486 | self.max_width, self.newline, | ||
|
r18518 | max_seq_length=self.max_seq_length, | ||
|
r3278 | singleton_pprinters=self.singleton_printers, | ||
type_pprinters=self.type_printers, | ||||
deferred_pprinters=self.deferred_printers) | ||||
|
r3209 | printer.pretty(obj) | ||
printer.flush() | ||||
return stream.getvalue() | ||||
|
r3278 | class HTMLFormatter(BaseFormatter): | ||
"""An HTML formatter. | ||||
|
r3209 | |||
|
r3278 | To define the callables that compute the HTML representation of your | ||
|
r3878 | objects, define a :meth:`_repr_html_` method or use the :meth:`for_type` | ||
|
r3278 | or :meth:`for_type_by_name` methods to register functions that handle | ||
this. | ||||
|
r3880 | |||
The return value of this formatter should be a valid HTML snippet that | ||||
|
r4872 | could be injected into an existing DOM. It should *not* include the | ||
|
r3880 | ```<html>`` or ```<body>`` tags. | ||
|
r3278 | """ | ||
|
r4046 | format_type = Unicode('text/html') | ||
|
r3209 | |||
|
r4047 | print_method = ObjectName('_repr_html_') | ||
|
r3209 | |||
|
r16364 | class MarkdownFormatter(BaseFormatter): | ||
"""A Markdown formatter. | ||||
To define the callables that compute the Markdown representation of your | ||||
objects, define a :meth:`_repr_markdown_` method or use the :meth:`for_type` | ||||
or :meth:`for_type_by_name` methods to register functions that handle | ||||
this. | ||||
The return value of this formatter should be a valid Markdown. | ||||
""" | ||||
format_type = Unicode('text/markdown') | ||||
print_method = ObjectName('_repr_markdown_') | ||||
|
r3278 | class SVGFormatter(BaseFormatter): | ||
"""An SVG formatter. | ||||
To define the callables that compute the SVG representation of your | ||||
|
r3878 | objects, define a :meth:`_repr_svg_` method or use the :meth:`for_type` | ||
|
r3278 | or :meth:`for_type_by_name` methods to register functions that handle | ||
this. | ||||
|
r3880 | |||
The return value of this formatter should be valid SVG enclosed in | ||||
```<svg>``` tags, that could be injected into an existing DOM. It should | ||||
*not* include the ```<html>`` or ```<body>`` tags. | ||||
|
r3209 | """ | ||
|
r4046 | format_type = Unicode('image/svg+xml') | ||
|
r3209 | |||
|
r4047 | print_method = ObjectName('_repr_svg_') | ||
|
r3209 | |||
|
r3278 | class PNGFormatter(BaseFormatter): | ||
"""A PNG formatter. | ||||
|
r3214 | |||
|
r3278 | To define the callables that compute the PNG representation of your | ||
|
r3878 | objects, define a :meth:`_repr_png_` method or use the :meth:`for_type` | ||
|
r3278 | or :meth:`for_type_by_name` methods to register functions that handle | ||
|
r3878 | this. | ||
|
r3880 | The return value of this formatter should be raw PNG data, *not* | ||
base64 encoded. | ||||
|
r3278 | """ | ||
|
r4046 | format_type = Unicode('image/png') | ||
|
r3278 | |||
|
r4047 | print_method = ObjectName('_repr_png_') | ||
|
r14152 | |||
|
r14162 | _return_type = (bytes, unicode_type) | ||
|
r3278 | |||
|
r4528 | class JPEGFormatter(BaseFormatter): | ||
"""A JPEG formatter. | ||||
To define the callables that compute the JPEG representation of your | ||||
objects, define a :meth:`_repr_jpeg_` method or use the :meth:`for_type` | ||||
or :meth:`for_type_by_name` methods to register functions that handle | ||||
this. | ||||
The return value of this formatter should be raw JPEG data, *not* | ||||
base64 encoded. | ||||
""" | ||||
format_type = Unicode('image/jpeg') | ||||
print_method = ObjectName('_repr_jpeg_') | ||||
|
r14162 | _return_type = (bytes, unicode_type) | ||
|
r14152 | |||
|
r4528 | |||
|
r3278 | class LatexFormatter(BaseFormatter): | ||
"""A LaTeX formatter. | ||||
To define the callables that compute the LaTeX representation of your | ||||
|
r3878 | objects, define a :meth:`_repr_latex_` method or use the :meth:`for_type` | ||
|
r3278 | or :meth:`for_type_by_name` methods to register functions that handle | ||
this. | ||||
|
r3880 | |||
The return value of this formatter should be a valid LaTeX equation, | ||||
|
r6065 | enclosed in either ```$```, ```$$``` or another LaTeX equation | ||
environment. | ||||
|
r3278 | """ | ||
|
r4046 | format_type = Unicode('text/latex') | ||
|
r3278 | |||
|
r4047 | print_method = ObjectName('_repr_latex_') | ||
|
r3278 | |||
class JSONFormatter(BaseFormatter): | ||||
"""A JSON string formatter. | ||||
|
r19557 | To define the callables that compute the JSONable representation of | ||
|
r3878 | your objects, define a :meth:`_repr_json_` method or use the :meth:`for_type` | ||
|
r3278 | or :meth:`for_type_by_name` methods to register functions that handle | ||
this. | ||||
|
r3880 | |||
|
r19557 | The return value of this formatter should be a JSONable list or dict. | ||
JSON scalars (None, number, string) are not allowed, only dict or list containers. | ||||
|
r3278 | """ | ||
|
r4046 | format_type = Unicode('application/json') | ||
|
r19557 | _return_type = (list, dict) | ||
|
r3278 | |||
|
r4047 | print_method = ObjectName('_repr_json_') | ||
|
r19557 | |||
def _check_return(self, r, obj): | ||||
"""Check that a return value is appropriate | ||||
Return the value if so, None otherwise, warning if invalid. | ||||
""" | ||||
if r is None: | ||||
return | ||||
md = None | ||||
if isinstance(r, tuple): | ||||
# unpack data, metadata tuple for type checking on first element | ||||
r, md = r | ||||
# handle deprecated JSON-as-string form from IPython < 3 | ||||
if isinstance(r, string_types): | ||||
warnings.warn("JSON expects JSONable list/dict containers, not JSON strings", | ||||
FormatterWarning) | ||||
r = json.loads(r) | ||||
if md is not None: | ||||
# put the tuple back together | ||||
r = (r, md) | ||||
return super(JSONFormatter, self)._check_return(r, obj) | ||||
|
r3878 | |||
class JavascriptFormatter(BaseFormatter): | ||||
"""A Javascript formatter. | ||||
To define the callables that compute the Javascript representation of | ||||
|
r4872 | your objects, define a :meth:`_repr_javascript_` method or use the | ||
|
r3878 | :meth:`for_type` or :meth:`for_type_by_name` methods to register functions | ||
that handle this. | ||||
|
r3880 | |||
The return value of this formatter should be valid Javascript code and | ||||
should *not* be enclosed in ```<script>``` tags. | ||||
|
r3878 | """ | ||
|
r4046 | format_type = Unicode('application/javascript') | ||
|
r3278 | |||
|
r4047 | print_method = ObjectName('_repr_javascript_') | ||
|
r3278 | |||
|
r15121 | |||
class PDFFormatter(BaseFormatter): | ||||
"""A PDF formatter. | ||||
|
r16283 | To define the callables that compute the PDF representation of your | ||
|
r15121 | objects, define a :meth:`_repr_pdf_` method or use the :meth:`for_type` | ||
or :meth:`for_type_by_name` methods to register functions that handle | ||||
this. | ||||
The return value of this formatter should be raw PDF data, *not* | ||||
base64 encoded. | ||||
""" | ||||
format_type = Unicode('application/pdf') | ||||
print_method = ObjectName('_repr_pdf_') | ||||
|
r18123 | _return_type = (bytes, unicode_type) | ||
|
r19382 | class IPythonDisplayFormatter(BaseFormatter): | ||
|
r19381 | """A Formatter for objects that know how to display themselves. | ||
To define the callables that compute the representation of your | ||||
objects, define a :meth:`_ipython_display_` method or use the :meth:`for_type` | ||||
or :meth:`for_type_by_name` methods to register functions that handle | ||||
this. Unlike mime-type displays, this method should not return anything, | ||||
instead calling any appropriate display methods itself. | ||||
This display formatter has highest priority. | ||||
If it fires, no other display formatter will be called. | ||||
""" | ||||
print_method = ObjectName('_ipython_display_') | ||||
_return_type = (type(None), bool) | ||||
|
r19929 | @catch_format_error | ||
|
r19381 | def __call__(self, obj): | ||
"""Compute the format for an object.""" | ||||
if self.enabled: | ||||
# lookup registered printer | ||||
try: | ||||
printer = self.lookup(obj) | ||||
except KeyError: | ||||
pass | ||||
else: | ||||
printer(obj) | ||||
return True | ||||
# Finally look for special method names | ||||
method = _safe_get_formatter_method(obj, self.print_method) | ||||
if method is not None: | ||||
method() | ||||
return True | ||||
|
r15121 | |||
|
r3278 | FormatterABC.register(BaseFormatter) | ||
FormatterABC.register(PlainTextFormatter) | ||||
FormatterABC.register(HTMLFormatter) | ||||
|
r16364 | FormatterABC.register(MarkdownFormatter) | ||
|
r3278 | FormatterABC.register(SVGFormatter) | ||
FormatterABC.register(PNGFormatter) | ||||
|
r15121 | FormatterABC.register(PDFFormatter) | ||
|
r4528 | FormatterABC.register(JPEGFormatter) | ||
|
r3278 | FormatterABC.register(LatexFormatter) | ||
FormatterABC.register(JSONFormatter) | ||||
|
r3878 | FormatterABC.register(JavascriptFormatter) | ||
|
r19382 | FormatterABC.register(IPythonDisplayFormatter) | ||
|
r3278 | |||
def format_display_data(obj, include=None, exclude=None): | ||||
"""Return a format data dict for an object. | ||||
By default all format types will be computed. | ||||
The following MIME types are currently implemented: | ||||
* text/plain | ||||
* text/html | ||||
|
r16364 | * text/markdown | ||
|
r3278 | * text/latex | ||
* application/json | ||||
|
r4526 | * application/javascript | ||
|
r15121 | * application/pdf | ||
|
r3278 | * image/png | ||
|
r4528 | * image/jpeg | ||
|
r4526 | * image/svg+xml | ||
|
r3278 | |||
Parameters | ||||
---------- | ||||
obj : object | ||||
The Python object whose format data will be computed. | ||||
Returns | ||||
------- | ||||
format_dict : dict | ||||
A dictionary of key/value pairs, one or each format that was | ||||
generated for the object. The keys are the format types, which | ||||
will usually be MIME type strings and the values and JSON'able | ||||
data structure containing the raw data for the representation in | ||||
that format. | ||||
include : list or tuple, optional | ||||
A list of format type strings (MIME types) to include in the | ||||
format data dict. If this is set *only* the format types included | ||||
in this list will be computed. | ||||
exclude : list or tuple, optional | ||||
A list of format type string (MIME types) to exclue in the format | ||||
data dict. If this is set all format types will be computed, | ||||
except for those included in this argument. | ||||
""" | ||||
from IPython.core.interactiveshell import InteractiveShell | ||||
|
r3209 | |||
|
r3278 | InteractiveShell.instance().display_formatter.format( | ||
obj, | ||||
include, | ||||
exclude | ||||
) | ||||
|
r4528 | |||