* Updated prompt request code to support the new silent execution mechanism.

* Improved frontend tracking of request ids. This should ensure that it is safe to use the frontend's kernel manager without confusing it.

IPython/frontend/qt/console/frontend_widget.py

@@ -1,466 +1,479 b''
 # Standard library imports
+from collections import namedtuple
 import signal
 import sys
 
 # System library imports
 from pygments.lexers import PythonLexer
 from PyQt4 import QtCore, QtGui
 
 # Local imports
 from IPython.core.inputsplitter import InputSplitter
 from IPython.frontend.qt.base_frontend_mixin import BaseFrontendMixin
 from IPython.utils.traitlets import Bool
 from bracket_matcher import BracketMatcher
 from call_tip_widget import CallTipWidget
 from completion_lexer import CompletionLexer
 from console_widget import HistoryConsoleWidget
 from pygments_highlighter import PygmentsHighlighter
 
 
 class FrontendHighlighter(PygmentsHighlighter):
     """ A PygmentsHighlighter that can be turned on and off and that ignores
         prompts.
     """
 
     def __init__(self, frontend):
         super(FrontendHighlighter, self).__init__(frontend._control.document())
         self._current_offset = 0
         self._frontend = frontend
         self.highlighting_on = False
 
     def highlightBlock(self, qstring):
         """ Highlight a block of text. Reimplemented to highlight selectively.
         """
         if not self.highlighting_on:
             return
 
         # The input to this function is unicode string that may contain
         # paragraph break characters, non-breaking spaces, etc. Here we acquire
         # the string as plain text so we can compare it.
         current_block = self.currentBlock()
         string = self._frontend._get_block_plain_text(current_block)
 
         # Decide whether to check for the regular or continuation prompt.
         if current_block.contains(self._frontend._prompt_pos):
             prompt = self._frontend._prompt
         else:
             prompt = self._frontend._continuation_prompt
 
         # Don't highlight the part of the string that contains the prompt.
         if string.startswith(prompt):
             self._current_offset = len(prompt)
             qstring.remove(0, len(prompt))
         else:
             self._current_offset = 0
 
         PygmentsHighlighter.highlightBlock(self, qstring)
 
     def rehighlightBlock(self, block):
         """ Reimplemented to temporarily enable highlighting if disabled.
         """
         old = self.highlighting_on
         self.highlighting_on = True
         super(FrontendHighlighter, self).rehighlightBlock(block)
         self.highlighting_on = old
 
     def setFormat(self, start, count, format):
         """ Reimplemented to highlight selectively.
         """
         start += self._current_offset
         PygmentsHighlighter.setFormat(self, start, count, format)
 
 
 class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):
     """ A Qt frontend for a generic Python kernel.
     """
 
     # An option and corresponding signal for overriding the default kernel
     # interrupt behavior.
     custom_interrupt = Bool(False)
     custom_interrupt_requested = QtCore.pyqtSignal()
 
     # An option and corresponding signals for overriding the default kernel
     # restart behavior.
     custom_restart = Bool(False)
     custom_restart_kernel_died = QtCore.pyqtSignal(float)
     custom_restart_requested = QtCore.pyqtSignal()
    
     # Emitted when an 'execute_reply' has been received from the kernel and
     # processed by the FrontendWidget.
     executed = QtCore.pyqtSignal(object)
     
     # Protected class variables.
+    _CallTipRequest = namedtuple('_CallTipRequest', ['id', 'pos'])
+    _CompletionRequest = namedtuple('_CompletionRequest', ['id', 'pos'])
+    _ExecutionRequest = namedtuple('_ExecutionRequest', ['id', 'kind'])
     _input_splitter_class = InputSplitter
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         super(FrontendWidget, self).__init__(*args, **kw)
 
         # FrontendWidget protected variables.
         self._bracket_matcher = BracketMatcher(self._control)
         self._call_tip_widget = CallTipWidget(self._control)
         self._completion_lexer = CompletionLexer(PythonLexer())
         self._hidden = False
         self._highlighter = FrontendHighlighter(self)
         self._input_splitter = self._input_splitter_class(input_mode='block')
         self._kernel_manager = None
         self._possible_kernel_restart = False
+        self._request_info = {}
 
         # Configure the ConsoleWidget.
         self.tab_width = 4
         self._set_continuation_prompt('... ')
 
         # Connect signal handlers.
         document = self._control.document()
         document.contentsChange.connect(self._document_contents_change)
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' abstract interface
     #---------------------------------------------------------------------------
 
     def _is_complete(self, source, interactive):
         """ Returns whether 'source' can be completely processed and a new
             prompt created. When triggered by an Enter/Return key press,
             'interactive' is True; otherwise, it is False.
         """
         complete = self._input_splitter.push(source.expandtabs(4))
         if interactive:
             complete = not self._input_splitter.push_accepts_more()
         return complete
 
     def _execute(self, source, hidden, user_variables=None,
                  user_expressions=None):
         """ Execute 'source'. If 'hidden', do not show any output.
 
         See parent class :meth:`execute` docstring for full details.
         """
         # tmp code for testing, disable in real use with 'if 0'.  Only delete
         # this code once we have automated tests for these fields.
         if 0:
             user_variables = ['x', 'y', 'z']
             user_expressions = {'sum' : '1+1',
                                 'bad syntax' : 'klsdafj kasd f',
                                 'bad call' : 'range("hi")',
                                 'time' : 'time.time()',
                                 }
         # /end tmp code
         
         # FIXME - user_variables/expressions are not visible in API above us.
