Merge pull request #7454 from minrk/project_name

add language name to kernelspec

IPython/html/static/base/less/page.less

@@ -144,3 +144,10 b' span#login_widget > .button,'
     .fa();
     content: @ico;
 }
+
+@media (min-width: @screen-sm-min) {
+    select.form-control {
+        margin-left: @padding-base-horizontal;
+        margin-right: @padding-base-horizontal;
+    }
+}

IPython/html/static/notebook/js/kernelselector.js

@@ -25,7 +25,8 b' define(['
         // Make the object globally available for user convenience & inspection
         IPython.kernelselector = this;
         this._finish_load = null;
-        this.loaded = new Promise(function(resolve, reject) {
+        this._loaded = false;
+        this.loaded = new Promise(function(resolve) {
             that._finish_load = resolve;
         });
         
@@ -37,16 +38,12 b' define(['
         utils.promising_ajax(url).then($.proxy(this._got_kernelspecs, this));
     };
     
-    KernelSelector.prototype._got_kernelspecs = function(data) {
-        var that = this;
-        this.kernelspecs = data.kernelspecs;
-        var change_kernel_submenu = $("#menu-change-kernel-submenu");
-        var new_notebook_submenu = $("#menu-new-notebook-submenu");
-        
-        var keys = Object.keys(data.kernelspecs).sort(function (a, b) {
+    var _sorted_names = function(kernelspecs) {
+        // sort kernel names
+        return Object.keys(kernelspecs).sort(function (a, b) {
             // sort by display_name
-            var da = data.kernelspecs[a].spec.display_name;
-            var db = data.kernelspecs[b].spec.display_name;
+            var da = kernelspecs[a].spec.display_name;
+            var db = kernelspecs[b].spec.display_name;
             if (da === db) {
                 return 0;
             } else if (da > db) {
@@ -55,6 +52,14 b' define(['
                 return -1;
             }
         });
+    };
+    
+    KernelSelector.prototype._got_kernelspecs = function(data) {
+        var that = this;
+        this.kernelspecs = data.kernelspecs;
+        var change_kernel_submenu = $("#menu-change-kernel-submenu");
+        var new_notebook_submenu = $("#menu-new-notebook-submenu");
+        var keys = _sorted_names(data.kernelspecs);
         
         keys.map(function (key) {
             // Create the Kernel > Change kernel submenu
@@ -83,6 +88,7 b' define(['
 
         });
         // trigger loaded promise
+        this._loaded = true;
         this._finish_load();
     };
     
@@ -154,28 +160,115 b' define(['
         }
     };
 
-    KernelSelector.prototype.set_kernel = function (kernel_name) {
-        /** set the kernel by name, ensuring kernelspecs have been loaded, first */
+    KernelSelector.prototype.set_kernel = function (selected) {
+        /** set the kernel by name, ensuring kernelspecs have been loaded, first 
+        
+        kernel can be just a kernel name, or a notebook kernelspec metadata
+        (name, language, display_name).
+        */
         var that = this;
-        return this.loaded.then(function () {
-            that._set_kernel(kernel_name);
-        });
+        if (typeof selected === 'string') {
+            selected = {
+                name: selected
+            };
+        }
+        if (this._loaded) {
+            this._set_kernel(selected);
+        } else {
+            return this.loaded.then(function () {
+                that._set_kernel(selected);
+            });
+        }
     };
 
-    KernelSelector.prototype._set_kernel = function (kernel_name) {
+    KernelSelector.prototype._set_kernel = function (selected) {
         /** Actually set the kernel (kernelspecs have been loaded) */
-        if (kernel_name === this.current_selection) {
+        if (selected.name === this.current_selection) {
             // only trigger event if value changed
             return;
         }
-        var ks = this.kernelspecs[kernel_name];
+        var kernelspecs = this.kernelspecs;
+        var ks = kernelspecs[selected.name];
+        if (ks === undefined) {
+            var available = _sorted_names(kernelspecs);
+            var matches = [];
+            if (selected.language && selected.language.length > 0) {
+                available.map(function (name) {
+                    if (kernelspecs[name].spec.language.toLowerCase() === selected.language.toLowerCase()) {
+                        matches.push(name);
+                    }
+                });
+            }
+            if (matches.length === 1) {
+                ks = kernelspecs[matches[0]];
+                console.log("No exact match found for " + selected.name +
+                    ", using only kernel that matches language=" + selected.language, ks);
+                this.events.trigger("spec_match_found.Kernel", {
+                    selected: selected,
+                    found: ks,
+                });
+            }
+            // if still undefined, trigger failure event
+            if (ks === undefined) {
+                this.events.trigger("spec_not_found.Kernel", {
+                    selected: selected,
+                    matches: matches,
+                    available: available,
+                });
+                return;
+            }
+        }
         if (this.notebook._session_starting) {
             console.error("Cannot change kernel while waiting for pending session start.");
             return;
         }
-        this.current_selection = kernel_name;
+        this.current_selection = ks.name;
         this.events.trigger('spec_changed.Kernel', ks);
     };
+    
+    KernelSelector.prototype._spec_not_found = function (event, data) {
+        var that = this;
+        var select = $("<select>").addClass('form-control');
+        console.warn("Kernelspec not found:", data);
+        var names;
+        if (data.matches.length > 1) {
+            names = data.matches;
+        } else {
+            names = data.available;
+        }
+        names.map(function (name) {
+            var ks = that.kernelspecs[name];
+            select.append(
+                $('<option/>').attr('value', ks.name).text(ks.spec.display_name || ks.name)
+            );
+        });
+        
+        var body = $("<form>").addClass("form-inline").append(
+            $("<span>").text(
+                "I couldn't find a kernel matching " + (data.selected.display_name || data.name) + "." +
+                " Please select a kernel:"
+            )
+        ).append(select);
+        
+        dialog.modal({
+            title : 'Kernel not found',
+            body : body,
+            buttons : {
+                'Continue without kernel' : {
+                    class : 'btn-danger',
+                    click : function () {
+                        that.events.trigger('no_kernel.Kernel');
+                    }
+                },
+                OK : {
+                    class : 'btn-primary',
+                    click : function () {
+                        that.set_kernel(select.val());
+                    }
+                }
+            }
+        });
+    };
 
     KernelSelector.prototype.new_notebook = function (kernel_name) {
         
@@ -213,7 +306,7 b' define(['
     KernelSelector.prototype.bind_events = function() {
         var that = this;
         this.events.on('spec_changed.Kernel', $.proxy(this._spec_changed, this));
-
+        this.events.on('spec_not_found.Kernel', $.proxy(this._spec_not_found, this));
         this.events.on('kernel_created.Session', function (event, data) {
             that.set_kernel(data.kernel.name);
         });

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

@@ -226,8 +226,11 b' define(function (require) {'
         });
         
         this.events.on('spec_changed.Kernel', function(event, data) {
-            that.metadata.kernelspec = 
-                {name: data.name, display_name: data.spec.display_name};
+            that.metadata.kernelspec = {
+                name: data.name,
+                display_name: data.spec.display_name,
+                language: data.spec.language,
+            };
             // start session if the current session isn't already correct
             if (!(this.session && this.session.kernel && this.session.kernel.name === data.name)) {
                 that.start_session(data.name);
@@ -2208,18 +2211,14 b' define(function (require) {'
         }
         
         if (this.session === null) {
-            var kernel_name;
-            if (this.metadata.kernelspec) {
-                var kernelspec = this.metadata.kernelspec || {};
-                kernel_name = kernelspec.name;
-            } else {
-                kernel_name = utils.get_url_param('kernel_name');
-            }
+            var kernel_name = utils.get_url_param('kernel_name');
             if (kernel_name) {
-                // setting kernel_name here triggers start_session
                 this.kernel_selector.set_kernel(kernel_name);
+            } else if (this.metadata.kernelspec) {
+                this.kernel_selector.set_kernel(this.metadata.kernelspec);
             } else {
-                // start a new session with the server's default kernel
+                // setting kernel via set_kernel above triggers start_session,
+                // otherwise start a new session with the server's default kernel
                 // spec_changed events will fire after kernel is loaded
                 this.start_session();
             }

IPython/html/static/notebook/js/notificationarea.js

@@ -14,7 +14,7 b' define(['
         this.save_widget = options.save_widget;
         this.notebook = options.notebook;
         this.keyboard_manager = options.keyboard_manager;
-    }
+    };
     
     NotebookNotificationArea.prototype = Object.create(NotificationArea.prototype);
     
@@ -38,7 +38,7 b' define(['
         var knw = this.new_notification_widget('kernel');
         var $kernel_ind_icon = $("#kernel_indicator_icon");
         var $modal_ind_icon = $("#modal_indicator");
-        var $body = $('body')
+        var $body = $('body');
 
         // Command/Edit mode
         this.events.on('edit_mode.Notebook', function () {
@@ -57,9 +57,9 b' define(['
 
         // Implicitly start off in Command mode, switching to Edit mode will trigger event
         $modal_ind_icon.addClass('modal_indicator').attr('title','Command Mode');
-        $body.addClass('command_mode')
+        $body.addClass('command_mode');
 
-        // Kernel events 
+        // Kernel events
 
         // this can be either kernel_created.Kernel or kernel_created.Session
         this.events.on('kernel_created.Kernel kernel_created.Session', function () {
@@ -105,7 +105,7 b' define(['
                         }
                     }
                 });
-            };
+            }
 
             that.save_widget.update_document_title();
             knw.danger("Dead kernel");
@@ -187,6 +187,10 b' define(['
 
             showMsg();
         });
+        
+        this.events.on("no_kernel.Kernel", function (evt, data) {
+            $("#kernel_indicator").find('.kernel_indicator_name').text("No Kernel");
+        });
 
         this.events.on('kernel_dead.Session', function (evt, info) {
             var full = info.xhr.responseJSON.message;
@@ -251,6 +255,13 b' define(['
             window.document.title='(Busy) '+window.document.title;
             $kernel_ind_icon.attr('class','kernel_busy_icon').attr('title','Kernel Busy');
         });
+
+        this.events.on('spec_match_found.Kernel', function (evt, data) {
+            that.widget('kernelspec').info("Using kernel: " + data.found.spec.display_name, 3000, undefined, {
+                title: "Only candidate for language: " + data.selected.language + " was " + data.found.spec.display_name
+            });
+        });
+
         
         // Start the kernel indicator in the busy state, and send a kernel_info request.
         // When the kernel_info reply arrives, the kernel is idle.

IPython/html/static/style/style.min.css

@@ -8588,6 +8588,12 b' span#login_widget > .button .badge,'
     width: 700px;
   }
 }
