Work on the server side of the html notebook.

IPython/frontend/html/notebook/kernelmanager.py

@@ -0,0 +1,98 b''
+import signal
+import sys
+import uuid
+
+from IPython.zmq.ipkernel import launch_kernel
+from session import SessionManager
+
+
+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):
+        kid = str(uuid.uuid4())
+        (process, shell_port, iopub_port, stdin_port, hb_port) = launch_kernel()
+        d = dict(
+            process = process,
+            stdin_port = stdin_port,
+            iopub_port = iopub_port,
+            shell_port = shell_port,
+            hb_port = hb_port,
+            session_manager = SessionManager(self, kid, self.context)
+        )
+        self._kernels[kid] = d
+        return kid
+
+    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/session.py

@@ -0,0 +1,56 b''
+import logging
+
+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()
+
+    def start_session(self, session_id):
+        ports = self.kernel_manager.get_kernel_ports(self.kernel_id)
+        iopub_stream = self.create_connected_stream(ports['iopub_port'], zmq.SUB)
+        shell_stream = self.create_connected_stream(ports['shell_port'], zmq.XREQ)
+        self._sessions[session_id] = dict(
+            iopub_stream = iopub_stream,
+            shell_stream = shell_stream
+        )
+
+    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)
+        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/zmqhttp.py

@@ -0,0 +1,80 b''
+import json
+
+from tornado import web
+
+import logging
+
+
+class ZMQHandler(web.RequestHandler):
+
+    def get_stream(self):
+        """Get the ZMQStream for this request."""
+        raise NotImplementedError('Implement get_stream() in a subclass.')
+
+    def _save_method_args(self, *args, **kwargs):
+        """Save the args and kwargs to get/post/put/delete for future use.
+
+        These arguments are not saved in the request or handler objects, but
+        are often needed by methods such as get_stream().
+        """ 
+        self._method_args = args
+        self._method_kwargs = kwargs
+
+    def _handle_msgs(self, msg):
+        msgs = [msg]
+        stream = self.get_stream()
+        stream.on_recv(lambda m: msgs.append(json.loads(m)))
+        stream.flush()
+        stream.stop_on_recv()
+        logging.info("Reply: %r" % msgs)
+        self.write(json.dumps(msgs))
+        self.finish()
+
+
+class ZMQPubHandler(ZMQHandler):
+
+    SUPPORTED_METHODS = ("POST",)
+
+    def post(self, *args, **kwargs):
+        self._save_method_args(*args, **kwargs)
+        try:
+            msg = json.loads(self.request.body)
+        except:
+            self.send_error(status_code=415)
+        else:
+            logging.info("Request: %r" % msg)
+            self.get_stream().send_json(msg)
+
+
+class ZMQSubHandler(ZMQHandler):
+
+    SUPPORTED_METHODS = ("GET",)
+
+    @web.asynchronous
+    def get(self, *args, **kwargs):
+        self._save_method_args(*args, **kwargs)
+        self.get_stream().on_recv(self._handle_msgs)
+
+
+class ZMQXReqHandler(ZMQHandler):
+
+    SUPPORTED_METHODS = ("POST",)
+
+    @web.asynchronous
+    def post(self, *args, **kwargs):
+        self._save_method_args(*args, **kwargs)
+        logging.info("request: %r" % self.request)
+        try:
+            msg = json.loads(self.request.body)
+        except:
+            self.send_error(status_code=415)
+        else:
+            logging.info("Reply: %r" % msg)
+            stream = self.get_stream()
+            stream.send_json(msg)
+            stream.on_recv(self._handle_msgs)
+
+
+
+
+    
  No newline at end of file

IPython/frontend/html/notebook/zmqws.py

@@ -0,0 +1,23 b''
+"""A simple WebSocket to ZMQ forwarder."""
+
+from tornado import websocket
+
+class ZMQWebSocketBridge(websocket.WebSocketHandler):
+    """A handler to forward between a WebSocket at ZMQ socket."""
+
+    def open(self):
+        self.stream
+
+    @property
+    def stream(self):
+        raise NotImplementedError("stream property must be implemented in a subclass")
+
+    def on_message(self, message):
+        self.stream.send(message)
+
+    def on_zmq_reply(self, reply_list):
+        for part in reply_list:
+            self.write_message(part)
+
+    def on_close(self):
+        print "WebSocket closed"

IPython/frontend/html/notebook/notebook.py

@@ -1,40 +1,124 b''
-
+import json
+import logging
 import os
+import uuid
+
+import zmq
 
