Initial reply handling implemented along with css fixes.

IPython/frontend/html/notebook/kernelmanager.py

@@ -1,102 +1,102 b''
 import signal
 import sys
 
 from IPython.zmq.ipkernel import launch_kernel
 from session import SessionManager
 
 
 class DuplicateKernelError(Exception):
     pass
 
 
 class KernelManager(object):
 
     ip = '127.0.0.1'
 
     def __init__(self, context):
         self.context = context
         self._kernels = {}
 
     @property
     def kernel_ids(self):
         return self._kernels.keys()
 
     def __len__(self):
         return len(self.kernel_ids)
 
     def __contains__(self, kernel_id):
         if kernel_id in self.kernel_ids:
             return True
         else:
             return False
 
     def start_kernel(self, kernel_id):
         if kernel_id in self._kernels:
             raise DuplicateKernelError("Kernel already exists: %s" % kernel_id)
-        (process, shell_port, iopub_port, stdin_port, hb_port) = launch_kernel()
+        (process, shell_port, iopub_port, stdin_port, hb_port) = launch_kernel(pylab='inline')
         d = dict(
             process = process,
             stdin_port = stdin_port,
             iopub_port = iopub_port,
             shell_port = shell_port,
             hb_port = hb_port,
             session_manager = SessionManager(self, kernel_id, self.context)
         )
         self._kernels[kernel_id] = d
         return kernel_id
 
     def kill_kernel(self, kernel_id):
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             # Attempt to kill the kernel.
             try:
                 kernel_process.kill()
             except OSError, e:
                 # In Windows, we will get an Access Denied error if the process
                 # has already terminated. Ignore it.
                 if not (sys.platform == 'win32' and e.winerror == 5):
                     raise
             del self._kernels[kernel_id]
 
     def interrupt_kernel(self, kernel_id):
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             if sys.platform == 'win32':
                 from parentpoller import ParentPollerWindows as Poller
                 Poller.send_interrupt(kernel_process.win32_interrupt_event)
             else:
                 kernel_process.send_signal(signal.SIGINT)
 
     def signal_kernel(self, kernel_id, signum):
         """ Sends a signal to the kernel. Note that since only SIGTERM is
         supported on Windows, this function is only useful on Unix systems.
         """
         kernel_process = self.get_kernel_process(kernel_id)
         if kernel_process is not None:
             kernel_process.send_signal(signum)
 
     def get_kernel_process(self, kernel_id):
         d = self._kernels.get(kernel_id)
         if d is not None:
             return d['process']
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_kernel_ports(self, kernel_id):
         d = self._kernels.get(kernel_id)
         if d is not None:
             dcopy = d.copy()
             dcopy.pop('process')
             return dcopy
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_session_manager(self, kernel_id):
         d = self._kernels.get(kernel_id)
         if d is not None:
             return d['session_manager']
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
 
 

IPython/frontend/html/notebook/notebook.py

@@ -1,133 +1,135 b''
 import json
 import logging
 import os
 
 import zmq
 
 # Install the pyzmq ioloop. This has to be done before anything else from
 # tornado is imported.
 from zmq.eventloop import ioloop
 import tornado.ioloop
 tornado.ioloop = ioloop
 
 from tornado import httpserver
 from tornado import options
 from tornado import web
 from tornado import websocket
 
 from kernelmanager import KernelManager
 
 options.define("port", default=8888, help="run on the given port", type=int)
 
 _session_id_regex = r"(?P<session_id>\w+-\w+-\w+-\w+-\w+)"
 _kernel_id_regex = r"(?P<kernel_id>\w+)"
 
 
 class MainHandler(web.RequestHandler):
     def get(self):
         self.render('notebook.html')
 
 
 class BaseKernelHandler(object):
 
     def get_kernel(self):
         return self.application.kernel_manager
 
     def get_session(self, kernel_id):
         km = self.get_kernel()
         sm = km.get_session_manager(kernel_id)
         return sm
 
 
 class KernelHandler(web.RequestHandler, BaseKernelHandler):
 
     def get(self):
         self.write(json.dumps(self.get_kernel().kernel_ids))
 
     def post(self, *args, **kwargs):
         kernel_id = kwargs['kernel_id']
         self.get_kernel().start_kernel(kernel_id)
         logging.info("Starting kernel: %s" % kernel_id)
         self.write(json.dumps(kernel_id))
 
 
 class SessionHandler(web.RequestHandler, BaseKernelHandler):
 
     def get(self, *args, **kwargs):
         kernel_id = kwargs['kernel_id']
         self.write(json.dumps(self.get_session(kernel_id).session_ids))
 
     def post(self, *args, **kwargs):
         kernel_id = kwargs['kernel_id']
         sm = self.get_session(kernel_id)
         session_id = sm.start_session()
         logging.info("Starting session: %s, %s" % (kernel_id, session_id))
         self.write(json.dumps(session_id))
 
 
 class ZMQStreamHandler(websocket.WebSocketHandler, BaseKernelHandler):
 
     stream_name = ''
 
     def open(self, *args, **kwargs):
         kernel_id = kwargs['kernel_id']
         session_id = kwargs['session_id']
         logging.info("Connection open: %s, %s" % (kernel_id,session_id))
         sm = self.get_session(kernel_id)
         method_name = "get_%s_stream" % self.stream_name
         method = getattr(sm, method_name)
         self.zmq_stream = method(session_id)
         self.zmq_stream.on_recv(self._on_zmq_reply)
 
     def on_message(self, msg):
-        logging.info("Message received: %r" % msg)
+        logging.info("Message received: %r, %r" % (msg, self.__class__))
+        logging.info(self.zmq_stream)
         self.zmq_stream.send_unicode(msg)
 
     def on_close(self):
         self.zmq_stream.close()
 
-    def _on_zmq_reply(self, msg):
-        logging.info("Message reply: %r" % msg)
-        self.write_message(msg)
+    def _on_zmq_reply(self, msg_list):
+        for msg in msg_list:
+            logging.info("Message reply: %r" % msg)
+            self.write_message(msg)
 
 
 class IOPubStreamHandler(ZMQStreamHandler):
 
     stream_name = 'iopub'
 
 
 class ShellStreamHandler(ZMQStreamHandler):
 
     stream_name = 'shell'
 
 
 class NotebookApplication(web.Application):
 
     def __init__(self):
         handlers = [
             (r"/", MainHandler),
             (r"/kernels/%s" % (_kernel_id_regex,), KernelHandler),
             (r"/kernels/%s/sessions" % (_kernel_id_regex,), SessionHandler),
             (r"/kernels/%s/sessions/%s/iopub" % (_kernel_id_regex,_session_id_regex), IOPubStreamHandler),
             (r"/kernels/%s/sessions/%s/shell" % (_kernel_id_regex,_session_id_regex), ShellStreamHandler),
         ]
         settings = dict(
             template_path=os.path.join(os.path.dirname(__file__), "templates"),
             static_path=os.path.join(os.path.dirname(__file__), "static"),
         )
         web.Application.__init__(self, handlers, **settings)
         self.context = zmq.Context()
         self.kernel_manager = KernelManager(self.context)
 
 
 def main():
     options.parse_command_line()
     application = NotebookApplication()
     http_server = httpserver.HTTPServer(application)
     http_server.listen(options.options.port)
     ioloop.IOLoop.instance().start()
 
 
 if __name__ == "__main__":
     main()
 

IPython/frontend/html/notebook/session.py

@@ -1,72 +1,73 b''
 import logging
 import uuid
 
 import zmq
 from zmq.eventloop.zmqstream import ZMQStream
 
 
 class SessionManager(object):
 
     def __init__(self, kernel_manager, kernel_id, context):
         self.context = context
         self.kernel_manager = kernel_manager
         self.kernel_id = kernel_id
         self._sessions = {}
 
     def __del__(self):
         self.stop_all()
 
     @property
     def session_ids(self):
         return self._session.keys()
 
     def __len__(self):
         return len(self.session_ids)
 
     def __contains__(self, session_id):
         if session_id in self.session_ids:
             return True
         else:
             return False
 
     def start_session(self):
         session_id = str(uuid.uuid4())
         ports = self.kernel_manager.get_kernel_ports(self.kernel_id)
         iopub_stream = self.create_connected_stream(ports['iopub_port'], zmq.SUB)