-        self.kernel_manager.xreq_channel.execute(source, hidden,
-                                                 user_variables,
-                                                 user_expressions)
+        msg_id = self.kernel_manager.xreq_channel.execute(source, hidden,
+                                                          user_variables,
+                                                          user_expressions)
+        self._request_info['execute'] = self._ExecutionRequest(msg_id, 'user')
         self._hidden = hidden
         
     def _prompt_started_hook(self):
         """ Called immediately after a new prompt is displayed.
         """
         if not self._reading:
             self._highlighter.highlighting_on = True
 
     def _prompt_finished_hook(self):
         """ Called immediately after a prompt is finished, i.e. when some input
             will be processed and a new prompt displayed.
         """
         if not self._reading:
             self._highlighter.highlighting_on = False
 
     def _tab_pressed(self):
         """ Called when the tab key is pressed. Returns whether to continue
             processing the event.
         """
         # Perform tab completion if:
         # 1) The cursor is in the input buffer.
         # 2) There is a non-whitespace character before the cursor.
         text = self._get_input_buffer_cursor_line()
         if text is None:
             return False
         complete = bool(text[:self._get_input_buffer_cursor_column()].strip())
         if complete:
             self._complete()
         return not complete
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _event_filter_console_keypress(self, event):
         """ Reimplemented to allow execution interruption.
         """
         key = event.key()
         if self._control_key_down(event.modifiers()):
             if key == QtCore.Qt.Key_C and self._executing:
                 self.interrupt_kernel()
                 return True
             elif key == QtCore.Qt.Key_Period:
                 message = 'Are you sure you want to restart the kernel?'
                 self.restart_kernel(message)
                 return True
         return super(FrontendWidget, self)._event_filter_console_keypress(event)
 
     def _insert_continuation_prompt(self, cursor):
         """ Reimplemented for auto-indentation.
         """
         super(FrontendWidget, self)._insert_continuation_prompt(cursor)
         spaces = self._input_splitter.indent_spaces
         cursor.insertText('\t' * (spaces / self.tab_width))
         cursor.insertText(' ' * (spaces % self.tab_width))
 
     #---------------------------------------------------------------------------
     # 'BaseFrontendMixin' abstract interface
     #---------------------------------------------------------------------------
 
     def _handle_complete_reply(self, rep):
         """ Handle replies for tab completion.
         """
         cursor = self._get_cursor()
-        if rep['parent_header']['msg_id'] == self._complete_id and \
-                cursor.position() == self._complete_pos:
+        info = self._request_info.get('complete')
+        if info and info.id == rep['parent_header']['msg_id'] and \
+                info.pos == cursor.position():
             text = '.'.join(self._get_context())
             cursor.movePosition(QtGui.QTextCursor.Left, n=len(text))
             self._complete_with_items(cursor, rep['content']['matches'])
 
     def _handle_execute_reply(self, msg):
         """ Handles replies for code execution.
         """
-        if not self._hidden:
+        info = self._request_info.get('execute')
+        if info and info.id == msg['parent_header']['msg_id'] and \
+                not self._hidden:
             # Make sure that all output from the SUB channel has been processed
             # before writing a new prompt.
             self.kernel_manager.sub_channel.flush()
 
             content = msg['content']
             status = content['status']
             if status == 'ok':
                 self._process_execute_ok(msg)
             elif status == 'error':
                 self._process_execute_error(msg)
             elif status == 'abort':
                 self._process_execute_abort(msg)
 
             self._show_interpreter_prompt_for_reply(msg)
             self.executed.emit(msg)
 
     def _handle_input_request(self, msg):
         """ Handle requests for raw_input.
         """
         if self._hidden:
             raise RuntimeError('Request for raw input during hidden execution.')
 
         # Make sure that all output from the SUB channel has been processed
         # before entering readline mode.
         self.kernel_manager.sub_channel.flush()
 
         def callback(line):
             self.kernel_manager.rep_channel.input(line)
         self._readline(msg['content']['prompt'], callback=callback)
 
     def _handle_kernel_died(self, since_last_heartbeat):
         """ Handle the kernel's death by asking if the user wants to restart.
         """
         message = 'The kernel heartbeat has been inactive for %.2f ' \
                   'seconds. Do you want to restart the kernel? You may ' \
                   'first want to check the network connection.' % \
                   since_last_heartbeat
         if self.custom_restart:
             self.custom_restart_kernel_died.emit(since_last_heartbeat)
         else:
             self.restart_kernel(message)
 
     def _handle_object_info_reply(self, rep):
         """ Handle replies for call tips.
         """
         cursor = self._get_cursor()
-        if rep['parent_header']['msg_id'] == self._call_tip_id and \
-                cursor.position() == self._call_tip_pos:
+        info = self._request_info.get('call_tip')
+        if info and info.id == rep['parent_header']['msg_id'] and \
+                info.pos == cursor.position():
             doc = rep['content']['docstring']
             if doc:
                 self._call_tip_widget.show_docstring(doc)
 
     def _handle_pyout(self, msg):
         """ Handle display hook output.
         """
         if not self._hidden and self._is_from_this_session(msg):
             self._append_plain_text(msg['content']['data'] + '\n')
 
     def _handle_stream(self, msg):
         """ Handle stdout, stderr, and stdin.
         """
         if not self._hidden and self._is_from_this_session(msg):
             self._append_plain_text(msg['content']['data'])
             self._control.moveCursor(QtGui.QTextCursor.End)
     
     def _started_channels(self):
         """ Called when the KernelManager channels have started listening or 
             when the frontend is assigned an already listening KernelManager.
         """
         self._control.clear()
         self._append_plain_text(self._get_banner())
         self._show_interpreter_prompt()
 
     def _stopped_channels(self):
         """ Called when the KernelManager channels have stopped listening or
             when a listening KernelManager is removed from the frontend.
         """
         self._executing = self._reading = False
         self._highlighter.highlighting_on = False
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' interface
     #---------------------------------------------------------------------------
 
     def execute_file(self, path, hidden=False):
         """ Attempts to execute file with 'path'. If 'hidden', no output is
             shown.
         """
         self.execute('execfile("%s")' % path, hidden=hidden)
 
     def interrupt_kernel(self):
         """ Attempts to interrupt the running kernel.
         """
         if self.custom_interrupt:
             self.custom_interrupt_requested.emit()
         elif self.kernel_manager.has_kernel:
             self.kernel_manager.signal_kernel(signal.SIGINT)
         else:
             self._append_plain_text('Kernel process is either remote or '
                                     'unspecified. Cannot interrupt.\n')
 
     def restart_kernel(self, message):
         """ Attempts to restart the running kernel.
         """
         # We want to make sure that if this dialog is already happening, that
         # other signals don't trigger it again. This can happen when the 
         # kernel_died heartbeat signal is emitted and the user is slow to
         # respond to the dialog.
         if not self._possible_kernel_restart:
             if self.custom_restart:
                 self.custom_restart_requested.emit()
             elif self.kernel_manager.has_kernel:
                 # Setting this to True will prevent this logic from happening
                 # again until the current pass is completed.
                 self._possible_kernel_restart = True
                 buttons = QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
                 result = QtGui.QMessageBox.question(self, 'Restart kernel?',
                                                     message, buttons)
                 if result == QtGui.QMessageBox.Yes:
                     try:
                         self.kernel_manager.restart_kernel()
                     except RuntimeError:
                         message = 'Kernel started externally. Cannot restart.\n'
                         self._append_plain_text(message)
                     else:
                         self._stopped_channels()
                         self._append_plain_text('Kernel restarting...\n')
                         self._show_interpreter_prompt()
                 # This might need to be moved to another location?
                 self._possible_kernel_restart = False
             else:
                 self._append_plain_text('Kernel process is either remote or '
                                         'unspecified. Cannot restart.\n')
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _call_tip(self):
         """ Shows a call tip, if appropriate, at the current cursor location.
         """
         # Decide if it makes sense to show a call tip
         cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.Left)
         if cursor.document().characterAt(cursor.position()).toAscii() != '(':
             return False
         context = self._get_context(cursor)
         if not context:
             return False
 
         # Send the metadata request to the kernel
         name = '.'.join(context)
