pyout -> execute_result

nbformat and nbconvert are not affected

IPython/html/static/notebook/js/outputarea.js

@@ -1,9 +1,5 b''
-//----------------------------------------------------------------------------
-//  Copyright (C) 2008 The IPython Development Team
-//
-//  Distributed under the terms of the BSD License.  The full license is in
-//  the file COPYING, distributed as part of this software.
-//----------------------------------------------------------------------------
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
 
 //============================================================================
 // OutputArea
@@ -221,9 +217,12 b' var IPython = (function (IPython) {'
             json = content.data;
             json.output_type = msg_type;
             json.metadata = content.metadata;
-        } else if (msg_type === "pyout") {
+        } else if (msg_type === "execute_result") {
             json = content.data;
-            json.output_type = msg_type;
+            // pyout message has been renamed to execute_result,
+            // but the nbformat has not been updated,
+            // so transform back to pyout for json.
+            json.output_type = "pyout";
             json.metadata = content.metadata;
             json.prompt_number = content.execution_count;
         } else if (msg_type === "pyerr") {
@@ -284,7 +283,7 b' var IPython = (function (IPython) {'
         }
 
         if (json.output_type === 'pyout') {
-            this.append_pyout(json);
+            this.append_execute_result(json);
         } else if (json.output_type === 'pyerr') {
             this.append_pyerr(json);
         } else if (json.output_type === 'stream') {
@@ -406,7 +405,7 b' var IPython = (function (IPython) {'
     };
 
 