+@media (min-width: 768px) {
+  select.form-control {
+    margin-left: 12px;
+    margin-right: 12px;
+  }
+}
 /*!
 *
 * IPython auth

IPython/kernel/kernelspec.py

@@ -36,6 +36,7 b' def _pythonfirst(s):'
 class KernelSpec(HasTraits):
     argv = List()
     display_name = Unicode()
+    language = Unicode()
     env = Dict()
     resource_dir = Unicode()
     
@@ -54,6 +55,7 b' class KernelSpec(HasTraits):'
         d = dict(argv=self.argv,
                  env=self.env,
                  display_name=self.display_name,
+                 language=self.language,
                 )
 
         return d
@@ -109,8 +111,10 b' class KernelSpecManager(HasTraits):'
         The native kernel is the kernel using the same Python runtime as this
         process. This will put its information in the user kernels directory.
         """
-        return {'argv': make_ipkernel_cmd(),
+        return {
+                'argv': make_ipkernel_cmd(),
                 'display_name': 'Python %i' % (3 if PY3 else 2),
+                'language': 'python',
                }
 
     @property

docs/source/development/kernels.rst

@@ -112,6 +112,11 b' JSON serialised dictionary containing the following keys and values:'
 - **display_name**: The kernel's name as it should be displayed in the UI.
   Unlike the kernel name used in the API, this can contain arbitrary unicode
   characters.
+- **language**: The name of the language of the kernel.
+  When loading notebooks, if no matching kernelspec key (may differ across machines)
+  is found, a kernel with a matching `language` will be used.
+  This allows a notebook written on any Python or Julia kernel to be properly associated
+  with the user's Python or Julia kernel, even if they aren't listed under the same name as the author's.
 - **env** (optional): A dictionary of environment variables to set for the kernel.
   These will be added to the current environment variables before the kernel is
   started.
@@ -121,7 +126,8 b' For example, the kernel.json file for IPython looks like this::'
     {
      "argv": ["python3", "-c", "from IPython.kernel.zmq.kernelapp import main; main()", 
               "-f", "{connection_file}"],
-     "display_name": "IPython (Python 3)"
+     "display_name": "IPython (Python 3)",
+     "language": "python"
     }
 
 To see the available kernel specs, run::