-import tornado.httpserver
+# Install the pyzmq ioloop. This has to be done before anything else from
+# tornado is imported.
+from zmq.eventloop.zmqstream import ZMQStream
+from zmq.eventloop import ioloop
 import tornado.ioloop
-import tornado.options
-import tornado.web
+tornado.ioloop = ioloop
+
+from tornado import httpserver
+from tornado import options
+from tornado import web
+from tornado import websocket
+
+from kernelmanager import KernelManager
 
-from tornado.options import define, options
+options.define("port", default=8888, help="run on the given port", type=int)
 
-define("port", default=8888, help="run on the given port", type=int)
+_kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
+_session_id_regex = r"(?P<session_id>\w+)"
 
-class MainHandler(tornado.web.RequestHandler):
+
+class MainHandler(web.RequestHandler):
     def get(self):
         self.render('notebook.html')
 
 
-class NotebookApplication(tornado.web.Application):
+class KernelHandler(web.RequestHandler):
+
+    def get(self):
+        self.write(json.dumps(self.application.kernel_manager.kernel_ids))
+
+    def post(self):
+        kid = self.application.kernel_manager.start_kernel()
+        logging.info("Starting kernel: %s" % kid)
+        self.write(json.dumps(kid))
+
+
+class SessionHandler(web.RequestHandler):
+
+    def post(self, *args, **kwargs):
+        kernel_id = kwargs['kernel_id']
+        session_id = kwargs['session_id']
+        logging.info("Starting session: %s, %s" % (kernel_id,session_id))
+        km = self.application.kernel_manager
+        sm = km.get_session_manager(kernel_id)
+        sm.start_session(session_id)
+        self.finish()
+
+
+class ZMQStreamHandler(websocket.WebSocketHandler):
+
+    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.application.kernel_manager.get_session_manager(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)
+        self.session_manager = sm
+        self.session_id = session_id
+
+    def on_message(self, msg):
+        logging.info("Message received: %r" % msg)
+        self.zmq_stream.send(msg)
+
+    def on_close(self):
+        logging.info("Connection closed: %s, %s" % (kernel_id,session_id))
+        self.zmq_stream.close()
+
+    def _on_zmq_reply(self, msg):
+        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"/", MainHandler),
+            (r"/kernels", KernelHandler),
+            (r"/kernels/%s/sessions/%s" % (_kernel_id_regex,_session_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"),
         )
-        tornado.web.Application.__init__(self, handlers, **settings)
+        web.Application.__init__(self, handlers, **settings)
+        self.context = zmq.Context()
+        self.kernel_manager = KernelManager(self.context)
 
 
 def main():
-    tornado.options.parse_command_line()
+    options.parse_command_line()
     application = NotebookApplication()
-    http_server = tornado.httpserver.HTTPServer(application)
-    http_server.listen(options.port)
-    tornado.ioloop.IOLoop.instance().start()
+    http_server = httpserver.HTTPServer(application)
+    http_server.listen(options.options.port)
+    ioloop.IOLoop.instance().start()
 
 
 if __name__ == "__main__":
     main()
 

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

@@ -1,539 +1,582 b''
 var IPYTHON = {};
 
 
 //============================================================================
 // Notebook
 //============================================================================
 
 
 var Notebook = function (selector) {
     this.element = $(selector);
+    this.element.scroll();
     this.element.data("notebook", this);
     this.next_prompt_number = 1;
     this.bind_events();
-}
+};
 
 
 Notebook.prototype.bind_events = function () {
     var that = this;
     $(document).keydown(function (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.
             event.preventDefault();
             that.insert_code_cell_after();
         }
     });
 };
 
 
 // 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.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();
 }
 
 
 //============================================================================
 // 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();
     }
 };
 
 
 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;
 };
 
 
 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 + ']:');
 };
 
 
 //============================================================================
 // 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");    
+    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";
+};
+
+
+KernelManager.prototype.create_kernel = function () {
+    var that = this;
+    $.post(this.baseurl, function (data) {
+        that.kernelid = data;
+    }, 'json');
+}
+
+
+KernelManager.prototype.execute = function (code, callback) {
+    var msg = {
+        header : {msg_id : 0, username : "bgranger", session: 0},
+        msg_type : "execute_request",
+        content : {code : code}
+    };
+    var settings = {
+      data : JSON.stringify(msg),
+      processData : false,
+      contentType : "application/json",
+      success : callback,
+      type : "POST"
+    }
+    var url = this.baseurl + "/" + this.kernelid + "/" + ""
+}
+
+
+//============================================================================
+// 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();});
 
 });
  No newline at end of file