-    OutputArea.prototype.append_pyout = function (json) {
+    OutputArea.prototype.append_execute_result = function (json) {
         var n = json.prompt_number || ' ';
         var toinsert = this.create_output_area();
         if (this.prompt_area) {

IPython/html/static/services/kernels/js/kernel.js

@@ -76,7 +76,7 b' var IPython = (function (IPython) {'
     // Initialize the iopub handlers
     
     Kernel.prototype.init_iopub_handlers = function () {
-        var output_types = ['stream', 'display_data', 'pyout', 'pyerr'];
+        var output_types = ['stream', 'display_data', 'execute_result', 'pyerr'];
         this._iopub_handlers = {};
         this.register_iopub_handler('status', $.proxy(this._handle_status_message, this));
         this.register_iopub_handler('clear_output', $.proxy(this._handle_clear_output, this));
@@ -573,7 +573,7 b' var IPython = (function (IPython) {'
     };
 
 
-    // handle an output message (pyout, display_data, etc.)
+    // handle an output message (execute_result, display_data, etc.)
     Kernel.prototype._handle_output_message = function (msg) {
         var callbacks = this.get_callbacks_for_msg(msg.parent_header.msg_id);
         if (!callbacks || !callbacks.iopub) {

IPython/html/tests/notebook/roundtrip.js

@@ -33,7 +33,7 b' function assert_has(short_name, json, result, result2) {'
 }
           
 // helper function for checkout that the first two cells have a particular
-// output_type (either 'pyout' or 'display_data'), and checks the to/fromJSON
+// output_type (either 'execute_result' or 'display_data'), and checks the to/fromJSON
 // for a set of mimetype keys, using their short names ('javascript', 'text',
 // 'png', etc).
 function check_output_area(output_type, keys) {
@@ -109,7 +109,7 b' casper.notebook_test(function () {'
     });
    
     this.then(function () {
-        check_output_area.apply(this, ['pyout', ['text', 'json']]);
+        check_output_area.apply(this, ['execute_result', ['text', 'json']]);
     });
 
     this.then(function() {
@@ -127,7 +127,7 b' casper.notebook_test(function () {'
     });
     
     this.then(function ( ) {
-        check_output_area.apply(this, ['pyout', ['text', 'latex']]);
+        check_output_area.apply(this, ['execute_result', ['text', 'latex']]);
     });
 
     this.then(function() {
@@ -145,7 +145,7 b' casper.notebook_test(function () {'
     });
     
     this.then(function ( ) {
-        check_output_area.apply(this, ['pyout', ['text', 'html']]);
+        check_output_area.apply(this, ['execute_result', ['text', 'html']]);
     });
 
     this.then(function() {
@@ -165,7 +165,7 b' casper.notebook_test(function () {'
     this.thenEvaluate(function() { IPython.notebook.save_notebook(); });
     
     this.then(function ( ) {
-        check_output_area.apply(this, ['pyout', ['text', 'png']]);
+        check_output_area.apply(this, ['execute_result', ['text', 'png']]);
     });
     
     this.then(function() {
@@ -184,7 +184,7 b' casper.notebook_test(function () {'
     });
     
     this.then(function ( ) {
-        check_output_area.apply(this, ['pyout', ['text', 'jpeg']]);
+        check_output_area.apply(this, ['execute_result', ['text', 'jpeg']]);
     });
     
     this.then(function() {
@@ -202,7 +202,7 b' casper.notebook_test(function () {'
     });
     
     this.then(function ( ) {
-        check_output_area.apply(this, ['pyout', ['text', 'svg']]);
+        check_output_area.apply(this, ['execute_result', ['text', 'svg']]);
     });
 
     this.then(function() {
@@ -238,7 +238,7 b' casper.notebook_test(function () {'
             'display_data custom mimetype ' + long_name);
         var result = this.get_output_cell(0, 1);
         this.test.assertTrue(result.hasOwnProperty(long_name),
-            'pyout custom mimetype ' + long_name);
+            'execute_result custom mimetype ' + long_name);
     
     });
     

IPython/kernel/tests/test_message_spec.py

@@ -185,7 +185,7 b' class DisplayData(Reference):'
             nt.assert_is_instance(v, string_types)
 
 
-class PyOut(Reference):
+class ExecuteResult(Reference):
     execution_count = Integer()
     data = Dict()
     def _data_changed(self, name, old, new):
@@ -201,7 +201,7 b' references = {'
     'complete_reply' : CompleteReply(),
     'kernel_info_reply': KernelInfoReply(),
     'execute_input' : ExecuteInput(),
-    'pyout' : PyOut(),
+    'execute_result' : ExecuteResult(),
     'pyerr' : PyErr(),
     'stream' : Stream(),
     'display_data' : DisplayData(),

IPython/kernel/zmq/displayhook.py

@@ -1,5 +1,8 b''
-"""Replacements for sys.displayhook that publish over ZMQ.
-"""
+"""Replacements for sys.displayhook that publish over ZMQ."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
 import sys
 
 from IPython.core.displayhook import DisplayHook
@@ -12,7 +15,7 b' from .session import extract_header, Session'
 class ZMQDisplayHook(object):
     """A simple displayhook that publishes the object's repr over a ZeroMQ
     socket."""
-    topic=b'pyout'
+    topic=b'execute_result'
 
     def __init__(self, session, pub_socket):
         self.session = session
@@ -26,7 +29,7 b' class ZMQDisplayHook(object):'
         builtin_mod._ = obj
         sys.stdout.flush()
         sys.stderr.flush()
-        msg = self.session.send(self.pub_socket, u'pyout', {u'data':repr(obj)},
+        msg = self.session.send(self.pub_socket, u'execute_result', {u'data':repr(obj)},
                                parent=self.parent_header, ident=self.topic)
 
     def set_parent(self, parent):
@@ -48,7 +51,7 b' class ZMQShellDisplayHook(DisplayHook):'
         self.parent_header = extract_header(parent)
 
     def start_displayhook(self):
-        self.msg = self.session.msg(u'pyout', {}, parent=self.parent_header)
+        self.msg = self.session.msg(u'execute_result', {}, parent=self.parent_header)
 
     def write_output_prompt(self):
         """Write the output prompt."""

IPython/kernel/zmq/ipkernel.py

@@ -143,7 +143,7 b' class Kernel(Configurable):'
         )
         self.shell.displayhook.session = self.session
         self.shell.displayhook.pub_socket = self.iopub_socket
-        self.shell.displayhook.topic = self._topic('pyout')
+        self.shell.displayhook.topic = self._topic('execute_result')
         self.shell.display_pub.session = self.session
         self.shell.display_pub.pub_socket = self.iopub_socket
         self.shell.data_pub.session = self.session

IPython/kernel/zmq/zmqshell.py

@@ -10,20 +10,18 b" implementation that doesn't rely on so much monkeypatching."
 But this lets us maintain a fully working IPython as we develop the new
 machinery.  This should thus be thought of as scaffolding.
 """
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
 from __future__ import print_function
 
-# Stdlib
 import os
 import sys
 import time
 
-# System library imports
 from zmq.eventloop import ioloop
 
-# Our own
 from IPython.core.interactiveshell import (
     InteractiveShell, InteractiveShellABC
 )
@@ -512,7 +510,7 b' class ZMQInteractiveShell(InteractiveShell):'
         # to pick up
         topic = None
         if dh.topic:
-            topic = dh.topic.replace(b'pyout', b'pyerr')
+            topic = dh.topic.replace(b'execute_result', b'pyerr')
         
         exc_msg = dh.session.send(dh.pub_socket, u'pyerr', json_clean(exc_content), dh.parent_header, ident=topic)
 

IPython/parallel/client/asyncresult.py

@@ -1,19 +1,7 b''
-"""AsyncResult objects for the client
+"""AsyncResult objects for the client"""
 
-Authors:
-
-* MinRK
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
@@ -436,7 +424,7 b' class AsyncResult(object):'
         for output in self.outputs:
             self._republish_displaypub(output, self.engine_id)
         
-        if self.pyout is not None:
+        if self.execute_result is not None:
             display(self.get())
     
     def _wait_for_outputs(self, timeout=-1):
@@ -495,15 +483,15 b' class AsyncResult(object):'
         
         stdouts = self.stdout
         stderrs = self.stderr
-        pyouts  = self.pyout
+        execute_results  = self.execute_result
         output_lists = self.outputs
         results = self.get()
         
         targets = self.engine_id
         
         if groupby == "engine":
-            for eid,stdout,stderr,outputs,r,pyout in zip(
-                    targets, stdouts, stderrs, output_lists, results, pyouts
+            for eid,stdout,stderr,outputs,r,execute_result in zip(
+                    targets, stdouts, stderrs, output_lists, results, execute_results
                 ):
                 self._display_stream(stdout, '[stdout:%i] ' % eid)
                 self._display_stream(stderr, '[stderr:%i] ' % eid, file=sys.stderr)
@@ -514,13 +502,13 b' class AsyncResult(object):'
                     # displaypub is meaningless outside IPython
                     return 
                 
-                if outputs or pyout is not None:
+                if outputs or execute_result is not None:
                     _raw_text('[output:%i]' % eid)
                 
                 for output in outputs:
                     self._republish_displaypub(output, eid)
                 
-                if pyout is not None:
+                if execute_result is not None:
                     display(r)
         
         elif groupby in ('type', 'order'):
@@ -555,9 +543,9 b' class AsyncResult(object):'
                     for output in outputs:
                         self._republish_displaypub(output, eid)
         
-            # finally, add pyout:
-            for eid,r,pyout in zip(targets, results, pyouts):
-                if pyout is not None:
+            # finally, add execute_result:
+            for eid,r,execute_result in zip(targets, results, execute_results):
+                if execute_result is not None:
                     display(r)
         
         else:

IPython/parallel/client/client.py

@@ -72,21 +72,21 b' class ExecuteReply(RichOutput):'
     
     @property
     def source(self):
-        pyout = self.metadata['pyout']
-        if pyout:
-            return pyout.get('source', '')
+        execute_result = self.metadata['execute_result']
+        if execute_result:
+            return execute_result.get('source', '')
     
     @property
     def data(self):
-        pyout = self.metadata['pyout']
-        if pyout:
-            return pyout.get('data', {})
+        execute_result = self.metadata['execute_result']
+        if execute_result:
+            return execute_result.get('data', {})
     
     @property
     def _metadata(self):
-        pyout = self.metadata['pyout']
-        if pyout:
-            return pyout.get('metadata', {})
+        execute_result = self.metadata['execute_result']
+        if execute_result:
+            return execute_result.get('metadata', {})
     
     def display(self):
         from IPython.display import publish_display_data
@@ -110,16 +110,16 b' class ExecuteReply(RichOutput):'
         return self.metadata[key]
     
     def __repr__(self):
-        pyout = self.metadata['pyout'] or {'data':{}}
-        text_out = pyout['data'].get('text/plain', '')
+        execute_result = self.metadata['execute_result'] or {'data':{}}
+        text_out = execute_result['data'].get('text/plain', '')
         if len(text_out) > 32:
             text_out = text_out[:29] + '...'
         
         return "<ExecuteReply[%i]: %s>" % (self.execution_count, text_out)
     
     def _repr_pretty_(self, p, cycle):
-        pyout = self.metadata['pyout'] or {'data':{}}
-        text_out = pyout['data'].get('text/plain', '')
+        execute_result = self.metadata['execute_result'] or {'data':{}}
+        text_out = execute_result['data'].get('text/plain', '')
         
         if not text_out:
             return
@@ -170,7 +170,7 b' class Metadata(dict):'
               'status' : None,
 
               'execute_input' : None,
-              'pyout' : None,
+              'execute_result' : None,
               'pyerr' : None,
               'stdout' : '',
               'stderr' : '',
@@ -875,8 +875,8 b' class Client(HasTraits):'
                 md.update({'execute_input' : content['code']})
             elif msg_type == 'display_data':
                 md['outputs'].append(content)
-            elif msg_type == 'pyout':
-                md['pyout'] = content
+            elif msg_type == 'execute_result':
+                md['execute_result'] = content
             elif msg_type == 'data_message':
                 data, remainder = serialize.unserialize_object(msg['buffers'])
                 md['data'].update(data)

IPython/parallel/controller/hub.py

@@ -67,7 +67,7 b' def empty_record():'
         'result_buffers' : None,
         'queue' : None,
         'execute_input' : None,
-        'pyout': None,
+        'execute_result': None,
         'pyerr': None,
         'stdout': '',
         'stderr': '',
@@ -95,7 +95,7 b' def init_record(msg):'
         'result_buffers' : None,
         'queue' : None,
         'execute_input' : None,
-        'pyout': None,
+        'execute_result': None,
         'pyerr': None,
         'stdout': '',
         'stderr': '',
@@ -869,7 +869,7 b' class Hub(SessionFactory):'
             d['pyerr'] = content
         elif msg_type == 'execute_input':
             d['execute_input'] = content['code']
-        elif msg_type in ('display_data', 'pyout'):
+        elif msg_type in ('display_data', 'execute_result'):
             d[msg_type] = content
         elif msg_type == 'status':
             pass
@@ -1316,7 +1316,7 b' class Hub(SessionFactory):'
     def _extract_record(self, rec):
         """decompose a TaskRecord dict into subsection of reply for get_result"""
         io_dict = {}
-        for key in ('execute_input', 'pyout', 'pyerr', 'stdout', 'stderr'):
+        for key in ('execute_input', 'execute_result', 'pyerr', 'stdout', 'stderr'):
                 io_dict[key] = rec[key]
         content = { 
             'header': rec['header'],

IPython/parallel/controller/sqlitedb.py

@@ -121,7 +121,7 b' class SQLiteDB(BaseDB):'
             'result_buffers' ,
             'queue' ,
             'execute_input' ,
-            'pyout',
+            'execute_result',
             'pyerr',
             'stdout',
             'stderr',
@@ -145,7 +145,7 b' class SQLiteDB(BaseDB):'
             'result_buffers' : 'bufs blob',
             'queue' : 'text',
             'execute_input' : 'text',
-            'pyout' : 'text',
+            'execute_result' : 'text',
             'pyerr' : 'text',
             'stdout' : 'text',
             'stderr' : 'text',
@@ -256,7 +256,7 b' class SQLiteDB(BaseDB):'
                 result_buffers bufs blob,
                 queue text,
                 execute_input text,
-                pyout text,
+                execute_result text,
                 pyerr text,
                 stdout text,
                 stderr text)

IPython/parallel/engine/engine.py

@@ -1,17 +1,10 b''
 """A simple engine that talks to a controller over 0MQ.
 it handles registration, etc. and launches a kernel
 connected to the Controller's Schedulers.
-
-Authors:
-
-* Min RK
 """
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
@@ -228,7 +221,7 b' class EngineFactory(RegistrationFactory):'
                 sys.stderr.topic = cast_bytes('engine.%i.stderr' % self.id)
             if self.display_hook_factory:
                 sys.displayhook = self.display_hook_factory(self.session, iopub_socket)
-                sys.displayhook.topic = cast_bytes('engine.%i.pyout' % self.id)
+                sys.displayhook.topic = cast_bytes('engine.%i.execute_result' % self.id)
 
             self.kernel = Kernel(parent=self, int_id=self.id, ident=self.ident, session=self.session,
                     control_stream=control_stream, shell_streams=shell_streams, iopub_socket=iopub_socket,

IPython/parallel/tests/test_client.py

@@ -1,20 +1,7 b''
-"""Tests for parallel client.py
+"""Tests for parallel client.py"""
 
-Authors:
-
-* Min RK
-"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from __future__ import division
 
@@ -177,7 +164,7 b' class TestClient(ClusterTestCase):'
         time.sleep(.25)
         ahr = self.client.get_result(ar.msg_ids[0])
         self.assertTrue(isinstance(ahr, AsyncHubResult))
-        self.assertEqual(ahr.get().pyout, ar.get().pyout)
+        self.assertEqual(ahr.get().execute_result, ar.get().execute_result)
         ar2 = self.client.get_result(ar.msg_ids[0])
         self.assertFalse(isinstance(ar2, AsyncHubResult))
         c.close()

IPython/parallel/tests/test_view.py

@@ -537,7 +537,7 b' class TestView(ClusterTestCase):'
         ar = e0.execute("5", silent=False)
         er = ar.get()
         self.assertEqual(str(er), "<ExecuteReply[%i]: 5>" % er.execution_count)
-        self.assertEqual(er.pyout['data']['text/plain'], '5')
+        self.assertEqual(er.execute_result['data']['text/plain'], '5')
 
     def test_execute_reply_rich(self):
         e0 = self.client[self.client.ids[0]]
@@ -558,21 +558,21 b' class TestView(ClusterTestCase):'
         er = ar.get()
         self.assertEqual(er.stdout.strip(), '5')
         
-    def test_execute_pyout(self):
-        """execute triggers pyout with silent=False"""
+    def test_execute_result(self):
+        """execute triggers execute_result with silent=False"""
         view = self.client[:]
         ar = view.execute("5", silent=False, block=True)
         
         expected = [{'text/plain' : '5'}] * len(view)
-        mimes = [ out['data'] for out in ar.pyout ]
+        mimes = [ out['data'] for out in ar.execute_result ]
         self.assertEqual(mimes, expected)
     
     def test_execute_silent(self):
-        """execute does not trigger pyout with silent=True"""
+        """execute does not trigger execute_result with silent=True"""
         view = self.client[:]
         ar = view.execute("5", block=True)
         expected = [None] * len(view)
-        self.assertEqual(ar.pyout, expected)
+        self.assertEqual(ar.execute_result, expected)
     
     def test_execute_magic(self):
         """execute accepts IPython commands"""

IPython/qt/console/frontend_widget.py

@@ -1,17 +1,19 b''
+"""Frontend widget for the Qt Console"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
 from __future__ import print_function
 
-# Standard library imports
 from collections import namedtuple
 import sys
 import uuid
 
-# System library imports
 from IPython.external import qt
 from IPython.external.qt import QtCore, QtGui
 from IPython.utils import py3compat
 from IPython.utils.importstring import import_item
 
-# Local imports
 from IPython.core.inputsplitter import InputSplitter, IPythonInputSplitter
 from IPython.core.inputtransformer import classic_prompt
 from IPython.core.oinspect import call_tip
@@ -526,10 +528,10 b' class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):'
             if call_info or doc:
                 self._call_tip_widget.show_call_info(call_info, doc)
 
-    def _handle_pyout(self, msg):
+    def _handle_execute_result(self, msg):
         """ Handle display hook output.
         """
-        self.log.debug("pyout: %s", msg.get('content', ''))
+        self.log.debug("execute_result: %s", msg.get('content', ''))
         if not self._hidden and self._is_from_this_session(msg):
             self.flush_clearoutput()
             text = msg['content']['data']

IPython/qt/console/ipython_widget.py

@@ -3,11 +3,9 b''
 This supports the additional functionality provided by the IPython kernel.
 """
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-# Standard library imports
 from collections import namedtuple
 import os.path
 import re
@@ -16,10 +14,8 b' import sys'
 import time
 from textwrap import dedent
 
-# System library imports
 from IPython.external.qt import QtCore, QtGui
 
-# Local imports
 from IPython.core.inputsplitter import IPythonInputSplitter
 from IPython.core.inputtransformer import ipy_prompt
 from IPython.utils.traitlets import Bool, Unicode
@@ -217,10 +213,10 b' class IPythonWidget(FrontendWidget):'
                 last_cell = cell
         self._set_history(items)
 
-    def _handle_pyout(self, msg):
+    def _handle_execute_result(self, msg):
         """ Reimplemented for IPython-style "display hook".
         """
-        self.log.debug("pyout: %s", msg.get('content', ''))
+        self.log.debug("execute_result: %s", msg.get('content', ''))
         if not self._hidden and self._is_from_this_session(msg):
             self.flush_clearoutput()
             content = msg['content']

IPython/qt/console/rich_ipython_widget.py

@@ -98,12 +98,12 b' class RichIPythonWidget(IPythonWidget):'
 
         Shared code for some the following if statement
         """
-        self.log.debug("pyout: %s", msg.get('content', ''))
+        self.log.debug("execute_result: %s", msg.get('content', ''))
         self._append_plain_text(self.output_sep, True)
         self._append_html(self._make_out_prompt(prompt_number), True)
         self._append_plain_text('\n', True)
 
-    def _handle_pyout(self, msg):
+    def _handle_execute_result(self, msg):
         """ Overridden to handle rich data types, like SVG.
         """
         if not self._hidden and self._is_from_this_session(msg):
@@ -128,7 +128,7 b' class RichIPythonWidget(IPythonWidget):'
                 self._append_html(self.output_sep2, True)
             else:
                 # Default back to the plain text representation.
-                return super(RichIPythonWidget, self)._handle_pyout(msg)
+                return super(RichIPythonWidget, self)._handle_execute_result(msg)
 
     def _handle_display_data(self, msg):
         """ Overridden to handle rich data types, like SVG.

IPython/qt/kernel_mixins.py

@@ -88,8 +88,8 b' class QtIOPubChannelMixin(ChannelQObject):'
     # Emitted when a message of type 'execute_input' is received.
     execute_input_received = QtCore.Signal(object)
 
-    # Emitted when a message of type 'pyout' is received.
-    pyout_received = QtCore.Signal(object)
+    # Emitted when a message of type 'execute_result' is received.
+    execute_result_received = QtCore.Signal(object)
 
     # Emitted when a message of type 'pyerr' is received.
     pyerr_received = QtCore.Signal(object)

IPython/terminal/console/interactiveshell.py

@@ -1,17 +1,9 b''
 # -*- coding: utf-8 -*-
-"""terminal client to the IPython kernel
-
-"""
-#-----------------------------------------------------------------------------
-# Copyright (C) 2013 The IPython Development Team
-#
-# Distributed under the terms of the BSD License. The full license is in
-# the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+"""terminal client to the IPython kernel"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
 from __future__ import print_function
 
 import bdb
@@ -228,7 +220,7 b' class ZMQTerminalInteractiveShell(TerminalInteractiveShell):'
         """Process messages on the IOPub channel
 
            This method consumes and processes messages on the IOPub channel,
-           such as stdout, stderr, pyout and status.
+           such as stdout, stderr, execute_result and status.
            
            It only displays output that is caused by this session.
         """
@@ -254,7 +246,7 b' class ZMQTerminalInteractiveShell(TerminalInteractiveShell):'
                         print(sub_msg["content"]["data"], file=io.stderr, end="")
                         io.stderr.flush()
 
-                elif msg_type == 'pyout':
+                elif msg_type == 'execute_result':
                     if self._pending_clearoutput:
                         print("\r", file=io.stdout, end="")
                         self._pending_clearoutput = False