+        iopub_stream.socket.setsockopt(zmq.SUBSCRIBE, b'')
         shell_stream = self.create_connected_stream(ports['shell_port'], zmq.XREQ)
         self._sessions[session_id] = dict(
             iopub_stream = iopub_stream,
             shell_stream = shell_stream
         )
         return session_id
 
     def stop_session(self, session_id):
         session_dict = self._sessions.get(session_id)
         if session_dict is not None:
             for name, stream in session_dict.items():
                 stream.close()
             del self._sessions[session_id]
 
     def stop_all(self):
         for session_id in self._sessions.keys():
             self.stop_session(session_id)
 
     def create_connected_stream(self, port, socket_type):
         sock = self.context.socket(socket_type)
         addr = "tcp://%s:%i" % (self.kernel_manager.ip, port)
-        logging.info("Connecting to: %s" % addr)
+        logging.info("Connecting to: %s, %r" % (addr, socket_type))
         sock.connect(addr)
         return ZMQStream(sock)
 
     def get_stream(self, session_id, stream_name):
         session_dict = self._sessions.get(session_id)
         if session_dict is not None:
             return session_dict[stream_name]
         else:
             raise KeyError("Session with id not found: %s" % session_id)
 
     def get_iopub_stream(self, session_id):
         return self.get_stream(session_id, 'iopub_stream')
 
     def get_shell_stream(self, session_id):
         return self.get_stream(session_id, 'shell_stream')

IPython/frontend/html/notebook/static/css/notebook.css

@@ -1,173 +1,217 b''
-html, body, div, span, applet, object, iframe,
+/**
+ * HTML5 ✰ Boilerplate
+ *
+ * style.css contains a reset, font normalization and some base styles.
+ *
+ * Credit is left where credit is due.
+ * Much inspiration was taken from these projects:
+ * - yui.yahooapis.com/2.8.1/build/base/base.css
+ * - camendesign.com/design/
+ * - praegnanz.de/weblog/htmlcssjs-kickstart
+ */
+
+
+/**
+ * html5doctor.com Reset Stylesheet (Eric Meyer's Reset Reloaded + HTML5 baseline)
+ * v1.6.1 2010-09-17 | Authors: Eric Meyer & Richard Clark
+ * html5doctor.com/html-5-reset-stylesheet/
+ */
+
+html, body, div, span, object, iframe,
 h1, h2, h3, h4, h5, h6, p, blockquote, pre,
-a, abbr, acronym, address, big, cite, code,
-del, dfn, em, img, ins, kbd, q, s, samp,
-small, strike, strong, sub, sup, tt, var,
-b, u, i, center,
-dl, dt, dd, ol, ul, li,
+abbr, address, cite, code, del, dfn, em, img, ins, kbd, q, samp,
+small, strong, sub, sup, var, b, i, dl, dt, dd, ol, ul, li,
 fieldset, form, label, legend,
 table, caption, tbody, tfoot, thead, tr, th, td,
-article, aside, canvas, details, embed,
-figure, figcaption, footer, header, hgroup,
-menu, nav, output, ruby, section, summary,
+article, aside, canvas, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section, summary,
 time, mark, audio, video {
-    margin: 0;
-    padding: 0;
-    border: 0;
-    font-size: 100%;
-    font: inherit;
-    vertical-align: baseline;
+  margin: 0;
+  padding: 0;
+  border: 0;
+  font-size: 100%;
+  font: inherit;
+  vertical-align: baseline;
+}
+
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+  display: block;
 }
 
+blockquote, q { quotes: none; }
+
+blockquote:before, blockquote:after,
+q:before, q:after { content: ""; content: none; }
+
+ins { background-color: #ff9; color: #000; text-decoration: none; }
+
+mark { background-color: #ff9; color: #000; font-style: italic; font-weight: bold; }
+
+del { text-decoration: line-through; }
+
+abbr[title], dfn[title] { border-bottom: 1px dotted; cursor: help; }
+
+table { border-collapse: collapse; border-spacing: 0; }
+
+hr { display: block; height: 1px; border: 0; border-top: 1px solid #ccc; margin: 1em 0; padding: 0; }
+
+input, select { vertical-align: middle; }
+
+
+/**
+ * Font normalization inspired by YUI Library's fonts.css: developer.yahoo.com/yui/
+ */
+
+body { font:13px/1.231 sans-serif; *font-size:small; } /* Hack retained to preserve specificity */
+select, input, textarea, button { font:99% sans-serif; }
+
+/* Normalize monospace sizing:
+   en.wikipedia.org/wiki/MediaWiki_talk:Common.css/Archive_11#Teletype_style_fix_for_Chrome */
+pre, code, kbd, samp { font-family: monospace, sans-serif; }
+
+
+
 body {
     background-color: white;
 }
 
 span#ipython_notebook h1 {
     font-family: "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif;
     font-size: 32pt;
     padding: 10px;
     margin: 10px;
 }
 
 
 div#toolbar {
     width: 100%;
     height: auto;
     border-bottom-width: 2px;
     border-bottom-style: solid;
     border-bottom-color: black;
-	padding: 5px;
+    padding: 5px;
 }
 
-#main_toolbar {
-}
 
-#main_toolbar button {
+/*#main_toolbar button {
     font-size: 0.9em;
-}
+}*/
 
 div.notebook {
-    width: 760px;
+    width: 790px;
     height: 100%;
     margin-left: auto;
     margin-right: auto;
     padding-top: 5px;
     padding-bottom: 5px;
     background-color: white;
-
-/*  Uncomment this block for help in debugging the padding and margins
-/*    border-left-width: 1px;
-    border-left-style: solid;
-    border-left-color: black;
-    border-right-width: 1px;
-    border-right-style: solid;
-    border-right-color: black;
-    border-bottom-width: 1px;
-    border-bottom-style: solid;
-    border-bottom-color: black;*/
 }
 
 div.cell {
     width: 740px;
-    margin: 5px 5px 5px 5px;
+    margin: 5px auto 5px 5px;
     padding: 5px;
-    font-size: 11pt;
     position: relative;
+    display: table;
 }
 
+
 div.code_cell {
     background-color: white;
 }
 
 div.prompt {
     vertical-align: top;
     display: table-cell;
-    width: 85px;
-    min-width 80px !important;
+    width: 80px;
+    padding: 0px;
+    margin: 0px;
     font-family: Menlo, "Courier New", Courier, mono;
     font-weight: normal;
     font-style: normal;
 }
 
 div.input {
-    display: table;
-    height: auto;
+    display: table-row;
+    padding: 0px;
+    margin: 0px;
 }
 
 div.input_prompt {
     color: blue;
 }
 
 
 textarea.input_area {
     text-align: left;
     font-family: Menlo, "Courier New", Courier, mono;
     font-size: inherit;
     border-style: none;
     display: table-cell;
-    margin: 0;
-    padding: 0;
+    padding: 0px;
+    margin: 0px;
     overflow: auto;
     font-weight: normal;
     font-style: normal;
-    width: 665px;
+    width: 650px;
     outline: none;
     resize: none;
 }
 
 
 div.output {
-    display: table;
+    display: table-row;
+    padding: 0px;
+    margin: 0px;
 }
 
 div.output_prompt {
     color: red;
 }
 
 div.output_area {
     text-align: left;
     font-family: Menlo, "Courier New", Courier, mono;
-    font-size: inherit;
-    margin:  0;
-    padding:  0;
+    padding: 0px;
+    margin: 0px;
     display: table-cell;
-    width:  665px;
+    width:  650px;
 }
 
 div.text_cell {
     background-color: white;
 }
 
 textarea.text_cell_input {
     font-family: "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif;
     font-size: inherit;
     outline: none;
     resize: none;
     width:  inherit;
     border-style: none;
     padding: 0;
     margin: 0;
     color: black;
 }
 
 div.text_cell_render {
     font-family: "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif;
     font-size: inherit;
     outline: none;
     resize: none;
     width:  inherit;
     border-style: none;
     padding: 0;
     margin: 0;
     color: black;
 }
 
 div.text_cell_render em {
     font-style: italic;
 }
 
 div.text_cell_render strong {
     font-weight: bold;
 }
 

