removing debug logs

IPython/html/services/kernels/handlers.py

@@ -1,187 +1,187 b''
 """Tornado handlers for the notebook.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import logging
 from tornado import web
 
 from zmq.utils import jsonapi
 
 from IPython.utils.jsonutil import date_default
 
 from ...base.handlers import IPythonHandler
 from ...base.zmqhandlers import AuthenticatedZMQStreamHandler
 
 #-----------------------------------------------------------------------------
 # Kernel handlers
 #-----------------------------------------------------------------------------
 
 
 class MainKernelHandler(IPythonHandler):
 
     @web.authenticated
     def get(self):
         km = self.kernel_manager
         self.finish(jsonapi.dumps(km.list_kernels()))
 
     @web.authenticated
     def post(self):
         km = self.kernel_manager
         nbm = self.notebook_manager
         kernel_id = km.start_kernel(cwd=nbm.notebook_dir)
         model = km.kernel_model(kernel_id, self.ws_url)
         self.set_header('Location', '{0}kernels/{1}'.format(self.base_kernel_url, kernel_id))
         self.finish(jsonapi.dumps(model))
 
 
 class KernelHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('DELETE', 'GET')
 
     @web.authenticated
     def get(self, kernel_id):
         km = self.kernel_manager
-        model = km.kernel_model(kernel_id,self.ws_url)
+        model = km.kernel_model(kernel_id, self.ws_url)
         self.finish(jsonapi.dumps(model))
 
     @web.authenticated
     def delete(self, kernel_id):
         km = self.kernel_manager
         km.shutdown_kernel(kernel_id)
         self.set_status(204)
         self.finish()
 
 
 class KernelActionHandler(IPythonHandler):
 
     @web.authenticated
     def post(self, kernel_id, action):
         km = self.kernel_manager
         if action == 'interrupt':
             km.interrupt_kernel(kernel_id)
             self.set_status(204)
         if action == 'restart':
             km.restart_kernel(kernel_id)
-            model = km.kernel_model(kernel_id,self.ws_url)
+            model = km.kernel_model(kernel_id, self.ws_url)
             self.set_header('Location', '{0}api/kernels/{1}'.format(self.base_kernel_url, kernel_id))
             self.write(jsonapi.dumps(model))
         self.finish()
 
 
 class ZMQChannelHandler(AuthenticatedZMQStreamHandler):
     
     def create_stream(self):
         km = self.kernel_manager
         meth = getattr(km, 'connect_%s' % self.channel)
         self.zmq_stream = meth(self.kernel_id, identity=self.session.bsession)
     
     def initialize(self, *args, **kwargs):
         self.zmq_stream = None
     
     def on_first_message(self, msg):
         try:
             super(ZMQChannelHandler, self).on_first_message(msg)
         except web.HTTPError:
             self.close()
             return
         try:
             self.create_stream()
         except web.HTTPError:
             # WebSockets don't response to traditional error codes so we
             # close the connection.
             if not self.stream.closed():
                 self.stream.close()
             self.close()
         else:
             self.zmq_stream.on_recv(self._on_zmq_reply)
 
     def on_message(self, msg):
         msg = jsonapi.loads(msg)
         self.session.send(self.zmq_stream, msg)
 
     def on_close(self):
         # This method can be called twice, once by self.kernel_died and once
         # from the WebSocket close event. If the WebSocket connection is
         # closed before the ZMQ streams are setup, they could be None.
         if self.zmq_stream is not None and not self.zmq_stream.closed():
             self.zmq_stream.on_recv(None)
             self.zmq_stream.close()
 
 
 class IOPubHandler(ZMQChannelHandler):
     channel = 'iopub'
     
     def create_stream(self):
         super(IOPubHandler, self).create_stream()
         km = self.kernel_manager
         km.add_restart_callback(self.kernel_id, self.on_kernel_restarted)
         km.add_restart_callback(self.kernel_id, self.on_restart_failed, 'dead')
     
     def on_close(self):
         km = self.kernel_manager
         if self.kernel_id in km:
             km.remove_restart_callback(
                 self.kernel_id, self.on_kernel_restarted,
             )
             km.remove_restart_callback(
                 self.kernel_id, self.on_restart_failed, 'dead',
             )
         super(IOPubHandler, self).on_close()
     
     def _send_status_message(self, status):
         msg = self.session.msg("status",
             {'execution_state': status}
         )
         self.write_message(jsonapi.dumps(msg, default=date_default))
 
     def on_kernel_restarted(self):
         logging.warn("kernel %s restarted", self.kernel_id)
         self._send_status_message('restarting')
 
     def on_restart_failed(self):
         logging.error("kernel %s restarted failed!", self.kernel_id)
         self._send_status_message('dead')
     
     def on_message(self, msg):
         """IOPub messages make no sense"""
         pass
 
 
 class ShellHandler(ZMQChannelHandler):
     channel = 'shell'
 
 
 class StdinHandler(ZMQChannelHandler):
     channel = 'stdin'
 
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 
 _kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
 _kernel_action_regex = r"(?P<action>restart|interrupt)"
 
 default_handlers = [
     (r"/api/kernels", MainKernelHandler),
     (r"/api/kernels/%s" % _kernel_id_regex, KernelHandler),
     (r"/api/kernels/%s/%s" % (_kernel_id_regex, _kernel_action_regex), KernelActionHandler),
     (r"/api/kernels/%s/iopub" % _kernel_id_regex, IOPubHandler),
     (r"/api/kernels/%s/shell" % _kernel_id_regex, ShellHandler),
     (r"/api/kernels/%s/stdin" % _kernel_id_regex, StdinHandler)
 ]

IPython/html/services/sessions/handlers.py

@@ -1,108 +1,105 b''
 """Tornado handlers for the notebooks web service.
 
 Authors:
 
 * Zach Sailer
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from tornado import web
 
 from zmq.utils import jsonapi
 
 from IPython.utils.jsonutil import date_default
 
 from ...base.handlers import IPythonHandler, authenticate_unless_readonly
 
 #-----------------------------------------------------------------------------
 # Session web service handlers
 #-----------------------------------------------------------------------------
 
 
 
 class SessionRootHandler(IPythonHandler):
