Adding transient and update, change to dict for outputs

IPython/core/displaypub.py

@@ -1,124 +1,125 b''
 """An interface for publishing rich data to frontends.
 
 There are two components of the display system:
 
 * Display formatters, which take a Python object and compute the
   representation of the object in various formats (text, HTML, SVG, etc.).
 * The display publisher that is used to send the representation data to the
   various frontends.
 
 This module defines the logic display publishing. The display publisher uses
 the ``display_data`` message type that is defined in the IPython messaging
 spec.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 import sys
 
 from traitlets.config.configurable import Configurable
 from traitlets import List
 
 # This used to be defined here - it is imported for backwards compatibility
 from .display import publish_display_data
 
 #-----------------------------------------------------------------------------
 # Main payload class
 #-----------------------------------------------------------------------------
 
 class DisplayPublisher(Configurable):
     """A traited class that publishes display data to frontends.
 
     Instances of this class are created by the main IPython object and should
     be accessed there.
     """
 
     def _validate_data(self, data, metadata=None):
         """Validate the display data.
 
         Parameters
         ----------
         data : dict
             The formata data dictionary.
         metadata : dict
             Any metadata for the data.
         """
 
         if not isinstance(data, dict):
             raise TypeError('data must be a dict, got: %r' % data)
         if metadata is not None:
             if not isinstance(metadata, dict):
                 raise TypeError('metadata must be a dict, got: %r' % data)
 
     # use * to indicate transient, update are keyword-only
     def publish(self, data, metadata=None, source=None, *, transient=None, update=False, **kwargs):
         """Publish data and metadata to all frontends.
 
         See the ``display_data`` message in the messaging documentation for
         more details about this message type.
 
         The following MIME types are currently implemented:
 
         * text/plain
         * text/html
         * text/markdown
         * text/latex
         * application/json
         * application/javascript
         * image/png
         * image/jpeg
         * image/svg+xml
 
         Parameters
         ----------
         data : dict
             A dictionary having keys that are valid MIME types (like
             'text/plain' or 'image/svg+xml') and values that are the data for
             that MIME type. The data itself must be a JSON'able data
             structure. Minimally all data should have the 'text/plain' data,
             which can be displayed by all frontends. If more than the plain
             text is given, it is up to the frontend to decide which
             representation to use.
         metadata : dict
             A dictionary for metadata related to the data. This can contain
             arbitrary key, value pairs that frontends can use to interpret
             the data.  Metadata specific to each mime-type can be specified
             in the metadata dict with the same mime-type keys as
             the data itself.
         source : str, deprecated
             Unused.
         transient: dict, keyword-only
             A dictionary for transient data.
             Data in this dictionary should not be persisted as part of saving this output.
             Examples include 'display_id'.
         update: bool, keyword-only, default: False
             If True, only update existing outputs with the same display_id,
             rather than creating a new output.
         """
 
         # The default is to simply write the plain text data using sys.stdout.
         if 'text/plain' in data:
             print(data['text/plain'])
 
     def clear_output(self, wait=False):
         """Clear the output of the cell receiving output."""
         print('\033[2K\r', end='')
         sys.stdout.flush()
         print('\033[2K\r', end='')
         sys.stderr.flush()
 
 
 class CapturingDisplayPublisher(DisplayPublisher):
     """A DisplayPublisher that stores"""
     outputs = List()
 
     def publish(self, data, metadata=None, source=None, *, transient=None, update=False):
-        self.outputs.append((data, metadata))
+        self.outputs.append({'data':data, 'metadata':metadata,
+                             'transient':transient, 'update':update})
 
     def clear_output(self, wait=False):
         super(CapturingDisplayPublisher, self).clear_output(wait)
 
         # empty the list, *do not* reassign a new list
-        del self.outputs[:]
+        self.outputs.clear()

IPython/utils/capture.py

@@ -1,167 +1,170 b''
 # encoding: utf-8
 """IO capturing utilities."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 import sys
 from io import StringIO
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 
 class RichOutput(object):
-    def __init__(self, data=None, metadata=None):
+    def __init__(self, data=None, metadata=None, transient=None, update=False):
         self.data = data or {}
         self.metadata = metadata or {}
-    
+        self.transient = transient or {}
+        self.update = update
+
     def display(self):
         from IPython.display import publish_display_data