IPython/frontend/html/notebook/static/js/notebook.js

@@ -1,582 +1,806 b''
 var IPYTHON = {};
 
 
 //============================================================================
+// Utilities
+//============================================================================
+
+
+var uuid = function () {
+    // http://www.ietf.org/rfc/rfc4122.txt
+    var s = [];
+    var hexDigits = "0123456789ABCDEF";
+    for (var i = 0; i < 32; i++) {
+        s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
+    }
+    s[12] = "4";  // bits 12-15 of the time_hi_and_version field to 0010
+    s[16] = hexDigits.substr((s[16] & 0x3) | 0x8, 1);  // bits 6-7 of the clock_seq_hi_and_reserved to 01
+
+    var uuid = s.join("");
+    return uuid;
+};
+
+
+//Fix raw text to parse correctly in crazy XML
+function xmlencode(string) {
+    return string.replace(/\&/g,'&'+'amp;')
+        .replace(/</g,'&'+'lt;')
+        .replace(/>/g,'&'+'gt;')
+        .replace(/\'/g,'&'+'apos;')
+        .replace(/\"/g,'&'+'quot;')
+        .replace(/`/g,'&'+'#96;')
+}
+
+//Map from terminal commands to CSS classes
+attrib = {
+    "30":"cblack", "31":"cred",
+    "32":"cgreen", "33":"cyellow",  
+    "34":"cblue", "36":"ccyan", 
+    "37":"cwhite", "01":"cbold"}
+
+//Fixes escaped console commands, IE colors. Turns them into HTML
+function fixConsole(txt) {
+    txt = xmlencode(txt)
+    var re = /\033\[([\d;]*?)m/
+    var opened = false
+    var cmds = []
+    var opener = ""
+    var closer = ""
+    
+    while (re.test(txt)) {
+        var cmds = txt.match(re)[1].split(";")
+        closer = opened?"</span>":""
+        opened = cmds.length > 1 || cmds[0] != 0
+        var rep = []
+        for (var i in cmds)
+            if (typeof(attrib[cmds[i]]) != "undefined")
+                rep.push(attrib[cmds[i]])
+        opener = rep.length > 0?"<span class=\""+rep.join(" ")+"\">":""
+        txt = txt.replace(re, closer + opener)
+    }
+    if (opened) txt += "</span>"
+    return txt.trim()
+}
+
+//============================================================================
 // Notebook
 //============================================================================
 
 
 var Notebook = function (selector) {
     this.element = $(selector);
     this.element.scroll();
     this.element.data("notebook", this);
     this.next_prompt_number = 1;
+    this.next_kernel_number = 0;
+    this.kernel = null;
+    this.msg_cell_map = {};
     this.bind_events();
+    this.start_kernel();
 };
 
 
 Notebook.prototype.bind_events = function () {
     var that = this;
     $(document).keydown(function (event) {
-        console.log(event);
+        // console.log(event);
         if (event.which == 38 && event.shiftKey) {
             event.preventDefault();
             that.select_prev();
         } else if (event.which == 40 && event.shiftKey) {
             event.preventDefault();
             that.select_next();
         } else if (event.which == 13 && event.shiftKey) {
             // The focus is not quite working here.
+            var cell = that.selected_cell();
+            var cell_index = that.find_cell_index(cell);
+            if (cell instanceof CodeCell) {
+                event.preventDefault();
+                cell.clear_output();
+                var msg_id = that.kernel.execute(cell.get_code());
+                that.msg_cell_map[msg_id] = cell.cell_id;
+                if (cell_index === (that.ncells()-1)) {
+                    that.insert_code_cell_after();
+                } else {
+                    that.select(cell_index+1);
+                };
+            }
+        } else if (event.which == 9) {
             event.preventDefault();
-            that.insert_code_cell_after();
-        }
+            var cell = that.selected_cell();
+            if (cell instanceof CodeCell) {
+                var ta = cell.element.find("textarea.input_area");
+                ta.val(ta.val() + "    ");
+            };
+        };
     });
 };
 
 
 // Cell indexing, retrieval, etc.
 
 
 Notebook.prototype.cell_elements = function () {
     return this.element.children("div.cell");
 }
 
 
 Notebook.prototype.ncells = function (cell) {
     return this.cell_elements().length;
 }
 
 
 // TODO: we are often calling cells as cells()[i], which we should optimize
 // to cells(i) or a new method.
 Notebook.prototype.cells = function () {
     return this.cell_elements().toArray().map(function (e) {
         return $(e).data("cell");
     });
 }
 
 
 Notebook.prototype.find_cell_index = function (cell) {
     var result = null;
     this.cell_elements().filter(function (index) {
         if ($(this).data("cell") === cell) {
             result = index;
         };
     });
     return result;
 };
 
 
 Notebook.prototype.index_or_selected = function (index) {
     return index || this.selected_index() || 0;
 }
 
 
 Notebook.prototype.select = function (index) {
     if (index !== undefined && index >= 0 && index < this.ncells()) {
         if (this.selected_index() !== null) {
             this.selected_cell().unselect();
         };
         this.cells()[index].select();
     };
     return this;
 };
 
 
 Notebook.prototype.select_next = function () {
     var index = this.selected_index();
     if (index !== null && index >= 0 && (index+1) < this.ncells()) {
         this.select(index+1);
     };
     return this;
 };
 
 
 Notebook.prototype.select_prev = function () {
     var index = this.selected_index();
     if (index !== null && index >= 0 && (index-1) < this.ncells()) {
         this.select(index-1);
     };
     return this;
 };
 
 
 Notebook.prototype.selected_index = function () {
     var result = null;
     this.cell_elements().filter(function (index) {
         if ($(this).data("cell").selected === true) {
             result = index;
         };
     });
     return result;
 };
 
 
+Notebook.prototype.cell_for_msg = function (msg_id) {
+    var cell_id = this.msg_cell_map[msg_id];
+    var result = null;
+    this.cell_elements().filter(function (index) {
+        cell = $(this).data("cell");
+        if (cell.cell_id === cell_id) {
+            result = cell;
+        };
+    });
+    return result;
+};
+
+
 Notebook.prototype.selected_cell = function () {
     return this.cell_elements().eq(this.selected_index()).data("cell");
 }
 
 
 // Cell insertion, deletion and moving.
 
 
 Notebook.prototype.delete_cell = function (index) {
     var i = index || this.selected_index();
     if (i !== null && i >= 0 && i < this.ncells()) {
         this.cell_elements().eq(i).remove();
         if (i === (this.ncells())) {
             this.select(i-1);
         } else {
             this.select(i);
         };
     };
     return this;
 };
 
 
 Notebook.prototype.append_cell = function (cell) {
     this.element.append(cell.element);
     return this;
 };
 
 
 Notebook.prototype.insert_cell_after = function (cell, index) {
     var ncells = this.ncells();
     if (ncells === 0) {
         this.append_cell(cell);
         return this;
     };
     if (index >= 0 && index < ncells) {
         this.cell_elements().eq(index).after(cell.element);
     };
     return this
 };
 
 
 Notebook.prototype.insert_cell_before = function (cell, index) {
     var ncells = this.ncells();
     if (ncells === 0) {
         this.append_cell(cell);
         return this;
     };
     if (index >= 0 && index < ncells) {
         this.cell_elements().eq(index).before(cell.element);
     };
     return this;
 };
 
 
 Notebook.prototype.move_cell_up = function (index) {
     var i = index || this.selected_index();
     if (i !== null && i < this.ncells() && i > 0) {
         var pivot = this.cell_elements().eq(i-1);
         var tomove = this.cell_elements().eq(i);
         if (pivot !== null && tomove !== null) {
             tomove.detach();
             pivot.before(tomove);
             this.select(i-1);
         };
     };
     return this;
 }
 
 
 Notebook.prototype.move_cell_down = function (index) {
     var i = index || this.selected_index();
     if (i !== null && i < (this.ncells()-1) && i >= 0) {
         var pivot = this.cell_elements().eq(i+1)
         var tomove = this.cell_elements().eq(i)
         if (pivot !== null && tomove !== null) {
             tomove.detach();
             pivot.after(tomove);
             this.select(i+1);
         };
     };
     return this;
 }
 
 
 Notebook.prototype.sort_cells = function () {
     var ncells = this.ncells();
     var sindex = this.selected_index();
     var swapped;
     do {
         swapped = false
         for (var i=1; i<ncells; i++) {
             current = this.cell_elements().eq(i).data("cell");
             previous = this.cell_elements().eq(i-1).data("cell");
             if (previous.input_prompt_number > current.input_prompt_number) {
                 this.move_cell_up(i);
                 swapped = true;
             };
         };
     } while (swapped);
     this.select(sindex);
     return this;
 };
 
 
 Notebook.prototype.insert_code_cell_before = function (index) {
     // TODO: Bounds check for i
     var i = this.index_or_selected(index);
     var cell = new CodeCell(this);
     cell.set_input_prompt(this.next_prompt_number);
     this.next_prompt_number = this.next_prompt_number + 1;
     this.insert_cell_before(cell, i);
     this.select(this.find_cell_index(cell));
     return this;
 }
 
 
 Notebook.prototype.insert_code_cell_after = function (index) {
     // TODO: Bounds check for i
     var i = this.index_or_selected(index);
     var cell = new CodeCell(this);
     cell.set_input_prompt(this.next_prompt_number);
     this.next_prompt_number = this.next_prompt_number + 1;
     this.insert_cell_after(cell, i);
     this.select(this.find_cell_index(cell));
     return this;
 }
 
 
 Notebook.prototype.insert_text_cell_before = function (index) {
     // TODO: Bounds check for i
     var i = this.index_or_selected(index);
     var cell = new TextCell(this);
     cell.config_mathjax();
     this.insert_cell_before(cell, i);
     this.select(this.find_cell_index(cell));
     return this;
 }
 
 
 Notebook.prototype.insert_text_cell_after = function (index) {
     // TODO: Bounds check for i
     var i = this.index_or_selected(index);
     var cell = new TextCell(this);
     cell.config_mathjax();
     this.insert_cell_after(cell, i);
     this.select(this.find_cell_index(cell));
     return this;
 }
 
 
 Notebook.prototype.text_to_code = function (index) {
     // TODO: Bounds check for i
     var i = this.index_or_selected(index);
     var source_element = this.cell_elements().eq(i);
     var source_cell = source_element.data("cell");
     if (source_cell instanceof TextCell) {
         this.insert_code_cell_after(i);
         var target_cell = this.cells()[i+1];
         var text = source_element.find("textarea.text_cell_input").val();
         target_cell.element.find("textarea.input_area").val(text);
         source_element.remove();
     };
 };
 
 
 Notebook.prototype.code_to_text = function (index) {
     // TODO: Bounds check for i
     var i = this.index_or_selected(index);
     var source_element = this.cell_elements().eq(i);
     var source_cell = source_element.data("cell");
     if (source_cell instanceof CodeCell) {
         this.insert_text_cell_after(i);
         var target_cell = this.cells()[i+1];
         var text = source_element.find("textarea.input_area").val();
         if (text === "") {text = target_cell.placeholder;};
         target_cell.element.find("textarea.text_cell_input").val(text);
         target_cell.element.find("textarea.text_cell_input").html(text);
         target_cell.element.find("div.text_cell_render").html(text);
 
         source_element.remove();
     };
 };
 
 
 // Cell collapsing
 
 Notebook.prototype.collapse = function (index) {
     var i = this.index_or_selected(index);
     this.cells()[i].collapse();
-}
+};
 
 
 Notebook.prototype.expand = function (index) {
     var i = this.index_or_selected(index);
     this.cells()[i].expand();
-}
+};
+
+
+// Kernel related things
+
+Notebook.prototype.start_kernel = function () {
+    this.kernel = new Kernel("kernel" + this.next_kernel_number);
+    this.next_kernel_number = this.next_kernel_number + 1;
+    this.kernel.start_kernel(this._kernel_started, this);
+};
+
+
+Notebook.prototype._kernel_started = function () {
+    console.log("Kernel started: ", this.kernel.kernel_id);
+    this.kernel.start_session(this._session_started, this);
+};
+
+
+Notebook.prototype._session_started = function () {
+    console.log("Session started: ", this.kernel.session_id);
+    var that = this;
+
+    this.kernel.shell_channel.onmessage = function (e) {
+        reply = $.parseJSON(e.data);
+        console.log(reply);
+        var msg_type = reply.msg_type;
+        var cell = that.cell_for_msg(reply.parent_header.msg_id);
+        if (msg_type === "execute_reply") {
+            cell.set_prompt(reply.content.execution_count);
+        };
+    };
+
+    this.kernel.iopub_channel.onmessage = function (e) {
+        reply = $.parseJSON(e.data);
+        console.log(reply);
+        var msg_type = reply.msg_type;
+        var cell = that.cell_for_msg(reply.parent_header.msg_id);
+        if (msg_type === "stream") {
+            cell.expand();
+            cell.append_stream(reply.content.data + "\n");
+        } else if (msg_type === "pyout" || msg_type === "display_data") {
+            cell.expand();
+            cell.append_display_data(reply.content.data);
+        };
+    };
+};
+
+
+Notebook.prototype._handle_execute_reply = function (reply, cell) {
+    cell.set_prompt(reply.content.execution_count);
+};
 
 
 //============================================================================
 // Cell
 //============================================================================
 
 
 var Cell = function (notebook) {
     this.notebook = notebook;
     this.selected = false;
     this.element;
     this.create_element();
     if (this.element !== undefined) {
         this.element.data("cell", this);
         this.bind_events();
     }
+    this.cell_id = uuid();
 };
 
 
 Cell.prototype.select = function () {
     this.element.addClass('ui-widget-content ui-corner-all');
     this.selected = true;
     // TODO: we need t test across browsers to see if both of these are needed.
     // In the meantime, there should not be any harm in having them both.
     this.element.find('textarea').trigger('focusin');
     this.element.find('textarea').trigger('focus');
 };
 
 
 Cell.prototype.unselect = function () {
     this.element.removeClass('ui-widget-content ui-corner-all');
     this.selected = false;
 };
 
 
 Cell.prototype.bind_events = function () {
     var that = this;
     var nb = that.notebook
     that.element.click(function (event) {
         if (that.selected === false) {
             nb.select(nb.find_cell_index(that));
         };
     });
     that.element.focusin(function (event) {
         if (that.selected === false) {
             nb.select(nb.find_cell_index(that));
         };
     });
 };
 
 
 // Subclasses must implement create_element.
 Cell.prototype.create_element = function () {};
 
 
 //============================================================================
 // CodeCell
 //============================================================================
 
 
 var CodeCell = function (notebook) {
     Cell.apply(this, arguments);
     this.input_prompt_number = ' ';
     this.output_prompt_number = ' ';
 };
 
 
 CodeCell.prototype = new Cell();
 
 
 CodeCell.prototype.create_element = function () {
     var cell =  $('<div></div>').addClass('cell code_cell')
     var input = $('<div></div>').addClass('input').append(
                     $('<div/>').addClass('prompt input_prompt')
                 ).append(
                     $('<textarea/>').addClass('input_area').
                     attr('rows',1).
                     attr('cols',80).
                     attr('wrap','hard').
                     autoGrow()
                 );
     var output = $('<div></div>').addClass('output').append(
                     $('<div/>').addClass('prompt output_prompt')
                 ).append(
                     $('<div/>').addClass('output_area')
                 );
-    output.hide();
     cell.append(input).append(output);
     this.element = cell;
+    this.collapse()
+};
+
+
+CodeCell.prototype.append_stream = function (data) {
+    var data_list = data.split("\n");
+    console.log(data_list);
+    if (data_list.length > 0) {
+        for (var i=0; i<data_list.length; i++) {
+            console.log(i, data_list[i]);
+            var toinsert = fixConsole(data_list[i]);
+            this.element.find("div.output_area").append($("<p>").append(toinsert));
+        };
+    }
+};
+
+
+CodeCell.prototype.append_display_data = function (data) {
+    if (data["image/svg+xml"] !== undefined) {
+        this.append_svg(data["image/svg+xml"]);
+    } else if (data["text/plain"] !== undefined) {
+        console.log(data["text/plain"]);
+        this.append_stream(data["text/plain"]);
+    };
+};
+
+CodeCell.prototype.append_svg = function (svg) {
+    this.element.find("div.output_area").append(svg);
+};
+
+
+CodeCell.prototype.clear_output = function () {
+    this.element.find("div.output_area").html("");
 };
 
 
 CodeCell.prototype.collapse = function () {
     this.element.find('div.output').hide();
 };
 
 
 CodeCell.prototype.expand = function () {
     this.element.find('div.output').show();
 };
 
 
 CodeCell.prototype.set_prompt = function (number) {
     this.set_input_prompt(number);
     this.set_output_prompt(number);
 };
 
 CodeCell.prototype.set_input_prompt = function (number) {
     var n = number || ' ';
     this.input_prompt_number = n
     this.element.find('div.input_prompt').html('In&nbsp;[' + n + ']:');
 };
 
 
 CodeCell.prototype.set_output_prompt = function (number) {
     var n = number || ' ';
     this.output_prompt_number = n
     this.element.find('div.output_prompt').html('Out[' + n + ']:');
 };
 
 
+CodeCell.prototype.get_code = function () {
+    return this.element.find("textarea.input_area").val();
+};
+
 //============================================================================
 // TextCell
 //============================================================================
 
 
 var TextCell = function (notebook) {
     Cell.apply(this, arguments);
     this.placeholder = "Type <strong>HTML</strong> and LaTeX: $\\alpha^2$"
 };
 
 
 TextCell.prototype = new Cell();
 
 
 TextCell.prototype.create_element = function () {
     var cell = $("<div>").addClass('cell text_cell').
                append(
                    $("<textarea>" + this.placeholder + "</textarea>").
                    addClass('text_cell_input').
                    attr('rows',1).
                    attr('cols',80).
                    autoGrow()
                ).append(
                    $('<div></div>').addClass('text_cell_render')
                )
     this.element = cell;
 };
 
 
 TextCell.prototype.select = function () {
     this.edit();
     Cell.prototype.select.apply(this);
 };
 
 
 TextCell.prototype.edit = function () {
     var text_cell = this.element;
     var input = text_cell.find("textarea.text_cell_input");
     var output = text_cell.find("div.text_cell_render");  
     output.hide();
     input.show().trigger('focus');
 };
 
 
 TextCell.prototype.render = function () {
     var text_cell = this.element;
     var input = text_cell.find("textarea.text_cell_input");
     var output = text_cell.find("div.text_cell_render");    
     var text = input.val();
     if (text === "") {
         text = this.placeholder;
         input.val(text);
     };
     output.html(text)
     input.html(text);
     MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
     input.hide();
     output.show();
 };
 
 
 TextCell.prototype.config_mathjax = function () {
     var text_cell = this.element;
     var that = this;
     text_cell.click(function () {
         that.edit();
     }).focusout(function () {
         that.render();
     });
     
     text_cell.trigger("focusout");
 };
 
 
 //============================================================================
 // On document ready
 //============================================================================
 
 
-var KernelManager = function () {
-    this.kernelid = null;
-    this.baseurl = "/kernels";
+var Kernel = function (kernel_id) {
+    this.kernel_id = kernel_id;
+    this.base_url = "/kernels";
+    this.kernel_url = this.base_url + "/" + this.kernel_id
+    this.session_id = null;
+};
+
+
+Kernel.prototype.get_msg = function (msg_type, content) {
+    var msg = {
+        header : {
+            msg_id : uuid(),
+            username : "bgranger",
+            session: this.session_id
+        },
+        msg_type : msg_type,
+        content : content,
+        parent_header : {}
+    };
+    return msg;
+}
+
+Kernel.prototype.start_kernel = function (callback, context) {
+    $.post(this.kernel_url, function () {
+        callback.call(context);
+    });
 };
 
 
-KernelManager.prototype.create_kernel = function () {
+Kernel.prototype.start_session = function (callback, context) {
     var that = this;
-    $.post(this.baseurl, function (data) {
-        that.kernelid = data;
-    }, 'json');
+    $.post(this.kernel_url + "/sessions",
+        function (session_id) {
+            that._handle_start_session(session_id, callback, context);
+        },
+        'json');
 }
 
 
-KernelManager.prototype.execute = function (code, callback) {
-    var msg = {
-        header : {msg_id : 0, username : "bgranger", session: 0},
-        msg_type : "execute_request",
-        content : {code : code}
+Kernel.prototype._handle_start_session = function (session_id, callback, context) {
+    this.session_id = session_id;
+    this.session_url = this.kernel_url + "/sessions/" + this.session_id;
+    this._start_channels();
+    callback.call(context);
+};
+
+
+Kernel.prototype._start_channels = function () {
+    var ws_url = "ws://127.0.0.1:8888" + this.session_url;
+    this.shell_channel = new WebSocket(ws_url + "/shell");
+    this.iopub_channel = new WebSocket(ws_url + "/iopub");
+}
+
+
+Kernel.prototype.execute = function (code) {
+    var content = {
+        code : code,
+        silent : false,
+        user_variables : [],
+        user_expressions : {}
     };
-    var settings = {
-      data : JSON.stringify(msg),
-      processData : false,
-      contentType : "application/json",
-      success : callback,
-      type : "POST"
-    }
-    var url = this.baseurl + "/" + this.kernelid + "/" + ""
+    var msg = this.get_msg("execute_request", content);
+
+    this.shell_channel.send(JSON.stringify(msg));
+    return msg.header.msg_id;
 }
 
 
 //============================================================================
 // On document ready
 //============================================================================
 
 
 $(document).ready(function () {
 
     MathJax.Hub.Config({
         tex2jax: {
             inlineMath: [ ['$','$'], ["\\(","\\)"] ],
             displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
         }
     });
 
     $("ul#main_menu").wijmenu({animation:{animated: "slide", duration: 100, easing: null}});
     IPYTHON.notebook = new Notebook('div.notebook');
     IPYTHON.notebook.insert_code_cell_after();
 
     $("#move_cell").buttonset();
     $("#move_up").button("option", "icons", {primary:"ui-icon-arrowthick-1-n"});
     $("#move_up").button("option", "text", false);
     $("#move_up").click(function () {IPYTHON.notebook.move_cell_up();});
     $("#move_down").button("option", "icons", {primary:"ui-icon-arrowthick-1-s"});
     $("#move_down").button("option", "text", false);
     $("#move_down").click(function () {IPYTHON.notebook.move_cell_down();});
 
     $("#insert_delete").buttonset();
     $("#insert_cell_before").click(function () {IPYTHON.notebook.insert_code_cell_before();});
     $("#insert_cell_after").click(function () {IPYTHON.notebook.insert_code_cell_after();});
     $("#delete_cell").button("option", "icons", {primary:"ui-icon-closethick"});
     $("#delete_cell").button("option", "text", false);
     $("#delete_cell").click(function () {IPYTHON.notebook.delete_cell();});
 
     $("#cell_type").buttonset();
     $("#to_code").click(function () {IPYTHON.notebook.text_to_code();});
     $("#to_text").click(function () {IPYTHON.notebook.code_to_text();});
 
     $("#sort").buttonset();
     $("#sort_cells").click(function () {IPYTHON.notebook.sort_cells();});
 
+    $("#toggle").buttonset();
+    $("#collapse").click(function () {IPYTHON.notebook.collapse();});
+    $("#expand").click(function () {IPYTHON.notebook.expand();});
+
 });
  No newline at end of file

IPython/frontend/html/notebook/templates/notebook.html

@@ -1,84 +1,88 b''
 <!DOCTYPE HTML>
 <html>
 
 <head>
     <meta charset="utf-8">
 
     <title>IPython Notebook</title>
     <link rel="stylesheet" href="static/css/notebook.css" type="text/css" />
     <link rel="stylesheet" href="static/jquery/css/jquery.wijmo-open.1.1.3.css" type="text/css" />
     <link rel="stylesheet" href="static/jquery/css/themes/aristo/jquery-wijmo.css" type="text/css" />
     <!-- <link rel="stylesheet" href="static/jquery/css/themes/ui-lightness/jquery-ui-1.8.10.custom.css" type="text/css" /> -->
     <!-- <script src="static/mathjax/MathJax.js?config=TeX-AMS-MML_HTMLorMML" type="text/javascript" charset="utf-8"></script> -->
     <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" charset="utf-8"></script>
 </head>
 
 <body>
 
 <div id="header">
     <span id="ipython_notebook"><h1>IPython Notebook</h1></span>
 </div>
 
 <div id="tools">
 
 <ul id="main_menu">
     <li><a>Cell</a>
         <ul>
             <li><a>Run</a></li>
             <li><a>Move up</a></li>
             <li><a>Move down</a></li>
             <li><a>Delete</a></li>
         </ul>
     </li>
     <li><a>Kernel</a>
         <ul>
             <li><a>Interrupt</a></li>
             <li><a>Restart</a></li>
         </ul>
     </li>
     <li><a>Help</a>
         <ul>
             <li><a>Notebook help</a></li>
             <li></li>
             <li><a href="http://docs.python.org" target="_blank">Python Docs</a></li>
             <li><a href="http://ipython.github.com/ipython-doc/dev/index.html" target="_blank">IPython Docs</a></li>
             <li><a href="http://docs.scipy.org/doc/numpy/reference/" target="_blank">NumPy Docs</a></li>
             <li><a href="http://docs.scipy.org/doc/scipy/reference/" target="_blank">SciPy Docs</a></li>
             <li><a href="http://docs.sympy.org/dev/index.html" target="_blank">SymPy Docs</a></li>
         </ul>
     </li>
 </ul>
 
 <div id="toolbar">
     <span id="main_toolbar">
         <span id="move_cell">
             <button id="move_up">Move up</button>
             <button id="move_down">Move down</button>
         </span>
         <span id="insert_delete">
             <button id="insert_cell_before">Before</button>
             <button id="insert_cell_after">After</button>
             <button id="delete_cell">Delete</button>
         </span>
         <span id="cell_type">
             <button id="to_code">Code</button>
             <button id="to_text">Text</button>
         </span>
         <span id="sort">
             <button id="sort_cells">Sort</button>
         </span>
+        <span id="toggle">
+            <button id="collapse">Collapse</button>
+            <button id="expand">Expand</button>
+        </span>
     </span>
 </div>
 
 </div>
 
 <div class="notebook"></div>
 
 <script src="static/jquery/js/jquery-1.5.1.min.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/jquery/js/jquery-ui-1.8.10.custom.min.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/jquery/js/jquery.autogrow.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/jquery/js/jquery.wijmo-open.1.1.3.min.js" type="text/javascript" charset="utf-8"></script>
 <script src="static/js/notebook.js" type="text/javascript" charset="utf-8"></script>
 </body>
 
 </html>
  No newline at end of file

IPython/zmq/ipkernel.py

@@ -1,680 +1,679 b''
 #!/usr/bin/env python
 """A simple interactive kernel that talks to a frontend over 0MQ.
 
 Things to do:
 
 * Implement `set_parent` logic. Right before doing exec, the Kernel should
   call set_parent on all the PUB objects with the message about to be executed.
 * Implement random port and security key logic.
 * Implement control messages.
 * Implement event loop and poll version.
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Standard library imports.
 import __builtin__
 import atexit
 import sys
 import time
 import traceback
 import logging
 # System library imports.
 import zmq
 
 # Local imports.
 from IPython.config.configurable import Configurable
 from IPython.config.application import boolean_flag
 from IPython.core.application import ProfileDir
 from IPython.core.shellapp import (
     InteractiveShellApp, shell_flags, shell_aliases
 )
 from IPython.utils import io
 from IPython.utils.jsonutil import json_clean
 from IPython.lib import pylabtools
 from IPython.utils.traitlets import (
     List, Instance, Float, Dict, Bool, Int, Unicode, CaselessStrEnum
 )
 
 from entry_point import base_launch_kernel
 from kernelapp import KernelApp, kernel_flags, kernel_aliases
 from iostream import OutStream
 from session import Session, Message
 from zmqshell import ZMQInteractiveShell
 
 
-
 #-----------------------------------------------------------------------------
 # Main kernel class
 #-----------------------------------------------------------------------------
 
 class Kernel(Configurable):
 
     #---------------------------------------------------------------------------
     # Kernel interface
     #---------------------------------------------------------------------------
 
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
     session = Instance(Session)
     shell_socket = Instance('zmq.Socket')
     iopub_socket = Instance('zmq.Socket')
     stdin_socket = Instance('zmq.Socket')
     log = Instance(logging.Logger)
 
     # Private interface
 
     # Time to sleep after flushing the stdout/err buffers in each execute
     # cycle.  While this introduces a hard limit on the minimal latency of the
     # execute cycle, it helps prevent output synchronization problems for
     # clients.
     # Units are in seconds.  The minimum zmq latency on local host is probably
     # ~150 microseconds, set this to 500us for now.  We may need to increase it
     # a little if it's not enough after more interactive testing.
     _execute_sleep = Float(0.0005, config=True)
 
     # Frequency of the kernel's event loop.
     # Units are in seconds, kernel subclasses for GUI toolkits may need to
     # adapt to milliseconds.
     _poll_interval = Float(0.05, config=True)
 
     # If the shutdown was requested over the network, we leave here the
     # necessary reply message so it can be sent by our registered atexit
     # handler.  This ensures that the reply is only sent to clients truly at
     # the end of our shutdown process (which happens after the underlying
     # IPython shell's own shutdown).
     _shutdown_message = None
 
     # This is a dict of port number that the kernel is listening on. It is set
     # by record_ports and used by connect_request.
     _recorded_ports = Dict()
 
 
 
     def __init__(self, **kwargs):
         super(Kernel, self).__init__(**kwargs)
 
         # Before we even start up the shell, register *first* our exit handlers
         # so they come before the shell's
         atexit.register(self._at_shutdown)
 
         # Initialize the InteractiveShell subclass
         self.shell = ZMQInteractiveShell.instance(config=self.config)
         self.shell.displayhook.session = self.session
         self.shell.displayhook.pub_socket = self.iopub_socket
         self.shell.display_pub.session = self.session
         self.shell.display_pub.pub_socket = self.iopub_socket
 
         # TMP - hack while developing
         self.shell._reply_content = None
 
         # Build dict of handlers for message types
         msg_types = [ 'execute_request', 'complete_request', 
                       'object_info_request', 'history_request',
                       'connect_request', 'shutdown_request']
         self.handlers = {}
         for msg_type in msg_types:
             self.handlers[msg_type] = getattr(self, msg_type)
 
     def do_one_iteration(self):
         """Do one iteration of the kernel's evaluation loop.
         """
         ident,msg = self.session.recv(self.shell_socket, zmq.NOBLOCK)
         if msg is None:
             return
 
         msg_type = msg['header']['msg_type']
 
         # This assert will raise in versions of zeromq 2.0.7 and lesser.
         # We now require 2.0.8 or above, so we can uncomment for safety.
         # print(ident,msg, file=sys.__stdout__)
         assert ident is not None, "Missing message part."
         
         # Print some info about this message and leave a '--->' marker, so it's
         # easier to trace visually the message chain when debugging.  Each
         # handler prints its message at the end.
         self.log.debug('\n*** MESSAGE TYPE:'+str(msg_type)+'***')
         self.log.debug('   Content: '+str(msg['content'])+'\n   --->\n   ')
 
         # Find and call actual handler for message
         handler = self.handlers.get(msg_type, None)
         if handler is None:
             self.log.error("UNKNOWN MESSAGE TYPE:" +str(msg))
         else:
             handler(ident, msg)
             
         # Check whether we should exit, in case the incoming message set the
         # exit flag on
         if self.shell.exit_now:
             self.log.debug('\nExiting IPython kernel...')
             # We do a normal, clean exit, which allows any actions registered
             # via atexit (such as history saving) to take place.
             sys.exit(0)
 
 
     def start(self):
         """ Start the kernel main loop.
         """
         poller = zmq.Poller()
         poller.register(self.shell_socket, zmq.POLLIN)
         while True:
             try:
                 # scale by extra factor of 10, because there is no
                 # reason for this to be anything less than ~ 0.1s
                 # since it is a real poller and will respond
                 # to events immediately
                 poller.poll(10*1000*self._poll_interval)
                 self.do_one_iteration()
             except KeyboardInterrupt:
                 # Ctrl-C shouldn't crash the kernel
                 io.raw_print("KeyboardInterrupt caught in kernel")
 
     def record_ports(self, ports):
         """Record the ports that this kernel is using.
 
         The creator of the Kernel instance must call this methods if they
         want the :meth:`connect_request` method to return the port numbers.
         """
         self._recorded_ports = ports
 
     #---------------------------------------------------------------------------
     # Kernel request handlers
     #---------------------------------------------------------------------------
 
     def _publish_pyin(self, code, parent):
         """Publish the code request on the pyin stream."""
 
         pyin_msg = self.session.send(self.iopub_socket, u'pyin',{u'code':code}, parent=parent)
 
     def execute_request(self, ident, parent):
         
         status_msg = self.session.send(self.iopub_socket,
             u'status',
             {u'execution_state':u'busy'},
             parent=parent
         )
         
         try:
             content = parent[u'content']
             code = content[u'code']
             silent = content[u'silent'] 
         except:
             self.log.error("Got bad msg: ")
             self.log.error(str(Message(parent)))
             return
 
         shell = self.shell # we'll need this a lot here
 
         # Replace raw_input. Note that is not sufficient to replace 
         # raw_input in the user namespace.
         raw_input = lambda prompt='': self._raw_input(prompt, ident, parent)
         __builtin__.raw_input = raw_input
 
         # Set the parent message of the display hook and out streams.
         shell.displayhook.set_parent(parent)
         shell.display_pub.set_parent(parent)
         sys.stdout.set_parent(parent)
         sys.stderr.set_parent(parent)
 
         # Re-broadcast our input for the benefit of listening clients, and
         # start computing output
         if not silent:
             self._publish_pyin(code, parent)
 
         reply_content = {}
         try:
             if silent:
                 # run_code uses 'exec' mode, so no displayhook will fire, and it
                 # doesn't call logging or history manipulations.  Print
                 # statements in that code will obviously still execute.
                 shell.run_code(code)
             else:
                 # FIXME: the shell calls the exception handler itself.
                 shell.run_cell(code)
         except:
             status = u'error'
             # FIXME: this code right now isn't being used yet by default,
             # because the run_cell() call above directly fires off exception
             # reporting.  This code, therefore, is only active in the scenario
             # where runlines itself has an unhandled exception.  We need to
             # uniformize this, for all exception construction to come from a
             # single location in the codbase.
             etype, evalue, tb = sys.exc_info()
             tb_list = traceback.format_exception(etype, evalue, tb)
             reply_content.update(shell._showtraceback(etype, evalue, tb_list))
         else:
             status = u'ok'
 
         reply_content[u'status'] = status
         
         # Return the execution counter so clients can display prompts
         reply_content['execution_count'] = shell.execution_count -1
 
         # FIXME - fish exception info out of shell, possibly left there by
         # runlines.  We'll need to clean up this logic later.
         if shell._reply_content is not None:
             reply_content.update(shell._reply_content)
             # reset after use
             shell._reply_content = None
 
         # At this point, we can tell whether the main code execution succeeded
         # or not.  If it did, we proceed to evaluate user_variables/expressions
         if reply_content['status'] == 'ok':
             reply_content[u'user_variables'] = \
                          shell.user_variables(content[u'user_variables'])
             reply_content[u'user_expressions'] = \
                          shell.user_expressions(content[u'user_expressions'])
         else:
             # If there was an error, don't even try to compute variables or
             # expressions
             reply_content[u'user_variables'] = {}
             reply_content[u'user_expressions'] = {}
 
         # Payloads should be retrieved regardless of outcome, so we can both
         # recover partial output (that could have been generated early in a
         # block, before an error) and clear the payload system always.
         reply_content[u'payload'] = shell.payload_manager.read_payload()
         # Be agressive about clearing the payload because we don't want
         # it to sit in memory until the next execute_request comes in.
         shell.payload_manager.clear_payload()
 
         # Flush output before sending the reply.
         sys.stdout.flush()
         sys.stderr.flush()
         # FIXME: on rare occasions, the flush doesn't seem to make it to the
         # clients... This seems to mitigate the problem, but we definitely need
         # to better understand what's going on.
         if self._execute_sleep:
             time.sleep(self._execute_sleep)
         
         # Send the reply.
         reply_msg = self.session.send(self.shell_socket, u'execute_reply',
                                       reply_content, parent, ident=ident)
         self.log.debug(str(reply_msg))
 
         if reply_msg['content']['status'] == u'error':
             self._abort_queue()
 
         status_msg = self.session.send(self.iopub_socket,
             u'status',
             {u'execution_state':u'idle'},
             parent=parent
         )
 
     def complete_request(self, ident, parent):
         txt, matches = self._complete(parent)
         matches = {'matches' : matches,
                    'matched_text' : txt,
                    'status' : 'ok'}
         completion_msg = self.session.send(self.shell_socket, 'complete_reply',
                                            matches, parent, ident)
         self.log.debug(str(completion_msg))
 
     def object_info_request(self, ident, parent):
         object_info = self.shell.object_inspect(parent['content']['oname'])
         # Before we send this object over, we scrub it for JSON usage
         oinfo = json_clean(object_info)
         msg = self.session.send(self.shell_socket, 'object_info_reply',
                                 oinfo, parent, ident)
         self.log.debug(msg)
 
     def history_request(self, ident, parent):
         # We need to pull these out, as passing **kwargs doesn't work with
         # unicode keys before Python 2.6.5.
         hist_access_type = parent['content']['hist_access_type']
         raw = parent['content']['raw']
         output = parent['content']['output']
         if hist_access_type == 'tail':
             n = parent['content']['n']
             hist = self.shell.history_manager.get_tail(n, raw=raw, output=output,
                                                             include_latest=True)
         
         elif hist_access_type == 'range':
             session = parent['content']['session']
             start = parent['content']['start']
             stop = parent['content']['stop']
             hist = self.shell.history_manager.get_range(session, start, stop,
                                                         raw=raw, output=output)
         
         elif hist_access_type == 'search':
             pattern = parent['content']['pattern']
             hist = self.shell.history_manager.search(pattern, raw=raw, output=output)
         
         else:
             hist = []
         content = {'history' : list(hist)}
         msg = self.session.send(self.shell_socket, 'history_reply',
                                 content, parent, ident)
         self.log.debug(str(msg))
 
     def connect_request(self, ident, parent):
         if self._recorded_ports is not None:
             content = self._recorded_ports.copy()
         else:
             content = {}
         msg = self.session.send(self.shell_socket, 'connect_reply',
                                 content, parent, ident)
         self.log.debug(msg)
 
     def shutdown_request(self, ident, parent):
         self.shell.exit_now = True
         self._shutdown_message = self.session.msg(u'shutdown_reply', parent['content'], parent)
         sys.exit(0)
 
     #---------------------------------------------------------------------------
     # Protected interface
     #---------------------------------------------------------------------------
 
     def _abort_queue(self):
         while True:
             ident,msg = self.session.recv(self.shell_socket, zmq.NOBLOCK)
             if msg is None:
                 break
             else:
                 assert ident is not None, \
                        "Unexpected missing message part."
 
             self.log.debug("Aborting:\n"+str(Message(msg)))
             msg_type = msg['header']['msg_type']
             reply_type = msg_type.split('_')[0] + '_reply'
             reply_msg = self.session.send(self.shell_socket, reply_type,
                     {'status' : 'aborted'}, msg, ident=ident)
             self.log.debug(reply_msg)
             # We need to wait a bit for requests to come in. This can probably
             # be set shorter for true asynchronous clients.
             time.sleep(0.1)
 
     def _raw_input(self, prompt, ident, parent):
         # Flush output before making the request.
         sys.stderr.flush()
         sys.stdout.flush()
 
         # Send the input request.
         content = dict(prompt=prompt)
         msg = self.session.send(self.stdin_socket, u'input_request', content, parent)
 
         # Await a response.
         ident, reply = self.session.recv(self.stdin_socket, 0)
         try:
             value = reply['content']['value']
         except:
             self.log.error("Got bad raw_input reply: ")
             self.log.error(str(Message(parent)))
             value = ''
         return value
     
     def _complete(self, msg):
         c = msg['content']
         try:
             cpos = int(c['cursor_pos'])
         except:
             # If we don't get something that we can convert to an integer, at
             # least attempt the completion guessing the cursor is at the end of
             # the text, if there's any, and otherwise of the line
             cpos = len(c['text'])
             if cpos==0:
                 cpos = len(c['line'])
         return self.shell.complete(c['text'], c['line'], cpos)
 
     def _object_info(self, context):
         symbol, leftover = self._symbol_from_context(context)
         if symbol is not None and not leftover:
             doc = getattr(symbol, '__doc__', '')
         else:
             doc = ''
         object_info = dict(docstring = doc)
         return object_info
 
     def _symbol_from_context(self, context):
         if not context:
             return None, context
 
         base_symbol_string = context[0]
         symbol = self.shell.user_ns.get(base_symbol_string, None)
         if symbol is None:
             symbol = __builtin__.__dict__.get(base_symbol_string, None)
         if symbol is None:
             return None, context
 
         context = context[1:]
         for i, name in enumerate(context):
             new_symbol = getattr(symbol, name, None)
             if new_symbol is None:
                 return symbol, context[i:]
             else:
                 symbol = new_symbol
 
         return symbol, []
 
     def _at_shutdown(self):
         """Actions taken at shutdown by the kernel, called by python's atexit.
         """
         # io.rprint("Kernel at_shutdown") # dbg
         if self._shutdown_message is not None:
             self.session.send(self.shell_socket, self._shutdown_message)
             self.session.send(self.iopub_socket, self._shutdown_message)
             self.log.debug(str(self._shutdown_message))
             # A very short sleep to give zmq time to flush its message buffers
             # before Python truly shuts down.
             time.sleep(0.01)
 
 
 class QtKernel(Kernel):
     """A Kernel subclass with Qt support."""
 
     def start(self):
         """Start a kernel with QtPy4 event loop integration."""
 
         from IPython.external.qt_for_kernel import QtCore
         from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4
 
         self.app = get_app_qt4([" "])
         self.app.setQuitOnLastWindowClosed(False)
         self.timer = QtCore.QTimer()
         self.timer.timeout.connect(self.do_one_iteration)
         # Units for the timer are in milliseconds
         self.timer.start(1000*self._poll_interval)
         start_event_loop_qt4(self.app)
 
 
 class WxKernel(Kernel):
     """A Kernel subclass with Wx support."""
 
     def start(self):
         """Start a kernel with wx event loop support."""
 
         import wx
         from IPython.lib.guisupport import start_event_loop_wx
 
         doi = self.do_one_iteration
          # Wx uses milliseconds
         poll_interval = int(1000*self._poll_interval)
 
         # We have to put the wx.Timer in a wx.Frame for it to fire properly.
         # We make the Frame hidden when we create it in the main app below.
         class TimerFrame(wx.Frame):
             def __init__(self, func):
                 wx.Frame.__init__(self, None, -1)
                 self.timer = wx.Timer(self)
                 # Units for the timer are in milliseconds
                 self.timer.Start(poll_interval)
                 self.Bind(wx.EVT_TIMER, self.on_timer)
                 self.func = func
 
             def on_timer(self, event):
                 self.func()
 
         # We need a custom wx.App to create our Frame subclass that has the
         # wx.Timer to drive the ZMQ event loop.
         class IPWxApp(wx.App):
             def OnInit(self):
                 self.frame = TimerFrame(doi)
                 self.frame.Show(False)
                 return True
 
         # The redirect=False here makes sure that wx doesn't replace
         # sys.stdout/stderr with its own classes.
         self.app = IPWxApp(redirect=False)
         start_event_loop_wx(self.app)
 
 
 class TkKernel(Kernel):
     """A Kernel subclass with Tk support."""
 
     def start(self):
         """Start a Tk enabled event loop."""
 
         import Tkinter
         doi = self.do_one_iteration
         # Tk uses milliseconds
         poll_interval = int(1000*self._poll_interval)
         # For Tkinter, we create a Tk object and call its withdraw method.
         class Timer(object):
             def __init__(self, func):
                 self.app = Tkinter.Tk()
                 self.app.withdraw()
                 self.func = func
                 
             def on_timer(self):
                 self.func()
                 self.app.after(poll_interval, self.on_timer)
                 
             def start(self):
                 self.on_timer()  # Call it once to get things going.
                 self.app.mainloop()
 
         self.timer = Timer(doi)
         self.timer.start()
 
 
 class GTKKernel(Kernel):
     """A Kernel subclass with GTK support."""
     
     def start(self):
         """Start the kernel, coordinating with the GTK event loop"""
         from .gui.gtkembed import GTKEmbed
         
         gtk_kernel = GTKEmbed(self)
         gtk_kernel.start()
 
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags for the IPKernelApp
 #-----------------------------------------------------------------------------
 
 flags = dict(kernel_flags)
 flags.update(shell_flags)
 
 addflag = lambda *args: flags.update(boolean_flag(*args))
 
 flags['pylab'] = (
     {'IPKernelApp' : {'pylab' : 'auto'}},
     """Pre-load matplotlib and numpy for interactive use with
     the default matplotlib backend."""
 )
 
 aliases = dict(kernel_aliases)
 aliases.update(shell_aliases)
 
 # it's possible we don't want short aliases for *all* of these:
 aliases.update(dict(
     pylab='IPKernelApp.pylab',
 ))
 
 #-----------------------------------------------------------------------------
 # The IPKernelApp class
 #-----------------------------------------------------------------------------
 
 class IPKernelApp(KernelApp, InteractiveShellApp):
     name = 'ipkernel'
 
     aliases = Dict(aliases)
     flags = Dict(flags)
     classes = [Kernel, ZMQInteractiveShell, ProfileDir, Session]
     # configurables
     pylab = CaselessStrEnum(['tk', 'qt', 'wx', 'gtk', 'osx', 'inline', 'auto'],
         config=True,
         help="""Pre-load matplotlib and numpy for interactive use,
         selecting a particular matplotlib backend and loop integration.
         """
     )
     pylab_import_all = Bool(True, config=True,
         help="""If true, an 'import *' is done from numpy and pylab,
         when using pylab"""
     )
     def initialize(self, argv=None):
         super(IPKernelApp, self).initialize(argv)
         self.init_shell()
         self.init_extensions()
         self.init_code()
 
     def init_kernel(self):
         kernel_factory = Kernel
 
         kernel_map = {
             'qt' : QtKernel,
             'qt4': QtKernel,
             'inline': Kernel,
             'osx': TkKernel,
             'wx' : WxKernel,
             'tk' : TkKernel,
             'gtk': GTKKernel,
         }
 
         if self.pylab:
             key = None if self.pylab == 'auto' else self.pylab
             gui, backend = pylabtools.find_gui_and_backend(key)
             kernel_factory = kernel_map.get(gui)
             if kernel_factory is None:
                 raise ValueError('GUI is not supported: %r' % gui)
             pylabtools.activate_matplotlib(backend)
 
         kernel = kernel_factory(config=self.config, session=self.session,
                                 shell_socket=self.shell_socket,
                                 iopub_socket=self.iopub_socket,
                                 stdin_socket=self.stdin_socket,
                                 log=self.log
         )
         self.kernel = kernel
         kernel.record_ports(self.ports)
 
         if self.pylab:
             import_all = self.pylab_import_all
             pylabtools.import_pylab(kernel.shell.user_ns, backend, import_all,
                                     shell=kernel.shell)
     
     def init_shell(self):
         self.shell = self.kernel.shell
 
 
 #-----------------------------------------------------------------------------
 # Kernel main and launch functions
 #-----------------------------------------------------------------------------
 
 def launch_kernel(*args, **kwargs):
     """Launches a localhost IPython kernel, binding to the specified ports.
 
     This function simply calls entry_point.base_launch_kernel with the right first
     command to start an ipkernel.  See base_launch_kernel for arguments.
 
     Returns
     -------
     A tuple of form:
         (kernel_process, shell_port, iopub_port, stdin_port, hb_port)
     where kernel_process is a Popen object and the ports are integers.
     """
     return base_launch_kernel('from IPython.zmq.ipkernel import main; main()',
                               *args, **kwargs)
 
 
 def main():
     """Run an IPKernel as an application"""
     app = IPKernelApp.instance()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     main()