-    
-    
+
     @authenticate_unless_readonly
     def get(self):
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         sessions = sm.list_sessions()
         self.finish(jsonapi.dumps(sessions))
-        
-        
+
     @web.authenticated
     def post(self):
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         notebook_path = self.get_argument('notebook_path', default=None)
         notebook_name, path = nbm.named_notebook_path(notebook_path)
         session_id, model = sm.get_session(notebook_name, path)
         if model == None:
             kernel_id = km.start_kernel()
             kernel = km.kernel_model(kernel_id, self.ws_url)
             model = sm.session_model(session_id, notebook_name, path, kernel)
         self.finish(jsonapi.dumps(model))
-        
-        
+
 class SessionHandler(IPythonHandler):
-    
+
     SUPPORTED_METHODS = ('GET', 'PATCH', 'DELETE')
-    
+
     @authenticate_unless_readonly
     def get(self, session_id):
         sm = self.session_manager
         model = sm.get_session_from_id(session_id)
         self.finish(jsonapi.dumps(model))
-    
+
     @web.authenticated
     def patch(self, session_id):
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         notebook_path = self.request.body
         notebook_name, path = nbm.named_notebook_path(notebook_path)
         kernel_id = sm.get_kernel_from_session(session_id)
         kernel = km.kernel_model(kernel_id, self.ws_url)
         sm.delete_mapping_for_session(session_id)
         model = sm.session_model(session_id, notebook_name, path, kernel)
         self.finish(jsonapi.dumps(model))
-        
+
     @web.authenticated
     def delete(self, session_id):
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         kernel_id = sm.get_kernel_from_session(session_id)
         km.shutdown_kernel(kernel_id)
         sm.delete_mapping_for_session(session_id)
         self.set_status(204)
         self.finish()
-        
+
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 _session_id_regex = r"(?P<session_id>\w+-\w+-\w+-\w+-\w+)"
 
 default_handlers = [
     (r"api/sessions/%s" % _session_id_regex, SessionHandler),
     (r"api/sessions",  SessionRootHandler)
 ]
 
 
 
 

IPython/html/static/services/sessions/js/session.js

@@ -1,97 +1,96 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2008-2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Notebook
 //============================================================================
 
 var IPython = (function (IPython) {
     
     var Session = function(notebook_path, Notebook){
         this.kernel = null;
         this.kernel_id = null;
         this.session_id = null;
         this.notebook_path = notebook_path;
         this.notebook = Notebook;
         this._baseProjectUrl = Notebook.baseProjectUrl() 
     };
     
     Session.prototype.start = function(){
         var that = this
         var qs = $.param({notebook_path:this.notebook_path});
         var url = '/api/sessions' + '?' + qs;
         $.post(url, 
             $.proxy(this.start_kernel, that),
             'json'
         );
     };
     
     Session.prototype.notebook_rename = function (notebook_path) {
         this.notebook_path = notebook_path;
-        console.log("TEST");
         var settings = {
             processData : false,
             cache : false,
             type : "PATCH",
             data: notebook_path,
             dataType : "json",
         };
         var url = this._baseProjectUrl + 'api/sessions/' + this.session_id;
         $.ajax(url, settings);
     }
     
     
     Session.prototype.delete_session = function() {
         var settings = {
             processData : false,
             cache : false,
             type : "DELETE",
             dataType : "json",
         };
         var url = this._baseProjectUrl + 'api/sessions/' + this.session_id;
         $.ajax(url, settings);
     };
     
     // Kernel related things
     /**
      * Start a new kernel and set it on each code cell.
      * 
      * @method start_kernel
      */
     Session.prototype.start_kernel = function (json) {
         this.session_id = json.session_id;
         this.kernel_content = json.kernel;
         var base_url = $('body').data('baseKernelUrl') + "api/kernels";
         this.kernel = new IPython.Kernel(base_url, this.session_id);
         // Now that the kernel has been created, tell the CodeCells about it.
         this.kernel._kernel_started(this.kernel_content);
     };
     
     /**
      * Prompt the user to restart the IPython kernel.
      * 
      * @method restart_kernel
      */
     Session.prototype.restart_kernel = function () {
         this.kernel.restart();
     };
     
     Session.prototype.interrupt_kernel = function() {
         this.kernel.interrupt();
     };
     
 
     Session.prototype.kill_kernel = function() {
         this.kernel.kill();        
     };
     
     IPython.Session = Session;
 
 
     return IPython;
 
 }(IPython));