-        self._call_tip_id = self.kernel_manager.xreq_channel.object_info(name)
-        self._call_tip_pos = self._get_cursor().position()
+        msg_id = self.kernel_manager.xreq_channel.object_info(name)
+        pos = self._get_cursor().position()
+        self._request_info['call_tip'] = self._CallTipRequest(msg_id, pos)
         return True
 
     def _complete(self):
         """ Performs completion at the current cursor location.
         """
         context = self._get_context()
         if context:
             # Send the completion request to the kernel
-            self._complete_id = self.kernel_manager.xreq_channel.complete(
+            msg_id = self.kernel_manager.xreq_channel.complete(
                 '.'.join(context),                       # text
                 self._get_input_buffer_cursor_line(),    # line
                 self._get_input_buffer_cursor_column(),  # cursor_pos
                 self.input_buffer)                       # block 
-            self._complete_pos = self._get_cursor().position()
+            pos = self._get_cursor().position()
+            info = self._CompletionRequest(msg_id, pos)
+            self._request_info['complete'] = info
 
     def _get_banner(self):
         """ Gets a banner to display at the beginning of a session.
         """
         banner = 'Python %s on %s\nType "help", "copyright", "credits" or ' \
             '"license" for more information.'
         return banner % (sys.version, sys.platform)
 
     def _get_context(self, cursor=None):
         """ Gets the context for the specified cursor (or the current cursor
             if none is specified).
         """
         if cursor is None:
             cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.StartOfBlock, 
                             QtGui.QTextCursor.KeepAnchor)
         text = str(cursor.selection().toPlainText())
         return self._completion_lexer.get_context(text)
 
     def _process_execute_abort(self, msg):
         """ Process a reply for an aborted execution request.
         """
         self._append_plain_text("ERROR: execution aborted\n")
 
     def _process_execute_error(self, msg):
         """ Process a reply for an execution request that resulted in an error.
         """
         content = msg['content']
         traceback = ''.join(content['traceback'])
         self._append_plain_text(traceback)
 
     def _process_execute_ok(self, msg):
         """ Process a reply for a successful execution equest.
         """
         payload = msg['content']['payload']
         for item in payload:
             if not self._process_execute_payload(item):
                 warning = 'Received unknown payload of type %s\n'
                 self._append_plain_text(warning % repr(item['source']))
 
     def _process_execute_payload(self, item):
         """ Process a single payload item from the list of payload items in an
             execution reply. Returns whether the payload was handled.
         """
         # The basic FrontendWidget doesn't handle payloads, as they are a
         # mechanism for going beyond the standard Python interpreter model.
         return False
 
     def _show_interpreter_prompt(self):
         """ Shows a prompt for the interpreter.
         """
         self._show_prompt('>>> ')
 
     def _show_interpreter_prompt_for_reply(self, msg):
         """ Shows a prompt for the interpreter given an 'execute_reply' message.
         """
         self._show_interpreter_prompt()
 
     #------ Signal handlers ----------------------------------------------------
 
     def _document_contents_change(self, position, removed, added):
         """ Called whenever the document's content changes. Display a call tip
             if appropriate.
         """
         # Calculate where the cursor should be *after* the change:
         position += added
 
         document = self._control.document()
         if position == self._get_cursor().position():
             self._call_tip()

IPython/frontend/qt/console/ipython_widget.py