-        publish_display_data(data=self.data, metadata=self.metadata)
-    
+        publish_display_data(data=self.data, metadata=self.metadata,
+                             transient=self.transient, update=self.update)
+
     def _repr_mime_(self, mime):
         if mime not in self.data:
             return
         data = self.data[mime]
         if mime in self.metadata:
             return data, self.metadata[mime]
         else:
             return data
 
     def _repr_mimebundle_(self, include=None, exclude=None):
         return self.data, self.metadata
 
     def _repr_html_(self):
         return self._repr_mime_("text/html")
-    
+
     def _repr_latex_(self):
         return self._repr_mime_("text/latex")
-    
+
     def _repr_json_(self):
         return self._repr_mime_("application/json")
-    
+
     def _repr_javascript_(self):
         return self._repr_mime_("application/javascript")
-    
+
     def _repr_png_(self):
         return self._repr_mime_("image/png")
-    
+
     def _repr_jpeg_(self):
         return self._repr_mime_("image/jpeg")
-    
+
     def _repr_svg_(self):
         return self._repr_mime_("image/svg+xml")
 
 
 class CapturedIO(object):
     """Simple object for containing captured stdout/err and rich display StringIO objects
 
     Each instance `c` has three attributes:
 
     - ``c.stdout`` : standard output as a string
     - ``c.stderr`` : standard error as a string
     - ``c.outputs``: a list of rich display outputs
 
     Additionally, there's a ``c.show()`` method which will print all of the
     above in the same order, and can be invoked simply via ``c()``.
     """
-    
+
     def __init__(self, stdout, stderr, outputs=None):
         self._stdout = stdout
         self._stderr = stderr
         if outputs is None:
             outputs = []
         self._outputs = outputs
-    
+
     def __str__(self):
         return self.stdout
-    
+
     @property
     def stdout(self):
         "Captured standard output"
         if not self._stdout:
             return ''
         return self._stdout.getvalue()
-    
+
     @property
     def stderr(self):
         "Captured standard error"
         if not self._stderr:
             return ''
         return self._stderr.getvalue()
-    
+
     @property
     def outputs(self):
         """A list of the captured rich display outputs, if any.
-        
+
         If you have a CapturedIO object ``c``, these can be displayed in IPython
         using::
 
             from IPython.display import display
             for o in c.outputs:
                 display(o)
         """
-        return [ RichOutput(d, md) for d, md in self._outputs ]
-    
+        return [ RichOutput(**kargs) for kargs in self._outputs ]
+
     def show(self):
         """write my output to sys.stdout/err as appropriate"""
         sys.stdout.write(self.stdout)
         sys.stderr.write(self.stderr)
         sys.stdout.flush()
         sys.stderr.flush()
-        for data, metadata in self._outputs:
-            RichOutput(data, metadata).display()
-    
+        for kargs in self._outputs:
+            RichOutput(**kargs).display()
+
     __call__ = show
 
 
 class capture_output(object):
     """context manager for capturing stdout/err"""
     stdout = True
     stderr = True
     display = True
-    
+
     def __init__(self, stdout=True, stderr=True, display=True):
         self.stdout = stdout
         self.stderr = stderr
         self.display = display
         self.shell = None
-    
+
     def __enter__(self):
         from IPython.core.getipython import get_ipython
         from IPython.core.displaypub import CapturingDisplayPublisher
         from IPython.core.displayhook import CapturingDisplayHook
-        
+
         self.sys_stdout = sys.stdout
         self.sys_stderr = sys.stderr
-        
+
         if self.display:
             self.shell = get_ipython()
             if self.shell is None:
                 self.save_display_pub = None
                 self.display = False
-        
+
         stdout = stderr = outputs = None
         if self.stdout:
             stdout = sys.stdout = StringIO()
         if self.stderr:
             stderr = sys.stderr = StringIO()
         if self.display:
             self.save_display_pub = self.shell.display_pub
             self.shell.display_pub = CapturingDisplayPublisher()
             outputs = self.shell.display_pub.outputs
             self.save_display_hook = sys.displayhook
             sys.displayhook = CapturingDisplayHook(shell=self.shell,
                                                    outputs=outputs)
-        
+
         return CapturedIO(stdout, stderr, outputs)
-    
+
     def __exit__(self, exc_type, exc_value, traceback):
         sys.stdout = self.sys_stdout
         sys.stderr = self.sys_stderr
         if self.display and self.shell:
             self.shell.display_pub = self.save_display_pub
             sys.displayhook = self.save_display_hook