display.py
1290 lines
| 41.5 KiB
| text/x-python
|
PythonLexer
|
r3278 | # -*- coding: utf-8 -*- | ||
|
r19557 | """Top-level display functions for displaying object in different formats.""" | ||
|
r3278 | |||
|
r19557 | # Copyright (c) IPython Development Team. | ||
# Distributed under the terms of the Modified BSD License. | ||||
|
r3278 | |||
|
r6422 | |||
|
r25612 | from binascii import b2a_base64, hexlify | ||
|
r26382 | import html | ||
|
r19557 | import json | ||
import mimetypes | ||||
|
r10050 | import os | ||
|
r10803 | import struct | ||
|
r19557 | import warnings | ||
|
r23746 | from copy import deepcopy | ||
|
r25057 | from os.path import splitext | ||
|
r25061 | from pathlib import Path, PurePath | ||
|
r10050 | |||
|
r23666 | from IPython.utils.py3compat import cast_unicode | ||
|
r15126 | from IPython.testing.skipdoctest import skip_doctest | ||
|
r25632 | from . import display_functions | ||
|
r10449 | |||
|
r25632 | |||
__all__ = ['display_pretty', 'display_html', 'display_markdown', | ||||
|
r25612 | 'display_svg', 'display_png', 'display_jpeg', 'display_latex', 'display_json', | ||
'display_javascript', 'display_pdf', 'DisplayObject', 'TextDisplayObject', | ||||
'Pretty', 'HTML', 'Markdown', 'Math', 'Latex', 'SVG', 'ProgressBar', 'JSON', | ||||
|
r25632 | 'GeoJSON', 'Javascript', 'Image', 'set_matplotlib_formats', | ||
'set_matplotlib_close', | ||||
|
r25612 | 'Video'] | ||
|
r17121 | |||
|
r25632 | _deprecated_names = ["display", "clear_output", "publish_display_data", "update_display", "DisplayHandle"] | ||
__all__ = __all__ + _deprecated_names | ||||
# ----- warn to import from IPython.display ----- | ||||
from warnings import warn | ||||
def __getattr__(name): | ||||
if name in _deprecated_names: | ||||
warn(f"Importing {name} from IPython.core.display is deprecated since IPython 7.14, please import from IPython display", DeprecationWarning, stacklevel=2) | ||||
return getattr(display_functions, name) | ||||
if name in globals().keys(): | ||||
return globals()[name] | ||||
else: | ||||
raise AttributeError(f"module {__name__} has no attribute {name}") | ||||
|
r10449 | |||
|
r17121 | |||
|
r3278 | #----------------------------------------------------------------------------- | ||
|
r10050 | # utility functions | ||
#----------------------------------------------------------------------------- | ||||
def _safe_exists(path): | ||||
|
r10213 | """Check path, but don't let exceptions raise""" | ||
|
r10050 | try: | ||
return os.path.exists(path) | ||||
except Exception: | ||||
return False | ||||
|
r10448 | |||
|
r10449 | def _display_mimetype(mimetype, objs, raw=False, metadata=None): | ||
"""internal implementation of all display_foo methods | ||||
Parameters | ||||
---------- | ||||
mimetype : str | ||||
The mimetype to be published (e.g. 'image/png') | ||||
|
r25584 | *objs : object | ||
|
r10449 | The Python objects to display, or if raw=True raw text data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
metadata : dict (optional) | ||||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r10449 | """ | ||
|
r10450 | if metadata: | ||
metadata = {mimetype: metadata} | ||||
|
r10449 | if raw: | ||
|
r10450 | # turn list of pngdata into list of { 'image/png': pngdata } | ||
objs = [ {mimetype: obj} for obj in objs ] | ||||
|
r27430 | display_functions.display(*objs, raw=raw, metadata=metadata, include=[mimetype]) | ||
|
r10450 | |||
|
r10050 | #----------------------------------------------------------------------------- | ||
|
r3278 | # Main functions | ||
#----------------------------------------------------------------------------- | ||||
|
r10448 | |||
def display_pretty(*objs, **kwargs): | ||||
"""Display the pretty (default) representation of an object. | ||||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r10448 | The Python objects to display, or if raw=True raw text data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
metadata : dict (optional) | ||||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r10448 | """ | ||
_display_mimetype('text/plain', objs, **kwargs) | ||||
|
r3279 | |||
|
r4526 | def display_html(*objs, **kwargs): | ||
|
r3278 | """Display the HTML representation of an object. | ||
|
r22947 | |||
|
r21995 | Note: If raw=False and the object does not have a HTML | ||
representation, no HTML will be shown. | ||||
|
r3278 | |||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r4528 | The Python objects to display, or if raw=True raw HTML data to | ||
|
r4526 | display. | ||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
|
r10448 | metadata : dict (optional) | ||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r4526 | """ | ||
|
r10448 | _display_mimetype('text/html', objs, **kwargs) | ||
|
r3278 | |||
|
r16364 | def display_markdown(*objs, **kwargs): | ||
"""Displays the Markdown representation of an object. | ||||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r16364 | The Python objects to display, or if raw=True raw markdown data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
metadata : dict (optional) | ||||
Metadata to be associated with the specific mimetype output. | ||||
""" | ||||
_display_mimetype('text/markdown', objs, **kwargs) | ||||
|
r4526 | def display_svg(*objs, **kwargs): | ||
|
r3278 | """Display the SVG representation of an object. | ||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r4526 | The Python objects to display, or if raw=True raw svg data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
|
r10448 | metadata : dict (optional) | ||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r3278 | """ | ||
|
r10448 | _display_mimetype('image/svg+xml', objs, **kwargs) | ||
|
r3278 | |||
|
r4526 | def display_png(*objs, **kwargs): | ||
|
r3278 | """Display the PNG representation of an object. | ||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r4526 | The Python objects to display, or if raw=True raw png data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
|
r10448 | metadata : dict (optional) | ||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r3278 | """ | ||
|
r10448 | _display_mimetype('image/png', objs, **kwargs) | ||
|
r3278 | |||
|
r4528 | def display_jpeg(*objs, **kwargs): | ||
"""Display the JPEG representation of an object. | ||||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r4528 | The Python objects to display, or if raw=True raw JPEG data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
|
r10448 | metadata : dict (optional) | ||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r4528 | """ | ||
|
r10448 | _display_mimetype('image/jpeg', objs, **kwargs) | ||
|
r4528 | |||
|
r4526 | def display_latex(*objs, **kwargs): | ||
|
r3278 | """Display the LaTeX representation of an object. | ||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r4526 | The Python objects to display, or if raw=True raw latex data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
|
r10448 | metadata : dict (optional) | ||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r3278 | """ | ||
|
r10448 | _display_mimetype('text/latex', objs, **kwargs) | ||
|
r3278 | |||
|
r4526 | def display_json(*objs, **kwargs): | ||
|
r3278 | """Display the JSON representation of an object. | ||
|
r10212 | |||
|
r8086 | Note that not many frontends support displaying JSON. | ||
|
r3278 | |||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r4526 | The Python objects to display, or if raw=True raw json data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
|
r10448 | metadata : dict (optional) | ||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r3278 | """ | ||
|
r10448 | _display_mimetype('application/json', objs, **kwargs) | ||
|
r3278 | |||
|
r4526 | def display_javascript(*objs, **kwargs): | ||
|
r3878 | """Display the Javascript representation of an object. | ||
|
r3278 | |||
|
r3878 | Parameters | ||
---------- | ||||
|
r25584 | *objs : object | ||
|
r4526 | The Python objects to display, or if raw=True raw javascript data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
|
r10448 | metadata : dict (optional) | ||
|
r10450 | Metadata to be associated with the specific mimetype output. | ||
|
r3878 | """ | ||
|
r10448 | _display_mimetype('application/javascript', objs, **kwargs) | ||
|
r4526 | |||
|
r15121 | |||
def display_pdf(*objs, **kwargs): | ||||
"""Display the PDF representation of an object. | ||||
Parameters | ||||
---------- | ||||
|
r25584 | *objs : object | ||
|
r15121 | The Python objects to display, or if raw=True raw javascript data to | ||
display. | ||||
raw : bool | ||||
Are the data objects raw data or Python objects that need to be | ||||
formatted before display? [default: False] | ||||
metadata : dict (optional) | ||||
Metadata to be associated with the specific mimetype output. | ||||
""" | ||||
_display_mimetype('application/pdf', objs, **kwargs) | ||||
|
r4526 | #----------------------------------------------------------------------------- | ||
# Smart classes | ||||
#----------------------------------------------------------------------------- | ||||
class DisplayObject(object): | ||||
"""An object that wraps data to be displayed.""" | ||||
|
r4528 | _read_flags = 'r' | ||
|
r16396 | _show_mem_addr = False | ||
|
r23746 | metadata = None | ||
|
r4528 | |||
|
r23746 | def __init__(self, data=None, url=None, filename=None, metadata=None): | ||
|
r4528 | """Create a display object given raw data. | ||
|
r4526 | |||
When this object is returned by an expression or passed to the | ||||
display function, it will result in the data being displayed | ||||
in the frontend. The MIME type of the data should match the | ||||
subclasses used, so the Png subclass should be used for 'image/png' | ||||
data. If the data is a URL, the data will first be downloaded | ||||
|
r28461 | and then displayed. | ||
|
r4526 | |||
Parameters | ||||
---------- | ||||
data : unicode, str or bytes | ||||
|
r10050 | The raw data or a URL or file to load the data from | ||
|
r4528 | url : unicode | ||
A URL to download the data from. | ||||
filename : unicode | ||||
Path to a local file to load the data from. | ||||
|
r23746 | metadata : dict | ||
Dict of metadata associated to be the object when displayed | ||||
|
r4526 | """ | ||
|
r25061 | if isinstance(data, (Path, PurePath)): | ||
data = str(data) | ||||
|
r23037 | if data is not None and isinstance(data, str): | ||
|
r10050 | if data.startswith('http') and url is None: | ||
url = data | ||||
filename = None | ||||
data = None | ||||
elif _safe_exists(data) and filename is None: | ||||
url = None | ||||
filename = data | ||||
data = None | ||||
|
r10212 | |||
|
r10050 | self.url = url | ||
|
r23044 | self.filename = filename | ||
|
r25614 | # because of @data.setter methods in | ||
# subclasses ensure url and filename are set | ||||
# before assigning to self.data | ||||
self.data = data | ||||
|
r10212 | |||
|
r23746 | if metadata is not None: | ||
self.metadata = metadata | ||||
elif self.metadata is None: | ||||
self.metadata = {} | ||||
|
r4528 | self.reload() | ||
|
r14153 | self._check_data() | ||
|
r16396 | |||
def __repr__(self): | ||||
if not self._show_mem_addr: | ||||
cls = self.__class__ | ||||
r = "<%s.%s object>" % (cls.__module__, cls.__name__) | ||||
else: | ||||
r = super(DisplayObject, self).__repr__() | ||||
return r | ||||
|
r14153 | def _check_data(self): | ||
"""Override in subclasses if there's something to check.""" | ||||
pass | ||||
|
r4528 | |||
|
r23746 | def _data_and_metadata(self): | ||
"""shortcut for returning metadata with shape information, if defined""" | ||||
if self.metadata: | ||||
return self.data, deepcopy(self.metadata) | ||||
else: | ||||
return self.data | ||||
|
r4528 | def reload(self): | ||
"""Reload the raw data from file or URL.""" | ||||
if self.filename is not None: | ||||
|
r27495 | encoding = None if "b" in self._read_flags else "utf-8" | ||
|
r27494 | with open(self.filename, self._read_flags, encoding=encoding) as f: | ||
|
r4528 | self.data = f.read() | ||
elif self.url is not None: | ||||
|
r25614 | # Deferred import | ||
from urllib.request import urlopen | ||||
response = urlopen(self.url) | ||||
data = response.read() | ||||
# extract encoding from header, if there is one: | ||||
encoding = None | ||||
|
r25615 | if 'content-type' in response.headers: | ||
|
r4684 | for sub in response.headers['content-type'].split(';'): | ||
sub = sub.strip() | ||||
if sub.startswith('charset'): | ||||
encoding = sub.split('=')[-1].strip() | ||||
break | ||||
|
r25615 | if 'content-encoding' in response.headers: | ||
# TODO: do deflate? | ||||
if 'gzip' in response.headers['content-encoding']: | ||||
import gzip | ||||
from io import BytesIO | ||||
|
r27495 | |||
|
r27494 | # assume utf-8 if encoding is not specified | ||
|
r27495 | with gzip.open( | ||
BytesIO(data), "rt", encoding=encoding or "utf-8" | ||||
) as fp: | ||||
|
r25615 | encoding = None | ||
data = fp.read() | ||||
|
r26382 | |||
|
r25614 | # decode data, if an encoding was specified | ||
# We only touch self.data once since | ||||
# subclasses such as SVG have @data.setter methods | ||||
# that transform self.data into ... well svg. | ||||
if encoding: | ||||
self.data = data.decode(encoding, 'replace') | ||||
else: | ||||
self.data = data | ||||
|
r4526 | |||
|
r14153 | class TextDisplayObject(DisplayObject): | ||
|
r27813 | """Create a text display object given raw data. | ||
Parameters | ||||
---------- | ||||
data : str or unicode | ||||
The raw data or a URL or file to load the data from. | ||||
url : unicode | ||||
A URL to download the data from. | ||||
filename : unicode | ||||
Path to a local file to load the data from. | ||||
metadata : dict | ||||
Dict of metadata associated to be the object when displayed | ||||
""" | ||||
|
r14153 | def _check_data(self): | ||
|
r23037 | if self.data is not None and not isinstance(self.data, str): | ||
|
r14159 | raise TypeError("%s expects text, not %r" % (self.__class__.__name__, self.data)) | ||
|
r14153 | |||
class Pretty(TextDisplayObject): | ||||
|
r4526 | |||
|
r23729 | def _repr_pretty_(self, pp, cycle): | ||
return pp.text(self.data) | ||||
|
r4526 | |||
|
r14153 | class HTML(TextDisplayObject): | ||
|
r4526 | |||
|
r24619 | def __init__(self, data=None, url=None, filename=None, metadata=None): | ||
|
r24654 | def warn(): | ||
if not data: | ||||
return False | ||||
# | ||||
# Avoid calling lower() on the entire data, because it could be a | ||||
# long string and we're only interested in its beginning and end. | ||||
# | ||||
prefix = data[:10].lower() | ||||
suffix = data[-10:].lower() | ||||
return prefix.startswith("<iframe ") and suffix.endswith("</iframe>") | ||||
if warn(): | ||||
|
r24619 | warnings.warn("Consider using IPython.display.IFrame instead") | ||
super(HTML, self).__init__(data=data, url=url, filename=filename, metadata=metadata) | ||||
|
r4526 | def _repr_html_(self): | ||
|
r24301 | return self._data_and_metadata() | ||
|
r4526 | |||
|
r10490 | def __html__(self): | ||
""" | ||||
This method exists to inform other HTML-using modules (e.g. Markupsafe, | ||||
htmltag, etc) that this object is HTML and does not need things like | ||||
special characters (<>&) escaped. | ||||
""" | ||||
return self._repr_html_() | ||||
|
r4526 | |||
|
r16364 | class Markdown(TextDisplayObject): | ||
def _repr_markdown_(self): | ||||
|
r24301 | return self._data_and_metadata() | ||
|
r16364 | |||
|
r14153 | class Math(TextDisplayObject): | ||
|
r4526 | |||
def _repr_latex_(self): | ||||
|
r24780 | s = r"$\displaystyle %s$" % self.data.strip('$') | ||
|
r24301 | if self.metadata: | ||
return s, deepcopy(self.metadata) | ||||
else: | ||||
return s | ||||
|
r6065 | |||
|
r14153 | class Latex(TextDisplayObject): | ||
|
r6065 | |||
def _repr_latex_(self): | ||||
|
r24301 | return self._data_and_metadata() | ||
|
r4526 | |||
|
r4528 | class SVG(DisplayObject): | ||
|
r25616 | """Embed an SVG into the display. | ||
Note if you just want to view a svg image via a URL use `:class:Image` with | ||||
a url=URL keyword argument. | ||||
""" | ||||
|
r10212 | |||
|
r23026 | _read_flags = 'rb' | ||
|
r5671 | # wrap data in a property, which extracts the <svg> tag, discarding | ||
# document headers | ||||
_data = None | ||||
|
r10212 | |||
|
r5671 | @property | ||
def data(self): | ||||
return self._data | ||||
|
r10212 | |||
|
r5671 | @data.setter | ||
def data(self, svg): | ||||
if svg is None: | ||||
self._data = None | ||||
return | ||||
# parse into dom object | ||||
|
r9390 | from xml.dom import minidom | ||
|
r5671 | x = minidom.parseString(svg) | ||
# get svg tag (should be 1) | ||||
found_svg = x.getElementsByTagName('svg') | ||||
if found_svg: | ||||
svg = found_svg[0].toxml() | ||||
else: | ||||
# fallback on the input, trust the user | ||||
# but this is probably an error. | ||||
pass | ||||
|
r11535 | svg = cast_unicode(svg) | ||
|
r5671 | self._data = svg | ||
|
r25612 | |||
|
r4526 | def _repr_svg_(self): | ||
|
r23746 | return self._data_and_metadata() | ||
|
r4526 | |||
|
r23856 | class ProgressBar(DisplayObject): | ||
|
r25612 | """Progressbar supports displaying a progressbar like element | ||
|
r23854 | """ | ||
def __init__(self, total): | ||||
"""Creates a new progressbar | ||||
|
r25612 | |||
|
r23854 | Parameters | ||
---------- | ||||
total : int | ||||
|
r23859 | maximum size of the progressbar | ||
|
r23854 | """ | ||
self.total = total | ||||
self._progress = 0 | ||||
|
r23860 | self.html_width = '60ex' | ||
self.text_width = 60 | ||||
self._display_id = hexlify(os.urandom(8)).decode('ascii') | ||||
def __repr__(self): | ||||
fraction = self.progress / self.total | ||||
filled = '=' * int(fraction * self.text_width) | ||||
rest = ' ' * (self.text_width - len(filled)) | ||||
return '[{}{}] {}/{}'.format( | ||||
filled, rest, | ||||
self.progress, self.total, | ||||
) | ||||
|
r23854 | |||
def _repr_html_(self): | ||||
|
r23860 | return "<progress style='width:{}' max='{}' value='{}'></progress>".format( | ||
self.html_width, self.total, self.progress) | ||||
|
r23854 | |||
def display(self): | ||||
|
r27430 | display_functions.display(self, display_id=self._display_id) | ||
|
r23854 | |||
def update(self): | ||||
|
r27430 | display_functions.display(self, display_id=self._display_id, update=True) | ||
|
r23854 | |||
@property | ||||
def progress(self): | ||||
return self._progress | ||||
@progress.setter | ||||
def progress(self, value): | ||||
self._progress = value | ||||
self.update() | ||||
|
r4526 | |||
|
r23943 | def __iter__(self): | ||
self.display() | ||||
self._progress = -1 # First iteration is 0 | ||||
return self | ||||
def __next__(self): | ||||
"""Returns current value and increments display by one.""" | ||||
self.progress += 1 | ||||
if self.progress < self.total: | ||||
return self.progress | ||||
else: | ||||
raise StopIteration() | ||||
|
r19557 | class JSON(DisplayObject): | ||
"""JSON expects a JSON-able dict or list | ||||
|
r22947 | |||
|
r19557 | not an already-serialized JSON string. | ||
|
r22947 | |||
|
r19557 | Scalar types (None, number, string) are not allowed, only dict or list containers. | ||
""" | ||||
# wrap data in a property, which warns about passing already-serialized JSON | ||||
_data = None | ||||
|
r24412 | def __init__(self, data=None, url=None, filename=None, expanded=False, metadata=None, root='root', **kwargs): | ||
|
r22947 | """Create a JSON display object given raw data. | ||
Parameters | ||||
---------- | ||||
data : dict or list | ||||
JSON data to display. Not an already-serialized JSON string. | ||||
Scalar types (None, number, string) are not allowed, only dict | ||||
or list containers. | ||||
url : unicode | ||||
A URL to download the data from. | ||||
filename : unicode | ||||
Path to a local file to load the data from. | ||||
expanded : boolean | ||||
Metadata to control whether a JSON display component is expanded. | ||||
|
r26294 | metadata : dict | ||
|
r22947 | Specify extra metadata to attach to the json display object. | ||
|
r24412 | root : str | ||
|
r25612 | The name of the root element of the JSON tree | ||
|
r22947 | """ | ||
|
r24412 | self.metadata = { | ||
'expanded': expanded, | ||||
'root': root, | ||||
} | ||||
|
r23501 | if metadata: | ||
self.metadata.update(metadata) | ||||
|
r23503 | if kwargs: | ||
self.metadata.update(kwargs) | ||||
|
r22947 | super(JSON, self).__init__(data=data, url=url, filename=filename) | ||
|
r19557 | def _check_data(self): | ||
if self.data is not None and not isinstance(self.data, (dict, list)): | ||||
raise TypeError("%s expects JSONable dict or list, not %r" % (self.__class__.__name__, self.data)) | ||||
@property | ||||
def data(self): | ||||
return self._data | ||||
|
r22947 | |||
|
r19557 | @data.setter | ||
def data(self, data): | ||||
|
r25061 | if isinstance(data, (Path, PurePath)): | ||
data = str(data) | ||||
|
r23037 | if isinstance(data, str): | ||
|
r25614 | if self.filename is None and self.url is None: | ||
|
r23393 | warnings.warn("JSON expects JSONable dict or list, not JSON strings") | ||
|
r19557 | data = json.loads(data) | ||
self._data = data | ||||
|
r4526 | |||
|
r22947 | def _data_and_metadata(self): | ||
|
r23501 | return self.data, self.metadata | ||
|
r22947 | |||
|
r4526 | def _repr_json_(self): | ||
|
r22947 | return self._data_and_metadata() | ||
|
r4526 | |||
|
r27849 | |||
|
r24470 | _css_t = """var link = document.createElement("link"); | ||
|
r27848 | link.rel = "stylesheet"; | ||
|
r24470 | link.type = "text/css"; | ||
link.href = "%s"; | ||||
document.head.appendChild(link); | ||||
|
r6120 | """ | ||
|
r24479 | _lib_t1 = """new Promise(function(resolve, reject) { | ||
var script = document.createElement("script"); | ||||
script.onload = resolve; | ||||
script.onerror = reject; | ||||
|
r24470 | script.src = "%s"; | ||
|
r24479 | document.head.appendChild(script); | ||
}).then(() => { | ||||
|
r6120 | """ | ||
|
r4526 | |||
|
r24479 | _lib_t2 = """ | ||
});""" | ||||
|
r24470 | |||
|
r23501 | class GeoJSON(JSON): | ||
|
r23404 | """GeoJSON expects JSON-able dict | ||
|
r23312 | |||
|
r23404 | not an already-serialized JSON string. | ||
Scalar types (None, number, string) are not allowed, only dict containers. | ||||
""" | ||||
|
r25612 | |||
|
r23501 | def __init__(self, *args, **kwargs): | ||
|
r23404 | """Create a GeoJSON display object given raw data. | ||
Parameters | ||||
---------- | ||||
data : dict or list | ||||
VegaLite data. Not an already-serialized JSON string. | ||||
Scalar types (None, number, string) are not allowed, only dict | ||||
or list containers. | ||||
url_template : string | ||||
Leaflet TileLayer URL template: http://leafletjs.com/reference.html#url-template | ||||
layer_options : dict | ||||
Leaflet TileLayer options: http://leafletjs.com/reference.html#tilelayer-options | ||||
url : unicode | ||||
A URL to download the data from. | ||||
filename : unicode | ||||
Path to a local file to load the data from. | ||||
|
r26294 | metadata : dict | ||
|
r23404 | Specify extra metadata to attach to the json display object. | ||
|
r23407 | |||
Examples | ||||
-------- | ||||
The following will display an interactive map of Mars with a point of | ||||
interest on frontend that do support GeoJSON display. | ||||
>>> from IPython.display import GeoJSON | ||||
>>> GeoJSON(data={ | ||||
... "type": "Feature", | ||||
... "geometry": { | ||||
... "type": "Point", | ||||
... "coordinates": [-81.327, 296.038] | ||||
... } | ||||
... }, | ||||
... url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png", | ||||
... layer_options={ | ||||
... "basemap_id": "celestia_mars-shaded-16k_global", | ||||
... "attribution" : "Celestia/praesepe", | ||||
... "minZoom" : 0, | ||||
... "maxZoom" : 18, | ||||
... }) | ||||
<IPython.core.display.GeoJSON object> | ||||
In the terminal IPython, you will only see the text representation of | ||||
the GeoJSON object. | ||||
|
r23404 | """ | ||
|
r25612 | |||
|
r23501 | super(GeoJSON, self).__init__(*args, **kwargs) | ||
|
r23312 | |||
def _ipython_display_(self): | ||||
bundle = { | ||||
'application/geo+json': self.data, | ||||
|
r23501 | 'text/plain': '<IPython.display.GeoJSON object>' | ||
|
r23312 | } | ||
|
r23404 | metadata = { | ||
|
r23501 | 'application/geo+json': self.metadata | ||
|
r23404 | } | ||
|
r27430 | display_functions.display(bundle, metadata=metadata, raw=True) | ||
|
r23312 | |||
|
r14153 | class Javascript(TextDisplayObject): | ||
|
r4526 | |||
|
r6120 | def __init__(self, data=None, url=None, filename=None, lib=None, css=None): | ||
"""Create a Javascript display object given raw data. | ||||
When this object is returned by an expression or passed to the | ||||
display function, it will result in the data being displayed | ||||
in the frontend. If the data is a URL, the data will first be | ||||
|
r10212 | downloaded and then displayed. | ||
|
r6425 | In the Notebook, the containing element will be available as `element`, | ||
|
r17002 | and jQuery will be available. Content appended to `element` will be | ||
|
r22947 | visible in the output area. | ||
|
r6120 | |||
Parameters | ||||
---------- | ||||
data : unicode, str or bytes | ||||
The Javascript source code or a URL to download it from. | ||||
url : unicode | ||||
A URL to download the data from. | ||||
filename : unicode | ||||
Path to a local file to load the data from. | ||||
lib : list or str | ||||
A sequence of Javascript library URLs to load asynchronously before | ||||
running the source code. The full URLs of the libraries should | ||||
be given. A single Javascript library URL can also be given as a | ||||
string. | ||||
|
r26294 | css : list or str | ||
|
r6120 | A sequence of css files to load before running the source code. | ||
|
r10212 | The full URLs of the css files should be given. A single css URL | ||
|
r6120 | can also be given as a string. | ||
""" | ||||
|
r23037 | if isinstance(lib, str): | ||
|
r6120 | lib = [lib] | ||
elif lib is None: | ||||
lib = [] | ||||
|
r23037 | if isinstance(css, str): | ||
|
r6120 | css = [css] | ||
elif css is None: | ||||
css = [] | ||||
if not isinstance(lib, (list,tuple)): | ||||
raise TypeError('expected sequence, got: %r' % lib) | ||||
if not isinstance(css, (list,tuple)): | ||||
raise TypeError('expected sequence, got: %r' % css) | ||||
self.lib = lib | ||||
self.css = css | ||||
|
r23816 | super(Javascript, self).__init__(data=data, url=url, filename=filename) | ||
|
r6120 | |||
|
r4526 | def _repr_javascript_(self): | ||
|
r6120 | r = '' | ||
for c in self.css: | ||||
|
r23524 | r += _css_t % c | ||
|
r6120 | for l in self.lib: | ||
|
r23524 | r += _lib_t1 % l | ||
|
r6120 | r += self.data | ||
|
r23524 | r += _lib_t2*len(self.lib) | ||
|
r6120 | return r | ||
|
r4526 | |||
|
r10049 | # constants for identifying png/jpeg data | ||
_PNG = b'\x89PNG\r\n\x1a\n' | ||||
_JPEG = b'\xff\xd8' | ||||
|
r4526 | |||
|
r10803 | def _pngxy(data): | ||
"""read the (width, height) from a PNG header""" | ||||
ihdr = data.index(b'IHDR') | ||||
# next 8 bytes are width/height | ||||
|
r23821 | return struct.unpack('>ii', data[ihdr+4:ihdr+12]) | ||
|
r10803 | |||
def _jpegxy(data): | ||||
"""read the (width, height) from a JPEG header""" | ||||
# adapted from http://www.64lines.com/jpeg-width-height | ||||
|
r22947 | |||
|
r10803 | idx = 4 | ||
while True: | ||||
block_size = struct.unpack('>H', data[idx:idx+2])[0] | ||||
idx = idx + block_size | ||||
if data[idx:idx+2] == b'\xFF\xC0': | ||||
# found Start of Frame | ||||
iSOF = idx | ||||
break | ||||
else: | ||||
# read another block | ||||
idx += 2 | ||||
|
r23851 | h, w = struct.unpack('>HH', data[iSOF+5:iSOF+9]) | ||
return w, h | ||||
|
r23849 | |||
|
r23821 | def _gifxy(data): | ||
"""read the (width, height) from a GIF header""" | ||||
return struct.unpack('<HH', data[6:10]) | ||||
|
r10803 | |||
|
r23849 | |||
|
r4528 | class Image(DisplayObject): | ||
_read_flags = 'rb' | ||||
|
r8077 | _FMT_JPEG = u'jpeg' | ||
_FMT_PNG = u'png' | ||||
|
r23814 | _FMT_GIF = u'gif' | ||
_ACCEPTABLE_EMBEDDINGS = [_FMT_JPEG, _FMT_PNG, _FMT_GIF] | ||||
|
r23849 | _MIMETYPES = { | ||
_FMT_PNG: 'image/png', | ||||
_FMT_JPEG: 'image/jpeg', | ||||
_FMT_GIF: 'image/gif', | ||||
} | ||||
|
r4528 | |||
|
r26410 | def __init__( | ||
self, | ||||
data=None, | ||||
url=None, | ||||
filename=None, | ||||
format=None, | ||||
embed=None, | ||||
width=None, | ||||
height=None, | ||||
retina=False, | ||||
unconfined=False, | ||||
metadata=None, | ||||
alt=None, | ||||
): | ||||
|
r23814 | """Create a PNG/JPEG/GIF image object given raw data. | ||
|
r4528 | |||
|
r12557 | When this object is returned by an input cell or passed to the | ||
|
r4528 | display function, it will result in the image being displayed | ||
in the frontend. | ||||
Parameters | ||||
---------- | ||||
data : unicode, str or bytes | ||||
|
r10619 | The raw image data or a URL or filename to load the data from. | ||
This always results in embedded image data. | ||||
|
r27290 | |||
|
r4528 | url : unicode | ||
|
r10619 | A URL to download the data from. If you specify `url=`, | ||
the image data will not be embedded unless you also specify `embed=True`. | ||||
|
r27290 | |||
|
r4528 | filename : unicode | ||
Path to a local file to load the data from. | ||||
|
r10619 | Images from a file are always embedded. | ||
|
r27290 | |||
|
r4528 | format : unicode | ||
|
r23814 | The format of the image data (png/jpeg/jpg/gif). If a filename or URL is given | ||
|
r4528 | for format will be inferred from the filename extension. | ||
|
r27290 | |||
|
r4528 | embed : bool | ||
|
r6529 | Should the image data be embedded using a data URI (True) or be | ||
loaded using an <img> tag. Set this to True if you want the image | ||||
to be viewable later with no internet connection in the notebook. | ||||
Default is `True`, unless the keyword argument `url` is set, then | ||||
default value is `False`. | ||||
Note that QtConsole is not able to display images if `embed` is set to `False` | ||||
|
r27290 | |||
|
r8077 | width : int | ||
|
r22394 | Width in pixels to which to constrain the image in html | ||
|
r27290 | |||
|
r8077 | height : int | ||
|
r22394 | Height in pixels to which to constrain the image in html | ||
|
r27290 | |||
|
r10803 | retina : bool | ||
Automatically set the width and height to half of the measured | ||||
width and height. | ||||
This only works for embedded images because it reads the width/height | ||||
from image data. | ||||
For non-embedded images, you can just set the desired display width | ||||
and height directly. | ||||
|
r27290 | |||
|
r26294 | unconfined : bool | ||
|
r20986 | Set unconfined=True to disable max-width confinement of the image. | ||
|
r27290 | |||
|
r26294 | metadata : dict | ||
|
r20986 | Specify extra metadata to attach to the image. | ||
|
r27290 | |||
|
r26382 | alt : unicode | ||
Alternative text for the image, for use by screen readers. | ||||
|
r6529 | |||
Examples | ||||
-------- | ||||
|
r26292 | embedded image data, works in qtconsole and notebook | ||
when passed positionally, the first arg can be any of raw image data, | ||||
a URL, or a filename from which to load image data. | ||||
The result is always embedding image data for inline images. | ||||
|
r27554 | >>> Image('https://www.google.fr/images/srpr/logo3w.png') # doctest: +SKIP | ||
|
r26292 | <IPython.core.display.Image object> | ||
>>> Image('/path/to/image.jpg') | ||||
<IPython.core.display.Image object> | ||||
>>> Image(b'RAW_PNG_DATA...') | ||||
<IPython.core.display.Image object> | ||||
Specifying Image(url=...) does not embed the image data, | ||||
it only generates ``<img>`` tag with a link to the source. | ||||
This will not work in the qtconsole or offline. | ||||
|
r27554 | >>> Image(url='https://www.google.fr/images/srpr/logo3w.png') | ||
|
r26294 | <IPython.core.display.Image object> | ||
|
r6529 | |||
|
r4528 | """ | ||
|
r25061 | if isinstance(data, (Path, PurePath)): | ||
data = str(data) | ||||
|
r4528 | if filename is not None: | ||
ext = self._find_ext(filename) | ||||
elif url is not None: | ||||
ext = self._find_ext(url) | ||||
|
r8077 | elif data is None: | ||
raise ValueError("No image data found. Expecting filename, url, or data.") | ||||
|
r23037 | elif isinstance(data, str) and ( | ||
|
r10050 | data.startswith('http') or _safe_exists(data) | ||
): | ||||
|
r4528 | ext = self._find_ext(data) | ||
else: | ||||
ext = None | ||||
|
r8077 | |||
|
r21818 | if format is None: | ||
if ext is not None: | ||||
if ext == u'jpg' or ext == u'jpeg': | ||||
format = self._FMT_JPEG | ||||
|
r23944 | elif ext == u'png': | ||
|
r21818 | format = self._FMT_PNG | ||
|
r23944 | elif ext == u'gif': | ||
|
r23818 | format = self._FMT_GIF | ||
|
r21818 | else: | ||
format = ext.lower() | ||||
elif isinstance(data, bytes): | ||||
# infer image type from image data header, | ||||
# only if format has not been specified. | ||||
if data[:2] == _JPEG: | ||||
format = self._FMT_JPEG | ||||
# failed to detect format, default png | ||||
if format is None: | ||||
|
r23814 | format = self._FMT_PNG | ||
|
r8077 | |||
|
r22013 | if format.lower() == 'jpg': | ||
# jpg->jpeg | ||||
format = self._FMT_JPEG | ||||
|
r23849 | |||
|
r23044 | self.format = format.lower() | ||
|
r6529 | self.embed = embed if embed is not None else (url is None) | ||
|
r8077 | |||
if self.embed and self.format not in self._ACCEPTABLE_EMBEDDINGS: | ||||
raise ValueError("Cannot embed the '%s' image format" % (self.format)) | ||||
|
r23849 | if self.embed: | ||
self._mimetype = self._MIMETYPES.get(self.format) | ||||
|
r8077 | self.width = width | ||
self.height = height | ||||
|
r10803 | self.retina = retina | ||
|
r20986 | self.unconfined = unconfined | ||
|
r26382 | self.alt = alt | ||
|
r25612 | super(Image, self).__init__(data=data, url=url, filename=filename, | ||
|
r23746 | metadata=metadata) | ||
if self.width is None and self.metadata.get('width', {}): | ||||
self.width = metadata['width'] | ||||
if self.height is None and self.metadata.get('height', {}): | ||||
self.height = metadata['height'] | ||||
|
r22947 | |||
|
r26410 | if self.alt is None and self.metadata.get("alt", {}): | ||
self.alt = metadata["alt"] | ||||
|
r26382 | |||
|
r10803 | if retina: | ||
self._retina_shape() | ||||
|
r22947 | |||
|
r23849 | |||
|
r10803 | def _retina_shape(self): | ||
"""load pixel-doubled width and height from image data""" | ||||
if not self.embed: | ||||
return | ||||
|
r23814 | if self.format == self._FMT_PNG: | ||
|
r10803 | w, h = _pngxy(self.data) | ||
|
r23814 | elif self.format == self._FMT_JPEG: | ||
|
r10803 | w, h = _jpegxy(self.data) | ||
|
r23818 | elif self.format == self._FMT_GIF: | ||
|
r23821 | w, h = _gifxy(self.data) | ||
|
r10803 | else: | ||
# retina only supports png | ||||
return | ||||
self.width = w // 2 | ||||
self.height = h // 2 | ||||
|
r4528 | |||
def reload(self): | ||||
"""Reload the raw data from file or URL.""" | ||||
if self.embed: | ||||
super(Image,self).reload() | ||||
|
r10803 | if self.retina: | ||
self._retina_shape() | ||||
|
r4528 | |||
def _repr_html_(self): | ||||
if not self.embed: | ||||
|
r26410 | width = height = klass = alt = "" | ||
|
r8077 | if self.width: | ||
width = ' width="%d"' % self.width | ||||
if self.height: | ||||
height = ' height="%d"' % self.height | ||||
|
r20986 | if self.unconfined: | ||
klass = ' class="unconfined"' | ||||
|
r26382 | if self.alt: | ||
alt = ' alt="%s"' % html.escape(self.alt) | ||||
|
r26410 | return '<img src="{url}"{width}{height}{klass}{alt}/>'.format( | ||
|
r20986 | url=self.url, | ||
width=width, | ||||
height=height, | ||||
klass=klass, | ||||
|
r26382 | alt=alt, | ||
|
r20986 | ) | ||
|
r10490 | |||
|
r23849 | def _repr_mimebundle_(self, include=None, exclude=None): | ||
"""Return the image as a mimebundle | ||||
Any new mimetype support should be implemented here. | ||||
""" | ||||
if self.embed: | ||||
mimetype = self._mimetype | ||||
data, metadata = self._data_and_metadata(always_both=True) | ||||
if metadata: | ||||
metadata = {mimetype: metadata} | ||||
return {mimetype: data}, metadata | ||||
else: | ||||
return {'text/html': self._repr_html_()} | ||||
def _data_and_metadata(self, always_both=False): | ||||
|
r10444 | """shortcut for returning metadata with shape information, if defined""" | ||
|
r24989 | try: | ||
|
r28114 | b64_data = b2a_base64(self.data, newline=False).decode("ascii") | ||
|
r25833 | except TypeError as e: | ||
|
r24989 | raise FileNotFoundError( | ||
|
r25833 | "No such file or directory: '%s'" % (self.data)) from e | ||
|
r10444 | md = {} | ||
|
r23746 | if self.metadata: | ||
md.update(self.metadata) | ||||
|
r10444 | if self.width: | ||
md['width'] = self.width | ||||
if self.height: | ||||
md['height'] = self.height | ||||
|
r20986 | if self.unconfined: | ||
md['unconfined'] = self.unconfined | ||||
|
r26382 | if self.alt: | ||
|
r26410 | md["alt"] = self.alt | ||
|
r23849 | if md or always_both: | ||
|
r23835 | return b64_data, md | ||
|
r10444 | else: | ||
|
r23835 | return b64_data | ||
|
r4528 | |||
def _repr_png_(self): | ||||
|
r24990 | if self.embed and self.format == self._FMT_PNG: | ||
return self._data_and_metadata() | ||||
|
r4528 | |||
def _repr_jpeg_(self): | ||||
|
r24990 | if self.embed and self.format == self._FMT_JPEG: | ||
return self._data_and_metadata() | ||||
|
r4528 | |||
def _find_ext(self, s): | ||||
|
r25057 | base, ext = splitext(s) | ||
if not ext: | ||||
return base | ||||
# `splitext` includes leading period, so we skip it | ||||
return ext[1:].lower() | ||||
|
r5080 | |||
|
r23849 | |||
|
r17001 | class Video(DisplayObject): | ||
|
r24623 | def __init__(self, data=None, url=None, filename=None, embed=False, | ||
|
r25603 | mimetype=None, width=None, height=None, html_attributes="controls"): | ||
|
r17001 | """Create a video object given raw data or an URL. | ||
When this object is returned by an input cell or passed to the | ||||
display function, it will result in the video being displayed | ||||
in the frontend. | ||||
Parameters | ||||
---------- | ||||
data : unicode, str or bytes | ||||
|
r22116 | The raw video data or a URL or filename to load the data from. | ||
|
r26333 | Raw data will require passing ``embed=True``. | ||
|
r27290 | |||
|
r17001 | url : unicode | ||
|
r26333 | A URL for the video. If you specify ``url=``, | ||
|
r22116 | the image data will not be embedded. | ||
|
r27290 | |||
|
r17001 | filename : unicode | ||
|
r22116 | Path to a local file containing the video. | ||
|
r26333 | Will be interpreted as a local URL unless ``embed=True``. | ||
|
r27290 | |||
|
r17001 | embed : bool | ||
|
r22116 | Should the video be embedded using a data URI (True) or be | ||
loaded using a <video> tag (False). | ||||
|
r17001 | |||
|
r22116 | Since videos are large, embedding them should be avoided, if possible. | ||
|
r26333 | You must confirm embedding as your intention by passing ``embed=True``. | ||
|
r22116 | |||
Local files can be displayed with URLs without embedding the content, via:: | ||||
Video('./video.mp4') | ||||
|
r27290 | |||
|
r26294 | mimetype : unicode | ||
|
r22116 | Specify the mimetype for embedded videos. | ||
Default will be guessed from file extension, if available. | ||||
|
r27290 | |||
|
r24623 | width : int | ||
Width in pixels to which to constrain the video in HTML. | ||||
If not supplied, defaults to the width of the video. | ||||
|
r27290 | |||
|
r24623 | height : int | ||
Height in pixels to which to constrain the video in html. | ||||
If not supplied, defaults to the height of the video. | ||||
|
r27290 | |||
|
r25603 | html_attributes : str | ||
|
r26333 | Attributes for the HTML ``<video>`` block. | ||
Default: ``"controls"`` to get video controls. | ||||
Other examples: ``"controls muted"`` for muted video with controls, | ||||
``"loop autoplay"`` for looping autoplaying video without controls. | ||||
|
r22115 | |||
|
r17001 | Examples | ||
-------- | ||||
|
r25604 | :: | ||
Video('https://archive.org/download/Sita_Sings_the_Blues/Sita_Sings_the_Blues_small.mp4') | ||||
Video('path/to/video.mp4') | ||||
Video('path/to/video.mp4', embed=True) | ||||
Video('path/to/video.mp4', embed=True, html_attributes="controls muted autoplay") | ||||
Video(b'raw-videodata', embed=True) | ||||
|
r17001 | """ | ||
|
r25061 | if isinstance(data, (Path, PurePath)): | ||
data = str(data) | ||||
|
r23037 | if url is None and isinstance(data, str) and data.startswith(('http:', 'https:')): | ||
|
r17001 | url = data | ||
data = None | ||||
|
r26060 | elif data is not None and os.path.exists(data): | ||
|
r17001 | filename = data | ||
data = None | ||||
|
r22947 | |||
|
r22116 | if data and not embed: | ||
msg = ''.join([ | ||||
"To embed videos, you must pass embed=True ", | ||||
"(this may make your notebook files huge)\n", | ||||
"Consider passing Video(url='...')", | ||||
]) | ||||
raise ValueError(msg) | ||||
|
r17001 | |||
self.mimetype = mimetype | ||||
|
r22116 | self.embed = embed | ||
|
r24623 | self.width = width | ||
self.height = height | ||||
|
r25603 | self.html_attributes = html_attributes | ||
|
r17001 | super(Video, self).__init__(data=data, url=url, filename=filename) | ||
def _repr_html_(self): | ||||
|
r24623 | width = height = '' | ||
if self.width: | ||||
width = ' width="%d"' % self.width | ||||
if self.height: | ||||
height = ' height="%d"' % self.height | ||||
|
r17001 | # External URLs and potentially local files are not embedded into the | ||
# notebook output. | ||||
if not self.embed: | ||||
url = self.url if self.url is not None else self.filename | ||||
|
r25603 | output = """<video src="{0}" {1} {2} {3}> | ||
|
r17001 | Your browser does not support the <code>video</code> element. | ||
|
r25603 | </video>""".format(url, self.html_attributes, width, height) | ||
|
r17001 | return output | ||
|
r22947 | |||
|
r22116 | # Embedded videos are base64-encoded. | ||
|
r22115 | mimetype = self.mimetype | ||
|
r17001 | if self.filename is not None: | ||
|
r22115 | if not mimetype: | ||
mimetype, _ = mimetypes.guess_type(self.filename) | ||||
|
r22947 | |||
|
r22115 | with open(self.filename, 'rb') as f: | ||
video = f.read() | ||||
else: | ||||
video = self.data | ||||
|
r23044 | if isinstance(video, str): | ||
|
r22115 | # unicode input is already b64-encoded | ||
b64_video = video | ||||
|
r17001 | else: | ||
|
r28114 | b64_video = b2a_base64(video, newline=False).decode("ascii").rstrip() | ||
|
r22947 | |||
|
r25603 | output = """<video {0} {1} {2}> | ||
<source src="data:{3};base64,{4}" type="{3}"> | ||||
|
r17001 | Your browser does not support the video tag. | ||
|
r25603 | </video>""".format(self.html_attributes, width, height, mimetype, b64_video) | ||
|
r17001 | return output | ||
def reload(self): | ||||
# TODO | ||||
pass | ||||
|
r5080 | |||
|
r15126 | @skip_doctest | ||
def set_matplotlib_formats(*formats, **kwargs): | ||||
|
r26464 | """ | ||
|
r26474 | .. deprecated:: 7.23 | ||
use `matplotlib_inline.backend_inline.set_matplotlib_formats()` | ||||
|
r26464 | |||
Select figure formats for the inline backend. Optionally pass quality for JPEG. | ||||
|
r15126 | |||
For example, this enables PNG and JPEG output with a JPEG quality of 90%:: | ||||
In [1]: set_matplotlib_formats('png', 'jpeg', quality=90) | ||||
To set this in your config files use the following:: | ||||
|
r22947 | |||
|
r15393 | c.InlineBackend.figure_formats = {'png', 'jpeg'} | ||
c.InlineBackend.print_figure_kwargs.update({'quality' : 90}) | ||||
|
r15124 | |||
Parameters | ||||
|
r15126 | ---------- | ||
|
r15393 | *formats : strs | ||
One or more figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'. | ||||
|
r26294 | **kwargs | ||
|
r15393 | Keyword args will be relayed to ``figure.canvas.print_figure``. | ||
|
r15124 | """ | ||
|
r26464 | warnings.warn( | ||
|
r26474 | "`set_matplotlib_formats` is deprecated since IPython 7.23, directly " | ||
"use `matplotlib_inline.backend_inline.set_matplotlib_formats()`", | ||||
|
r26464 | DeprecationWarning, | ||
stacklevel=2, | ||||
) | ||||
from matplotlib_inline.backend_inline import ( | ||||
set_matplotlib_formats as set_matplotlib_formats_orig, | ||||
) | ||||
set_matplotlib_formats_orig(*formats, **kwargs) | ||||
|
r15124 | |||
|
r15126 | @skip_doctest | ||
|
r15395 | def set_matplotlib_close(close=True): | ||
|
r26464 | """ | ||
|
r26474 | .. deprecated:: 7.23 | ||
use `matplotlib_inline.backend_inline.set_matplotlib_close()` | ||||
|
r26464 | Set whether the inline backend closes all figures automatically or not. | ||
|
r22947 | |||
|
r15126 | By default, the inline backend used in the IPython Notebook will close all | ||
matplotlib figures automatically after each cell is run. This means that | ||||
plots in different cells won't interfere. Sometimes, you may want to make | ||||
a plot in one cell and then refine it in later cells. This can be accomplished | ||||
by:: | ||||
|
r22947 | |||
|
r15126 | In [1]: set_matplotlib_close(False) | ||
|
r22947 | |||
|
r15126 | To set this in your config files use the following:: | ||
|
r22947 | |||
|
r15126 | c.InlineBackend.close_figures = False | ||
|
r22947 | |||
|
r15126 | Parameters | ||
---------- | ||||
close : bool | ||||
Should all matplotlib figures be automatically closed after each cell is | ||||
run? | ||||
""" | ||||
|
r26464 | warnings.warn( | ||
|
r26474 | "`set_matplotlib_close` is deprecated since IPython 7.23, directly " | ||
"use `matplotlib_inline.backend_inline.set_matplotlib_close()`", | ||||
|
r26464 | DeprecationWarning, | ||
stacklevel=2, | ||||
) | ||||
from matplotlib_inline.backend_inline import ( | ||||
set_matplotlib_close as set_matplotlib_close_orig, | ||||
) | ||||
set_matplotlib_close_orig(close) | ||||