@@ -1,408 +1,414 b''
 """ A FrontendWidget that emulates the interface of the console IPython and
     supports the additional functionality provided by the IPython kernel.
 
     TODO: Add support for retrieving the system default editor. Requires code
           paths for Windows (use the registry), Mac OS (use LaunchServices), and
           Linux (use the xdg system).
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Standard library imports
 from collections import namedtuple
 import re
 from subprocess import Popen
 
 # System library imports
 from PyQt4 import QtCore, QtGui
 
 # Local imports
 from IPython.core.inputsplitter import IPythonInputSplitter
 from IPython.core.usage import default_banner
-from IPython.utils import io
 from IPython.utils.traitlets import Bool, Str
 from frontend_widget import FrontendWidget
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 # The default light style sheet: black text on a white background.
 default_light_style_sheet = '''
     .error { color: red; }
     .in-prompt { color: navy; }
     .in-prompt-number { font-weight: bold; }
     .out-prompt { color: darkred; }
     .out-prompt-number { font-weight: bold; }
 '''
 default_light_syntax_style = 'default'
 
 # The default dark style sheet: white text on a black background.
 default_dark_style_sheet = '''
     QPlainTextEdit, QTextEdit { background-color: black; color: white }
     QFrame { border: 1px solid grey; }
     .error { color: red; }
     .in-prompt { color: lime; }
     .in-prompt-number { color: lime; font-weight: bold; }
     .out-prompt { color: red; }
     .out-prompt-number { color: red; font-weight: bold; }
 '''
 default_dark_syntax_style = 'monokai'
 
 # Default strings to build and display input and output prompts (and separators
 # in between)
 default_in_prompt = 'In [<span class="in-prompt-number">%i</span>]: '
 default_out_prompt = 'Out[<span class="out-prompt-number">%i</span>]: '
 default_input_sep = '\n'
 default_output_sep = ''
 default_output_sep2 = ''
 
 #-----------------------------------------------------------------------------
 # IPythonWidget class
 #-----------------------------------------------------------------------------
 
 class IPythonWidget(FrontendWidget):
     """ A FrontendWidget for an IPython kernel.
     """
 
     # If set, the 'custom_edit_requested(str, int)' signal will be emitted when
     # an editor is needed for a file. This overrides 'editor' and 'editor_line'
     # settings.
     custom_edit = Bool(False)
     custom_edit_requested = QtCore.pyqtSignal(object, object)
 
     # A command for invoking a system text editor. If the string contains a
     # {filename} format specifier, it will be used. Otherwise, the filename will
     # be appended to the end the command.
     editor = Str('default', config=True)
 
     # The editor command to use when a specific line number is requested. The
     # string should contain two format specifiers: {line} and {filename}. If
     # this parameter is not specified, the line number option to the %edit magic
     # will be ignored.
     editor_line = Str(config=True)
 
     # A CSS stylesheet. The stylesheet can contain classes for:
     #     1. Qt: QPlainTextEdit, QFrame, QWidget, etc
     #     2. Pygments: .c, .k, .o, etc (see PygmentsHighlighter)
     #     3. IPython: .error, .in-prompt, .out-prompt, etc
     style_sheet = Str(config=True)
     
     # If not empty, use this Pygments style for syntax highlighting. Otherwise,
     # the style sheet is queried for Pygments style information.
     syntax_style = Str(config=True)
 
     # Prompts.
     in_prompt = Str(default_in_prompt, config=True)
     out_prompt = Str(default_out_prompt, config=True)
     input_sep = Str(default_input_sep, config=True)
     output_sep = Str(default_output_sep, config=True)
     output_sep2 = Str(default_output_sep2, config=True)
 
     # FrontendWidget protected class variables.
     _input_splitter_class = IPythonInputSplitter
 
     # IPythonWidget protected class variables.
     _PromptBlock = namedtuple('_PromptBlock', ['block', 'length', 'number'])
     _payload_source_edit = 'IPython.zmq.zmqshell.ZMQInteractiveShell.edit_magic'
     _payload_source_page = 'IPython.zmq.page.page'
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         super(IPythonWidget, self).__init__(*args, **kw)
 
         # IPythonWidget protected variables.
         self._previous_prompt_obj = None
 
         # Initialize widget styling.
         if self.style_sheet:
             self._style_sheet_changed()
             self._syntax_style_changed()
         else:
             self.set_default_style()
 
     #---------------------------------------------------------------------------
     # 'BaseFrontendMixin' abstract interface
     #---------------------------------------------------------------------------
 
     def _handle_complete_reply(self, rep):
         """ Reimplemented to support IPython's improved completion machinery.
         """
         cursor = self._get_cursor()
-        if rep['parent_header']['msg_id'] == self._complete_id and \
-                cursor.position() == self._complete_pos:
+        info = self._request_info.get('complete')
+        if info and info.id == rep['parent_header']['msg_id'] and \
+                info.pos == cursor.position():
             matches = rep['content']['matches']
             text = rep['content']['matched_text']
 
             # Clean up matches with '.'s and path separators.
             parts = re.split(r'[./\\]', text) 
             sep_count = len(parts) - 1
             if sep_count:
                 chop_length = sum(map(len, parts[:sep_count])) + sep_count
                 matches = [ match[chop_length:] for match in matches ]
                 text = text[chop_length:]
 
             # Move the cursor to the start of the match and complete.
             cursor.movePosition(QtGui.QTextCursor.Left, n=len(text))
             self._complete_with_items(cursor, matches)
 
+    def _handle_execute_reply(self, msg):
+        """ Reimplemented to support prompt requests.
+        """
+        info = self._request_info.get('execute')
+        if info and info.id == msg['parent_header']['msg_id']:
+            if info.kind == 'prompt':
+                number = msg['content']['execution_count'] + 1
+                self._show_interpreter_prompt(number)
+            else:
+                super(IPythonWidget, self)._handle_execute_reply(msg)
+
     def _handle_history_reply(self, msg):
         """ Implemented to handle history replies, which are only supported by
             the IPython kernel.
         """
         history_dict = msg['content']['history']
         items = [ history_dict[key] for key in sorted(history_dict.keys()) ]
         self._set_history(items)
 
-    def _handle_prompt_reply(self, msg):
-        """ Implemented to handle prompt number replies, which are only
-            supported by the IPython kernel.
-        """
-        self._show_interpreter_prompt(msg['content']['execution_count'])
-
     def _handle_pyout(self, msg):
         """ Reimplemented for IPython-style "display hook".
         """
         if not self._hidden and self._is_from_this_session(msg):
             content = msg['content']
             prompt_number = content['execution_count']
             self._append_plain_text(self.output_sep)
             self._append_html(self._make_out_prompt(prompt_number))
             self._append_plain_text(content['data']+self.output_sep2)
 
     def _started_channels(self):
         """ Reimplemented to make a history request.
         """
         super(IPythonWidget, self)._started_channels()
         # FIXME: Disabled until history requests are properly implemented.
         #self.kernel_manager.xreq_channel.history(raw=True, output=False)
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' interface
     #---------------------------------------------------------------------------
 
     def execute_file(self, path, hidden=False):
         """ Reimplemented to use the 'run' magic.
         """
         self.execute('%%run %s' % path, hidden=hidden)
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _complete(self):
         """ Reimplemented to support IPython's improved completion machinery.
         """
         # We let the kernel split the input line, so we *always* send an empty
         # text field. Readline-based frontends do get a real text field which
         # they can use.
         text = ''
         
         # Send the completion request to the kernel
-        self._complete_id = self.kernel_manager.xreq_channel.complete(
+        msg_id = self.kernel_manager.xreq_channel.complete(
             text,                                    # text
             self._get_input_buffer_cursor_line(),    # line
             self._get_input_buffer_cursor_column(),  # cursor_pos
             self.input_buffer)                       # block 
-        self._complete_pos = self._get_cursor().position()
+        pos = self._get_cursor().position()
+        info = self._CompletionRequest(msg_id, pos)
+        self._request_info['complete'] = info
 
     def _get_banner(self):
         """ Reimplemented to return IPython's default banner.
         """
         return default_banner + '\n'
 
     def _process_execute_error(self, msg):
         """ Reimplemented for IPython-style traceback formatting.
         """
         content = msg['content']
         traceback = '\n'.join(content['traceback']) + '\n'
         if False:
             # FIXME: For now, tracebacks come as plain text, so we can't use
             # the html renderer yet.  Once we refactor ultratb to produce
             # properly styled tracebacks, this branch should be the default
             traceback = traceback.replace(' ', '&nbsp;')
             traceback = traceback.replace('\n', '<br/>')
 
             ename = content['ename']
             ename_styled = '<span class="error">%s</span>' % ename
             traceback = traceback.replace(ename, ename_styled)
 
             self._append_html(traceback)
         else:
             # This is the fallback for now, using plain text with ansi escapes
             self._append_plain_text(traceback)
 
     def _process_execute_payload(self, item):
         """ Reimplemented to handle %edit and paging payloads.
         """
         if item['source'] == self._payload_source_edit:
             self._edit(item['filename'], item['line_number'])
             return True
         elif item['source'] == self._payload_source_page:
             self._page(item['data'])
             return True
         else:
             return False
 
     def _show_interpreter_prompt(self, number=None):
         """ Reimplemented for IPython-style prompts.
         """
         # If a number was not specified, make a prompt number request.
         if number is None:
-            # FIXME - fperez: this should be a silent code request
-            number = 1
-            ##self.kernel_manager.xreq_channel.prompt()
-            ##return
+            msg_id = self.kernel_manager.xreq_channel.execute('', silent=True)
+            info = self._ExecutionRequest(msg_id, 'prompt')
+            self._request_info['execute'] = info
+            return
 
         # Show a new prompt and save information about it so that it can be
         # updated later if the prompt number turns out to be wrong.
         self._prompt_sep = self.input_sep
         self._show_prompt(self._make_in_prompt(number), html=True)
         block = self._control.document().lastBlock()
         length = len(self._prompt)
         self._previous_prompt_obj = self._PromptBlock(block, length, number)
 
         # Update continuation prompt to reflect (possibly) new prompt length.
         self._set_continuation_prompt(
             self._make_continuation_prompt(self._prompt), html=True)
 
     def _show_interpreter_prompt_for_reply(self, msg):
         """ Reimplemented for IPython-style prompts.
         """
         # Update the old prompt number if necessary.
         content = msg['content']
-        ##io.rprint('_show_interpreter_prompt_for_reply\n', content) # dbg
         previous_prompt_number = content['execution_count']
         if self._previous_prompt_obj and \
                 self._previous_prompt_obj.number != previous_prompt_number:
             block = self._previous_prompt_obj.block
 
             # Make sure the prompt block has not been erased.
             if block.isValid() and not block.text().isEmpty():
 
                 # Remove the old prompt and insert a new prompt.
                 cursor = QtGui.QTextCursor(block)
                 cursor.movePosition(QtGui.QTextCursor.Right,
                                     QtGui.QTextCursor.KeepAnchor, 
                                     self._previous_prompt_obj.length)
                 prompt = self._make_in_prompt(previous_prompt_number)
                 self._prompt = self._insert_html_fetching_plain_text(
                     cursor, prompt)
 
                 # When the HTML is inserted, Qt blows away the syntax
                 # highlighting for the line, so we need to rehighlight it.
                 self._highlighter.rehighlightBlock(cursor.block())
 
             self._previous_prompt_obj = None
 
         # Show a new prompt with the kernel's estimated prompt number.
         self._show_interpreter_prompt(previous_prompt_number+1)
 
     #---------------------------------------------------------------------------
     # 'IPythonWidget' interface
     #---------------------------------------------------------------------------
 
     def set_default_style(self, lightbg=True):
         """ Sets the widget style to the class defaults.
 
         Parameters:
         -----------
         lightbg : bool, optional (default True)
             Whether to use the default IPython light background or dark
             background style.
         """
         if lightbg:
             self.style_sheet = default_light_style_sheet
             self.syntax_style = default_light_syntax_style
         else:
             self.style_sheet = default_dark_style_sheet
             self.syntax_style = default_dark_syntax_style
 
     #---------------------------------------------------------------------------
     # 'IPythonWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _edit(self, filename, line=None):
         """ Opens a Python script for editing.
 
         Parameters:
         -----------
         filename : str
             A path to a local system file.
 
         line : int, optional
             A line of interest in the file.
         """
         if self.custom_edit:
             self.custom_edit_requested.emit(filename, line)
         elif self.editor == 'default':
             self._append_plain_text('No default editor available.\n')
         else:
             try:
                 filename = '"%s"' % filename
                 if line and self.editor_line:
                     command = self.editor_line.format(filename=filename,
                                                       line=line)
                 else:
                     try:
                         command = self.editor.format()
                     except KeyError:
                         command = self.editor.format(filename=filename)
                     else:
                         command += ' ' + filename
             except KeyError:
                 self._append_plain_text('Invalid editor command.\n')
             else:
                 try:
                     Popen(command, shell=True)
                 except OSError:
                     msg = 'Opening editor with command "%s" failed.\n'
                     self._append_plain_text(msg % command)
 
     def _make_in_prompt(self, number):
         """ Given a prompt number, returns an HTML In prompt.
         """
         body = self.in_prompt % number
         return '<span class="in-prompt">%s</span>' % body
 
     def _make_continuation_prompt(self, prompt):
         """ Given a plain text version of an In prompt, returns an HTML
             continuation prompt.
         """
         end_chars = '...: '
         space_count = len(prompt.lstrip('\n')) - len(end_chars)
         body = '&nbsp;' * space_count + end_chars
         return '<span class="in-prompt">%s</span>' % body
         
     def _make_out_prompt(self, number):
         """ Given a prompt number, returns an HTML Out prompt.
         """
         body = self.out_prompt % number
         return '<span class="out-prompt">%s</span>' % body
 
     #------ Trait change handlers ---------------------------------------------
 
     def _style_sheet_changed(self):
         """ Set the style sheets of the underlying widgets.
         """
         self.setStyleSheet(self.style_sheet)
         self._control.document().setDefaultStyleSheet(self.style_sheet)
         if self._page_control:
             self._page_control.document().setDefaultStyleSheet(self.style_sheet)
 
         bg_color = self._control.palette().background().color()
         self._ansi_processor.set_background_color(bg_color)
 
     def _syntax_style_changed(self):
         """ Set the style for the syntax highlighter.
         """
         if self.syntax_style:
             self._highlighter.set_style(self.syntax_style)
         else:
             self._highlighter.set_style_sheet(self.style_sheet)
         

IPython/zmq/kernelmanager.py

@@ -1,786 +1,785 b''
 """Base classes to manage the interaction with a running kernel.
 
 Todo
 ====
 
 * Create logger to handle debugging and console messages.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2010  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
 #-----------------------------------------------------------------------------
 
 # Standard library imports.
 from Queue import Queue, Empty
 from subprocess import Popen
 from threading import Thread
 import time
 
 # System library imports.
 import zmq
 from zmq import POLLIN, POLLOUT, POLLERR
 from zmq.eventloop import ioloop
 
 # Local imports.
 from IPython.utils import io
 from IPython.utils.traitlets import HasTraits, Any, Instance, Type, TCPAddress
 from session import Session
 
 #-----------------------------------------------------------------------------
 # Constants and exceptions
 #-----------------------------------------------------------------------------
 
 LOCALHOST = '127.0.0.1'
 
 class InvalidPortNumber(Exception):
     pass
 
 #-----------------------------------------------------------------------------
 # Utility functions
 #-----------------------------------------------------------------------------
 
 # some utilities to validate message structure, these might get moved elsewhere
 # if they prove to have more generic utility
 
 def validate_string_list(lst):
     """Validate that the input is a list of strings.
 
     Raises ValueError if not."""
     if not isinstance(lst, list):
         raise ValueError('input %r must be a list' % lst)
     for x in lst:
         if not isinstance(x, basestring):
             raise ValueError('element %r in list must be a string' % x)
 
 
 def validate_string_dict(dct):
     """Validate that the input is a dict with string keys and values.
 
     Raises ValueError if not."""
     for k,v in dct.iteritems():
         if not isinstance(k, basestring):
             raise ValueError('key %r in dict must be a string' % k)
         if not isinstance(v, basestring):
             raise ValueError('value %r in dict must be a string' % v)
 
 
 #-----------------------------------------------------------------------------
 # ZMQ Socket Channel classes
 #-----------------------------------------------------------------------------
 
 class ZmqSocketChannel(Thread):
     """The base class for the channels that use ZMQ sockets.
     """
     context = None
     session = None
     socket = None
     ioloop = None
     iostate = None
     _address = None
 
     def __init__(self, context, session, address):
         """Create a channel
 
         Parameters
         ----------
         context : :class:`zmq.Context`
             The ZMQ context to use.
         session : :class:`session.Session`
             The session to use.
         address : tuple
             Standard (ip, port) tuple that the kernel is listening on.
         """
         super(ZmqSocketChannel, self).__init__()
         self.daemon = True
 
         self.context = context
         self.session = session
         if address[1] == 0:
             message = 'The port number for a channel cannot be 0.'
             raise InvalidPortNumber(message)
         self._address = address
 
     def stop(self):
         """Stop the channel's activity.
 
         This calls :method:`Thread.join` and returns when the thread
         terminates. :class:`RuntimeError` will be raised if 
         :method:`self.start` is called again.
         """
         self.join()
 
     @property
     def address(self):
         """Get the channel's address as an (ip, port) tuple.
         
         By the default, the address is (localhost, 0), where 0 means a random
         port.
         """
         return self._address
 
     def add_io_state(self, state):
         """Add IO state to the eventloop.
 
         Parameters
         ----------
         state : zmq.POLLIN|zmq.POLLOUT|zmq.POLLERR
             The IO state flag to set.
 
         This is thread safe as it uses the thread safe IOLoop.add_callback.
         """
         def add_io_state_callback():
             if not self.iostate & state:
                 self.iostate = self.iostate | state
                 self.ioloop.update_handler(self.socket, self.iostate)
         self.ioloop.add_callback(add_io_state_callback)
 
     def drop_io_state(self, state):
         """Drop IO state from the eventloop.
 
         Parameters
         ----------
         state : zmq.POLLIN|zmq.POLLOUT|zmq.POLLERR
             The IO state flag to set.
 
         This is thread safe as it uses the thread safe IOLoop.add_callback.
         """
         def drop_io_state_callback():
             if self.iostate & state:
                 self.iostate = self.iostate & (~state)
                 self.ioloop.update_handler(self.socket, self.iostate)
         self.ioloop.add_callback(drop_io_state_callback)
 
 
 class XReqSocketChannel(ZmqSocketChannel):
     """The XREQ channel for issues request/replies to the kernel.
     """
 
     command_queue = None
 
     def __init__(self, context, session, address):
         self.command_queue = Queue()
         super(XReqSocketChannel, self).__init__(context, session, address)
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.XREQ)
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.ioloop = ioloop.IOLoop()
         self.iostate = POLLERR|POLLIN
         self.ioloop.add_handler(self.socket, self._handle_events, 
                                 self.iostate)
         self.ioloop.start()
 
     def stop(self):
         self.ioloop.stop()
         super(XReqSocketChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def execute(self, code, silent=False,
                 user_variables=None, user_expressions=None):
         """Execute code in the kernel.
 
         Parameters
         ----------
         code : str
             A string of Python code.
             
         silent : bool, optional (default False)
             If set, the kernel will execute the code as quietly possible.
 
         user_variables : list, optional
-        
             A list of variable names to pull from the user's namespace.  They
             will come back as a dict with these names as keys and their
             :func:`repr` as values.
             
         user_expressions : dict, optional
             A dict with string keys and  to pull from the user's
             namespace.  They will come back as a dict with these names as keys
             and their :func:`repr` as values.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         if user_variables is None:
             user_variables = []
         if user_expressions is None:
             user_expressions = {}
             
         # Don't waste network traffic if inputs are invalid
         if not isinstance(code, basestring):
             raise ValueError('code %r must be a string' % code)
         validate_string_list(user_variables)
         validate_string_dict(user_expressions)
 
         # Create class for content/msg creation. Related to, but possibly
         # not in Session.
         content = dict(code=code, silent=silent,
                        user_variables=user_variables,
                        user_expressions=user_expressions)
         msg = self.session.msg('execute_request', content)
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def complete(self, text, line, cursor_pos, block=None):
         """Tab complete text in the kernel's namespace.
 
         Parameters
         ----------
         text : str
             The text to complete.
         line : str
             The full line of text that is the surrounding context for the 
             text to complete.
         cursor_pos : int
             The position of the cursor in the line where the completion was
             requested.
         block : str, optional
             The full block of code in which the completion is being requested.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(text=text, line=line, block=block, cursor_pos=cursor_pos)
         msg = self.session.msg('complete_request', content)
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def object_info(self, oname):
         """Get metadata information about an object.
 
         Parameters
         ----------
         oname : str
             A string specifying the object name.
         
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(oname=oname)
         msg = self.session.msg('object_info_request', content)
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def history(self, index=None, raw=False, output=True):
         """Get the history list.
 
         Parameters
         ----------
         index : n or (n1, n2) or None
             If n, then the last entries. If a tuple, then all in
             range(n1, n2). If None, then all entries. Raises IndexError if
             the format of index is incorrect.
         raw : bool
             If True, return the raw input.
         output : bool
             If True, then return the output as well.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(index=index, raw=raw, output=output)
         msg = self.session.msg('history_request', content)
         self._queue_request(msg)
         return msg['header']['msg_id']
 
     def _handle_events(self, socket, events):
         if events & POLLERR:
             self._handle_err()
         if events & POLLOUT:
             self._handle_send()
         if events & POLLIN:
             self._handle_recv()
 
     def _handle_recv(self):
         msg = self.socket.recv_json()
         self.call_handlers(msg)
 
     def _handle_send(self):
         try:
             msg = self.command_queue.get(False)
         except Empty:
             pass
         else:
             self.socket.send_json(msg)
         if self.command_queue.empty():
             self.drop_io_state(POLLOUT)
 
     def _handle_err(self):
         # We don't want to let this go silently, so eventually we should log.
         raise zmq.ZMQError()
 
     def _queue_request(self, msg):
         self.command_queue.put(msg)
         self.add_io_state(POLLOUT)
 
 
 class SubSocketChannel(ZmqSocketChannel):
     """The SUB channel which listens for messages that the kernel publishes.
     """
 
     def __init__(self, context, session, address):
         super(SubSocketChannel, self).__init__(context, session, address)
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.SUB)
         self.socket.setsockopt(zmq.SUBSCRIBE,'')
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.ioloop = ioloop.IOLoop()
         self.iostate = POLLIN|POLLERR
         self.ioloop.add_handler(self.socket, self._handle_events, 
                                 self.iostate)
         self.ioloop.start()
 
     def stop(self):
         self.ioloop.stop()
         super(SubSocketChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def flush(self, timeout=1.0):
         """Immediately processes all pending messages on the SUB channel.
 
         Callers should use this method to ensure that :method:`call_handlers`
         has been called for all messages that have been received on the
         0MQ SUB socket of this channel.
 
         This method is thread safe.
 
         Parameters
         ----------
         timeout : float, optional
             The maximum amount of time to spend flushing, in seconds. The
             default is one second.
         """
         # We do the IOLoop callback process twice to ensure that the IOLoop
         # gets to perform at least one full poll.
         stop_time = time.time() + timeout
         for i in xrange(2):
             self._flushed = False
             self.ioloop.add_callback(self._flush)
             while not self._flushed and time.time() < stop_time:
                 time.sleep(0.01)
 
     def _handle_events(self, socket, events):
         # Turn on and off POLLOUT depending on if we have made a request
         if events & POLLERR:
             self._handle_err()
         if events & POLLIN:
             self._handle_recv()
 
     def _handle_err(self):
         # We don't want to let this go silently, so eventually we should log.
         raise zmq.ZMQError()
 
     def _handle_recv(self):
         # Get all of the messages we can
         while True:
             try:
                 msg = self.socket.recv_json(zmq.NOBLOCK)
             except zmq.ZMQError:
                 # Check the errno?
                 # Will this trigger POLLERR?
                 break
             else:
                 self.call_handlers(msg)
 
     def _flush(self):
         """Callback for :method:`self.flush`."""
         self._flushed = True
 
 
 class RepSocketChannel(ZmqSocketChannel):
     """A reply channel to handle raw_input requests that the kernel makes."""
 
     msg_queue = None
 
     def __init__(self, context, session, address):
         self.msg_queue = Queue()
         super(RepSocketChannel, self).__init__(context, session, address)
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.XREQ)
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.ioloop = ioloop.IOLoop()
         self.iostate = POLLERR|POLLIN
         self.ioloop.add_handler(self.socket, self._handle_events, 
                                 self.iostate)
         self.ioloop.start()
 
     def stop(self):
         self.ioloop.stop()
         super(RepSocketChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def input(self, string):
         """Send a string of raw input to the kernel."""
         content = dict(value=string)
         msg = self.session.msg('input_reply', content)
         self._queue_reply(msg)
 
     def _handle_events(self, socket, events):
         if events & POLLERR:
             self._handle_err()
         if events & POLLOUT:
             self._handle_send()
         if events & POLLIN:
             self._handle_recv()
 
     def _handle_recv(self):
         msg = self.socket.recv_json()
         self.call_handlers(msg)
 
     def _handle_send(self):
         try:
             msg = self.msg_queue.get(False)
         except Empty:
             pass
         else:
             self.socket.send_json(msg)
         if self.msg_queue.empty():
             self.drop_io_state(POLLOUT)
 
     def _handle_err(self):
         # We don't want to let this go silently, so eventually we should log.
         raise zmq.ZMQError()
 
     def _queue_reply(self, msg):
         self.msg_queue.put(msg)
         self.add_io_state(POLLOUT)
 
 
 class HBSocketChannel(ZmqSocketChannel):
     """The heartbeat channel which monitors the kernel heartbeat."""
 
     time_to_dead = 3.0
     socket = None
     poller = None
 
     def __init__(self, context, session, address):
         super(HBSocketChannel, self).__init__(context, session, address)
         self._running = False
 
     def _create_socket(self):
         self.socket = self.context.socket(zmq.REQ)
         self.socket.setsockopt(zmq.IDENTITY, self.session.session)
         self.socket.connect('tcp://%s:%i' % self.address)
         self.poller = zmq.Poller()
         self.poller.register(self.socket, zmq.POLLIN)
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self._create_socket()
         self._running = True
         # Wait 2 seconds for the kernel to come up and the sockets to auto
         # connect. If we don't we will see the kernel as dead. Also, before
         # the sockets are connected, the poller.poll line below is returning
         # too fast. This avoids that because the polling doesn't start until
         # after the sockets are connected.
         time.sleep(2.0)
         while self._running:
             since_last_heartbeat = 0.0
             request_time = time.time()
             try:
                 #io.rprint('Ping from HB channel') # dbg
                 self.socket.send_json('ping')
             except zmq.ZMQError, e:
                 #io.rprint('*** HB Error:', e) # dbg
                 if e.errno == zmq.EFSM:
                     #io.rprint('sleep...', self.time_to_dead) # dbg
                     time.sleep(self.time_to_dead)
                     self._create_socket()
                 else:
                     raise
             else:
                 while True:
                     try:
                         self.socket.recv_json(zmq.NOBLOCK)
                     except zmq.ZMQError, e:
                         #io.rprint('*** HB Error 2:', e) # dbg
                         if e.errno == zmq.EAGAIN:
                             before_poll = time.time()
                             until_dead = self.time_to_dead - (before_poll -
                                                               request_time)
 
                             # When the return value of poll() is an empty list,
                             # that is when things have gone wrong (zeromq bug).
                             # As long as it is not an empty list, poll is
                             # working correctly even if it returns quickly.
                             # Note: poll timeout is in milliseconds.
                             self.poller.poll(1000*until_dead)
                             
                             since_last_heartbeat = time.time() - request_time
                             if since_last_heartbeat > self.time_to_dead:
                                 self.call_handlers(since_last_heartbeat)
                                 break
                         else:
                             # FIXME: We should probably log this instead.
                             raise
                     else:
                         until_dead = self.time_to_dead - (time.time() -
                                                           request_time)
                         if until_dead > 0.0:
                             #io.rprint('sleep...', self.time_to_dead) # dbg
                             time.sleep(until_dead)
                         break
 
     def stop(self):
         self._running = False
         super(HBSocketChannel, self).stop()
 
     def call_handlers(self, since_last_heartbeat):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
 
 #-----------------------------------------------------------------------------
 # Main kernel manager class
 #-----------------------------------------------------------------------------
 
 class KernelManager(HasTraits):
     """ Manages a kernel for a frontend.
 
     The SUB channel is for the frontend to receive messages published by the
     kernel.
         
     The REQ channel is for the frontend to make requests of the kernel.
     
     The REP channel is for the kernel to request stdin (raw_input) from the
     frontend.
     """
     # The PyZMQ Context to use for communication with the kernel.
     context = Instance(zmq.Context,(),{})
 
     # The Session to use for communication with the kernel.
     session = Instance(Session,(),{})
 
     # The kernel process with which the KernelManager is communicating.
     kernel = Instance(Popen)
 
     # The addresses for the communication channels. 
     xreq_address = TCPAddress((LOCALHOST, 0))
     sub_address = TCPAddress((LOCALHOST, 0))
     rep_address = TCPAddress((LOCALHOST, 0))
     hb_address = TCPAddress((LOCALHOST, 0))
 
     # The classes to use for the various channels.
     xreq_channel_class = Type(XReqSocketChannel)
     sub_channel_class = Type(SubSocketChannel)
     rep_channel_class = Type(RepSocketChannel)
     hb_channel_class = Type(HBSocketChannel)
     
     # Protected traits.
     _launch_args = Any
     _xreq_channel = Any
     _sub_channel = Any
     _rep_channel = Any
     _hb_channel = Any
 
     #--------------------------------------------------------------------------
     # Channel management methods:
     #--------------------------------------------------------------------------
 
     def start_channels(self):
         """Starts the channels for this kernel.
 
         This will create the channels if they do not exist and then start
         them. If port numbers of 0 are being used (random ports) then you
         must first call :method:`start_kernel`. If the channels have been
         stopped and you call this, :class:`RuntimeError` will be raised.
         """
         self.xreq_channel.start()
         self.sub_channel.start()
         self.rep_channel.start()
         self.hb_channel.start()
 
     def stop_channels(self):
         """Stops the channels for this kernel.
 
         This stops the channels by joining their threads. If the channels
         were not started, :class:`RuntimeError` will be raised.
         """
         self.xreq_channel.stop()
         self.sub_channel.stop()
         self.rep_channel.stop()
         self.hb_channel.stop()
 
     @property
     def channels_running(self):
         """Are all of the channels created and running?"""
         return self.xreq_channel.is_alive() \
             and self.sub_channel.is_alive() \
             and self.rep_channel.is_alive() \
             and self.hb_channel.is_alive()
 
     #--------------------------------------------------------------------------
     # Kernel process management methods:
     #--------------------------------------------------------------------------
 
     def start_kernel(self, **kw):
         """Starts a kernel process and configures the manager to use it.
 
         If random ports (port=0) are being used, this method must be called
         before the channels are created.
 
         Parameters:
         -----------
         ipython : bool, optional (default True)
              Whether to use an IPython kernel instead of a plain Python kernel.
         """
         xreq, sub, rep, hb = self.xreq_address, self.sub_address, \
             self.rep_address, self.hb_address
         if xreq[0] != LOCALHOST or sub[0] != LOCALHOST or \
                 rep[0] != LOCALHOST or hb[0] != LOCALHOST:
             raise RuntimeError("Can only launch a kernel on localhost."
                                "Make sure that the '*_address' attributes are "
                                "configured properly.")
 
         self._launch_args = kw.copy()
         if kw.pop('ipython', True):
             from ipkernel import launch_kernel as launch
         else:
             from pykernel import launch_kernel as launch
         self.kernel, xrep, pub, req, hb = launch(
             xrep_port=xreq[1], pub_port=sub[1], 
             req_port=rep[1], hb_port=hb[1], **kw)
         self.xreq_address = (LOCALHOST, xrep)
         self.sub_address = (LOCALHOST, pub)
         self.rep_address = (LOCALHOST, req)
         self.hb_address = (LOCALHOST, hb)
 
     def restart_kernel(self):
         """Restarts a kernel with the same arguments that were used to launch
         it. If the old kernel was launched with random ports, the same ports
         will be used for the new kernel.
         """
         if self._launch_args is None:
             raise RuntimeError("Cannot restart the kernel. "
                                "No previous call to 'start_kernel'.")
         else:
             if self.has_kernel:
                 self.kill_kernel()
             self.start_kernel(**self._launch_args)
 
     @property
     def has_kernel(self):
         """Returns whether a kernel process has been specified for the kernel
         manager.
         """
         return self.kernel is not None
 
     def kill_kernel(self):
         """ Kill the running kernel. """
         if self.kernel is not None:
             self.kernel.kill()
             self.kernel = None
         else:
             raise RuntimeError("Cannot kill kernel. No kernel is running!")
 
     def signal_kernel(self, signum):
         """ Sends a signal to the kernel. """
         if self.kernel is not None:
             self.kernel.send_signal(signum)
         else:
             raise RuntimeError("Cannot signal kernel. No kernel is running!")
 
     @property
     def is_alive(self):
         """Is the kernel process still running?"""
         if self.kernel is not None:
             if self.kernel.poll() is None:
                 return True
             else:
                 return False
         else:
             # We didn't start the kernel with this KernelManager so we don't
             # know if it is running. We should use a heartbeat for this case.
             return True
 
     #--------------------------------------------------------------------------
     # Channels used for communication with the kernel:
     #--------------------------------------------------------------------------
 
     @property
     def xreq_channel(self):
         """Get the REQ socket channel object to make requests of the kernel."""
         if self._xreq_channel is None:
             self._xreq_channel = self.xreq_channel_class(self.context, 
                                                          self.session,
                                                          self.xreq_address)
         return self._xreq_channel
 
     @property
     def sub_channel(self):
         """Get the SUB socket channel object."""
         if self._sub_channel is None:
             self._sub_channel = self.sub_channel_class(self.context,
                                                        self.session,
                                                        self.sub_address)
         return self._sub_channel
 
     @property
     def rep_channel(self):
         """Get the REP socket channel object to handle stdin (raw_input)."""
         if self._rep_channel is None:
             self._rep_channel = self.rep_channel_class(self.context, 
                                                        self.session,
                                                        self.rep_address)
         return self._rep_channel
 
     @property
     def hb_channel(self):
         """Get the REP socket channel object to handle stdin (raw_input)."""
         if self._hb_channel is None:
             self._hb_channel = self.hb_channel_class(self.context, 
                                                        self.session,
                                                        self.hb_address)
         return self._hb_channel