Add files using upload-large-folder tool

.cache/wandb/logs/core-debug-20240926_180813.log

@@ -0,0 +1,17 @@
+{"time":"2024-09-26T18:08:13.661085645Z","level":"INFO","msg":"started logging, with flags","port-filename":"/tmp/tmp586bghqd/port-6168.txt","pid":6168,"debug":false,"disable-analytics":false}
+{"time":"2024-09-26T18:08:13.66112903Z","level":"INFO","msg":"FeatureState","shutdownOnParentExitEnabled":false}
+{"time":"2024-09-26T18:08:13.661979363Z","level":"INFO","msg":"Will exit if parent process dies.","ppid":6168}
+{"time":"2024-09-26T18:08:13.661969217Z","level":"INFO","msg":"server is running","addr":{"IP":"127.0.0.1","Port":43071,"Zone":""}}
+{"time":"2024-09-26T18:08:13.857998352Z","level":"INFO","msg":"created new connection","id":"127.0.0.1:50862"}
+{"time":"2024-09-26T18:08:14.29644191Z","level":"INFO","msg":"connection init received","streamId":"1klxtkie","id":"127.0.0.1:50862"}
+{"time":"2024-09-26T18:08:14.296870522Z","level":"ERROR","msg":"error creating symlink","error":"symlink /root/.cache/wandb/logs/core-debug-20240926_180813.log /root/wandb/run-20240926_180814-1klxtkie/logs/debug-core.log: file exists"}
+{"time":"2024-09-26T18:08:14.300104442Z","level":"INFO","msg":"connection init completed","streamId":"1klxtkie","id":"127.0.0.1:50862"}
+{"time":"2024-09-27T00:54:24.403773763Z","level":"INFO","msg":"handle finish received","streamId":"1klxtkie","id":"127.0.0.1:50862"}
+{"time":"2024-09-27T00:54:24.933689321Z","level":"INFO","msg":"connection init received","streamId":"60260ulk","id":"127.0.0.1:50862"}
+{"time":"2024-09-27T00:54:24.934341547Z","level":"ERROR","msg":"error creating symlink","error":"symlink /root/.cache/wandb/logs/core-debug-20240926_180813.log /root/wandb/run-20240927_005424-60260ulk/logs/debug-core.log: file exists"}
+{"time":"2024-09-27T00:54:24.937048792Z","level":"INFO","msg":"connection init completed","streamId":"60260ulk","id":"127.0.0.1:50862"}
+{"time":"2024-09-27T07:40:10.740842849Z","level":"INFO","msg":"handle finish received","streamId":"60260ulk","id":"127.0.0.1:50862"}
+{"time":"2024-09-27T07:40:11.365393025Z","level":"INFO","msg":"connection init received","streamId":"gzu8f7wl","id":"127.0.0.1:50862"}
+{"time":"2024-09-27T07:40:11.365761867Z","level":"ERROR","msg":"error creating symlink","error":"symlink /root/.cache/wandb/logs/core-debug-20240926_180813.log /root/wandb/run-20240927_074011-gzu8f7wl/logs/debug-core.log: file exists"}
+{"time":"2024-09-27T07:40:11.368624142Z","level":"INFO","msg":"connection init completed","streamId":"gzu8f7wl","id":"127.0.0.1:50862"}
+{"time":"2024-09-27T14:25:58.663233862Z","level":"INFO","msg":"Parent process exited, terminating service process."}

.local/share/jupyter/nbextensions/addbefore/main.js

@@ -0,0 +1,42 @@
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'base/js/events',
+    'base/js/utils',
+], function(Jupyter, $, requirejs, events, configmod, utils) {
+    "use strict";
+
+    var load_extension = function() {
+             Jupyter.toolbar.add_buttons_group([
+                 Jupyter.keyboard_manager.actions.register ({
+                      'help'   : 'Insert Cell Above',
+                      'icon'   : 'fa-arrow-circle-o-up',
+                      'handler': function () {
+                                                    Jupyter.notebook.insert_cell_above('code');
+                                                    Jupyter.notebook.select_prev();
+                                                    Jupyter.notebook.focus_cell();
+                      }
+                 }, 'insert-cell-above', 'addbefore'),
+                 Jupyter.keyboard_manager.actions.register ({
+                      'help'   : 'Insert Cell Below',
+                      'icon'   : 'fa-arrow-circle-o-down',
+                      'handler': function () {
+                                                    Jupyter.notebook.insert_cell_below('code');
+                                                    Jupyter.notebook.select_next();
+                                                    Jupyter.notebook.focus_cell();
+                      }
+                 }, 'insert-cell-below', 'addbefore'),
+                 ]);
+             $('#insert_above_below').remove()
+
+    };
+
+
+
+    var extension = {
+        load_jupyter_extension : load_extension,
+        load_ipython_extension : load_extension
+    };
+    return extension;
+});

.local/share/jupyter/nbextensions/autosavetime/main.js

@@ -0,0 +1,81 @@
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/events'
+], function(
+    $,
+    IPython,
+    events
+) {
+    "use strict";
+
+    // define default values for config parameters
+    var params = {
+        autosavetime_set_starting_interval : false,
+        autosavetime_starting_interval : 2,
+        autosavetime_show_selector : true
+    };
+
+    // update params with any specified in the server's config file
+    var update_params = function() {
+        var config = IPython.notebook.config;
+        for (var key in params) {
+            if (config.data.hasOwnProperty(key))
+                params[key] = config.data[key];
+        }
+    };
+
+    var initialize = function () {
+        update_params();
+
+        var si = params.autosavetime_starting_interval;
+        var set_si = params.autosavetime_set_starting_interval;
+
+        if (params.autosavetime_show_selector) {
+            var select = $('<select class="ui-widget-content"/>');
+            select.change(function() {
+                 var interval = parseInt($(this).val(), 10) * 60 * 1000;
+                 IPython.notebook.set_autosave_interval(interval);
+            });
+
+            var thresholds = [0,2,5,10,15,20,30,60];
+
+            if (set_si && thresholds.indexOf(si) < 0) thresholds.push(si);
+
+            thresholds.sort(function(a, b) { return a-b; });
+
+            for (var i in thresholds) {
+                var thr = thresholds[i];
+                select.append($('<option/>').attr('value', thr).text(thr));
+            }
+
+            select.find('option[value="2"]').text('2 (default)');
+            select.find('option[value="0"]').text('off');
+
+            if (set_si) select.val(si);
+
+            IPython.toolbar.element.append(
+                $('<label class="navbar-text"/>').text('Autosave interval (min):')
+            ).append(select);
+        }
+
+        events.on("autosave_enabled.Notebook", function(event, value) {
+            if (set_si) {
+                IPython.notebook.set_autosave_interval(si * 60 * 1000);
+            }
+            else {
+                if (params.autosavetime_show_selector) {
+                    select.val(parseInt(value, 10) / 60 / 1000);
+                }
+            }
+        });
+    };
+
+    var load_ipython_extension = function() {
+        return IPython.notebook.config.loaded.then(initialize);
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/autoscroll/README.md

@@ -0,0 +1,22 @@
+autoscroll
+==========
+
+
+Description
+-----------
+
+Optionally set the output autoscroll threshold, and/or add a selector to the
+toolbar to set it, and/or add a toolbar button to enable/disable it.
+
+
+Parameters
+----------
+
+* `autoscroll_set_on_load` -
+  Set an autoscroll threshold on notebook load. If false, the default is unchanged.
+* `autoscroll_starting_threshold` -
+  Autoscroll threshold which would be set on notebook load. `-1` disables autoscrolling.
+* `autoscroll_show_selector` -
+  Add a selector to the toolbar to change the autoscroll threshold
+* `autoscroll_show_button` -
+  Add a button to the toolbar to disable/enable autoscrolling

.local/share/jupyter/nbextensions/autoscroll/autoscroll.yaml

@@ -0,0 +1,26 @@
+Type: IPython Notebook Extension
+Compatibility: 3.x, 4.x
+Name: Autoscroll
+Main: main.js
+Icon: icon.png
+Link: README.md
+Description: Optionally set the output autoscroll threshold, and/or add a selector to the toolbar to set it, and/or add a toolbar button to enable/disable it
+Parameters:
+- name: autoscroll_set_on_load
+  description: Set an autoscroll threshold on notebook load. If false, the default is unchanged.
+  input_type: checkbox
+  default: false
+- name: autoscroll_starting_threshold
+  description: Autoscroll threshold which would be set on notebook load. -1 disables autoscrolling.
+  input_type: number
+  min: -1
+  step: 1
+  default: 100
+- name: autoscroll_show_selector
+  description: add a selector to the toolbar to change the autoscroll threshold
+  input_type: checkbox
+  default: true
+- name: autoscroll_show_button
+  description: add a button to the toolbar to disable/enable autoscrolling
+  input_type: checkbox
+  default: false

.local/share/jupyter/nbextensions/cell_filter/README.md

@@ -0,0 +1,4 @@
+Cell filter
+===========
+
+An extension that allows you to filter cells by tags. Keywords entered into the search bar separated by spaces joins them with logical AND.

.local/share/jupyter/nbextensions/code_font_size/README.md

@@ -0,0 +1,4 @@
+Code Font Size
+==============
+
+Adds toolbar buttons to increase and decrease code's font size. This is useful, for example, when projecting the notebook.

.local/share/jupyter/nbextensions/code_prettify/README_autopep8.md

@@ -0,0 +1,136 @@
+jupyter-autopep8
+================
+
+This nbextension reformats/prettifies code in notebook python code cells.
+
+Under the hood, it uses a call to the current notebook kernel to reformat the
+code.
+The conversion run by the kernel uses the python [autopep8] package, and thus is compatible only with python kernels.
+
+The nbextension provides
+
+- a toolbar button (configurable to be added or not)
+
+- a keyboard shortcut for reformatting the current code-cell (default shortcut
+  is `Alt-A`, can also be configured not to add the keyboard shortcut).
+
+- a keyboard shortcut for reformatting the whole notebook (default shortcut
+  is `Alt-Shift-A`, can also be configured not to add the keyboard shortcut).
+
+Syntax needs to be correct, but the nbextension may be able to point out basic
+syntax errors.
+
+
+Prerequisites
+-------------
+
+Of course, you must have the necessary kernel-specific package installed for
+the prettifier call to work:
+
+    pip install autopep8
+
+
+Options
+-------
+
+All options are provided by the [KerneExecOnCells library] - see the
+[internals] section below for details.
+There are a few nbextension-wide options, configurable using the
+[jupyter_nbextensions_configurator] or by editing the `notebook` section config
+file directly.
+The options are as follows:
+
+- `autopep8.add_toolbar_button`:
+  Whether to add a toolbar button to transform the selected cell(s).
+  Defaults to `true`.
+
+- `autopep8.button_icon`:
+  A font-awesome class defining the icon used for the toolbar button and actions.
+  See [fontawesome] for available icon classes.
+  Defaults to `fa-cog`.
+
+- `autopep8.button_label`:
+  Toolbar button label text. Also used in the actions' help text.
+  Defaults to `Prettify (using autopep8)`.
+
+- `autopep8.register_hotkey`:
+  Whether to register hotkeys to transform the selected cell(s)/whole notebook.
+  Defaults to `true`.
+
+- `autopep8.hotkeys.process_all`:
+  Hotkey to use to transform all the code cells in the notebook.
+  Defaults to `Alt-Shift-A`.
+
+- `autopep8.hotkeys.process_selected`:
+  Hotkey to use to transform the selected cell(s).
+  Defaults to `Alt-A`.
+
+- `autopep8.show_alerts_for_not_supported_kernel`:
+  Whether to show alerts if the kernel is not supported.
+  Defaults to `false`.
+
+- `autopep8.show_alerts_for_errors`:
+  Whether to show alerts for errors in the kernel calls.
+  Defaults to `true`.
+
+- `autopep8.kernel_config_map_json`:
+  The value of this key is a string which can be parsed into a json object
+  giving the config for each kernel language.
+
+  The following give the per-kernel options of the parsed json, using the
+  language key `python `:
+
+  * `autopep8.kernel_config_map_json.python.library`:
+    String to execute in the kernel in order to load any necessary kernel
+    libraries.
+
+  * `autopep8.kernel_config_map_json.python.replacements_json_to_kernel`:
+    a list of pairs of strings, used as arguments to javascript's
+    `String.replace(from, to)` to translate from a json string into a valid
+    representation of the same string in the kernel language. Since json
+    strings are particularly simple, this can often (as with the python
+    language) be left as the default, an empty list.
+
+  * `autopep8.kernel_config_map_json.python.prefix` and
+    `autopep8.kernel_config_map_json.python.postfix`:
+    Strings added as bookends to the kernel string (translated from the json
+    string using the replacements above) to make up the kernel prettifier call
+    kernel's prettifier libraries.
+
+  * `autopep8.kernel_config_map_json.python.trim_formatted_text`:
+    Whether to trim whitespace from the transformed cell text. Since jupyter
+    cells don't usually have leading or trailing whitespace, the default
+    behaviour is to trim the transformed text, in order to prevent the
+    transform adding extra newlines at the end (a common behaviour for source
+    files, where having a trailing newline is often considered good practice).
+
+
+Internals
+---------
+
+Under the hood, this nbextension uses the [KerneExecOnCells library], a shared
+library for creating Jupyter nbextensions which transform code cell text using
+calls to the active kernel.
+
+See the [shared README] for the internal model used by the nbextension.
+
+
+History
+-------
+
+The project was forked by [@kenkoooo] from [@jfbercher]'s [code_prettify],
+retaining most of the code.
+
+It has since been altered to use the [KerneExecOnCells library], a shared
+library for creating Jupyter nbextensions which transform code cell text using
+calls to the active kernel.
+
+[@jfbercher]: https://github.com/jfbercher
+[@kenkoooo]: https://github.com/kenkoooo
+[autopep8]: https://github.com/hhatto/autopep8
+[code_prettify]: https://github.com/jfbercher/code_prettify
+[fontawesome]: https://fontawesome.com/icons
+[internals]: #Internals
+[jupyter_nbextensions_configurator]: https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator
+[KerneExecOnCells library]: README.md
+[shared README]: README.md

.local/share/jupyter/nbextensions/highlighter/export_highlights.tex

@@ -0,0 +1,457 @@
+
+% Default to the notebook output style
+
+
+% Inherit from the specified cell style.
+
+
+
+
+
+    
+\documentclass{article}
+
+    
+    
+
+    \usepackage{graphicx} % Used to insert images
+    \usepackage{adjustbox} % Used to constrain images to a maximum size 
+    \usepackage{color} % Allow colors to be defined
+    \usepackage{enumerate} % Needed for markdown enumerations to work
+    \usepackage{geometry} % Used to adjust the document margins
+    \usepackage{amsmath} % Equations
+    \usepackage{amssymb} % Equations
+    \usepackage{eurosym} % defines \euro
+    \usepackage[mathletters]{ucs} % Extended unicode (utf-8) support
+    \usepackage[utf8x]{inputenc} % Allow utf-8 characters in the tex document
+    \usepackage{fancyvrb} % verbatim replacement that allows latex
+    \usepackage{grffile} % extends the file name processing of package graphics 
+                         % to support a larger range 
+    % The hyperref package gives us a pdf with properly built
+    % internal navigation ('pdf bookmarks' for the table of contents,
+    % internal cross-reference links, web links for URLs, etc.)
+    \usepackage{hyperref}
+    \usepackage{longtable} % longtable support required by pandoc >1.10
+    \usepackage{booktabs}  % table support for pandoc > 1.12.2
+    
+\usepackage{color}
+\usepackage{soul}
+\usepackage[framemethod=tikz]{mdframed}
+
+
+    
+    
+    \definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
+    \definecolor{darkorange}{rgb}{.71,0.21,0.01}
+    \definecolor{darkgreen}{rgb}{.12,.54,.11}
+    \definecolor{myteal}{rgb}{.26, .44, .56}
+    \definecolor{gray}{gray}{0.45}
+    \definecolor{lightgray}{gray}{.95}
+    \definecolor{mediumgray}{gray}{.8}
+    \definecolor{inputbackground}{rgb}{.95, .95, .85}
+    \definecolor{outputbackground}{rgb}{.95, .95, .95}
+    \definecolor{traceback}{rgb}{1, .95, .95}
+    % ansi colors
+    \definecolor{red}{rgb}{.6,0,0}
+    \definecolor{green}{rgb}{0,.65,0}
+    \definecolor{brown}{rgb}{0.6,0.6,0}
+    \definecolor{blue}{rgb}{0,.145,.698}
+    \definecolor{purple}{rgb}{.698,.145,.698}
+    \definecolor{cyan}{rgb}{0,.698,.698}
+    \definecolor{lightgray}{gray}{0.5}
+    
+    % bright ansi colors
+    \definecolor{darkgray}{gray}{0.25}
+    \definecolor{lightred}{rgb}{1.0,0.39,0.28}
+    \definecolor{lightgreen}{rgb}{0.48,0.99,0.0}
+    \definecolor{lightblue}{rgb}{0.53,0.81,0.92}
+    \definecolor{lightpurple}{rgb}{0.87,0.63,0.87}
+    \definecolor{lightcyan}{rgb}{0.5,1.0,0.83}
+    
+    % commands and environments needed by pandoc snippets
+    % extracted from the output of `pandoc -s`
+    \providecommand{\tightlist}{%
+      \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
+    \DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
+    % Add ',fontsize=\small' for more characters per line
+    \newenvironment{Shaded}{}{}
+    \newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{{#1}}}}
+    \newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.56,0.13,0.00}{{#1}}}
+    \newcommand{\DecValTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\FloatTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\CharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}}
+    \newcommand{\StringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}}
+    \newcommand{\CommentTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textit{{#1}}}}
+    \newcommand{\OtherTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{{#1}}}
+    \newcommand{\AlertTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{{#1}}}}
+    \newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.02,0.16,0.49}{{#1}}}
+    \newcommand{\RegionMarkerTok}[1]{{#1}}
+    \newcommand{\ErrorTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{{#1}}}}
+    \newcommand{\NormalTok}[1]{{#1}}
+    
+    % Define a nice break command that doesn't care if a line doesn't already
+    % exist.
+    \def\br{\hspace*{\fill} \\* }
+    % Math Jax compatability definitions
+    \def\gt{>}
+    \def\lt{<}
+    % Document parameters
+    \title{export\_highlights}
+    
+    
+\author{}
+
+    
+
+    % Pygments definitions
+    
+\makeatletter
+\def\PY@reset{\let\PY@it=\relax \let\PY@bf=\relax%
+    \let\PY@ul=\relax \let\PY@tc=\relax%
+    \let\PY@bc=\relax \let\PY@ff=\relax}
+\def\PY@tok#1{\csname PY@tok@#1\endcsname}
+\def\PY@toks#1+{\ifx\relax#1\empty\else%
+    \PY@tok{#1}\expandafter\PY@toks\fi}
+\def\PY@do#1{\PY@bc{\PY@tc{\PY@ul{%
+    \PY@it{\PY@bf{\PY@ff{#1}}}}}}}
+\def\PY#1#2{\PY@reset\PY@toks#1+\relax+\PY@do{#2}}
+
+\expandafter\def\csname PY@tok@gp\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@no\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.53,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@il\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@sx\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kt\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.69,0.00,0.25}{##1}}}
+\expandafter\def\csname PY@tok@mo\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@sh\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@bp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@gd\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.63,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@sb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@err\endcsname{\def\PY@bc##1{\setlength{\fboxsep}{0pt}\fcolorbox[rgb]{1.00,0.00,0.00}{1,1,1}{\strut ##1}}}
+\expandafter\def\csname PY@tok@nd\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
+\expandafter\def\csname PY@tok@gr\endcsname{\def\PY@tc##1{\textcolor[rgb]{1.00,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kd\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@s\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@cs\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@sd\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@ss\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@nn\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@w\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.73,0.73}{##1}}}
+\expandafter\def\csname PY@tok@kn\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@sc\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@s1\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@ge\endcsname{\let\PY@it=\textit}
+\expandafter\def\csname PY@tok@cp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.74,0.48,0.00}{##1}}}
+\expandafter\def\csname PY@tok@gh\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@gi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.63,0.00}{##1}}}
+\expandafter\def\csname PY@tok@vc\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@si\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.53}{##1}}}
+\expandafter\def\csname PY@tok@ow\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
+\expandafter\def\csname PY@tok@vg\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@sr\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.53}{##1}}}
+\expandafter\def\csname PY@tok@cm\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@c\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@mi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@kc\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@ne\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.82,0.25,0.23}{##1}}}
+\expandafter\def\csname PY@tok@nf\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@go\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
+\expandafter\def\csname PY@tok@m\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@mh\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@nc\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@mb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@se\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.13}{##1}}}
+\expandafter\def\csname PY@tok@gt\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.27,0.87}{##1}}}
+\expandafter\def\csname PY@tok@nv\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@c1\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@kp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@s2\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@nb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@ni\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.60,0.60,0.60}{##1}}}
+\expandafter\def\csname PY@tok@k\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@na\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.49,0.56,0.16}{##1}}}
+\expandafter\def\csname PY@tok@o\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@mf\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@nl\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.63,0.63,0.00}{##1}}}
+\expandafter\def\csname PY@tok@nt\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@gs\endcsname{\let\PY@bf=\textbf}
+\expandafter\def\csname PY@tok@vi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@gu\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.50,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@kr\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+
+\def\PYZbs{\char`\\}
+\def\PYZus{\char`\_}
+\def\PYZob{\char`\{}
+\def\PYZcb{\char`\}}
+\def\PYZca{\char`\^}
+\def\PYZam{\char`\&}
+\def\PYZlt{\char`\<}
+\def\PYZgt{\char`\>}
+\def\PYZsh{\char`\#}
+\def\PYZpc{\char`\%}
+\def\PYZdl{\char`\$}
+\def\PYZhy{\char`\-}
+\def\PYZsq{\char`\'}
+\def\PYZdq{\char`\"}
+\def\PYZti{\char`\~}
+% for compatibility with earlier versions
+\def\PYZat{@}
+\def\PYZlb{[}
+\def\PYZrb{]}
+\makeatother
+
+
+
+    
+
+    
+    % Prevent overflowing lines due to hard-to-break entities
+    \sloppy 
+    % Setup hyperref package
+    \hypersetup{
+      breaklinks=true,  % so long urls are correctly broken across lines
+      colorlinks=true,
+      urlcolor=blue,
+      linkcolor=darkorange,
+      citecolor=darkgreen,
+      }
+    % Slightly bigger margins than the latex defaults
+    
+    \geometry{verbose,tmargin=1in,bmargin=1in,lmargin=1in,rmargin=1in}
+    
+    
+    \newcommand{\highlighta}[1]{{\sethlcolor{yellow} \textcolor{red}{\hl{#1}}}}
+    \newcommand{\highlightb}[1]{{\sethlcolor{red} \textcolor{yellow}{\hl{#1}}}}
+    \newcommand{\highlightc}[1]{{\sethlcolor{green} \textcolor{yellow}{\hl{#1}}}}
+    \newenvironment{highlightA}{\begin{mdframed}[hidealllines=true,backgroundcolor=yellow!20]}{\end{mdframed}}
+    \newenvironment{highlightB}{\begin{mdframed}[hidealllines=true,backgroundcolor=red!20]}{\end{mdframed}}
+    \newenvironment{highlightC}{\begin{mdframed}[hidealllines=true,backgroundcolor=green!20]}{\end{mdframed}}
+
+
+%\usepackage{foo}
+
+    \begin{document}
+    
+    
+    \maketitle
+    
+    
+
+    
+    \section{Exporting the notebook}\label{exporting-the-notebook}
+
+As suggested by @juhasch, it is interesting to keep the highlights when
+exporting the notebook to another format. We give and explain below some
+possibilities:
+
+    \subsection{Short version}\label{short-version}
+
+\begin{itemize}
+\item
+  Html export:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{nbconvert FILE  --config JUPYTER_DATA_DIR/extensions/highlight_html_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+\item
+  LaTeX export:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{nbconvert FILE  --config JUPYTER_DATA_DIR/extensions/highlight_latex_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+
+  where JUPYTER\_DATA\_DIR can be found from the output of
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{--paths}
+\end{Highlighting}
+\end{Shaded}
+
+  eg \texttt{\textasciitilde{}/.local/share/jupyter} in my case. Seems
+  to be
+  \texttt{c:\textbackslash{}users\textbackslash{}NAME\textbackslash{}AppData\textbackslash{}Roaming\textbackslash{}jupyter}
+  under Windows.
+\end{itemize}
+
+Examples can be found here: \href{tst_highlights.ipynb}{initial
+notebook}, \href{tst_highlights.html}{html version},
+\href{tst_highlights.pdf}{pdf version} (after an additional LaTeX
+\(\rightarrow\) pdf compilation).
+
+    \subsection{Html export}\label{html-export}
+
+This is quite easy. Actually, highlight formatting embedded in markdown
+cells is preserved while converting with the standard
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{jupyter} \NormalTok{nbconvert file.ipynb}
+\end{Highlighting}
+\end{Shaded}
+
+However, the css file is missing and must be added. Here we have several
+possibilities
+
+\begin{itemize}
+\item
+  Embed the css \emph{within} the notebook. For that, consider the last
+  cell of the present notebook. This code reads the css file
+  \texttt{highlighter.css} in the extension directory and displays the
+  corresponding style. So doing the
+  \texttt{\textless{}style\textgreater{}\ ...\textless{}/style\textgreater{}}
+  section will be present in the cell output and interpreted by the web
+  browser. Drawbacks of this solution is that user still have to execute
+  this cell and that the this is not language agnostic.
+\item
+  Use a \textbf{template file} to link or include the css file during
+  conversion. Such a file is provided as
+  \texttt{templates/highlighter.tpl}. It was choosen here to
+  \emph{include} the css content in the produced html file rather than
+  linking it. This avoids the necessity to keep the css file with the
+  html files.
+\item
+  This works directly if the css resides in the same directory as the
+  file the user is attempting to convert --thus requires the user to
+  copy \texttt{highlighter.css} in the current directory. Then the
+  conversion is simply
+
+\begin{Shaded}
+\begin{Highlighting}[]
+  \KeywordTok{jupyter} \NormalTok{nbconvert file.ipynb --template highlighter}
+\end{Highlighting}
+\end{Shaded}
+\item
+  It still remains two problems with this approach. First, it can be
+  annoying to have to systematically copy the css file in the current
+  directory. Second, the data within the html tags is not converted (and
+  thus markdown remains unmodified). A solution is to use a pair of
+  preprocessor/postprocessor that modify the html tags and enable the
+  subsequent markdown to html converter to operate on the included data.
+  Also, a config file is provided which redefines the template path to
+  enable direct inclusion of the css file in the extension directory.
+  Unfortunately, \highlighta{it seems that the \emph{full path} to
+  the config file has to be provided}. This file resides in the
+  extensions subdirectory of the jupyter\_data\_dir. The path can be
+  found by looking at the output of
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{--paths}
+\end{Highlighting}
+\end{Shaded}
+
+  Then the command to issue for converting the notebook to html is
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{nbconvert FILE  --config JUPYTER_DATA_DIR/extensions/highlight_html_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+\end{itemize}
+
+For instance
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{jupyter} \NormalTok{nbconvert tst_highlights.ipynb  --config ~/.local/share/jupyter/extensions/highlight_html_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+
+    \subsection{LaTeX export}\label{latex-export}
+
+This is a bit more complicated since the direct conversion removes all
+html formatting present in markdown cells. Thus use again a
+\textbf{preprocessor} which runs before the markdown \(\rightarrow\)
+LaTeX conversion. In turn, it appears that we also need to postprocess
+the result.
+
+Three LaTeX commands, namely \emph{highlighta, highlightb, highlightc},
+and three environments \emph{highlightA, highlightB, highlightC} are
+defined. Highlighting html markup is then transformed into the
+corresponding LaTeX commands and the text for completely highlighted
+cells is put in the adequate LaTeX environment.
+
+Pre and PostProcessor classes are defined in the file
+\texttt{pp\_highlighter.py} located in the \texttt{extensions}
+directory. A LaTeX template, that includes the necessary packages and
+the definitions of commands/environments is provides as
+\texttt{highlighter.tplx} in the template directory. The template
+inherits from \texttt{article.ltx}. For more complex scenarios,
+typically if the latex template file has be customized, the user shall
+modify its template or inherit from his base template rather than from
+article.
+
+Finally, a config file fixes the different options for the conversion.
+Then the command to issue is simply
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{nbconvert FILE  --config JUPYTER_DATA_DIR/extensions/highlight_latex_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+
+e.g.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{jupyter} \NormalTok{nbconvert tst_highlights.ipynb  --config ~/.local/share/jupyter/extensions/highlight_latex_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+
+    \subsection{Configuring paths}\label{configuring-paths}
+
+\highlighta{For those who do not have taken the extension from the
+\texttt{jupyter_contrib_nbextensions} repository or have not configured
+extensions via its \texttt{setup.py} utility,} a file
+\texttt{set\_paths.py} is present in the extension directory (it is
+merely a verbatim copy of the relevant parts in setup.py). This file
+configure the paths to the \texttt{templates} and \texttt{extension}
+directories. It should be executed by something like
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{python3} \NormalTok{set_paths.py}
+\end{Highlighting}
+\end{Shaded}
+
+Additionaly, you may also have to execute \texttt{mv\_paths.py} if you
+installed from the original repo via
+\texttt{jupyter\ nbextension\ install\ ..}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{python3} \NormalTok{mv_paths.py}
+\end{Highlighting}
+\end{Shaded}
+
+    \subsection{Example for embedding the css within the notebook before
+conversion}\label{example-for-embedding-the-css-within-the-notebook-before-conversion}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+>>> \PY{k+kn}{from} \PY{n+nn}{IPython}\PY{n+nn}{.}\PY{n+nn}{core}\PY{n+nn}{.}\PY{n+nn}{display} \PY{k}{import} \PY{n}{display}\PY{p}{,} \PY{n}{HTML}
+... \PY{k+kn}{from} \PY{n+nn}{jupyter\PYZus{}core}\PY{n+nn}{.}\PY{n+nn}{paths} \PY{k}{import} \PY{n}{jupyter\PYZus{}config\PYZus{}dir}\PY{p}{,} \PY{n}{jupyter\PYZus{}data\PYZus{}dir}
+... \PY{k+kn}{import} \PY{n+nn}{os}
+... \PY{n}{csspath}\PY{o}{=}\PY{n}{os}\PY{o}{.}\PY{n}{path}\PY{o}{.}\PY{n}{join}\PY{p}{(}\PY{n}{jupyter\PYZus{}data\PYZus{}dir}\PY{p}{(}\PY{p}{)}\PY{p}{,}\PY{l+s}{\PYZsq{}}\PY{l+s}{nbextensions}\PY{l+s}{\PYZsq{}}\PY{p}{,}
+...                        \PY{l+s}{\PYZsq{}}\PY{l+s}{highlighter}\PY{l+s}{\PYZsq{}}\PY{p}{,}\PY{l+s}{\PYZsq{}}\PY{l+s}{highlighter.css}\PY{l+s}{\PYZsq{}}\PY{p}{)}
+... \PY{n}{HTML}\PY{p}{(}\PY{l+s}{\PYZsq{}}\PY{l+s}{\PYZlt{}style\PYZgt{}}\PY{l+s}{\PYZsq{}}\PY{o}{+}\PY{n+nb}{open}\PY{p}{(}\PY{n}{csspath}\PY{p}{,} \PY{l+s}{\PYZdq{}}\PY{l+s}{r}\PY{l+s}{\PYZdq{}}\PY{p}{)}\PY{o}{.}\PY{n}{read}\PY{p}{(}\PY{p}{)}\PY{o}{+}\PY{l+s}{\PYZsq{}}\PY{l+s}{\PYZlt{}/style\PYZgt{}}\PY{l+s}{\PYZsq{}}\PY{p}{)}
+    \end{Verbatim}
+
+    
+    
+    \begin{verbatim}
+<IPython.core.display.HTML object>
+    \end{verbatim}
+
+    
+
+
+    % Add a bibliography block to the postdoc
+    
+    
+    
+    \end{document}

.local/share/jupyter/nbextensions/highlighter/highlighter.js

@@ -0,0 +1,378 @@
+/*
+Three different highlighting schemes "mark"|"burk"|"girk"|"birk"|"pirk" are defined in the css highlighter.css
+The following functions highlight the selected text, according to the scheme chosen by a menu button. More precisely, they replace selected text, both in edit or command mode, by 
+a span tag with a given class and the selected text as data.
+if no text is selected, then the whole cell is highlighted (using a div tag and a class corresponding to the chosen scheme). A function to remove all hihlightings is also provided. 
+*/
+
+function removeFullCellHighlight(cell_text) {
+    cell_text = cell_text.replace(/<div class=(?:"mark"|"burk"|"girk"|"birk"|"pirk")>\n([\s\S]*?)<\/div><i class="fa fa-lightbulb-o "><\/i>/g, function (w, g) {
+        return g
+    })
+    return cell_text
+}
+
+function fullCellHighlight(cell_text, scheme) {
+    cell_text = removeFullCellHighlight(cell_text);
+    return '<div class=' + '"' + scheme + '"' + '>\n' + cell_text + '</div><i class="fa fa-lightbulb-o "><\/i>'
+}
+
+function highlight(text, scheme) {
+    var scheme = scheme;
+    // replace by a span, wile preserving leading and trailing spaces
+    var rep = text.replace(/(\S[\S\s]*\S)/, function (w, internal_text) {
+        return '<span class=' + '"' + scheme + '"' + '>' + internal_text + '</span>'
+    })
+    return rep
+    //return '<span class='+'"'+scheme+'"'+'>'+text+'</span>'
+}
+
+
+function add_div(text) {
+    if (text.match(/^<div>([\S\s]*)<\/div>$/) == null) {
+        return '<div>' + text + '</div>'
+    } else {
+        return text
+    }
+}
+
+function rem_div(text) {
+    return text.replace(/^<div>([\S\s]*)<\/div>$/, function (w, g) {
+        return g
+    })
+}
+
+function highlightInCmdMode(event, scheme) {
+    var cell = IPython.notebook.get_selected_cell()
+    var cm = IPython.notebook.get_selected_cell().code_mirror
+    var selectedText = window.getSelection().toString();
+    var cell_text = cell.get_text();
+    if (selectedText.length == 0) {
+        cell_text = fullCellHighlight(cell_text, scheme);
+    } else {
+        var identifiedText = align(selectedText, cell_text);
+        cell_text = cell_text.replace(identifiedText, highlight(identifiedText, scheme));
+    }
+    cell.set_text(cell_text);
+    cell.render();
+    return false;
+}
+
+function highlightInEditMode(event, scheme) {
+    var cell = IPython.notebook.get_selected_cell()
+    var cm = cell.code_mirror
+    var selectedText = cm.getSelection()
+    if (selectedText.length == 0) {
+        var cell_text = cell.get_text();
+        cell_text = fullCellHighlight(cell_text, scheme);
+        cell.set_text(cell_text);
+    } else {
+        cm.replaceSelection(highlight(selectedText, scheme))
+    }
+    return false;
+}
+
+function removeHighlights() {
+    var cell = IPython.notebook.get_selected_cell();
+    var cell_text = removeFullCellHighlight(cell.get_text());
+    cell_text = cell_text.replace(/<span class=(?:"mark"|"burk"|"girk"|"birk"|"pirk")>([\s\S]*?)<\/span>/g,
+        function (w, g) {
+            return g
+        }
+    )
+    cell.set_text(cell_text)
+    cell.render();
+}
+
+//*****************************************************************************************
+// Utilitary functions for finding a candidate corresponding text from an unformatted selection
+
+/* In case of text selection in rendered cells, the returned text retains no formatting 
+therefore, when looking for this text in the actual formatted text, we need to do a 
+kind of "fuzzy" alignment. Though there exists specialized libraries for such task, 
+we have developed here a simple heuristics that should work 90% of the time, 
+but the problem cannot get a perfect solution. 
+A first point is to replace special characters that could be interpreded with 
+a special meaning in regular expressions. Then the idea is to find the exact matches 
+on the longest substring from the beginning of text, then the longest substring 
+from the end of the text. Finally, given the locations of the two substring, 
+we extract the corresponding global match in the original text. 
+*/
+function escapeRegExp(str) {
+    return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "#");
+    // return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+    return str
+}
+
+// Extract the longest matching substring from the beginning of the text
+function exsub_up(sub, text) {
+    for (k = 0; k <= sub.length; k++) {
+        if (text.match(sub.substr(0, k)) == null) {
+            k = k - 2
+            break
+        }
+    }
+    return text.match(sub.substr(0, k + 1))
+}
+
+// Extract the longest matching substring from the end of the text
+function exsub_down(sub, text) {
+    var L = sub.length
+    try {
+        for (k = 0; k <= sub.length; k++) {
+            tst = sub.substr(L - k - 1, L);
+            if (text.match(tst) == null) {
+                // console.log(tst)
+                k = k - 1
+                break
+            }
+        }
+        return text.match(sub.substr(L - k - 1, L))
+    } catch (e) {
+        console.log('Error', e)
+        return ""
+    }
+
+}
+
+// Function that tries to find the best match of the unformatted 
+// text in the formatted one. 
+
+function align(tofind, text) {
+
+    sub = escapeRegExp(tofind)
+    textModified = escapeRegExp(text)
+    //console.log(textModified.match(sub))
+    if (textModified.match(sub) == null) {
+        a = exsub_up(sub, textModified)
+        b = exsub_down(sub, textModified)
+        return text.substr(a.index, b.index + b[0].length - a.index)
+    } else {
+        var tmpMatch = textModified.match(sub)
+        return text.substr(tmpMatch.index, tmpMatch[0].length)
+    }
+}
+
+
+
+// ***************** Keyboard shortcuts ******************************
+
+var add_cmd_shortcuts = {
+    'Alt-g': {
+        help: 'highlight selected text',
+        help_index: 'ht',
+        handler: function (event) {
+            highlightInCmdMode("", mark);
+            return false;
+        }
+    },
+    'Alt-h': {
+        help: 'highlight selected text',
+        help_index: 'ht',
+        handler: function (event) {
+            highlightInCmdMode("", burk);
+            return false;
+        }
+    },
+};
+
+
+var add_edit_shortcuts = {
+    'Alt-g': {
+        help: 'highlight selected text',
+        help_index: 'ht',
+        handler: function (event) {
+            var highlight = mark;
+            highlightInEditMode("", mark);
+            return false;
+        }
+    },
+    'Alt-h': {
+        help: 'highlight selected text',
+        help_index: 'ht',
+        handler: function (event) {
+            var highlight = burk;
+            highlightInEditMode("", burk);
+            return false;
+        }
+    },
+};
+
+
+//******Toolbar buttons *************************************************
+
+function highlightText(scheme) {
+    var cell = IPython.notebook.get_selected_cell();
+    var rendered = cell.rendered;
+    if (rendered) highlightInCmdMode("", scheme);
+    else highlightInEditMode("", scheme);
+}
+
+
+function build_toolbar() {
+    var test = ' <div id="hgl" class="toolbar btn-group" role="toolbar"> \
+<button type="button" class="btn btn-default btn-group" id="higlighter_menu" href="#">\
+ <i id="menu-hgl" class="fa fa-caret-right"></i></button>\
+<div id="submenu" class="btn-group" style="font-weight:bold;margin-left:0" > \
+    <button type="button" class="btn btn-default highlighter-btn burk" style="font-weight:bold;margin-left:0"  href="#" id="b1"></button>\
+    <button type="button" class="btn btn-default highlighter-btn mark" style="font-weight:bold;margin-left:0"  href="#" id="b2"></button>\
+    <button type="button" class="btn btn-default highlighter-btn girk" style="font-weight:bold;margin-left:0"  href="#" id="b3"></button>\
+    <button type="button" class="btn btn-default highlighter-btn birk" style="font-weight:bold;margin-left:0"  href="#" id="b4"></button>\
+    <button type="button" class="btn btn-default highlighter-btn pirk" style="font-weight:bold;margin-left:0"  href="#" id="b5"></button>\
+<button type="button" class="btn btn-default" style="font-weight:bold;margin-left:0"\
+ href="#" id="remove_highlights">\<i class="fa fa-times highlighter-close"></i> </button></div>\
+                 </div>'
+
+
+    $("#maintoolbar-container").append(test);
+    $("#test").css({
+        'padding': '5px'
+    });
+
+    $("#submenu").hide(); // initially hide the submenu
+
+    //buttons initial css -- shall check if this is really necessary
+    // $("#higlighter_menu").css({
+    //     'padding': '2px 8px',
+    //     'display': 'inline-block',
+    //     'border': '1px solid',
+    //     'border-color': '#cccccc',
+    //     'font-weight': 'bold',
+    //     'text-align': 'center',
+    //     'vertical-align': 'middle',
+    //     'margin-left': '0px',
+    //     'margin-right': '0px'
+    // })
+
+
+    //Actions
+
+
+    $("#higlighter_menu")
+        .on('click', function () {
+            $("#submenu").toggle();
+            $("#menu-hgl").toggleClass("fa-caret-right")
+            $("#menu-hgl").toggleClass("fa-caret-left")
+        })
+        .attr('title', 'Highlight Selected Text');
+
+
+    $("#b1")
+        .on('click', function () {
+            highlightText("burk")
+        })
+        .on('mouseover', function () {
+            $("#b1").removeClass("btn btn-default").addClass("btn burk")
+            //.addClass("burk");
+        }) //!!
+        .on('mouseout', function () {
+            $("#b1").addClass("btn btn-default")
+        })
+
+
+    $("#b2")
+        .on('click', function () {
+            highlightText("mark")
+        })
+        .on('mouseover', function () {
+            $("#b2").removeClass("btn btn-default").addClass("btn mark")
+        }) //!!
+        .on('mouseout', function () {
+            $("#b2").addClass("btn btn-default")
+        })
+
+    $("#b3")
+        .on('click', function () {
+            highlightText("girk")
+        })
+        .on('mouseover', function () {
+            $(this).removeClass("btn btn-default").addClass("btn girk")
+        }) //!!
+        .on('mouseout', function () {
+            $(this).addClass("btn btn-default")
+        })
+
+    $("#b4")
+        .on('click', function () {
+            highlightText("birk")
+        })
+        .on('mouseover', function () {
+            $(this).removeClass("btn btn-default").addClass("btn birk")
+        }) //!!
+        .on('mouseout', function () {
+            $(this).addClass("btn btn-default")
+        })
+
+    $("#b5")
+        .on('click', function () {
+            highlightText("pirk")
+        })
+        .on('mouseover', function () {
+            $(this).removeClass("btn btn-default").addClass("btn pirk")
+        }) //!!
+        .on('mouseout', function () {
+            $(this).addClass("btn btn-default")
+        })
+
+
+    $("#remove_highlights")
+        .on('click', function () {
+            removeHighlights()
+        })
+        .attr('title', 'Remove highlightings in selected cell');
+} // end build_toolbar
+
+//******************************* MAIN FUNCTION **************************
+
+define(["require",
+    'base/js/namespace'
+], function (requirejs, Jupyter) {
+
+    var security = requirejs("base/js/security")
+
+    var load_css = function (name) {
+        var link = document.createElement("link");
+        link.type = "text/css";
+        link.rel = "stylesheet";
+        link.href = requirejs.toUrl(name);
+        document.getElementsByTagName("head")[0].appendChild(link);
+
+    };
+
+    //Load_ipython_extension
+    var load_ipython_extension = requirejs(['base/js/namespace'], function (Jupyter) {
+        "use strict";
+        if (Jupyter.version[0] < 3) {
+            console.log("This extension requires Jupyter or IPython >= 3.x")
+            return
+        }
+
+        console.log("[highlighter] Loading highlighter.css");
+        load_css('./highlighter.css')
+
+        IPython.keyboard_manager.edit_shortcuts.add_shortcuts(add_edit_shortcuts);
+        IPython.keyboard_manager.command_shortcuts.add_shortcuts(add_cmd_shortcuts);
+
+        build_toolbar();
+
+        var _on_reload = true; /* make sure cells render on reload */
+
+        //highlighter_init_cells(); /* initialize cells */
+
+
+        /* on reload */
+        $([Jupyter.events]).on('status_started.Kernel', function () {
+
+            //highlighter_init_cells();
+            console.log("[highlighter] reload...");
+            _on_reload = false;
+        })
+
+    }); //end of load_ipython_extension function
+
+    return {
+        load_ipython_extension: load_ipython_extension,
+    };
+}); //End of main function
+
+console.log("Loading ./highlighter.js");

.local/share/jupyter/nbextensions/highlighter/readme.md

@@ -0,0 +1,47 @@
+Highlighter
+===========
+
+- Firstable, the extension provides <span class="mark">several toolbar buttons</span> for highlighting a selected text _within a markdown cell_. Three different \`color schemes' are provided, which can be easily customized in the stylesheet `highlighter.css`. The last button enables to remove all highlightings in the current cell. 
+- This works both <span class="burk">when the cell is _rendered_ and when the cell is in edit mode</span>; 
+- In both modes, it is possible to highlight formatted portions of text (In rendered mode, since the selected text loose its formatting, an heuristic is applied to find the best alignment with the actual text)
+- When no text is selected, the whole cell is highlighted; 
+- The extension also provides two keyboard shortcuts (Alt-G and Alt-H) which fire the highlighting of the selected text. 
+- Highlights can be preserved when exporting to html or to LaTeX -- details are provided in [export_highlights](https://rawgit.com/jfbercher/small_nbextensions/master/usability/highlighter/export_highlights.html)
+
+
+![](image.gif)
+
+
+Installation
+------------
+
+The extension can be installed with the nice UI available on jupyter_nbextensions_configurator website, which also allows to enable/disable the extension.
+
+You may also install the extension from the original repo: issue
+
+```bash
+jupyter nbextension install https://rawgit.com/jfbercher/small_nbextensions/master/highlighter.zip  --user
+```
+at the command line.
+
+
+Testing
+-------
+
+Use a code cell with
+
+```python
+%%javascript
+require("base/js/utils").load_extensions("highlighter/highlighter")
+```
+
+
+Automatic load
+--------------
+
+You may also automatically load the extension for any notebook via
+
+```bash
+jupyter nbextension enable highlighter/highlighter
+```
+

.local/share/jupyter/nbextensions/hinterland/hinterland.js

@@ -0,0 +1,194 @@
+define([
+	'module',
+	'jquery',
+	'base/js/namespace',
+	'base/js/keyboard',
+	'notebook/js/cell',
+	'notebook/js/codecell',
+	'notebook/js/completer',
+], function (
+	module,
+	$,
+	Jupyter,
+	keyboard,
+	cell,
+	codecell,
+	completer
+) {
+	'use strict';
+
+	var Cell = cell.Cell;
+	var CodeCell = codecell.CodeCell;
+	var Completer = completer.Completer;
+
+	var log_prefix = '[' + module.id + ']';
+
+	// default config (updated on nbextension load)
+	var config = {
+		enable_at_start: true,
+		exclude_regexp: ':',
+		include_regexp: '',
+		tooltip_regexp: '\\(',
+		hint_delay: 20,
+		hint_inside_comments: false,
+	};
+	// flag denoting whether hinting is enabled
+	var do_hinting;
+
+	// ignore most specially-named keys
+	var specials = [
+		keyboard.keycodes.enter,
+		keyboard.keycodes.esc,
+		keyboard.keycodes.backspace,
+		keyboard.keycodes.tab,
+		keyboard.keycodes.up,
+		keyboard.keycodes.down,
+		keyboard.keycodes.left,
+		keyboard.keycodes.right,
+		keyboard.keycodes.shift,
+		keyboard.keycodes.ctrl,
+		keyboard.keycodes.alt,
+		keyboard.keycodes.meta,
+		keyboard.keycodes.capslock,
+		keyboard.keycodes.space,
+		keyboard.keycodes.pageup,
+		keyboard.keycodes.pagedown,
+		keyboard.keycodes.end,
+		keyboard.keycodes.home,
+		keyboard.keycodes.insert,
+		keyboard.keycodes.delete,
+		keyboard.keycodes.numlock,
+		keyboard.keycodes.f1,
+		keyboard.keycodes.f2,
+		keyboard.keycodes.f3,
+		keyboard.keycodes.f4,
+		keyboard.keycodes.f5,
+		keyboard.keycodes.f6,
+		keyboard.keycodes.f7,
+		keyboard.keycodes.f8,
+		keyboard.keycodes.f9,
+		keyboard.keycodes.f10,
+		keyboard.keycodes.f11,
+		keyboard.keycodes.f12,
+		keyboard.keycodes.f13,
+		keyboard.keycodes.f14,
+		keyboard.keycodes.f15
+	];
+
+	/**
+	 * copied from base/js/keyboard, since it isn't exported
+	 * Return `true` if the event only contains modifiers keys.
+	 * false otherwise
+	 **/
+	function only_modifier_event (event) {
+		var key = keyboard.inv_keycodes[event.which];
+		return (
+			(event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) &&
+			(key === 'alt'|| key === 'ctrl'|| key === 'meta'|| key === 'shift')
+		);
+	}
+
+	function patch_cell_keyevent () {
+		console.log(log_prefix, 'patching Cell.prototype.handle_codemirror_keyevent');
+		var orig_handle_codemirror_keyevent = Cell.prototype.handle_codemirror_keyevent;
+		Cell.prototype.handle_codemirror_keyevent = function (editor, event) {
+			if (do_hinting && (this instanceof CodeCell) && !only_modifier_event(event)) {
+				// Tab completion.
+				this.tooltip.remove_and_cancel_tooltip();
+				// don't attempt completion when selecting, or when using multicursor
+				if (    !editor.somethingSelected() &&
+						editor.getSelections().length <= 1 &&
+						!this.completer.visible &&
+						specials.indexOf(event.keyCode) == -1) {
+					var cell = this;
+					// set a timeout to try to ensure that CodeMirror inserts
+					// the new key *before* the completion request happens
+					setTimeout(function () {
+						var cur = editor.getCursor();
+						var pre_cursor = editor.getRange({
+							line: cur.line,
+							ch: cur.ch - 1
+						}, cur);
+						if (	pre_cursor !== '' &&
+								(config.hint_inside_comments || editor.getTokenAt(cur).type !== "comment") &&
+								(config.include_regexp.test(pre_cursor) || config.tooltip_regexp.test(pre_cursor)) &&
+								!config.exclude_regexp.test(pre_cursor) ) {
+							if (config.tooltip_regexp.test(pre_cursor)) {
+								cell.tooltip.request(cell);
+							}
+							else {
+								cell.completer.startCompletion();
+								cell.completer.autopick = false;
+							}
+						}
+					}, config.hint_delay);
+				}
+			}
+			return orig_handle_codemirror_keyevent.apply(this, arguments);
+		};
+	}
+
+	function set_hinterland_state (new_state) {
+		do_hinting = new_state;
+		$('.hinterland-toggle > .fa')
+			.toggleClass('fa-check', do_hinting);
+		console.log(log_prefix, 'continuous hinting', do_hinting ? 'on' : 'off');
+	}
+
+	function toggle_hinterland () {
+		set_hinterland_state(!do_hinting);
+	}
+
+	function add_menu_item () {
+		if ($('#help_menu').find('.hinterland_toggle').length > 0) {
+			return;
+		}
+		var menu_item = $('<li/>')
+			.insertAfter('#keyboard_shortcuts');
+		var menu_link = $('<a/>')
+			.text('Continuous hints')
+			.addClass('hinterland-toggle')
+			.attr('title', 'Provide continuous code hints')
+			.on('click', toggle_hinterland)
+			.appendTo(menu_item);
+		$('<i/>')
+			.addClass('fa menu-icon pull-right')
+			.prependTo(menu_link);
+	}
+
+	function load_notebook_extension () {
+		
+		Jupyter.notebook.config.loaded.then(function on_success () {
+			$.extend(true, config, Jupyter.notebook.config.data.hinterland);
+			// special defaults:
+			// default include is taken from Completer, rather than the blank
+			if (config.include_regexp === '') {
+				config.include_regexp = Completer.reinvoke_re;
+			}
+			// now turn regexps loaded from config (which will be strings) into
+			// actual RegExp objects.
+			var regexp_names = ['exclude_regexp', 'include_regexp', 'tooltip_regexp'];
+			for (var ii=0; ii < regexp_names.length; ii++) {
+				if (config[regexp_names[ii]] === '') {
+					continue;
+				}
+				try {
+					config[regexp_names[ii]] = new RegExp(config[regexp_names[ii]]);
+				}
+				catch (err) {
+					console.warn(log_prefix, 'error parsing', regexp_names[ii] + ':', err);
+				}
+			}
+		}, function on_error (err) {
+			console.warn(log_prefix, 'error loading config:', err);
+		}).then(function on_success () {
+			patch_cell_keyevent();
+			add_menu_item();
+			set_hinterland_state(config.enable_at_start);
+		});
+	}
+
+	return {
+		load_ipython_extension : load_notebook_extension
+	};
+});

.local/share/jupyter/nbextensions/move_selected_cells/README.md

@@ -0,0 +1,12 @@
+# Move selected cells
+
+This is a quick (and dirty) extension - move up or down several selected cell*s*. Moving cells or series of cells via simple keystrokes can be super useful. 
+Note: Alternatively, it is now possible to use the `keyboard_shortcut_editor` to bind the move cell up & move cell down actions to Alt-up and Alt-down (or anything else).
+
+Initial version for Jupyter 4.0: a bit dirty because it would be better to act on DOM elements and write a correct move_cells() function. 
+New version, updated to Jupyter 4.2+, now takes advantage of `Jupyter.notebook.move_selection_{down, up}` new functions
+
+
+Keyboard shortcuts: *Alt-up* and *Alt-down* (works also with single cells!)
+
+**Cell selection**: Cells can be selected using the rubberband (if this extension is enabled) or via Shift-up/Shift-down or Shift-K/Shift-J

.local/share/jupyter/nbextensions/move_selected_cells/move_selected_cells.yaml

@@ -0,0 +1,6 @@
+Type: IPython Notebook Extension
+Name: Move selected cells
+Description: Move selected cell*s* using keybaord shortcuts Alt-up and Alt-down
+Link: README.md
+Main: main.js
+Compatibility: 4.x, 5.x

.local/share/jupyter/nbextensions/python-markdown/main.js

@@ -0,0 +1,212 @@
+// Allow Python-code in markdown cells
+// Encapsulate using {{...}}
+// - You can also return html or markdown from your Python code
+// - You can embed images, however they will be sanitized on reload.
+
+// TODO: Markdown cells will only be reevaluated when a notebook is dirty
+//       (i.e. you have made changes). If you save it before reevaluating MD cells,
+//       they will show the old value.
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'notebook/js/cell',
+    'base/js/security',
+    'components/marked/lib/marked',
+    'base/js/events',
+    'notebook/js/textcell'
+], function(IPython, $, requirejs, cell, security, marked, events, textcell) {
+    "use strict";
+
+    /*
+     * Find Python expression enclosed in {{ }}, execute and add to text as
+     * <span> tags. The actual content gets filled in later by a callback.
+     * Already executed expressions are cached in cell metadata.
+     *
+     * @method execute_python
+     * @param cell {Cell} notebook cell
+     * @param text {String} text in cell
+     */
+    var execute_python = function(cell,text) {
+        /* never execute code in untrusted notebooks */
+        if (IPython.notebook.trusted === false ) {
+            return undefined
+        }
+        /* always clear stored variables if notebook is dirty */
+        if (IPython.notebook.dirty === true ) delete cell.metadata.variables;
+        // search for code in double curly braces: {{}}
+        var found = false;
+        var newtext = text.replace(/{{(.*?)}}/g, function(match,tag,cha) {
+            found = true;
+            if (tag === "") return undefined;
+            var code = tag;
+            var id = 'python_'+cell.cell_id+'_'+cha; /* create an individual ID */
+            var thiscell = cell;
+            var thismatch = tag;
+
+            /* there a two possible options:
+               a) notebook dirty or variable not stored in metadata: evaluate variable
+               b) notebook clean and variable stored in metadata: display stored value
+            */
+            if (typeof cell.metadata.variables === "undefined") {
+                cell.metadata.variables = {}
+            }
+            var val = cell.metadata.variables[thismatch];
+            if (IPython.notebook.dirty === true || val === undefined || jQuery.isEmptyObject(val)) {
+                cell.metadata.variables[thismatch] = {};
+                var execute_callback = function (out_data)
+                        {
+                        var html;
+                        if (out_data.msg_type === "error") {
+                            var text = "**" + out_data.content.ename + "**: " +  out_data.content.evalue;
+                            html = marked(text);
+                        } else if (out_data.msg_type === "stream") {
+                            html = marked(out_data.content.text);
+                            var t = html.match(/^\s*<p>([\s\S]*?)<\/p>\s*$/); //strip <p> and </p> that marked (maybe) adds and we don't want
+                            html = t !== null ? t[1] : html;
+                            var q = html.match(/^&#39;([\s\S]*?)&#39;$/); // strip quotes from strings
+                            if (q !== null) html = q[1]
+                        } else if (out_data.msg_type === "execute_result" | out_data.msg_type === "display_data" ) {
+                            var ul = out_data.content.data;
+                            if (ul != undefined) {
+                                if (ul['text/latex'] != undefined) {
+                                    html = ul['text/latex'];
+                                } else if (ul['image/svg+xml'] != undefined) {
+                                    var svg = ul['image/svg+xml'];
+                                    /* embed SVG in an <img> tag, still get eaten by sanitizer... */
+                                    svg = btoa(svg);
+                                    html = '<img src="data:image/svg+xml;base64,' + svg + '"/>';
+                                } else if (ul['image/jpeg'] != undefined) {
+                                    var jpeg = ul['image/jpeg'];
+                                    html = '<img src="data:image/jpeg;base64,' + jpeg + '"/>';
+                                } else if (ul['image/png'] != undefined) {
+                                    var png = ul['image/png'];
+                                    html = '<img src="data:image/png;base64,' + png + '"/>';
+                                } else if (ul['text/markdown'] != undefined) {
+                                    html = marked(ul['text/markdown']);
+                                } else if (ul['text/html'] != undefined) {
+                                    html = ul['text/html'];
+                                } else {
+                                    html = marked(ul['text/plain']);
+                                    // [\s\S] is used to also catch newlines
+                                    var t = html.match(/^\s*<p>([\s\S]*?)<\/p>\s*$/); //strip <p> and </p> that marked adds and we don't want
+                                    html = t !== null ? t[1] : html;
+                                    var q = html.match(/^&#39;([\s\S]*?)&#39;$/); // strip quotes from strings
+                                    if (q !== null) html = q[1]
+                                }
+                            }
+                        } else {
+                            return;
+                        }
+                        thiscell.metadata.variables[thismatch] = html;
+                        var el = document.getElementById(id);
+                        el.innerHTML = el.innerHTML + html; // output result
+                    };
+                var callbacks = { iopub : { output: execute_callback } };
+                if (cell.notebook.kernel != null) {
+                    cell.notebook.kernel.execute(code, callbacks, {silent: false, store_history : false, stop_on_error: false });
+                    return "<span id='"+id+"'></span>"; // add HTML tag with ID where output will be placed
+                    }
+                return undefined;
+            } else {
+                /* Notebook not dirty: replace tags with metadata */
+                val = cell.metadata.variables[tag];
+                return "<span id='"+id+"'>"+val+"</span>"
+            }
+        });
+        if (found == true) return newtext;
+        return undefined
+    };
+
+    /*
+     * Render markdown cell and replace {{...}} with python code
+     *
+     */
+    var render_cell = function(cell) {
+        var element = cell.element.find('div.text_cell_render');
+        var text = execute_python(cell, element[0].innerHTML);
+        if (text !== undefined) {
+            element[0].innerHTML = text;
+            MathJax.Hub.Queue(["Typeset",MathJax.Hub,element[0]]);
+        }
+    };
+
+	/* force rendering of markdown cell if notebook is dirty */
+	var original_render = textcell.MarkdownCell.prototype.render;
+	textcell.MarkdownCell.prototype.render = function() {
+		if (IPython.notebook.dirty === true) {
+			this.rendered = false
+		}
+		return original_render.apply(this)
+	};
+
+    var set_trusted_indicator = function() {
+        var ind = $('.notebook-trusted');
+        if (IPython.notebook.trusted === true) {
+            ind.attr('title','Notebook is trusted');
+            ind.removeClass('fa-question');
+            ind.addClass('fa-check');
+        } else {
+            ind.attr('title','Notebook is not trusted');
+            ind.removeClass('fa-check');
+            ind.addClass('fa-question');
+        }
+    };
+
+
+   /**
+     * Add CSS file
+     *
+     * @param name filename
+     */
+    var load_css = function (name) {
+        var link = document.createElement("link");
+        link.type = "text/css";
+        link.rel = "stylesheet";
+        link.href = requirejs.toUrl(name);
+        document.getElementsByTagName("head")[0].appendChild(link);
+    };
+
+
+   /**
+     * Update all references variables in markdown cells
+     *
+     */
+   var update_md_cells = function () {
+       var ncells = IPython.notebook.ncells();
+       var cells = IPython.notebook.get_cells();
+       for (var i = 0; i < ncells; i++) {
+           var cell = cells[i];
+           if (cell.metadata.hasOwnProperty('variables')) {
+               render_cell(cell)
+           }
+       }
+   };
+
+    var load_ipython_extension = function() {
+        load_css('./main.css');
+        events.on("rendered.MarkdownCell", function (event, data) {
+            render_cell(data.cell);
+        });
+        events.on("trust_changed.Notebook", set_trusted_indicator);
+
+        $('#save_widget').append('<i id="notebook-trusted-indicator" class="fa fa-question notebook-trusted" />');
+        set_trusted_indicator();
+
+        /* Show values stored in metadata on reload */
+        events.on("kernel_ready.Kernel", function () {
+            if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+                update_md_cells()
+            } else {
+                events.on("notebook_loaded.Notebook", function () {
+                    update_md_cells()
+                })
+            }
+        });
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/rubberband/rubberband.yaml

@@ -0,0 +1,7 @@
+Type: IPython Notebook Extension
+Name: Rubberband
+Description: The rubberband extension allows selecting multiple cells
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x, 5.x

.local/share/jupyter/nbextensions/ruler/edit.js

@@ -0,0 +1,4 @@
+define(['./main'], function (ruler) {
+    "use strict";
+    return ruler;
+});

.local/share/jupyter/nbextensions/ruler/main.js

@@ -0,0 +1,124 @@
+// Add rulers to codecells
+define([
+    'base/js/namespace',
+    'base/js/events',
+    'services/config',
+    'notebook/js/codecell',
+    'codemirror/lib/codemirror',
+    'codemirror/addon/display/rulers'
+], function (Jupyter, events, configmod, codecell, codemirror) {
+    "use strict";
+
+    var log_prefix = '[ruler]';
+
+    // define default config parameter values
+    var params = {
+        ruler_column: [78],
+        ruler_color: ["#ff0000"],
+        ruler_linestyle: ["dashed"],
+        ruler_do_css_patch: false
+    };
+
+
+    var rulers = [];
+
+    var isNumber = function (n) {
+        return !isNaN(parseFloat(n)) && isFinite(n);
+    };
+
+    // updates default params with any specified in the provided config data
+    var update_params = function (config_data) {
+        for (var key in params) {
+            if (config_data.hasOwnProperty(key)) {
+                params[key] = config_data[key];
+            }
+        }
+    };
+
+    var on_config_loaded = function () {
+
+        if (Jupyter.notebook !== undefined) {
+            var i, config = Jupyter.notebook.config;
+        } else {
+            var i, config = Jupyter.editor.config;
+        }
+
+        if (config.data.hasOwnProperty('ruler_color') && config.data.ruler_color.length > 0) {
+            params.ruler_color = config.data.ruler_color;
+        }
+
+        if (config.data.hasOwnProperty('ruler_column')) {
+            var new_columns = [];
+            for (i in config.data.ruler_column) {
+                if (isNumber(config.data.ruler_column[i])) {
+                    new_columns.push(config.data.ruler_column[i]);
+                }
+            }
+            if (new_columns.length > 0) {
+                params.ruler_column = new_columns;
+            }
+        }
+
+        if (config.data.hasOwnProperty('ruler_linestyle') && config.data.ruler_linestyle.length > 0) {
+            params.ruler_linestyle = config.data.ruler_linestyle;
+        }
+
+        for (i in params.ruler_column) {
+            rulers.push({
+                color: params.ruler_color[i % params.ruler_color.length],
+                column: params.ruler_column[i],
+                lineStyle: params.ruler_linestyle[i % params.ruler_linestyle.length]
+            });
+        }
+        console.debug(log_prefix, 'ruler specs:', rulers);
+
+        if (Jupyter.notebook !== undefined) {
+            var i, config = Jupyter.notebook.config;
+
+            // Change default for new cells
+            codecell.CodeCell.options_default.cm_config.rulers = rulers;
+            // Apply to any already-existing cells
+            var cells = Jupyter.notebook.get_cells().forEach(function (cell) {
+                if (cell instanceof codecell.CodeCell) {
+                    cell.code_mirror.setOption('rulers', rulers);
+                }
+            });
+
+        }
+        else {
+            Jupyter.editor.codemirror.setOption('rulers', rulers);
+        }
+    };
+
+    var load_extension = function () {
+
+        // first, check which view we're in, in order to decide whether to load
+        var conf_sect;
+        if (Jupyter.notebook) {
+            // we're in notebook view
+            conf_sect = Jupyter.notebook.config;
+        }
+        else if (Jupyter.editor) {
+            // we're in file-editor view
+            conf_sect = Jupyter.editor.config;
+        }
+        else {
+            // we're some other view like dashboard, terminal, etc, so bail now
+            return;
+        }
+
+        conf_sect.loaded
+            .then(function () {
+                update_params(conf_sect.data);
+            })
+            .then(on_config_loaded)
+            .catch(function on_error(reason) {
+                console.warn(log_prefix, 'error:', reason);
+            });
+    };
+
+    var extension = {
+        load_ipython_extension: load_extension
+    };
+    return extension;
+});

.local/share/jupyter/nbextensions/runtools/gutter.css

@@ -0,0 +1,3 @@
+.CodeMirror-cellstate {
+  width: 0.5em;
+}

.local/share/jupyter/nbextensions/runtools/main.js

@@ -0,0 +1,745 @@
+// Extended code execution commands and more
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'base/js/events',
+    'services/config',
+    'base/js/utils',
+    'notebook/js/codecell'
+], function(Jupyter, $, requirejs, events, configmod, utils, codecell) {
+    "use strict";
+
+    var run_list = []; /* list of cells to be run */
+
+    // define default config parameter values
+    var params = {
+        run_cells_above: 'Alt-a',
+        run_cells_below: 'Alt-b',
+        toggle_marker: 'Alt-t',
+        mark_all_codecells: 'Alt-m',
+        unmark_all_codecells: 'Alt-u',
+        run_marked_cells: 'Alt-r',
+        run_all_cells: 'Alt-x',
+        run_all_cells_ignore_errors: 'Alt-f',
+        stop_execution: 'Ctrl-c',
+        marked_color: '#20f224',
+        scheduled_color: '#00def0',
+        run_color: '#f30a2d'
+    };
+
+    /**
+     * Add event if user clicks on codemirror gutter
+     *
+     */
+    function add_gutter_events() {
+        var ncells = Jupyter.notebook.ncells();
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < ncells; i++) {
+            var cell = cells[i];
+            if ((cell.cell_type === "code")) {
+                cell.code_mirror.on("gutterClick", changeEvent);
+                if (is_marked(cell)) {
+                    var g = cell.code_mirror.getGutterElement();
+                    $(g).css({
+                        "background-color": params.marked_color
+                    });
+                }
+            }
+        }
+    }
+
+    /*
+     * Initialize toolbar and gutter after config was loaded
+     */
+    function initialize() {
+        $.extend(true, params, Jupyter.notebook.config.data.runtools);
+
+        add_gutter_events();
+
+        /* Add run control buttons to toolbar */
+        $(Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register ({
+                help: 'Toggle Runtools Toolbar',
+                icon: 'fa-cogs',
+                handler: toggle_toolbar
+            }, 'toggle-runtools-toolbar', 'runtools')
+        ])).find('.btn').attr('id', 'toggle_runtools').css({
+            'outline': 'none'
+        });
+
+        /* Add keyboard shortcuts */
+        var add_command_shortcuts = {};
+        add_command_shortcuts[params["run_cells_above"]] = {
+            help: 'Run cells above',
+            help_index: 'xa',
+            handler: function() {
+                execute_cells_above();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["run_cells_below"]] = {
+            help: 'Run cells below',
+            help_index: 'aa',
+            handler: function() {
+                execute_cells_below();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["toggle_marker"]] = {
+            help: 'Toggle marker',
+            help_index: 'mt',
+            handler: function() {
+                toggle_marker();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["mark_all_codecells"]] = {
+            help: 'Mark all codecells',
+            help_index: 'ma',
+            handler: function() {
+                mark_all();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["unmark_all_codecells"]] = {
+            help: 'Unmark all codecells',
+            help_index: 'mu',
+            handler: function() {
+                mark_none();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["run_marked_cells"]] = {
+            help: 'Run marked cells',
+            help_index: 'rm',
+            handler: function() {
+                run_marked_cells();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["run_all_cells"]] = {
+            help: 'Run all cells',
+            help_index: 'ra',
+            handler: function() {
+                var pos = Jupyter.notebook.element.scrollTop();
+                execute_all_cells();
+                Jupyter.notebook.element.animate({
+                    scrollTop: pos
+                }, 100);
+                return false;
+            }
+        };
+        add_command_shortcuts[params["run_all_cells_ignore_errors"]] = {
+            help: 'Run all cells - ignore errors',
+            help_index: 'rf',
+            handler: function() {
+                run_all_cells_ignore_errors();
+                return false;
+            }
+        };
+        Jupyter.keyboard_manager.command_shortcuts.add_shortcuts(add_command_shortcuts);
+        Jupyter.keyboard_manager.edit_shortcuts.add_shortcuts(add_command_shortcuts);
+
+        events.on('finished_execute.CodeCell', finished_execute_event);
+    }
+
+    /**
+     * Hide or show a cell
+     *
+     * @param cell
+     * @param io 'i' for cell input, 'o' for cell output
+     * @param showme {Boolean} show (true) or hide (false) cell
+     */
+    function showCell(cell, io, showme) {
+        if (io === 'i') {
+            if (showme === true) {
+                cell.element.find("div.input").show();
+                cell.metadata.hide_input = false;
+            } else {
+                cell.element.find("div.input").hide();
+                cell.metadata.hide_input = true;
+            }
+        } else {
+            if (showme === true) {
+                cell.element.find('div.output').show();
+                cell.metadata.hide_output = false;
+            } else {
+                cell.element.find('div.output').hide();
+                cell.metadata.hide_output = true;
+            }
+        }
+    }
+
+    function _show_input_output_of_marked(show, char) {
+        var cells = Jupyter.notebook.get_cells();
+        var ncells = cells.length;
+        for (var i = 0; i < ncells; i++) {
+            var _cell = cells[i];
+            if (is_marked(_cell))
+                showCell(_cell, char, show);
+        }
+    }
+
+    /**
+     * Hide or show input of all marked code cells
+     *
+     * @param show {Boolean} show (true) or hide (false) code cells
+     */
+    function show_input(show) {
+        _show_input_output_of_marked(show, 'i');
+    }
+
+    /**
+     * Hide or show output area of all marked code cells
+     *
+     * @param {Boolean} show show (true) or hide (false)
+     */
+    function show_output(show) {
+        _show_input_output_of_marked(show, 'o');
+    }
+
+
+    /**
+     * Execute next cell in run list, if it is still marked
+     *
+     */
+    function execute_next_marked_cell() {
+        var cells = Jupyter.notebook.get_cells();
+        var end = cells.length;
+        while (run_list.length > 0) {
+            var runcell = run_list.shift();
+            for (var i = 0; i < end; i++) {
+                if (runcell === cells[i]) {
+                    if (runcell.metadata.run_control !== undefined && runcell.metadata.run_control.marked === true) {
+                        var g = runcell.code_mirror.getGutterElement();
+                        $(g).css({
+                            "background-color": params.run_color
+                        });
+                        runcell.execute();
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    function _execute_without_selecting(idx_start, idx_end, stop_on_error) {
+        // notebook.execute_cells alters selection, this doesn't
+        var cells = Jupyter.notebook.get_cells();
+        idx_start = idx_start !== undefined ? idx_start : 0;
+        idx_end = idx_end !== undefined ? idx_end : cells.length;
+        for (var ii = idx_start; ii < idx_end; ii++) {
+            cells[ii].execute(stop_on_error);
+        }
+    }
+
+    function execute_cells_above() {
+        _execute_without_selecting(0, Jupyter.notebook.get_selected_index());
+    }
+
+    function execute_cells_below() {
+        _execute_without_selecting(Jupyter.notebook.get_selected_index(), undefined);
+    }
+
+    function execute_all_cells(stop_on_error) {
+        _execute_without_selecting(0, undefined, stop_on_error);
+    }
+
+    /**
+     * Run code cells marked in metadata
+     *
+     */
+    function run_marked_cells() {
+        var cells = Jupyter.notebook.get_cells();
+        var end = cells.length;
+        run_list = [];
+        /* Show all marked cells as scheduled to be run with new gutter background color  */
+        for (var i = 0; i < end; i++) {
+            var cell = cells[i];
+            if (cell instanceof codecell.CodeCell) {
+                var last_line = cell.code_mirror.lastLine();
+                var cell_empty = ( last_line === 0 && cell.code_mirror.getLine(last_line) === "");
+                if (cell.metadata.run_control !== undefined && cell_empty === false) {
+                    if (cell.metadata.run_control.marked === true) {
+                        var g = cell.code_mirror.getGutterElement();
+                        $(g).css({
+                            "background-color": params.scheduled_color
+                        });
+                        run_list.push(cell);
+                    }
+                }
+            }
+        }
+        execute_next_marked_cell();
+    }
+
+    /*
+     * Execute next cell in run_list when notified execution of last cell has been finished
+     * @param evt Event
+     * @param data Cell that has finished executing
+     */
+    var finished_execute_event = function(evt, data) {
+        var cell = data.cell;
+        /* Reset gutter color no non-queued state */
+        if (is_marked(cell)) {
+            var g = cell.code_mirror.getGutterElement();
+            $(g).css({
+                "background-color": params.marked_color
+            });
+        }
+        execute_next_marked_cell();
+    };
+
+    /**
+     *
+     * @param cell
+     * @param value
+     */
+    function setCell(cell, value) {
+        if (!(cell instanceof codecell.CodeCell)) return;
+        if (cell.metadata.run_control === undefined) cell.metadata.run_control = {};
+        if (cell.metadata.run_control.marked === undefined) cell.metadata.run_control.marked = false;
+        if (value === undefined) value = !cell.metadata.run_control.marked;
+        var g = cell.code_mirror.getGutterElement();
+        if (value === false) {
+            cell.metadata.run_control.marked = false;
+            $(g).css({
+                "background-color": ""
+            });
+        } else {
+            cell.metadata.run_control.marked = true;
+            $(g).css({
+                "background-color": params.marked_color
+            });
+        }
+    }
+
+    function setCellsMarked(cells, value) {
+        var ncells = cells.length;
+        for (var i = 0; i < ncells; i++) {
+            setCell(cells[i], value);
+        }
+    }
+
+    /**
+     * Toggle code cell marker
+     */
+    function toggle_marker() {
+        setCellsMarked(Jupyter.notebook.get_selected_cells(), undefined);
+    }
+
+    /**
+     *
+     */
+    function mark_all() {
+        setCellsMarked(Jupyter.notebook.get_cells(), true);
+    }
+
+    /**
+     *
+     */
+    function mark_none() {
+        setCellsMarked(Jupyter.notebook.get_cells(), false);
+    }
+
+    /**
+     *
+     * @param cell notebook cell instance
+     * @param state {string} state to be display [ '', 'locked', 'executed', 'modified' ]
+     */
+    function set_cell_state(cell, state) {
+        var icon = "";
+        if (state === 'locked') {
+            icon = '<div class="fa fa-lock" style="font-size:70%;" /div>'
+        }
+        cell.code_mirror.setGutterMarker(0, "CodeMirror-cellstate", celltypeMarker(icon))
+    }
+
+    /**
+     * Change event to mark/unmark cell
+     *
+     * @param cm codemirror instance
+     * @param line current line
+     * @param gutter not used
+     */
+    function changeEvent(cm, line, gutter) {
+        if (gutter === "CodeMirror-foldgutter") return; /* Don't collide with codefolding extension */
+
+        var cmline = cm.doc.children[0].lines[line];
+        if (cmline === undefined) {
+            return;
+        }
+        var cell = $(cm.display.gutters).closest('.cell').data('cell');
+        if (cell.metadata.run_control === undefined)
+            cell.metadata.run_control = {};
+        setCell(cell, !cell.metadata.run_control.marked);
+    }
+
+    /**
+     *
+     * @param cell cell to be tested
+     * @returns {boolean} true if marked
+     */
+    var is_marked = function(cell) {
+        return (cell instanceof codecell.CodeCell) &&
+            cell.metadata.run_control !== undefined &&
+            cell.metadata.run_control.marked;
+    };
+
+    /**
+     * Return div element to set in cellstate gutter
+     *
+     * @param val HTML string
+     * @returns {Element} div Element
+     */
+    function celltypeMarker(val) {
+        var marker = document.createElement("div");
+        marker.style.color = "#822";
+        marker.innerHTML = val;
+        return marker;
+    }
+
+    /**
+     * Lock/Unlock current code cell
+     *             if (cell.metadata.run_control != undefined && cell.metadata.run_control.read_only) {
+     *                     cell.code_mirror.setOption('readOnly', cell.metadata.run_control.read_only);
+     */
+    var lock_cell = function(locked) {
+        var ncells = Jupyter.notebook.ncells();
+        for (var i = ncells - 2; i >= 0; i--) {
+            var cells = Jupyter.notebook.get_cells();
+            if ((cells[i].cell_type === "code") && is_marked(cells[i])) {
+                if (locked === true) {
+                    cells[i].metadata.editable = false;
+                    set_cell_state(cells[i], 'locked')
+                } else {
+                    cells[i].metadata.editable = true;
+                    set_cell_state(cells[i], '')
+                }
+            }
+        }
+    };
+
+    /**
+     * Execute all cells and don't stop on errors
+     *
+     */
+    var run_all_cells_ignore_errors = function() {
+        execute_all_cells(false);
+    };
+
+    /**
+     * Create floating toolbar
+     *
+     */
+    var create_runtools_div = function() {
+        var btn = '<div class="btn-toolbar">\
+            <div class="btn-group">\
+                <button type="button" id="run_c" class="btn-primary fa fa-step-forward" title="Run current cell"></button>\
+                <button type="button" id="run_ca" class="btn-primary fa icon-run-to" title="' +
+            'Run cells above (' + params["run_cells_above"] + ')"</button>\
+                <button type="button" id="run_cb" class="btn-primary fa icon-run-from" title="' +
+            'Run cells below (' + params["run_cells_below"] + ')"</button>\
+                <button type="button" id="run_a" class="btn-primary fa icon-run-all" title="' +
+            'Run all cells (' + params["run_all_cells"] + ')"</button>\
+                <button type="button" id="run_af" class="btn-primary fa icon-run-all-forced" title="' +
+            'Run all - ignore errors (' + params["run_all_cells_ignore_errors"] + ')"</button>\
+                <button type="button" id="run_m" class="btn-primary fa icon-run-marked" title="' +
+            'Run marked codecells (' + params["run_marked_cells"] + ')"</button>\
+                <button type="button" id="interrupt_b" class="btn-primary fa fa-stop" title="' +
+            'Stop execution (' + params["stop_execution"] + ')"</button>\
+            </div>\
+            <div class="btn-group">\
+                <button type="button" id="mark_toggle" class="btn-primary fa icon-mark-toggle" title="Mark single code cell"></button>\
+                <button type="button" id="mark_all" class="btn-primary fa icon-mark-all" title="Mark all code cells"></button>\
+                <button type="button" id="mark_none" class="btn-primary fa icon-mark-none" title="Unmark all code cells"></button>\
+            </div>\
+            <div class="btn-group">\
+                <button type="button" id="show_input" class="btn-primary fa icon-show-input" title="Show input of code cell"></button>\
+                <button type="button" id="hide_input" class="btn-primary fa icon-hide-input" title="Hide input of code cell"></button>\
+                <button type="button" id="show_output" class="btn-primary fa icon-show-output" title="Show output of code cell"></button>\
+                <button type="button" id="hide_output" class="btn-primary fa icon-hide-output" title="Hide output of code cell"></button>\
+                <button type="button" id="lock_marked" class="btn-primary fa fa-lock" title="Lock marked cells"></button>\
+                <button type="button" id="unlock_marked" class="btn-primary fa fa-unlock" title="Unlock marked cells"></button>\
+            </div>\
+            </div>';
+
+        var runtools_wrapper = $('<div id="runtools-wrapper">')
+            .text("Runtools")
+            .append(btn)
+            .draggable()
+            .append("</div>");
+
+        $("#header").append(runtools_wrapper);
+        $("#runtools-wrapper").css({
+            'position': 'absolute'
+        });
+        $('#run_c').on('click', function(e) {
+                var idx = Jupyter.notebook.get_selected_index();
+                _execute_without_selecting(idx, idx + 1);
+                e.target.blur();
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_ca').on('click', function(e) {
+                execute_cells_above();
+                e.target.blur();
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_cb').on('click', function(e) {
+                execute_cells_below();
+                e.target.blur();
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_a').on('click', function(e) {
+                execute_all_cells();
+                e.target.blur();
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_af').on('click', function(e) {
+                run_all_cells_ignore_errors();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_m').on('click', function(e) {
+                run_marked_cells();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#interrupt_b').on('click', function(e) {
+                interrupt_execution();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#mark_toggle').on('click', function() {
+                toggle_marker()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#mark_all').on('click', function() {
+                mark_all()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#mark_none').on('click', function() {
+                mark_none()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#show_input').on('click', function() {
+                show_input(true);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#hide_input').on('click', function() {
+                show_input(false);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#show_output').on('click', function() {
+                show_output(true);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#hide_output').on('click', function() {
+                show_output(false);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#lock_marked').on('click', function() {
+                lock_cell(true);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#unlock_marked').on('click', function() {
+                lock_cell(false);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+    };
+
+    /**
+     * Show/hide toolbar
+     *
+     */
+    var toggle_toolbar = function() {
+        var dom = $("#runtools-wrapper");
+
+        if (dom.is(':visible')) {
+            $('#toggle_runtools').removeClass('active').blur();
+            dom.hide();
+        } else {
+            $('#toggle_runtools').addClass('active');
+            dom.show();
+        }
+
+        if (dom.length === 0) {
+            create_runtools_div()
+        }
+    };
+
+
+    /**
+     * Add CSS file
+     *
+     * @param name filename
+     */
+    var load_css = function(name) {
+        var link = document.createElement("link");
+        link.type = "text/css";
+        link.rel = "stylesheet";
+        link.href = requirejs.toUrl(name);
+        document.getElementsByTagName("head")[0].appendChild(link);
+    };
+
+    /**
+     * Add gutter to a new cell
+     *
+     * @param event
+     * @param nbcell
+     *
+     */
+    var createCell = function(event, nbcell) {
+        var cell = nbcell.cell;
+        if (cell instanceof codecell.CodeCell) {
+            var gutters = cell.code_mirror.getOption('gutters').slice();
+            if ($.inArray("CodeMirror-cellstate", gutters) < 0) {
+                gutters.push('CodeMirror-cellstate');
+                cell.code_mirror.setOption('gutters', gutters);
+                cell.code_mirror.on("gutterClick", changeEvent);
+
+            }
+        }
+    };
+
+
+    /**
+     * Initialize all cells with new gutter
+     */
+    var initGutter = function() {
+        var cells = Jupyter.notebook.get_cells();
+        var ncells = cells.length;
+        for (var i = 0; i < ncells; i++) {
+            var cell = cells[i];
+            if (cell instanceof codecell.CodeCell) {
+                var gutters = cell.code_mirror.getOption('gutters').slice();
+                if ($.inArray("CodeMirror-cellstate", gutters) < 0) {
+                    gutters.push('CodeMirror-cellstate');
+                    cell.code_mirror.setOption('gutters', gutters);
+                }
+            }
+            /**
+             * Restore hide/show status after reload
+             */
+            if (cell.metadata.hasOwnProperty('hide_input') && cell.metadata.hide_input === true)
+                showCell(cell, 'i', false);
+            if (cell.metadata.hasOwnProperty('hide_output') && cell.metadata.hide_output === true)
+                showCell(cell, 'o', false);
+            if (cell.is_editable() === false) {
+                set_cell_state(cell, 'locked');
+            }
+            cell.code_mirror.refresh();
+        }
+        events.on('create.Cell', createCell);
+    };
+
+    /**
+     * Called from notebook after extension was loaded
+     *
+     */
+    var load_extension = function() {
+        load_css('./main.css');
+        load_css('./gutter.css'); /* set gutter width */
+        requirejs(['./cellstate'], function() {
+            if (Jupyter.notebook._fully_loaded) {
+                initGutter();
+            } else {
+                events.one('notebook_loaded.Notebook', initGutter);
+            }
+        });
+        Jupyter.notebook.config.loaded.then(initialize);
+    };
+
+    return {
+        load_jupyter_extension: load_extension,
+        load_ipython_extension: load_extension
+    };
+});

.local/share/jupyter/nbextensions/runtools/runtools.yaml

@@ -0,0 +1,59 @@
+Type: IPython Notebook Extension
+Name: Runtools
+Description: Runtools provide a number of additional functions for working with code cells in the IPython notebook
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 5.x
+Parameters:
+- name: runtools.run_cells_above
+  description: run cells above
+  input_type: hotkey
+  default: Alt-a
+- name: runtools.run_cells_below
+  description: run cells below
+  input_type: hotkey
+  default: Alt-b
+- name: runtools.toggle_marker
+  description: Toggle marker
+  input_type: hotkey
+  default: Alt-t
+- name: runtools.mark_all_codecells
+  description: Mark all codecells
+  input_type: hotkey
+  default: Alt-m
+- name: runtools.unmark_all_codecells
+  description: Unmark all codecells
+  input_type: hotkey
+  default: Alt-u
+- name: runtools.run_marked_cells
+  description: run marked cells
+  input_type: hotkey
+  default: Alt-r
+- name: runtools.stop_execution
+  description: stop execution
+  input_type: hotkey
+  default: Ctrl-c
+- name: runtools.run_all_cells
+  description: run all cells
+  input_type: hotkey
+  default: Alt-x
+- name: runtools.run_alls_cells_ignore_errors
+  description: run all cells - ignore errors
+  input_type: hotkey
+  default: Alt-f
+- name: runtools.marked_color
+  description: |
+    Color for marking a codecell
+  default: '#20f224'
+  input_type: color
+- name: runtools.scheduled_color
+  description: |
+    Color when a codecell is scheduled to be rund
+  default: '#00def0'
+  input_type: color
+- name: runtools.run_color
+  description: |
+    Color while a codecell is being run
+  default: '#f30a2d'
+  input_type: color

.local/share/jupyter/nbextensions/scratchpad/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2016, Min RK
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of nbextension-scratchpad nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

.local/share/jupyter/nbextensions/scratchpad/README.md

@@ -0,0 +1,14 @@
+# Scratchpad notebook extension
+
+Adds a scratchpad cell to Jupyter notebook.
+This is a cell in which you can execute code against the current kernel without modifying the notebook document.
+
+Scratchpad cells can be executed using `Shift-Enter` (other shortcuts are appled to the notebook document). The scratchpad can be toggled by clicking the icon in the bottom-right, or via the keyboard shortcut `Ctrl-B`.
+
+![demo](demo.gif)
+
+
+## Credits
+
+This extension is a copy of the extension from MinRK here:
+`git clone git://github.com/minrk/nbextension-scratchpad`.

.local/share/jupyter/nbextensions/scratchpad/main.js

@@ -0,0 +1,149 @@
+define([
+  'require',
+  'jquery',
+  'base/js/namespace',
+  'base/js/events',
+  'base/js/utils',
+  'notebook/js/codecell',
+], function (
+  requirejs,
+  $,
+  Jupyter,
+  events,
+  utils,
+  codecell
+) {
+  "use strict";
+  var CodeCell = codecell.CodeCell;
+
+  var Scratchpad = function (nb) {
+    var scratchpad = this;
+    this.notebook = nb;
+    this.kernel = nb.kernel;
+    this.km = nb.keyboard_manager;
+    this.collapsed = true;
+
+    // create elements
+    this.element = $("<div id='nbextension-scratchpad'>");
+    this.close_button = $("<i>").addClass("fa fa-caret-square-o-down scratchpad-btn scratchpad-close");
+    this.open_button = $("<i>").addClass("fa fa-caret-square-o-up scratchpad-btn scratchpad-open");
+    this.element.append(this.close_button);
+    this.element.append(this.open_button);
+    this.open_button.click(function () {
+      scratchpad.expand();
+    });
+    this.close_button.click(function () {
+      scratchpad.collapse();
+    });
+
+    // create my cell
+    var cell = this.cell = new CodeCell(nb.kernel, {
+      events: nb.events,
+      config: nb.config,
+      keyboard_manager: nb.keyboard_manager,
+      notebook: nb,
+      tooltip: nb.tooltip,
+    });
+    cell.set_input_prompt();
+    this.element.append($("<div/>").addClass('cell-wrapper').append(this.cell.element));
+    cell.render();
+    cell.refresh();
+    this.collapse();
+
+    // override ctrl/shift-enter to execute me if I'm focused instead of the notebook's cell
+    var execute_and_select_action = this.km.actions.register({
+      handler: $.proxy(this.execute_and_select_event, this),
+    }, 'scratchpad-execute-and-select');
+    var execute_action = this.km.actions.register({
+      handler: $.proxy(this.execute_event, this),
+    }, 'scratchpad-execute');
+    var toggle_action = this.km.actions.register({
+      handler: $.proxy(this.toggle, this),
+    }, 'scratchpad-toggle');
+    
+    var shortcuts = {
+      'shift-enter': execute_and_select_action,
+      'ctrl-enter': execute_action,
+      'ctrl-b': toggle_action,
+    }
+    this.km.edit_shortcuts.add_shortcuts(shortcuts);
+    this.km.command_shortcuts.add_shortcuts(shortcuts);
+
+    // finally, add me to the page
+    $("body").append(this.element);
+  };
+
+  Scratchpad.prototype.toggle = function () {
+    if (this.collapsed) {
+      this.expand();
+    } else {
+      this.collapse();
+    }
+    return false;
+  };
+
+  Scratchpad.prototype.expand = function () {
+    this.collapsed = false;
+    var site_height = $("#site").height();
+    this.element.animate({
+      height: site_height,
+    }, 200);
+    this.open_button.hide();
+    this.close_button.show();
+    this.cell.element.show();
+    this.cell.focus_editor();
+    //$("#notebook-container").css('margin-left', 0);
+  };
+
+  Scratchpad.prototype.collapse = function () {
+    this.collapsed = true;
+    //$("#notebook-container").css('margin-left', 'auto');
+    this.element.animate({
+      height: 0,
+    }, 100);
+    this.close_button.hide();
+    this.open_button.show();
+    this.cell.element.hide();
+  };
+
+  Scratchpad.prototype.execute_and_select_event = function (evt) {
+    if (utils.is_focused(this.element)) {
+      this.cell.execute();
+    } else {
+      this.notebook.execute_cell_and_select_below();
+    }
+  };
+
+  Scratchpad.prototype.execute_event = function (evt) {
+    if (utils.is_focused(this.element)) {
+      this.cell.execute();
+    } else {
+      this.notebook.execute_selected_cells();
+    }
+  };
+
+  function setup_scratchpad () {
+    // lazy, hook it up to Jupyter.notebook as the handle on all the singletons
+    console.log("Setting up scratchpad");
+    return new Scratchpad(Jupyter.notebook);
+  }
+
+  function load_extension () {
+    // add css
+    var link = document.createElement("link");
+    link.type = "text/css";
+    link.rel = "stylesheet";
+    link.href = requirejs.toUrl("./scratchpad.css");
+    document.getElementsByTagName("head")[0].appendChild(link);
+    // load when the kernel's ready
+    if (Jupyter.notebook.kernel) {
+      setup_scratchpad();
+    } else {
+      events.on('kernel_ready.Kernel', setup_scratchpad);
+    }
+  }
+
+  return {
+    load_ipython_extension: load_extension,
+  };
+});

.local/share/jupyter/nbextensions/scroll_down/config.yaml

@@ -0,0 +1,12 @@
+Type: IPython Notebook Extension
+Name: ScrollDown
+Description: Scroll outputs down automatically
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x, 5.x
+Parameters:
+- name: scrollDownIsEnabled
+  description: enable scroll_down toolbar button
+  input_type: checkbox
+  default: false

.local/share/jupyter/nbextensions/select_keymap/select_keymap.yaml

@@ -0,0 +1,15 @@
+Type: Jupyter Notebook Extension
+Name: Select CodeMirror Keymap
+Link: README.md
+Description: "A little extension to choose between CodeMirror keymaps: default, emacs, vim, and sublime"
+Main: main.js
+Compatibility: 4.x, 5.x
+Parameters:
+- name: select_keymap_line_wrap
+  description: Enable line wrap in CodeMirror
+  input_type: checkbox
+  default: true
+- name: select_keymap_local_storage
+  description: Store keymap selection on the client instead of server config
+  input_type: checkbox
+  default: true

.local/share/jupyter/nbextensions/skill/main.js

@@ -0,0 +1,14 @@
+define(function() {
+	"use strict";
+	// jupyter nbextensions must export a load_ipython_extension function to
+	// avoid throwing an error. Also, loading the module should do nothing
+	// unless the function is called, so we wrap requiring the codemirror mode
+	// in the load call.
+	return {
+		load_ipython_extension: function () {
+			requirejs(['./skill'], function () {
+				console.log('[SKILL Syntax] loaded');
+			});
+		}
+	};
+});

.local/share/jupyter/nbextensions/snippets/snippets.yaml

@@ -0,0 +1,6 @@
+Type: IPython Notebook Extension
+Compatibility: 4.x, 5.x
+Name: Snippets
+Main: main.js
+Description: Adds a drop-down menu to insert snippet cells into the current notebook.
+Link: README.md

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/astropy.js

@@ -0,0 +1,164 @@
+define({
+    'name' : 'Astropy',
+    'sub-menu' : [
+        {
+            'name' : 'Constants',
+            'sub-menu' : [
+                {
+                    'name' : 'Setup',
+                    'snippet' : ['import astropy.constants'],
+                },
+                '---',
+                {
+                    'name' : 'Extracting value',
+                    'snippet' : ['astropy.constants.G.value'],
+                },
+                {
+                    'name' : 'Extracting units',
+                    'snippet' : ['astropy.constants.G.unit'],
+                },
+                {
+                    'name' : 'Extracting uncertainty',
+                    'snippet' : ['astropy.constants.G.uncertainty'],
+                },
+                {
+                    'name' : 'Converting to SI',
+                    'snippet' : ['astropy.constants.G.si'],
+                },
+                {
+                    'name' : 'Converting to cgs',
+                    'snippet' : ['astropy.constants.G.cgs'],
+                },
+                '---',
+                {
+                    'name' : 'Gravitational constant [\\(\\mathrm{m}^3 / (\\mathrm{kg}\\, \\mathrm{s}^2)\\)]',
+                    'snippet' : ['astropy.constants.G',],
+                },
+                {
+                    'name' : 'Solar luminosity [\\(\\mathrm{W}\\)]',
+                    'snippet' : ['astropy.constants.L_sun',],
+                },
+                {
+                    'name' : 'Earth mass [\\(\\mathrm{kg}\\)]',
+                    'snippet' : ['astropy.constants.M_earth',],
+                },
+                {
+                    'name' : 'Jupiter mass [\\(\\mathrm{kg}\\)]',
+                    'snippet' : ['astropy.constants.M_jup',],
+                },
+                {
+                    'name' : 'Solar mass [\\(\\mathrm{kg}\\)]',
+                    'snippet' : ['astropy.constants.M_sun',],
+                },
+                {
+                    'name' : 'Avogadro’s number [\\(1 / \\mathrm{mol}\\)]',
+                    'snippet' : ['astropy.constants.N_A',],
+                },
+                {
+                    'name' : 'Gas constant [\\(\\mathrm{J} / (\\mathrm{K}\\, \\mathrm{mol})\\)]',
+                    'snippet' : ['astropy.constants.R',],
+                },
+                {
+                    'name' : 'Earth equatorial radius [\\(\\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.R_earth',],
+                },
+                {
+                    'name' : 'Jupiter equatorial radius [\\(\\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.R_jup',],
+                },
+                {
+                    'name' : 'Solar radius [\\(\\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.R_sun',],
+                },
+                {
+                    'name' : 'Rydberg constant [\\(1 / \\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.Ryd',],
+                },
+                {
+                    'name' : 'Bohr radius [\\(\\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.a0',],
+                },
+                {
+                    'name' : 'Fine-structure constant (dimensionless)',
+                    'snippet' : ['astropy.constants.alpha',],
+                },
+                {
+                    'name' : 'Atmosphere [\\(\\mathrm{Pa}\\)]',
+                    'snippet' : ['astropy.constants.atmosphere',],
+                },
+                {
+                    'name' : 'Astronomical Unit [\\(\\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.au',],
+                },
+                {
+                    'name' : 'Wien wavelength displacement law constant [\\(\\mathrm{m}\\, \\mathrm{K}\\)]',
+                    'snippet' : ['astropy.constants.b_wien',],
+                },
+                {
+                    'name' : 'Speed of light in vacuum [\\(\\mathrm{m} / \\mathrm{s}\\)]',
+                    'snippet' : ['astropy.constants.c',],
+                },
+                {
+                    'name' : 'Electron charge [\\(\\mathrm{C}\\)]',
+                    'snippet' : ['astropy.constants.e',],
+                },
+                {
+                    'name' : 'Electric constant [\\(\\mathrm{F}/\\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.eps0',],
+                },
+                {
+                    'name' : 'Standard acceleration of gravity [\\(\\mathrm{m} / \\mathrm{s}^2\\)]',
+                    'snippet' : ['astropy.constants.g0',],
+                },
+                {
+                    'name' : 'Planck constant [\\(\\mathrm{J}\\, \\mathrm{s}\\)]',
+                    'snippet' : ['astropy.constants.h',],
+                },
+                {
+                    'name' : 'Reduced Planck constant [\\(\\mathrm{J}\\, \\mathrm{s}\\)]',
+                    'snippet' : ['astropy.constants.hbar',],
+                },
+                {
+                    'name' : 'Boltzmann constant [\\(\\mathrm{J} / \\mathrm{K}\\)]',
+                    'snippet' : ['astropy.constants.k_B',],
+                },
+                {
+                    'name' : 'Kiloparsec [\\(\\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.kpc',],
+                },
+                {
+                    'name' : 'Electron mass [\\(\\mathrm{kg}\\)]',
+                    'snippet' : ['astropy.constants.m_e',],
+                },
+                {
+                    'name' : 'Neutron mass [\\(\\mathrm{kg}\\)]',
+                    'snippet' : ['astropy.constants.m_n',],
+                },
+                {
+                    'name' : 'Proton mass [\\(\\mathrm{kg}\\)]',
+                    'snippet' : ['astropy.constants.m_p',],
+                },
+                {
+                    'name' : 'Magnetic constant [\\(\\mathrm{N}/\\mathrm{A}^2\\)]',
+                    'snippet' : ['astropy.constants.mu0',],
+                },
+                {
+                    'name' : 'Bohr magneton [\\(\\mathrm{J}/\\mathrm{T}\\)]',
+                    'snippet' : ['astropy.constants.muB',],
+                },
+                {
+                    'name' : 'Parsec [\\(\\mathrm{m}\\)]',
+                    'snippet' : ['astropy.constants.pc',],
+                },
+                {
+                    'name' : 'Stefan-Boltzmann constant [\\(\\mathrm{W} / (\\mathrm{K}^4\\, \\mathrm{m}^2)\\)]',
+                    'snippet' : ['astropy.constants.sigma_sb',],
+                },
+                {
+                    'name' : 'Atomic mass [\\(\\mathrm{kg}\\)]',
+                    'snippet' : ['astropy.constants.u',],
+                },
+            ],
+        },
+    ],
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/matplotlib.js

@@ -0,0 +1,186 @@
+define({
+    'name' : 'Matplotlib',
+    'sub-menu' : [
+        {
+            'name' : 'Setup for notebook',
+            'snippet'  : [
+                'from __future__ import print_function, division',
+                'import numpy as np',
+                'import matplotlib as mpl',
+                'import matplotlib.pyplot as plt',
+                '%matplotlib inline',
+            ],
+        },
+        {
+            'name' : 'Setup for scripts',
+            'snippet'  : [
+                'import matplotlib as mpl',
+                'mpl.use("Agg")  # Must come after importing mpl, but before importing plt',
+                'import matplotlib.pyplot as plt',
+            ],
+        },
+        {
+            'name' : 'Documentation',
+            'external-link' : 'http://matplotlib.org/contents.html',
+        },
+        '---',
+        {
+            'name' : 'Example plots',
+            'sub-menu' : [
+                {
+                    'name' : 'Basic line plot',
+                    'snippet'  : [
+                        '# Silly example data',
+                        'bp_x = np.linspace(0, 2*np.pi, num=40, endpoint=True)',
+                        'bp_y = np.sin(bp_x)',
+                        '',
+                        '# Make the plot',
+                        'plt.plot(bp_x, bp_y, linewidth=3, linestyle="--",',
+                        '         color="blue", label=r"Legend label $\\sin(x)$")',
+                        'plt.xlabel(r"Description of $x$ coordinate (units)")',
+                        'plt.ylabel(r"Description of $y$ coordinate (units)")',
+                        'plt.title(r"Title here (remove for papers)")',
+                        'plt.xlim(0, 2*np.pi)',
+                        'plt.ylim(-1.1, 1.1)',
+                        'plt.legend(loc="lower left")',
+                        'plt.show()',
+                    ],
+                },
+
+                {
+                    'name' : 'Histogram',
+                    'snippet'  : [
+                        'x = np.random.randn(10000)  # example data, random normal distribution',
+                        'num_bins = 50',
+                        'n, bins, patches = plt.hist(x, num_bins, normed=1, facecolor="green", alpha=0.5)',
+                        'plt.xlabel(r"Description of $x$ coordinate (units)")',
+                        'plt.ylabel(r"Description of $y$ coordinate (units)")',
+                        'plt.title(r"Histogram title here (remove for papers)")',
+                        'plt.show();',
+                    ],
+                },
+
+                {
+                    'name' : 'Contour plot',
+                    'snippet'  : [
+                        '# Silly example data',
+                        'x_min, x_max, y_min, y_max = 0.0, 2*np.pi, 0.0, 2*np.pi',
+                        'f = [[np.sin(x**2 + y**2) for x in np.linspace(x_min, x_max, num=200)]',
+                        '     for y in np.linspace(y_min, y_max, num=200)]',
+                        '',
+                        '# Make the plot',
+                        'plt.figure()',
+                        'plt.imshow(f, interpolation="bicubic", origin="lower",',
+                        '           extent=[x_min, x_max, y_min, y_max])',
+                        'plt.colorbar()',
+                        'plt.title(r"Title here (remove for papers)")',
+                        'plt.xlabel(r"Description of $x$ coordinate (units)")',
+                        'plt.ylabel(r"Description of $y$ coordinate (units)")',
+                        'plt.show()',
+                    ],
+                },
+
+                {
+                    'name' : '3-d plot',
+                    'snippet'  : [
+                        'from mpl_toolkits.mplot3d import Axes3D',
+                        'from matplotlib import cm',
+                        '',
+                        '# Silly example data',
+                        'X = np.arange(-5, 5, 0.25)',
+                        'Y = np.arange(-5, 5, 0.25)',
+                        'X, Y = np.meshgrid(X, Y)',
+                        'R = np.sqrt(X**2 + Y**2)',
+                        'Z = np.sin(R)',
+                        '',
+                        '# Make the plot',
+                        'fig = plt.figure()',
+                        'ax = fig.gca(projection="3d")',
+                        'surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,',
+                        '                       linewidth=0, antialiased=False)',
+                        'ax.set_zlim(-1.01, 1.01)',
+                        'fig.colorbar(surf, shrink=0.5, aspect=5)',
+                        'plt.show()',
+                    ],
+                },
+
+                {
+                    'name' : 'Error bars',
+                    'snippet'  : [
+                        '# Silly example data',
+                        'x = np.linspace(0.1, 4, num=10)',
+                        'y = np.exp(-x)',
+                        'dx = 0.1 - x/25.0',
+                        'dy = 0.2 + x/15.0',
+                        '',
+                        '# Make the plot',
+                        'plt.figure()',
+                        'plt.errorbar(x, y, xerr=dx, yerr=dy)',
+                        'plt.title(r"Title here (remove for papers)")',
+                        'plt.xlabel(r"Description of $x$ coordinate (units)")',
+                        'plt.ylabel(r"Description of $y$ coordinate (units)")',
+                        'plt.show()',
+                    ],
+                },
+
+                {
+                    'name' : 'Grouped plots',
+                    'snippet'  : [
+                        '# Silly example data',
+                        'bp_x1 = np.linspace(0, 2*np.pi, num=40, endpoint=True)',
+                        'bp_y1 = np.sin(bp_x1)',
+                        'bp_x2 = np.linspace(0, np.pi, num=40, endpoint=True)',
+                        'bp_y2 = np.cos(bp_x2)',
+                        '',
+                        '# Make the plot',
+                        'fig, (ax1, ax2) = plt.subplots(ncols=2)',
+                        'ax1.plot(bp_x1, bp_y1, linewidth=3, linestyle="--",',
+                        '         color="blue", label=r"Legend label $\\sin(x)$")',
+                        'ax1.set_xlabel(r"Description of $x_{1}$ coordinate (units)")',
+                        'ax1.set_ylabel(r"Description of $y_{1}$ coordinate (units)")',
+                        'ax1.set_title(r"Title 1 here (remove for papers)")',
+                        'ax1.set_xlim(0, 2*np.pi)',
+                        'ax1.set_ylim(-1.1, 1.1)',
+                        'ax1.legend(loc="lower left")',
+                        'ax2.plot(bp_x2, bp_y2, linewidth=3, linestyle="--",',
+                        '         color="blue", label=r"Legend label $\\cos(x)$")',
+                        'ax2.set_xlabel(r"Description of $x_{2}$ coordinate (units)")',
+                        'ax2.set_ylabel(r"Description of $y_{2}$ coordinate (units)")',
+                        'ax2.set_title(r"Title 2 here (remove for papers)")',
+                        'ax2.set_xlim(0, np.pi)',
+                        'ax2.set_ylim(-1.1, 1.1)',
+                        'ax2.legend(loc="lower left")',
+                        'plt.show()',
+                    ],
+                },
+            ],
+        },
+        {
+            'name' : 'Save the current figure',
+            'snippet' : ['plt.savefig("figure_file_name.pdf")'],
+            'sub-menu' : [
+                {
+                    'name' : 'Save as PDF',
+                    'snippet' : ['plt.savefig("figure_file_name.pdf")'],
+                },
+                {
+                    'name' : 'Save as PNG',
+                    'snippet' : ['plt.savefig("figure_file_name.png", transparent=True, dpi=300)'],
+                },
+                {
+                    'name' : 'Save as SVG',
+                    'snippet' : ['plt.savefig("figure_file_name.svg")'],
+                },
+                {
+                    'name' : 'Save as EPS',
+                    'snippet' : ['plt.savefig("figure_file_name.eps")'],
+                },
+                {
+                    'name' : 'Save as PS',
+                    'snippet' : ['plt.savefig("figure_file_name.ps")'],
+                },
+
+            ],
+        },
+    ],
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/pandas.js

@@ -0,0 +1,182 @@
+define({
+    'name' :'pandas',
+    'sub-menu' : [
+        {
+            'name' : 'Setup',
+            'snippet' : [
+                'from __future__ import print_function, division',
+                'import pandas as pd',
+            ],
+        },
+        {
+            'name' : 'Documentation',
+            'external-link' : 'http://pandas.pydata.org/pandas-docs/stable/',
+        },
+        '---',
+        {
+            'name' : 'Set options',
+            'snippet'  : [
+                'pd.set_option(""display.height"", 10)',
+                'pd.set_option(""display.max_rows"", 20)',
+                'pd.set_option(""display.max_columns"", 500)',
+                'pd.set_option(""display.width"", 1000)',
+            ],
+        },
+
+        {
+            'name' : 'To/from file',
+            'sub-menu' : [
+                {
+                    'name' : 'Read from CSV',
+                    'snippet'  : [
+                        'bp_data = pd.read_csv("path/to/file.csv", header=1, delim_whitespace=True)',
+                    ],
+                },
+
+                {
+                    'name' : 'Write to CSV',
+                    'snippet' : ['bp_data.to_csv("path/to/new_file.csv", sep=" ", header=False, index=False)',],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Deal with NaNs',
+            'sub-menu' : [
+                {
+                    'name' : 'Filter out NaNs',
+                    'snippet' : ['bp_data = bp_data.dropna()',],
+                },
+                
+                {
+                    'name' : 'Replace NaNs with number',
+                    'snippet' : ['bp_data = bp_data.fillna(0.0)',],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Select rows',
+            'snippet' : ['bp_data[:5]',],
+        },
+
+        {
+            'name' : 'Select by column',
+            'snippet' : ['bp_column = bp_data[["Column name"]]',],
+            'sub-menu' : [
+                {
+                    'name' : 'Select single column',
+                    'snippet' : ['bp_column = bp_data[["Column name"]]',],
+                },
+                
+                {
+                    'name' : 'Select multiple columns',
+                    'snippet'  : [
+                        'bp_columns = bp_data[["Column name 1", "Column name 2", "Column name 3"]]',],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Get numerical values from selection',
+            'sub-menu' : [
+                {
+                    'name' : 'Select single column',
+                    'snippet' : ['bp_num_value = bp_data[["Numerical column"]].values',],
+                },
+                {
+                    'name' : 'Select multiple columns',
+                    'snippet'  : [
+                        'bp_num_values = bp_data[["Numerical column 1", "Numerical column 2"]].values',],
+                },
+                {
+                    'name' : 'Select rows',
+                    'snippet' : ['bp_num_value = bp_data[:5].values',],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Iteration',
+            'snippet' : ['',],
+        },
+
+        {
+            'name' : 'Grouping',
+            'snippet' : ['',],
+        },
+
+        {
+            'name' : 'Sorting',
+            'snippet' : ['',],
+        },
+
+        {
+            'name' : 'Combining',
+            'sub-menu' : [
+                {
+                    'name' : 'Split-apply-combine (sum)',
+                    'snippet' : ['df['label_count'] = df.groupby('label', as_index=False)['label'].transform(lambda x: x.count())',],
+                },
+                {
+                    'name' : 'Split-apply-combine (mean)',
+                    'snippet' : ['df['label_mean'] = df.groupby('label', as_index=False)['label'].transform(lambda x: x.mean())',],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Basic stats',
+            'sub-menu' : [
+                {
+                    'name' : 'Mean',
+                    'snippet' : ['bp_mean = bp_data[["Numerical column 1"]].mean()',],
+                },
+                {
+                    'name' : 'Mode',
+                    'snippet' : ['bp_mode = bp_data[["Numerical column 1"]].mode()',],
+                },
+                {
+                    'name' : 'Median',
+                    'snippet' : ['bp_median = bp_data[["Numerical column 1"]].median()',],
+                },
+                {
+                    'name' : 'Standard deviation (unbiased)',
+                    'snippet' : ['bp_std = bp_data[["Numerical column 1"]].std()',],
+                },
+                {
+                    'name' : 'Variance (unbiased)',
+                    'snippet' : ['bp_var = bp_data[["Numerical column 1"]].var()',],
+                },
+                {
+                    'name' : 'Skew (unbiased)',
+                    'snippet' : ['bp_skew = bp_data[["Numerical column 1"]].skew()',],
+                },
+                {
+                    'name' : 'Kurtosis (unbiased)',
+                    'snippet' : ['bp_kurtosis = bp_data[["Numerical column 1"]].kurt()',],
+                },
+                {
+                    'name' : 'Min',
+                    'snippet' : ['bp_min = bp_data[["Numerical column 1"]].min()',],
+                },
+                {
+                    'name' : 'Max',
+                    'snippet' : ['bp_max = bp_data[["Numerical column 1"]].max()',],
+                },
+                {
+                    'name' : 'Sum',
+                    'snippet' : ['bp_sum = bp_data[["Numerical column 1"]].sum()',],
+                },
+                {
+                    'name' : 'Product',
+                    'snippet' : ['bp_product = bp_data[["Numerical column 1"]].product()',],
+                },
+                {
+                    'name' : 'Number of elements',
+                    'snippet' : ['bp_count = bp_data[["Numerical column 1"]].count()',],
+                },
+            ],
+        },
+    ],
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python.js

@@ -0,0 +1,209 @@
+define([
+    "require",
+    "./python_regex",
+], function (requirejs, python_regex) {
+    return {
+        'name' : 'Python',
+        'sub-menu' : [
+            {
+                'name' : 'Setup',
+                'snippet' : ['from __future__ import print_function, division',],
+            },
+            {
+                'name' : 'Documentation',
+                'external-link' : 'https://docs.python.org/',
+            },
+            '---',
+
+            {
+                'name' : 'Lists',
+                'sub-menu' : [
+                    {
+                        'name' : 'List comprehension',
+                        'snippet' : ['[x**2 for x in range(-10, 11)]',],
+                    },
+                    {
+                        'name' : 'Conditional list comprehension',
+                        'snippet' : ['[x**2 for x in range(-10, 11) if (x%3)==0]',],
+                    },
+                    {
+                        'name' : 'Conditional alternative list comprehension',
+                        'snippet' : ['[x**2 if (x%3)==0 else x**3 for x in range(-10, 11)]',],
+                    },
+                    {
+                        'name' : 'Reversed list',
+                        'snippet' : ['reversed(l)'],
+                    },
+                    {
+                        'name' : 'Sorted list',
+                        'snippet' : ['sorted(l)'],
+                    },
+                    {
+                        'name' : 'Sort two lists at the same time',
+                        'snippet' : ['x, y = [list(tmp) for tmp in zip(*sorted(zip(x,y), key=lambda pair: pair[0]))]'],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Basic file input/output',
+                'sub-menu' : [
+                    {
+                        'name' : 'Read file into string',
+                        'snippet' : [
+                            'with open("some/file.txt", "r") as file_handle:',
+                            '    file_contents = file_handle.read()',
+                        ],
+                    },
+                    {
+                        'name' : 'Read file into string, operating on each line',
+                        'snippet' : [
+                            'file_contents = ""',
+                            'with open("some/file.txt", "r") as file_handle:',
+                            '    for line in file_handle.readlines():',
+                            '        file_contents += line.replace("-", "_")',
+                        ],
+                    }
+                ],
+            },
+            
+            {
+                'name' : 'Defining functions',
+                'sub-menu' : [
+                    {
+                        'name' : 'Simple function',
+                        'snippet'  : [
+                            'def bp_some_func(x):',
+                            '    r"""Brief description of the function"""',
+                            '    return x**2',
+                        ],
+                    },
+                    {
+                        'name' : 'Complicated function',
+                        'snippet'  : [
+                            'def bp_some_func(x, y, z=3.14, **kwargs):',
+                            '    r"""Some function',
+                            '    ',
+                            '    Does some stuff.',
+                            '    ',
+                            '    Parameters',
+                            '    ----------',
+                            '    x : int',
+                            '        Description of x',
+                            '    y : str',
+                            '        Description of y',
+                            '    z : float, optional',
+                            '        Description of z.  Defaults to 3.14',
+                            '    **kwargs',
+                            '        Arbitrary optional keyword arguments.',
+                            '        w : float',
+                            '            Defaults to 6.28',
+                            '    ',
+                            '    Returns',
+                            '    -------',
+                            '    double',
+                            '        Some nonsensical number computed from some ugly formula',
+                            '    ',
+                            '    """',
+                            '    w = kwargs.pop("w", 6.28)',
+                            '    if kwargs:',
+                            '        print("Got {0} unused kwargs".format(len(kwargs)))',
+                            '    return (x**2 + len(y)) * (w + z)',
+                        ],
+                    },
+                ],
+            },
+            
+            {
+                'name' : 'Defining classes',
+                'sub-menu' : [
+                    {
+                        'name' : 'Simple class',
+                        'snippet'  : [
+                            'class BPSomeClass(object):',
+                            '    r"""Describe the class"""',
+                            '    def __init__(self, arg1, arg2):',
+                            '        self.attr1 = arg1',
+                            '        self.attr2 = arg2',
+                            '    ',
+                            '    def attribute1(self):',
+                            '        return self.attr1',
+                            'bp_obj = BPSomeClass("a", 2.7182)',
+                            'bp_obj.attribute1()',
+                        ],
+                    },
+                    {
+                        'name' : 'Complicated class',
+                        'snippet'  : [
+                            'class BPSomeClass(object):',
+                            '    """Brief class description',
+                            '    ',
+                            '    Some more extensive description',
+                            '    ',
+                            '    Attributes',
+                            '    ----------',
+                            '    attr1 : string',
+                            '        Purpose of attr1.',
+                            '    attr2 : float',
+                            '        Purpose of attr2.',
+                            '    ',
+                            '    """',
+                            '    ',
+                            '    def __init__(self, param1, param2, param3=0):',
+                            '        """Example of docstring on the __init__ method.',
+                            '        ',
+                            '        Parameters',
+                            '        ----------',
+                            '        param1 : str',
+                            '            Description of `param1`.',
+                            '        param2 : float',
+                            '            Description of `param2`.',
+                            '        param3 : int, optional',
+                            '            Description of `param3`, defaults to 0.',
+                            '        ',
+                            '        """',
+                            '        self.attr1 = param1',
+                            '        self.attr2 = param2',
+                            '        print(param3 // 4)',
+                            '    ',
+                            '    @property',
+                            '    def attribute2(self):',
+                            '        return self.attr2',
+                            '    ',
+                            '    @attribute2.setter',
+                            '    def attribute2(self, new_attr2):',
+                            '        if not isinstance(float, new_attr2):',
+                            '            raise ValueError("attribute2 must be a float, not {0}".format(new_attr2))',
+                            '        self.attr2 = new_attr2',
+                            '',
+                            '',
+                            'bp_obj = BPSomeClass("a", 1.618)',
+                            'print(bp_obj.attribute2)',
+                            'bp_obj.attribute2 = 3.236',
+                            '',
+                        ],
+                    },
+                    {
+                        'name' : 'Subclass',
+                        'snippet'  : [
+                            'class BP_A(object):',
+                            '    def __init__(self, param1):',
+                            '        self.attr1 = param1',
+                            '',
+                            'class BP_B(BP_A):',
+                            '    def __init__(self, param1, param2):',
+                            '        super(BP_B, self).__init__(param1)',
+                            '        self.attr2 = param2',
+                            '',
+                            '',
+                            'bp_b = BP_B("a", "b")',
+                            'print(bp_b.attr1, bp_b.attr2)',
+                        ],
+                    },
+                ],
+            },
+
+            python_regex,
+        ],
+    };
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python_regex.js

@@ -0,0 +1,309 @@
+define({
+    'name' : 'Regular expressions',
+    'sub-menu' : [
+        {
+            'name' : 'Setup',
+            'snippet' : [
+                'import re',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Basic search for pattern anywhere in string',
+            'snippet' : [
+                'string = " abc def "',
+                'pattern = re.compile(r"[a-z]+")',
+                'result = re.search(pattern, string)',
+                'if result is not None:',
+                '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+            ],
+        },
+        {
+            'name' : 'Basic search (match) for exact pattern at beginning of string',
+            'snippet' : [
+                'string = " abc def "',
+                'pattern = re.compile(r".*[a-z]+")',
+                'result = re.match(pattern, string)',
+                'if result is not None:',
+                '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+            ],
+        },
+        {
+            'name' : 'Basic substitution',
+            'snippet' : [
+                'string = " abc def "',
+                'pattern = re.compile(r"[a-z]+")',
+                'new_string = re.sub(pattern, "something", string)',
+                'print("New string is \'{0}\'".format(new_string))',
+            ],
+        },
+        {
+            'name' : 'Substitution with backreferences',
+            'snippet' : [
+                'string = "John Doe lives at 221B Baker Street."',
+                'pattern = re.compile(r"""',
+                '    ([a-zA-Z ]+)      # Save as many letters and spaces as possible to group 1',
+                '    \\ lives\\ at\\      # Match " lives at "',
+                '    (?P<address>.*)   # Save everything in between as a group named `address`',
+                '    \\.                # Match the period at the end',
+                '""", re.VERBOSE)',
+                'new_string = re.sub(pattern, r"\\g<address> is occupied by \\1.", string)',
+                'print("New string is \'{0}\'".format(new_string))',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Escaped special characters',
+            'sub-menu' : [
+                {
+                    'name' : '.',
+                    'snippet' : ['\\.',],
+                },
+                {
+                    'name' : '^',
+                    'snippet' : ['\\^',],
+                },
+                {
+                    'name' : '$',
+                    'snippet' : ['\\$',],
+                },
+                {
+                    'name' : '*',
+                    'snippet' : ['\\*',],
+                },
+                {
+                    'name' : '+',
+                    'snippet' : ['\\+',],
+                },
+                {
+                    'name' : '?',
+                    'snippet' : ['\\?',],
+                },
+                {
+                    'name' : '{',
+                    'snippet' : ['\\{',],
+                },
+                {
+                    'name' : '}',
+                    'snippet' : ['\\}',],
+                },
+                {
+                    'name' : '[',
+                    'snippet' : ['\\[',],
+                },
+                {
+                    'name' : ']',
+                    'snippet' : ['\\]',],
+                },
+                {
+                    'name' : '\\',
+                    'snippet' : ['\\\\',],
+                },
+                {
+                    'name' : '|',
+                    'snippet' : ['\\|',],
+                },
+                {
+                    'name' : '(',
+                    'snippet' : ['\\(',],
+                },
+                {
+                    'name' : ')',
+                    'snippet' : ['\\)',],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Character classes and alternatives',
+            'sub-menu' : [
+                {
+                    'name' : 'Standard character-class abbreviations',
+                    'sub-menu' : [
+                        {
+                            'name' : 'Any decimal digit',
+                            'snippet' : ['\\d',],
+                        },
+                        {
+                            'name' : 'Any non-digit character',
+                            'snippet' : ['\\D',],
+                        },
+                        {
+                            'name' : 'Any whitespace character',
+                            'snippet' : ['\\s',],
+                        },
+                        {
+                            'name' : 'Any non-whitespace character',
+                            'snippet' : ['\\S',],
+                        },
+                        {
+                            'name' : 'Any alphanumeric character',
+                            'snippet' : ['\\w',],
+                        },
+                        {
+                            'name' : 'Any non-alphanumeric character',
+                            'snippet' : ['\\W',],
+                        },
+                    ],
+                },
+                {
+                    'name' : 'Inclusive character classes',
+                    'snippet' : [
+                        '[a-zA-Z0-9 \\t\\n\\r\\f\\v]',
+                    ],
+                },
+                {
+                    'name' : 'Exclusive character classes',
+                    'snippet' : [
+                        '[^a-zA-Z0-9]',
+                    ],
+                },
+                {
+                    'name' : 'Alternatives',
+                    'snippet' : [
+                        '(?:abc|def)',
+                    ],
+                },
+                
+            ],
+        },
+
+        {
+            'name' : 'Repetition',
+            'sub-menu' : [
+                {
+                    'name' : 'Match 0 or more repetitions of the preceding, greedily',
+                    'snippet' : ['*',],
+                },
+                {
+                    'name' : 'Match 1 or more repetitions of the preceding, greedily',
+                    'snippet' : ['+',],
+                },
+                {
+                    'name' : 'Match 0 or 1 repetitions of the preceding, greedily',
+                    'snippet' : ['?',],
+                },
+                '---',
+                {
+                    'name' : 'Match 0 or more repetitions of the preceding, non-greedily',
+                    'snippet' : ['*?',],
+                },
+                {
+                    'name' : 'Match 1 or more repetitions of the preceding, non-greedily',
+                    'snippet' : ['+?',],
+                },
+                {
+                    'name' : 'Match 0 or 1 repetitions of the preceding, non-greedily',
+                    'snippet' : ['??',],
+                },
+                '---',
+                {
+                    'name' : 'Match exactly n repeititions of the preceding',
+                    'snippet' : ['{3}',],
+                },
+                {
+                    'name' : 'Match between m and n repetions of the preceding, greedily',
+                    'snippet' : ['{3,5}',],
+                },
+                {
+                    'name' : 'Match between m and n repetions of the preceding, non-greedily',
+                    'snippet' : ['{3,5}?',],
+                },
+            ],
+        },
+
+        // {
+        //     'name' : '',
+        //     'sub-menu' : [
+                
+        //     ],
+        // },
+
+        // {
+        //     'name' : '',
+        //     'sub-menu' : [
+                
+        //     ],
+        // },
+
+        {
+            'name' : 'Lookahead/behind',
+            'sub-menu' : [
+                {
+                    'name' : 'Positive lookahead',
+                    'snippet' : [
+                        'string = "Isaac Asimov"',
+                        'pattern = re.compile(r"Isaac(?= Asimov)")  # Only match "Isaac Asimov", but drop the " Asimov"',
+                        'result = re.match(pattern, string)',
+                        'if result is not None:',
+                        '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+                    ],
+                },
+                {
+                    'name' : 'Negative lookahead',
+                    'snippet' : [
+                        'string = "Isaac Newton"',
+                        'pattern = re.compile(r"Isaac(?! Asimov)")  # Match any Isaac except Asimov, and only keep the "Isaac"',
+                        'result = re.match(pattern, string)',
+                        'if result is not None:',
+                        '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+                    ],
+                },
+                {
+                    'name' : 'Positive lookbehind',
+                    'snippet' : [
+                        'string = "Janet Asimov"',
+                        'pattern = re.compile(r"(?<=Janet )Asimov")  # Only match "Janet Asimov", but drop the "Janet "',
+                        'result = re.search(pattern, string)',
+                        'if result is not None:',
+                        '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+                    ],
+                },
+                {
+                    'name' : 'Negative lookbehind',
+                    'snippet' : [
+                        'string = "Janet Asimov"',
+                        'pattern = re.compile(r"(?<!Isaac )Asimov")  # Will match any Asimov except Isaac, and only keep "Asimov"',
+                        'result = re.search(pattern, string)',
+                        'if result is not None:',
+                        '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Compilation flags',
+            'sub-menu' : [
+                {
+                    'name' : 'Enable verbose REs, for cleaner and more organized code',
+                    'snippet' : ['re.VERBOSE',],
+                },
+                {
+                    'name' : 'Do case-insensitive matches',
+                    'snippet' : ['re.IGNORECASE',],
+                },
+                {
+                    'name' : 'Make "." match any character, including newlines',
+                    'snippet' : ['re.DOTALL',],
+                },
+                {
+                    'name' : 'Multi-line matching, affecting "^" and "$"',
+                    'snippet' : ['re.MULTILINE',],
+                },
+                {
+                    'name' : 'Make \\w, \\W, \\b, \\B, \\s, and \\S Unicode aware',
+                    'snippet' : ['re.UNICODE',],
+                },
+                {
+                    'name' : 'Make \\w, \\W, \\b, \\B, \\s, and \\S dependent on the current locale',
+                    'snippet' : ['re.LOCALE',],
+                },
+                {
+                    'name' : 'Display debug info about compiled regex',
+                    'snippet' : ['re.DEBUG',],
+                },
+            ],
+        },
+    ],
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/scipy.js

@@ -0,0 +1,620 @@
+define([
+    "require",
+    "./scipy_constants",
+    "./scipy_special",
+], function (requirejs, scipy_constants, scipy_special) {
+    return {
+        'name' : 'SciPy',
+        'sub-menu' : [
+            {
+                'name' : 'Setup',
+                'snippet'  : [
+                    'from __future__ import print_function, division',
+                    'import numpy as np',
+                    'import scipy as sp',
+                ],
+            },
+
+            {
+                'name' : 'Documentation',
+                'external-link' : 'http://docs.scipy.org/doc/scipy/reference/',
+            },
+
+            '---',
+            
+            // {
+            //     'name' : 'Clustering algorithms',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import cluster',],
+            //         },
+            //     ],
+            // },
+
+            scipy_constants,
+
+            {
+                'name' : 'Fast Fourier Transform routines',
+                'sub-menu' : [
+                    {
+                        'name' : 'Setup',
+                        'snippet' : ['from scipy import fftpack',],
+                    },
+                    '---',
+                    {
+                        'name' : 'Docs',
+                        'external-link' : 'http://docs.scipy.org/doc/scipy-0.15.1/reference/fftpack.html'
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Integration and ODE solvers',
+                'sub-menu' : [
+                    {
+                        'name' : 'Setup',
+                        'snippet' : ['from scipy import integrate',],
+                    },
+                    '---',
+                    {
+                        'name' : 'Integrate given function object',
+                        'sub-menu' : [
+                            {
+                                'name' : 'General-purpose integration',
+                                'snippet' : [
+                                    'from scipy import integrate',
+                                    'def f(x, a, b):',
+                                    '    return a * x + b',
+                                    'integral,error = integrate.quad(f, 0, 4.5, args=(2,1))  # integrates 2*x+1',
+                                    'print(integral, error)',
+                                ],
+                            },
+                            {
+                                'name' : 'General purpose double integration',
+                                'snippet' : [
+                                    'from scipy import integrate',
+                                    'def integrand(y, x):',
+                                    '    return x * y**2',
+                                    'x_lower_lim, x_upper_lim = 0.0, 0.5',
+                                    'y_lower_lim, y_upper_lim = lambda x:0.0, lambda x:1.0-2.0*x',
+                                    '# int_{x=0}^{0.5} int_{y=0}^{1-2x} x y dx dy',
+                                    'integral,error = integrate.dblquad(integrand,',
+                                    '                                   x_lower_lim, x_upper_lim,',
+                                    '                                   y_lower_lim, y_upper_lim)',
+                                    'print(integral, error)',
+                                ],
+                            },
+                            {
+                                'name' : 'General purpose triple integration',
+                                'snippet' : [
+                                    'from scipy import integrate',
+                                    'def integrand(z, y, x):',
+                                    '    return x * y**2 + z',
+                                    'x_lower_lim, x_upper_lim = 0.0, 0.5',
+                                    'y_lower_lim, y_upper_lim = lambda x:0.0, lambda x:1.0-2.0*x',
+                                    'z_lower_lim, z_upper_lim = lambda x,y:-1.0, lambda x,y:1.0+2.0*x-y',
+                                    '# int_{x=0}^{0.5} int_{y=0}^{1-2x} int_{z=-1}^{1+2x-y} (x y**2 + z) dz dy dx',
+                                    'integral,error = integrate.tplquad(integrand,',
+                                    '                                   x_lower_lim, x_upper_lim,',
+                                    '                                   y_lower_lim, y_upper_lim,',
+                                    '                                   z_lower_lim, z_upper_lim)',
+                                    'print(integral, error)',
+                                ],
+                            },
+                            {
+                                'name' : 'General purpose n-fold integration',
+                                'snippet' : [
+                                    'from scipy import integrate',
+                                    'def integrand(x0, x1, x2):',
+                                    '    return x2 * x1**2 + x0',
+                                    'x2_lim = (0.0, 0.5)',
+                                    'x1_lim = lambda x2:(0.0, 1.0-2.0*x2)',
+                                    'x0_lim = lambda x1,x2:(-1.0, 1.0+2.0*x2-x1)',
+                                    '# int_{x2=0}^{0.5} int_{x1=0}^{1-2x2} int_{x0=-1}^{1+2x2-x1} (x2 x1**2 + x0) dx0 dx1 dx2',
+                                    'integral,error = integrate.nquad(integrand, [x0_lim, x1_lim, x2_lim])',
+                                    'print(integral, error)',
+                                ],
+                            },
+                            {
+                                'name' : 'Integrate func(x) using Gaussian quadrature of order $n$',
+                                'snippet' : [
+                                    'gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)',
+                                    'a,b = 0,1  # limits of integration',
+                                    'result,err = integrate.fixed_quad(gaussian, a, b, n=5)',
+                                ],
+                            },
+                            {
+                                'name' : 'Integrate with given tolerance using Gaussian quadrature',
+                                'snippet' : [
+                                    'gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)',
+                                    'a,b = 0,1  # limits of integration',
+                                    'result,err = integrate.quadrature(gaussian, a, b, tol=1e-8, rtol=1e-8)',
+                                ],
+                            },
+                            {
+                                'name' : 'Integrate using Romberg integration',
+                                'snippet' : [
+                                    'gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)',
+                                    'a,b = 0,1  # limits of integration',
+                                    'result = integrate.romberg(gaussian, a, b, tol=1e-8, rtol=1e-8)',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Integrate given fixed samples',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Trapezoidal rule to compute integral from samples',
+                                'snippet' : [
+                                    'x = np.linspace(1, 5, num=100)',
+                                    'y = 3*x**2 + 1',
+                                    'integrate.trapz(y, x) # Exact value is 128',
+                                ],
+                            },
+                            {
+                                'name' : 'Trapezoidal rule to cumulatively compute integral from samples',
+                                'snippet' : [
+                                    'x = np.linspace(1, 5, num=100)',
+                                    'y = 3*x**2 + 1',
+                                    'integrate.cumtrapz(y, x) # Should range from ~0 to ~128',
+                                ],
+                            },
+                            {
+                                'name' : "Simpson's rule to compute integral from samples",
+                                'snippet' : [
+                                    'x = np.linspace(1, 5, num=100)',
+                                    'y = 3*x**2 + 1',
+                                    'integrate.simps(y, x) # Exact value is 128',
+                                ],
+                            },
+                            {
+                                'name' : 'Romberg Integration to compute integral from $2^k + 1$ evenly spaced samples',
+                                'snippet' : [
+                                    'x = np.linspace(1, 5, num=2**7+1)',
+                                    'y = 3*x**2 + 1',
+                                    'integrate.romb(y, x) # Exact value is 128',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Numerically integrate ODE systems',
+                        'sub-menu' : [
+                            {
+                                'name' : 'General integration of ordinary differential equations',
+                                'snippet' : [
+                                    'from scipy.special import gamma, airy',
+                                    'def func(y, t):',
+                                    '    return [t*y[1], y[0]]',
+                                    'x = np.arange(0, 4.0, 0.01)',
+                                    'y_0 = [-1.0 / 3**(1.0/3.0) / gamma(1.0/3.0), 1.0 / 3**(2.0/3.0) / gamma(2.0/3.0)]',
+                                    'Ai, Aip, Bi, Bip = airy(x)',
+                                    'y = odeint(func, y_0, x, rtol=1e-12, atol=1e-12) # Exact answer: (Aip, Ai)',
+                                ],
+                            },
+                            {
+                                'name' : 'General integration of ordinary differential equations with known gradient',
+                                'snippet' : [
+                                    'from scipy.special import gamma, airy',
+                                    'def func(y, t):',
+                                    '    return [t*y[1], y[0]]',
+                                    'def gradient(y, t):',
+                                    '    return [[0,t], [1,0]]',
+                                    'x = np.arange(0, 4.0, 0.01)',
+                                    'y_0 = [-1.0 / 3**(1.0/3.0) / gamma(1.0/3.0), 1.0 / 3**(2.0/3.0) / gamma(2.0/3.0)]',
+                                    'Ai, Aip, Bi, Bip = airy(x)',
+                                    'y = odeint(func, y_0, x, rtol=1e-12, atol=1e-12, Dfun=gradient) # Exact answer: (Aip, Ai)',
+                                ],
+                            },
+                            {
+                                'name' : 'Integrate ODE using VODE and ZVODE routines',
+                                'snippet' : [
+                                    "def f(t, y, arg1):",
+                                    "    return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]",
+                                    "def jac(t, y, arg1):",
+                                    "    return [[1j*arg1, 1], [0, -arg1*2*y[1]]]",
+                                    "y0 = [1.0j, 2.0]",
+                                    "t0, t1, dt = 0.0, 10.0, 1.0",
+                                    "r = integrate.ode(f, jac).set_integrator('zvode', method='bdf')",
+                                    "r.set_initial_value(y0, t0)",
+                                    "r.set_f_params(2.0)",
+                                    "r.set_jac_params(2.0)",
+                                    "while r.successful() and r.t < t1:",
+                                    "    r.integrate(r.t+dt)",
+                                    "    print('{0}: {1}'.format(r.t, r.y))",
+                                ],
+                            },
+                            // {
+                            //     'name' : 'Integrate complex ODE using VODE and ZVODE routines',
+                            //     'snippet' : [
+                            //         'integrate.complex_ode',
+                            //     ],
+                            // },
+                        ],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Interpolation and smoothing splines',
+                'sub-menu' : [
+                    {
+                        'name' : 'Setup',
+                        'snippet' : ['from scipy import interpolate',],
+                    },
+                    '---',
+                    {
+                        'name' : 'interp1d',
+                        'snippet' : [
+                            '# NOTE: `interp1d` is very slow; prefer `InterpolatedUnivariateSpline`',
+                            'x = np.linspace(0, 10, 10)',
+                            'y = np.cos(-x**2/8.0)',
+                            "f = interpolate.interp1d(x, y, kind='cubic')",
+                            'X = np.linspace(0, 10, 100)',
+                            'Y = f(X)',
+                        ],
+                    },
+                    {
+                        'name' : 'splrep / splrev',
+                        'snippet' : [
+                            'x = np.arange(0, 2*np.pi+np.pi/4, 2*np.pi/8)',
+                            'y = np.sin(x)',
+                            'tck = interpolate.splrep(x, y, s=0)',
+                            'xnew = np.arange(0,2*np.pi,np.pi/50)',
+                            'ynew = interpolate.splev(xnew, tck, der=0)',
+                        ],
+                    },
+                    {
+                        'name' : 'InterpolatedUnivariateSpline',
+                        'snippet' : [
+                            'x = np.arange(0, 2*np.pi+np.pi/4, 2*np.pi/8)',
+                            'y = np.sin(x)',
+                            's = interpolate.InterpolatedUnivariateSpline(x, y)',
+                            'xnew = np.arange(0, 2*np.pi, np.pi/50)',
+                            'ynew = s(xnew)',
+                        ],
+                    },
+                    {
+                        'name' : 'Multivariate interpolation',
+                        'sub-menu' : [
+
+                        ],
+                    },
+                    {
+                        'name' : '2-D Splines',
+                        'sub-menu' : [
+
+                        ],
+                    },
+                    {
+                        'name' : 'Radial basis functions',
+                        'sub-menu' : [
+
+                        ],
+                    },
+                ],
+            },
+
+            // {
+            //     'name' : 'Input and Output',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import io',],
+            //         },
+            //        '---',
+            //     ],
+            // },
+
+            {
+                'name' : 'Linear algebra',
+                'sub-menu' : [
+                    {
+                        'name' : 'Setup',
+                        'snippet' : ['from scipy import linalg',],
+                    },
+                    '---',
+                    {
+                        'name' : 'Docs',
+                        'external-link' : 'http://docs.scipy.org/doc/scipy-0.15.1/reference/linalg.html'
+                    },
+                ],
+            },
+
+            // {
+            //     'name' : 'Maximum entropy methods',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import maxentropy',],
+            //         },
+            //        '---',
+            //     ],
+            // },
+
+            // {
+            //     'name' : 'N-dimensional image processing',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import ndimage',],
+            //         },
+            //        '---',
+            //     ],
+            // },
+
+            // {
+            //     'name' : 'Orthogonal distance regression',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import odr',],
+            //         },
+            //        '---',
+            //     ],
+            // },
+
+            {
+                'name' : 'Optimization and root-finding routines',
+                'sub-menu' : [
+                    {
+                        'name' : 'Setup',
+                        'snippet' : [
+                            'from scipy import optimize',
+                        ],
+                    },
+                    '---',
+                    {
+                        'name' : 'Scalar function minimization',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Unconstrained minimization',
+                                'snippet' : [
+                                    'f = lambda x: (x - 2) * (x + 1)**2',
+                                    "res = optimize.minimize_scalar(f, method='brent')",
+                                    'print(res.x)',
+                                ],
+                            },
+                            {
+                                'name' : 'Bounded minimization',
+                                'snippet' : [
+                                    'from scipy.special import j1  # Test function',
+                                    "res = optimize.minimize_scalar(j1, bounds=(4, 7), method='bounded')",
+                                    'print(res.x)',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'General-purpose optimization',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Nelder-Mead Simplex algorithm',
+                                'snippet' : [
+                                    'def rosen(x):',
+                                    '    """The Rosenbrock function"""',
+                                    '    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)',
+                                    'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])',
+                                    "res = optimize.minimize(rosen, x0, method='nelder-mead',",
+                                    "                        options={'xtol': 1e-8, 'disp': True})",
+                                    'print(res.x)',],
+                            },
+                            {
+                                'name' : 'Broyden-Fletcher-Goldfarb-Shanno (BFGS), analytical derivative',
+                                'snippet' : [
+                                    'def rosen(x):',
+                                    '    """The Rosenbrock function"""',
+                                    '    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)',
+                                    'def rosen_der(x):',
+                                    '    """Derivative of the Rosenbrock function"""',
+                                    '    xm = x[1:-1]',
+                                    '    xm_m1 = x[:-2]',
+                                    '    xm_p1 = x[2:]',
+                                    '    der = np.zeros_like(x)',
+                                    '    der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)',
+                                    '    der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])',
+                                    '    der[-1] = 200*(x[-1]-x[-2]**2)',
+                                    '    return der',
+                                    'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])',
+                                    "res = optimize.minimize(rosen, x0, method='BFGS', jac=rosen_der, options={'disp': True})",
+                                    'print(res.x)',],
+                            },
+                            {
+                                'name' : 'Broyden-Fletcher-Goldfarb-Shanno (BFGS), finite-difference derivative',
+                                'snippet' : [
+                                    'def rosen(x):',
+                                    '    """The Rosenbrock function"""',
+                                    '    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)',
+                                    'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])',
+                                    "res = optimize.minimize(rosen, x0, method='BFGS', options={'disp': True})",
+                                    'print(res.x)',],
+                            },
+                            {
+                                'name' : 'Newton-Conjugate-Gradient, full Hessian',
+                                'snippet' : [
+                                    'def rosen(x):',
+                                    '    """The Rosenbrock function"""',
+                                    '    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)',
+                                    'def rosen_der(x):',
+                                    '    """Derivative of the Rosenbrock function"""',
+                                    '    xm = x[1:-1]',
+                                    '    xm_m1 = x[:-2]',
+                                    '    xm_p1 = x[2:]',
+                                    '    der = np.zeros_like(x)',
+                                    '    der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)',
+                                    '    der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])',
+                                    '    der[-1] = 200*(x[-1]-x[-2]**2)',
+                                    '    return der',
+                                    'def rosen_hess(x):',
+                                    '    x = np.asarray(x)',
+                                    '    H = np.diag(-400*x[:-1],1) - np.diag(400*x[:-1],-1)',
+                                    '    diagonal = np.zeros_like(x)',
+                                    '    diagonal[0] = 1200*x[0]-400*x[1]+2',
+                                    '    diagonal[-1] = 200',
+                                    '    diagonal[1:-1] = 202 + 1200*x[1:-1]**2 - 400*x[2:]',
+                                    '    H = H + np.diag(diagonal)',
+                                    '    return H',
+                                    'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])',
+                                    "res = optimize.minimize(rosen, x0, method='Newton-CG', jac=rosen_der, hess=rosen_hess,",
+                                    "                        options={'xtol': 1e-8, 'disp': True})",
+                                    'print(res.x)'],
+                            },
+                            {
+                                'name' : 'Newton-Conjugate-Gradient, Hessian product',
+                                'snippet' : [
+                                    'def rosen(x):',
+                                    '    """The Rosenbrock function"""',
+                                    '    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)',
+                                    'def rosen_der(x):',
+                                    '    """Derivative of the Rosenbrock function"""',
+                                    '    xm = x[1:-1]',
+                                    '    xm_m1 = x[:-2]',
+                                    '    xm_p1 = x[2:]',
+                                    '    der = np.zeros_like(x)',
+                                    '    der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)',
+                                    '    der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])',
+                                    '    der[-1] = 200*(x[-1]-x[-2]**2)',
+                                    '    return der',
+                                    'def rosen_hess_p(x,p):',
+                                    '    x = np.asarray(x)',
+                                    '    Hp = np.zeros_like(x)',
+                                    '    Hp[0] = (1200*x[0]**2 - 400*x[1] + 2)*p[0] - 400*x[0]*p[1]',
+                                    '    Hp[1:-1] = (-400*x[:-2]*p[:-2]+(202+1200*x[1:-1]**2-400*x[2:])*p[1:-1] ',
+                                    '                -400*x[1:-1]*p[2:])',
+                                    '    Hp[-1] = -400*x[-2]*p[-2] + 200*p[-1]',
+                                    '    return Hp',
+                                    'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])',
+                                    "res = optimize.minimize(rosen, x0, method='Newton-CG', jac=rosen_der, hessp=rosen_hess_p,",
+                                    "                        options={'xtol': 1e-8, 'disp': True})",
+                                    'print(res.x)'],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Constrained multivariate minimization',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Unconstrained Sequential Least SQuares Programming (SLSQP)',
+                                'snippet' : [
+                                    'def func(x, sign=1.0):',
+                                    '    """ Objective function """',
+                                    '    return sign*(2*x[0]*x[1] + 2*x[0] - x[0]**2 - 2*x[1]**2)',
+                                    'def func_deriv(x, sign=1.0):',
+                                    '    """ Derivative of objective function """',
+                                    '    dfdx0 = sign*(-2*x[0] + 2*x[1] + 2)',
+                                    '    dfdx1 = sign*(2*x[0] - 4*x[1])',
+                                    '    return np.array([ dfdx0, dfdx1 ])',
+                                    "res = optimize.minimize(func, [-1.0,1.0], args=(-1.0,), jac=func_deriv,",
+                                    "                        method='SLSQP', options={'disp': True})",
+                                    'print(res.x)',
+                                ],
+                            },
+                            {
+                                'name' : 'Constrained Sequential Least SQuares Programming (SLSQP)',
+                                'snippet' : [
+                                    'def func(x, sign=1.0):',
+                                    '    """ Objective function """',
+                                    '    return sign*(2*x[0]*x[1] + 2*x[0] - x[0]**2 - 2*x[1]**2)',
+                                    'def func_deriv(x, sign=1.0):',
+                                    '    """ Derivative of objective function """',
+                                    '    dfdx0 = sign*(-2*x[0] + 2*x[1] + 2)',
+                                    '    dfdx1 = sign*(2*x[0] - 4*x[1])',
+                                    '    return np.array([ dfdx0, dfdx1 ])',
+                                    '# Constraints correspond to x**3-y=0 and y-1>=0, respectively',
+                                    "cons = ({'type': 'eq',",
+                                    "         'fun' : lambda x: np.array([x[0]**3 - x[1]]),",
+                                    "         'jac' : lambda x: np.array([3.0*(x[0]**2.0), -1.0])},",
+                                    "        {'type': 'ineq',",
+                                    "         'fun' : lambda x: np.array([x[1] - 1]),",
+                                    "         'jac' : lambda x: np.array([0.0, 1.0])})",
+                                    "res = optimize.minimize(func, [-1.0,1.0], args=(-1.0,), jac=func_deriv,",
+                                    "                        constraints=cons, method='SLSQP', options={'disp': True})",
+                                    'print(res.x)',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Fitting (see also numpy.polynomial)',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Basic function fitting',
+                                'snippet' : [
+                                    'def fitting_function(x, a, b, c):',
+                                    '    return a * np.exp(-b * x) + c',
+                                    'xdata = np.linspace(0, 4, 50)',
+                                    'ydata = fitting_function(xdata, 2.5, 1.3, 0.5) + 0.2 * np.random.normal(size=len(xdata))',
+                                    'optimal_parameters, estimated_covariance = optimize.curve_fit(fitting_function, xdata, ydata)',
+                                    'estimated_std_dev = np.sqrt(np.diag(estimated_covariance))',
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+
+            // {
+            //     'name' : 'Signal processing',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import signal',],
+            //         },
+            //        '---',
+            //     ],
+            // },
+
+            // {
+            //     'name' : 'Sparse matrices and associated routines',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import sparse',],
+            //         },
+            //        '---',
+            //     ],
+            // },
+
+            // {
+            //     'name' : 'Spatial data structures and algorithms',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import spatial',],
+            //         },
+            //        '---',
+            //     ],
+            // },
+
+            scipy_special,
+
+            {
+                'name' : 'Statistical distributions and functions',
+                'sub-menu' : [
+                    {
+                        'name' : 'Setup',
+                        'snippet' : ['from scipy import stats',],
+                    },
+                    '---',
+                    {
+                        'name' : 'Docs',
+                        'external-link' : 'http://docs.scipy.org/doc/scipy-0.15.1/reference/stats.html'
+                    },
+                ],
+            },
+
+            // {
+            //     'name' : 'C/C++ integration',
+            //     'sub-menu' : [
+            //         {
+            //             'name' : 'Setup',
+            //             'snippet' : ['from scipy import weave',],
+            //         },
+            //         '---',
+            //     ],
+            // },
+        ],
+    };
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/scipy_special.js

@@ -0,0 +1,2198 @@
+define({
+    'name' : 'Special functions',
+    'sub-menu' : [
+        {
+            'name' : 'Setup',
+            'snippet' : ['from scipy import special',],
+        },
+        '---',
+
+        {
+            'name' : 'Airy functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'airy: Airy functions and their derivatives',
+                    'snippet' : [
+                        'special.airy(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'airye: Exponentially scaled Airy functions and their derivatives',
+                    'snippet' : [
+                        'special.airye(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'ai_zeros: Compute $n$ zeros $a$ and $a\'$ of $\\mathrm{Ai}(x)$ and $\\mathrm{Ai}\'(x)$, and $\\mathrm{Ai}(a\')$ and $\\mathrm{Ai}\'(a)$',
+                    'snippet' : [
+                        'special.ai_zeros(n)',
+                    ],
+                },
+
+                {
+                    'name' : 'bi_zeros: Compute $n$ zeros $b$ and $b\'$ of $\\mathrm{Bi}(x)$ and $\\mathrm{Bi}\'(x)$, and $\\mathrm{Bi}(b\')$ and $\\mathrm{Bi}\'(b)$',
+                    'snippet' : [
+                        'special.bi_zeros(n)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Elliptic Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'ellipj: Jacobian elliptic functions',
+                    'snippet' : [
+                        'special.ellipj(u, m)',
+                    ],
+                },
+
+                {
+                    'name' : 'ellipk: Computes the complete elliptic integral of the first kind',
+                    'snippet' : [
+                        'special.ellipk(m)',
+                    ],
+                },
+
+                {
+                    'name' : 'ellipkm1: The complete elliptic integral of the first kind around m=1',
+                    'snippet' : [
+                        'special.ellipkm1(p)',
+                    ],
+                },
+
+                {
+                    'name' : 'ellipkinc: Incomplete elliptic integral of the first kind',
+                    'snippet' : [
+                        'special.ellipkinc(phi, m)',
+                    ],
+                },
+
+                {
+                    'name' : 'ellipe: Complete elliptic integral of the second kind',
+                    'snippet' : [
+                        'special.ellipe(m)',
+                    ],
+                },
+
+                {
+                    'name' : 'ellipeinc: Incomplete elliptic integral of the second kind',
+                    'snippet' : [
+                        'special.ellipeinc(phi,m)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Bessel Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'Bessel Functions',
+                    'sub-menu' : [
+
+                        {
+                            'name' : 'jv: Bessel function of the first kind of real order $v$, $J_v(z)$',
+                            'snippet' : [
+                                'special.jv(v, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'jve: Exponentially scaled Bessel function of the first kind of order $v$, $J_v(z)\\, e^{-|\\Im{z}|}$',
+                            'snippet' : [
+                                'special.jve(v, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'yn: Bessel function of the second kind of integer order $n$, $Y_n(x)$',
+                            'snippet' : [
+                                'special.yn(n,x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'yv: Bessel function of the second kind of real order $v$, $Y_v(z)$',
+                            'snippet' : [
+                                'special.yv(v,z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'yve: Exponentially scaled Bessel function of the second kind of real order, $Y_v(z)\\, e^{-|\\Im{z}|}$',
+                            'snippet' : [
+                                'special.yve(v,z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'kn: Modified Bessel function of the second kind of integer order $n$, $K_n(x)$',
+                            'snippet' : [
+                                'special.kn(n, x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'kv: Modified Bessel function of the second kind of real order $v$, $K_v(z)$',
+                            'snippet' : [
+                                'special.kv(v,z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'kve: Exponentially scaled modified Bessel function of the second kind, $K_v(z)\\, e^{z}$',
+                            'snippet' : [
+                                'special.kve(v,z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'iv: Modified Bessel function of the first kind of real order $v$, $I_v(z)$',
+                            'snippet' : [
+                                'special.iv(v,z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'ive: Exponentially scaled modified Bessel function of the first kind of real order $v$, $I_v(z)\\, e^{-|\\Re{z}|}$',
+                            'snippet' : [
+                                'special.ive(v,z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'hankel1: Hankel function of the first kind, $H^{(1)}_v(z)$',
+                            'snippet' : [
+                                'special.hankel1(v, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'hankel1e: Exponentially scaled Hankel function of the first kind, $H^{(1)}_v(z)\\, e^{-i\\, z}$',
+                            'snippet' : [
+                                'special.hankel1e(v, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'hankel2: Hankel function of the second kind, $H^{(2)}_v(z)$',
+                            'snippet' : [
+                                'special.hankel2(v, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'hankel2e: Exponentially scaled Hankel function of the second kind, $H^{(2)}_v(z)\\, e^{i\\, z}$',
+                            'snippet' : [
+                                'special.hankel2e(v, z)',
+                            ],
+                        },
+
+                        // The following is not an universal function:
+
+                        {
+                            'name' : 'lmbda: Compute sequence of lambda functions with arbitrary order $v$ and their derivatives',
+                            'snippet' : [
+                                'special.lmbda(v, x)',
+                            ],
+                        },
+
+                    ],
+                },
+
+                {
+                    'name' : 'Zeros of Bessel Functions',
+                    'sub-menu' : [
+
+                        // These are not universal functions:
+
+                        {
+                            'name' : 'jnjnp_zeros: Compute nt (<=1200) zeros of the Bessel functions $J_n$ and $J_n\'$ and arange them in order of their magnitudes',
+                            'snippet' : [
+                                'special.jnjnp_zeros(nt)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'jnyn_zeros: Compute nt zeros of the Bessel functions $J_n(x)$, $J_n\'(x)$, $Y_n(x)$, and $Y_n\'(x)$, respectively',
+                            'snippet' : [
+                                'special.jnyn_zeros(n, nt)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'jn_zeros: Compute nt zeros of the Bessel function $J_n(x)$',
+                            'snippet' : [
+                                'special.jn_zeros(n, nt)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'jnp_zeros: Compute nt zeros of the Bessel function $J_n\'(x)$',
+                            'snippet' : [
+                                'special.jnp_zeros(n, nt)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'yn_zeros: Compute nt zeros of the Bessel function $Y_n(x)$',
+                            'snippet' : [
+                                'special.yn_zeros(n, nt)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'ynp_zeros: Compute nt zeros of the Bessel function $Y_n\'(x)$',
+                            'snippet' : [
+                                'special.ynp_zeros(n, nt)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'y0_zeros: Returns nt (complex or real) zeros of $Y_0(z)$, $z_0$, and the value of $Y_0\'(z_0) = -Y_1(z_0)$ at each zero',
+                            'snippet' : [
+                                'special.y0_zeros(nt, complex=0)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'y1_zeros: Returns nt (complex or real) zeros of $Y_1(z)$, $z_1$, and the value of $Y_1\'(z_1) = Y_0(z_1)$ at each zero',
+                            'snippet' : [
+                                'special.y1_zeros(nt, complex=0)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'y1p_zeros: Returns nt (complex or real) zeros of $Y_1\'(z)$, $z_1\'$, and the value of $Y_1(z_1\')$ at each zero',
+                            'snippet' : [
+                                'special.y1p_zeros(nt, complex=0)',
+                            ],
+                        },
+
+                    ],
+                },
+
+                {
+                    'name' : 'Faster versions of common Bessel Functions',
+                    'sub-menu' : [
+
+                        {
+                            'name' : 'j0: Bessel function the first kind of order 0, $J_0(x)$',
+                            'snippet' : [
+                                'special.j0(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'j1: Bessel function of the first kind of order 1, $J_1(x)$',
+                            'snippet' : [
+                                'special.j1(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'y0: Bessel function of the second kind of order 0, $Y_0(x)$',
+                            'snippet' : [
+                                'special.y0(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'y1: Bessel function of the second kind of order 1, $Y_1(x)$',
+                            'snippet' : [
+                                'special.y1(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'i0: Modified Bessel function of order 0, $I_0(x)$',
+                            'snippet' : [
+                                'special.i0(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'i0e: Exponentially scaled modified Bessel function of order 0, $I_0(x)\\, e^{-|x|}$',
+                            'snippet' : [
+                                'special.i0e(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'i1: Modified Bessel function of order 1, $I_1(x)$',
+                            'snippet' : [
+                                'special.i1(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'i1e: Exponentially scaled modified Bessel function of order 1, $I_1(x)\\, e^{-|x|}$',
+                            'snippet' : [
+                                'special.i1e(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'k0: Modified Bessel function K of order 0, $K_0(x)$',
+                            'snippet' : [
+                                'special.k0(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'k0e: Exponentially scaled modified Bessel function K of order 0, $K_0(x)\\, e^{x}$',
+                            'snippet' : [
+                                'special.k0e(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'k1: Modified Bessel function of the first kind of order 1, $K_1(x)$',
+                            'snippet' : [
+                                'special.k1(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'k1e: Exponentially scaled modified Bessel function K of order 1, $K_1(x)\\, e^{x}$',
+                            'snippet' : [
+                                'special.k1e(x)',
+                            ],
+                        },
+
+                    ],
+                },
+
+                {
+                    'name' : 'Integrals of Bessel Functions',
+                    'sub-menu' : [
+
+                        {
+                            'name' : 'itj0y0: Integrals of Bessel functions of order 0: $\\int_0^x J_0(t)\\, dt$, $\\int_0^x Y_0(t)\\, dt$',
+                            'snippet' : [
+                                'special.itj0y0(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'it2j0y0: Integrals related to Bessel functions of order 0: $\\int_0^x \\frac{1-J_0(t)}{t}\\, dt$, $\\int_x^\\infty \\frac{Y_0(t)}{t}\\, dt$',
+                            'snippet' : [
+                                'special.it2j0y0(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'iti0k0: Integrals of modified Bessel functions of order 0: $\\int_0^x I_0(t)\\, dt$, $\\int_0^x K_0(t)\\, dt$',
+                            'snippet' : [
+                                'special.iti0k0(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'it2i0k0: Integrals related to modified Bessel functions of order 0: $\\int_0^x \\frac{I_0(t)-1}{t}\\, dt$, $\\int_x^\\infty \\frac{K_0(t)}{t}\\, dt$',
+                            'snippet' : [
+                                'special.it2i0k0(x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'besselpoly: Weighted integral of a Bessel function, $\\int_0^1 x^\\lambda J_\\nu(2 a x) \\, dx$',
+                            'snippet' : [
+                                'special.besselpoly(a, lmb, nu)',
+                            ],
+                        },
+
+                    ],
+                },
+
+                {
+                    'name' : 'Derivatives of Bessel Functions',
+                    'sub-menu' : [
+
+                        {
+                            'name' : 'jvp: Return the $n$th derivative of $J_v(z)$ with respect to $z$',
+                            'snippet' : [
+                                'special.jvp(v, z, n=1)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'yvp: Return the $n$th derivative of $Y_v(z)$ with respect to $z$',
+                            'snippet' : [
+                                'special.yvp(v, z, n=1)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'kvp: Return the $n$th derivative of $K_v(z)$ with respect to $z$',
+                            'snippet' : [
+                                'special.kvp(v, z, n=1)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'ivp: Return the $n$th derivative of $I_v(z)$ with respect to $z$',
+                            'snippet' : [
+                                'special.ivp(v, z, n=1)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'h1vp: Return the $n$th derivative of $H^{(1)}_v(z)$ with respect to $z$',
+                            'snippet' : [
+                                'special.h1vp(v, z, n=1)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'h2vp: Return the $n$th derivative of $H^{(2)}_v(z)$ with respect to z',
+                            'snippet' : [
+                                'special.h2vp(v, z, n=1)',
+                            ],
+                        },
+
+                    ],
+                },
+
+                {
+                    'name' : 'Spherical Bessel Functions',
+                    'sub-menu' : [
+
+                        // These are not universal functions:
+
+                        {
+                            'name' : 'sph_jn: Compute the spherical Bessel function $j_n(z)$ and its derivative for all orders up to and including $n$',
+                            'snippet' : [
+                                'special.sph_jn(n, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'sph_yn: Compute the spherical Bessel function $y_n(z)$ and its derivative for all orders up to and including $n$',
+                            'snippet' : [
+                                'special.sph_yn(n, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'sph_jnyn: Compute the spherical Bessel functions, $j_n(z)$ and $y_n(z)$ and their derivatives for all orders up to and including $n$',
+                            'snippet' : [
+                                'special.sph_jnyn(n, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'sph_in: Compute the spherical Bessel function $i_n(z)$ and its derivative for all orders up to and including $n$',
+                            'snippet' : [
+                                'special.sph_in(n, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'sph_kn: Compute the spherical Bessel function $k_n(z)$ and its derivative for all orders up to and including $n$',
+                            'snippet' : [
+                                'special.sph_kn(n, z)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'sph_inkn: Compute the spherical Bessel functions, $i_n(z)$ and $k_n(z)$ and their derivatives for all orders up to and including $n$',
+                            'snippet' : [
+                                'special.sph_inkn(n, z)',
+                            ],
+                        },
+
+                    ],
+                },
+
+                {
+                    'name' : 'Riccati-Bessel Functions',
+                    'sub-menu' : [
+
+                        // These are not universal functions:
+
+                        {
+                            'name' : 'riccati_jn: Compute the Ricatti-Bessel function of the first kind and its derivative for all orders up to and including n',
+                            'snippet' : [
+                                'special.riccati_jn(n, x)',
+                            ],
+                        },
+
+                        {
+                            'name' : 'riccati_yn: Compute the Ricatti-Bessel function of the second kind and its derivative for all orders up to and including n',
+                            'snippet' : [
+                                'special.riccati_yn(n, x)',
+                            ],
+                        },
+
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Struve Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'struve: Struve function',
+                    'snippet' : [
+                        'special.struve(v,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'modstruve: Modified Struve function',
+                    'snippet' : [
+                        'special.modstruve(v, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'itstruve0: Integral of the Struve function of order 0',
+                    'snippet' : [
+                        'special.itstruve0(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'it2struve0: Integral related to Struve function of order 0',
+                    'snippet' : [
+                        'special.it2struve0(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'itmodstruve0: Integral of the modified Struve function of order 0',
+                    'snippet' : [
+                        'special.itmodstruve0(x)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Statistical Functions (see also scipy.stats)',
+            'sub-menu' : [
+
+// See also
+// scipy.stats: Friendly versions of these functions.
+
+                {
+                    'name' : 'bdtr: Binomial distribution cumulative distribution function',
+                    'snippet' : [
+                        'special.bdtr(k, n, p)',
+                    ],
+                },
+
+                {
+                    'name' : 'bdtrc: Binomial distribution survival function',
+                    'snippet' : [
+                        'special.bdtrc(k, n, p)',
+                    ],
+                },
+
+                {
+                    'name' : 'bdtri: Inverse function to bdtr vs',
+                    'snippet' : [
+                        'special.bdtri(k, n, y)',
+                    ],
+                },
+
+                {
+                    'name' : 'btdtr: Cumulative beta distribution',
+                    'snippet' : [
+                        'special.btdtr(a,b,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'btdtri: p-th quantile of the beta distribution',
+                    'snippet' : [
+                        'special.btdtri(a,b,p)',
+                    ],
+                },
+
+                {
+                    'name' : 'fdtr: F cumulative distribution function',
+                    'snippet' : [
+                        'special.fdtr(dfn, dfd, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'fdtrc: F survival function',
+                    'snippet' : [
+                        'special.fdtrc(dfn, dfd, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'fdtri: Inverse to fdtr vs x',
+                    'snippet' : [
+                        'special.fdtri(dfn, dfd, p)',
+                    ],
+                },
+
+                {
+                    'name' : 'gdtr: Gamma distribution cumulative density function',
+                    'snippet' : [
+                        'special.gdtr(a,b,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'gdtrc: Gamma distribution survival function',
+                    'snippet' : [
+                        'special.gdtrc(a,b,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'gdtria: Inverse of gdtr vs a',
+                    'snippet' : [
+                        'special.gdtria(p, b, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'gdtrib: Inverse of gdtr vs b',
+                    'snippet' : [
+                        'special.gdtrib(a, p, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'gdtrix: Inverse of gdtr vs x',
+                    'snippet' : [
+                        'special.gdtrix(a, b, p)',
+                    ],
+                },
+
+                {
+                    'name' : 'nbdtr: Negative binomial cumulative distribution function',
+                    'snippet' : [
+                        'special.nbdtr(k, n, p)',
+                    ],
+                },
+
+                {
+                    'name' : 'nbdtrc: Negative binomial survival function',
+                    'snippet' : [
+                        'special.nbdtrc(k,n,p)',
+                    ],
+                },
+
+                {
+                    'name' : 'nbdtri: Inverse of nbdtr vs p',
+                    'snippet' : [
+                        'special.nbdtri(k, n, y)',
+                    ],
+                },
+
+                {
+                    'name' : 'ncfdtr: Cumulative distribution function of the non-central $F$ distribution.',
+                    'snippet' : [
+                        'special.ncfdtr(dfn, dfd, nc, f)',
+                    ],
+                },
+
+                {
+                    'name' : 'ncfdtridfd: Calculate degrees of freedom (denominator) for the noncentral $F$ distribution.',
+                    'snippet' : [
+                        'special.ncfdtridfd(p, f, dfn, nc)',
+                    ],
+                },
+
+                {
+                    'name' : 'ncfdtridfn: Calculate degrees of freedom (numerator) for the noncentral $F$ distribution.',
+                    'snippet' : [
+                        'special.ncfdtridfn(p, f, dfd, nc)',
+                    ],
+                },
+
+                {
+                    'name' : 'ncfdtri: Inverse cumulative distribution function of the non-central $F$ distribution.',
+                    'snippet' : [
+                        'special.ncfdtri(p, dfn, dfd, nc)',
+                    ],
+                },
+
+                {
+                    'name' : 'ncfdtrinc: Calculate non-centrality parameter for non-central $F$ distribution.',
+                    'snippet' : [
+                        'special.ncfdtrinc(p, f, dfn, dfd)',
+                    ],
+                },
+
+                {
+                    'name' : 'nctdtr: Cumulative distribution function of the non-central $t$ distribution.',
+                    'snippet' : [
+                        'special.nctdtr(df, nc, t)',
+                    ],
+                },
+
+                {
+                    'name' : 'nctdtridf: Calculate degrees of freedom for non-central $t$ distribution.',
+                    'snippet' : [
+                        'special.nctdtridf(p, nc, t)',
+                    ],
+                },
+
+                {
+                    'name' : 'nctdtrit: Inverse cumulative distribution function of the non-central $t$ distribution.',
+                    'snippet' : [
+                        'special.nctdtrit(df, nc, p)',
+                    ],
+                },
+
+                {
+                    'name' : 'nctdtrinc: Calculate non-centrality parameter for non-central $t$ distribution.',
+                    'snippet' : [
+                        'special.nctdtrinc(df, p, t)',
+                    ],
+                },
+
+                {
+                    'name' : 'nrdtrimn: Calculate mean of normal distribution given other params.',
+                    'snippet' : [
+                        'special.nrdtrimn(p, x, std)',
+                    ],
+                },
+
+                {
+                    'name' : 'nrdtrisd: Calculate standard deviation of normal distribution given other params.',
+                    'snippet' : [
+                        'special.nrdtrisd(p, x, mn)',
+                    ],
+                },
+
+                {
+                    'name' : 'pdtr: Poisson cumulative distribution function',
+                    'snippet' : [
+                        'special.pdtr(k, m)',
+                    ],
+                },
+
+                {
+                    'name' : 'pdtrc: Poisson survival function',
+                    'snippet' : [
+                        'special.pdtrc(k, m)',
+                    ],
+                },
+
+                {
+                    'name' : 'pdtri: Inverse to pdtr vs m',
+                    'snippet' : [
+                        'special.pdtri(k,y)',
+                    ],
+                },
+
+                {
+                    'name' : 'stdtr: Student $t$ distribution cumulative density function',
+                    'snippet' : [
+                        'special.stdtr(df,t)',
+                    ],
+                },
+
+                {
+                    'name' : 'stdtridf: Inverse of stdtr vs df',
+                    'snippet' : [
+                        'special.stdtridf(p,t)',
+                    ],
+                },
+
+                {
+                    'name' : 'stdtrit: Inverse of stdtr vs t',
+                    'snippet' : [
+                        'special.stdtrit(df,p)',
+                    ],
+                },
+
+                {
+                    'name' : 'chdtr: Chi square cumulative distribution function',
+                    'snippet' : [
+                        'special.chdtr(v, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'chdtrc: Chi square survival function',
+                    'snippet' : [
+                        'special.chdtrc(v,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'chdtri: Inverse to chdtrc',
+                    'snippet' : [
+                        'special.chdtri(v,p)',
+                    ],
+                },
+
+                {
+                    'name' : 'ndtr: Gaussian cumulative distribution function',
+                    'snippet' : [
+                        'special.ndtr(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'ndtri: Inverse of ndtr vs x',
+                    'snippet' : [
+                        'special.ndtri(y)',
+                    ],
+                },
+
+                {
+                    'name' : 'smirnov: Kolmogorov-Smirnov complementary cumulative distribution function',
+                    'snippet' : [
+                        'special.smirnov(n,e)',
+                    ],
+                },
+
+                {
+                    'name' : 'smirnovi: Inverse to smirnov',
+                    'snippet' : [
+                        'special.smirnovi(n,y)',
+                    ],
+                },
+
+                {
+                    'name' : 'kolmogorov: Complementary cumulative distribution function of Kolmogorov distribution',
+                    'snippet' : [
+                        'special.kolmogorov(y)',
+                    ],
+                },
+
+                {
+                    'name' : 'kolmogi: Inverse function to kolmogorov',
+                    'snippet' : [
+                        'special.kolmogi(p)',
+                    ],
+                },
+
+                {
+                    'name' : 'tklmbda: Tukey-Lambda cumulative distribution function',
+                    'snippet' : [
+                        'special.tklmbda(x, lmbda)',
+                    ],
+                },
+
+                {
+                    'name' : 'logit: Logit ufunc for ndarrays',
+                    'snippet' : [
+                        'special.logit(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'expit: Expit ufunc for ndarrays',
+                    'snippet' : [
+                        'special.expit(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'boxcox: Compute the Box-Cox transformation',
+                    'snippet' : [
+                        'special.boxcox(x, lmbda)',
+                    ],
+                },
+
+                {
+                    'name' : 'boxcox1p: Compute the Box-Cox transformation of 1 + x',
+                    'snippet' : [
+                        'special.boxcox1p(x, lmbda)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Information Theory Functions',
+            'sub-menu' : [
+                {
+                    'name' : 'entr: Elementwise function for computing entropy.',
+                    'snippet' : [
+                        'special.entr(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'rel_entr: Elementwise function for computing relative entropy.',
+                    'snippet' : [
+                        'special.rel_entr(x, y)',
+                    ],
+                },
+
+                {
+                    'name' : 'kl_div: Elementwise function for computing Kullback-Leibler divergence.',
+                    'snippet' : [
+                        'special.kl_div(x, y)',
+                    ],
+                },
+
+                {
+                    'name' : 'huber: Huber loss function.',
+                    'snippet' : [
+                        'special.huber(delta, r)',
+                    ],
+                },
+
+                {
+                    'name' : 'pseudo_huber: Pseudo-Huber loss function.',
+                    'snippet' : [
+                        'special.pseudo_huber(delta, r)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Gamma and Related Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'gamma: Gamma function',
+                    'snippet' : [
+                        'special.gamma(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'gammaln: Logarithm of absolute value of gamma function',
+                    'snippet' : [
+                        'special.gammaln(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'gammasgn: Sign of the gamma function',
+                    'snippet' : [
+                        'special.gammasgn(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'gammainc: Incomplete gamma function',
+                    'snippet' : [
+                        'special.gammainc(a, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'gammaincinv: Inverse to gammainc',
+                    'snippet' : [
+                        'special.gammaincinv(a, y)',
+                    ],
+                },
+
+                {
+                    'name' : 'gammaincc: Complemented incomplete gamma integral',
+                    'snippet' : [
+                        'special.gammaincc(a,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'gammainccinv: Inverse to gammaincc',
+                    'snippet' : [
+                        'special.gammainccinv(a,y)',
+                    ],
+                },
+
+                {
+                    'name' : 'beta: Beta function',
+                    'snippet' : [
+                        'special.beta(a, b)',
+                    ],
+                },
+
+                {
+                    'name' : 'betaln: Natural logarithm of absolute value of beta function',
+                    'snippet' : [
+                        'special.betaln(a, b)',
+                    ],
+                },
+
+                {
+                    'name' : 'betainc: Incomplete beta integral',
+                    'snippet' : [
+                        'special.betainc(a, b, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'betaincinv: Inverse function to beta integral',
+                    'snippet' : [
+                        'special.betaincinv(a, b, y)',
+                    ],
+                },
+
+                {
+                    'name' : 'psi: Digamma function',
+                    'snippet' : [
+                        'special.psi(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'rgamma: Gamma function inverted',
+                    'snippet' : [
+                        'special.rgamma(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'polygamma: Polygamma function which is the $n$th derivative of the digamma (psi) function',
+                    'snippet' : [
+                        'special.polygamma(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'multigammaln: Returns the log of multivariate gamma, also sometimes called the generalized gamma',
+                    'snippet' : [
+                        'special.multigammaln(a, d)',
+                    ],
+                },
+
+                {
+                    'name' : 'digamma: Digamma function',
+                    'snippet' : [
+                        'special.digamma(z)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Error Function and Fresnel Integrals',
+            'sub-menu' : [
+
+                {
+                    'name' : 'erf: Returns the error function of complex argument',
+                    'snippet' : [
+                        'special.erf(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'erfc: Complementary error function, $1 - \\mathrm{erf}(x)$',
+                    'snippet' : [
+                        'special.erfc(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'erfcx: Scaled complementary error function, $\\exp(x^2)\\, \\mathrm{erfc}(x)$',
+                    'snippet' : [
+                        'special.erfcx(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'erfi: Imaginary error function, $-i\\, \\mathrm{erf}(i\\, z)$',
+                    'snippet' : [
+                        'special.erfi(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'erfinv: Inverse function for erf',
+                    'snippet' : [
+                        'special.erfinv(y)',
+                    ],
+                },
+
+                {
+                    'name' : 'erfcinv: Inverse function for erfc',
+                    'snippet' : [
+                        'special.erfcinv(y)',
+                    ],
+                },
+
+                {
+                    'name' : 'wofz: Faddeeva function',
+                    'snippet' : [
+                        'special.wofz(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'dawsn: Dawson’s integral',
+                    'snippet' : [
+                        'special.dawsn(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'fresnel: Fresnel sin and cos integrals',
+                    'snippet' : [
+                        'special.fresnel(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'fresnel_zeros: Compute nt complex zeros of the sine and cosine Fresnel integrals S(z) and C(z)',
+                    'snippet' : [
+                        'special.fresnel_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'modfresnelp: Modified Fresnel positive integrals',
+                    'snippet' : [
+                        'special.modfresnelp(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'modfresnelm: Modified Fresnel negative integrals',
+                    'snippet' : [
+                        'special.modfresnelm(x)',
+                    ],
+                },
+
+// These are not universal functions:
+
+                {
+                    'name' : 'erf_zeros: Compute nt complex zeros of the error function erf(z)',
+                    'snippet' : [
+                        'special.erf_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'fresnelc_zeros: Compute nt complex zeros of the cosine Fresnel integral C(z)',
+                    'snippet' : [
+                        'special.fresnelc_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'fresnels_zeros: Compute nt complex zeros of the sine Fresnel integral S(z)',
+                    'snippet' : [
+                        'special.fresnels_zeros(nt)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Legendre Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'lpmv: Associated legendre function of integer order',
+                    'snippet' : [
+                        'special.lpmv(m, v, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sph_harm: Spherical harmonic of degree $n \\geq 0$ and order $|m| \\leq n$',
+                    'snippet' : [
+                        '# Note: n >= 0 and |m| <= n; azimuthal angle in [0, 2pi) and polar in [0, pi]',
+                        'special.sph_harm(order_m, degree_n, azimuthal_angle, polar_angle)',
+                    ],
+                },
+
+// These are not universal functions:
+
+                {
+                    'name' : 'clpmn: Associated Legendre function of the first kind, $P_{m,n}(z)$',
+                    'snippet' : [
+                        'special.clpmn(m, n, z[, type])',
+                    ],
+                },
+
+                {
+                    'name' : 'lpn: Compute sequence of Legendre functions of the first kind (polynomials), $P_n(z)$ and derivatives for all degrees from 0 to $n$ (inclusive)',
+                    'snippet' : [
+                        'special.lpn(n, z)',
+                    ],
+                },
+
+                {
+                    'name' : 'lqn: Compute sequence of Legendre functions of the second kind, $Q_n(z)$ and derivatives for all degrees from 0 to $n$ (inclusive)',
+                    'snippet' : [
+                        'special.lqn(n, z)',
+                    ],
+                },
+
+                {
+                    'name' : 'lpmn: Associated Legendre function of the first kind, $P_{m,n}(z)$',
+                    'snippet' : [
+                        'special.lpmn(m, n, z)',
+                    ],
+                },
+
+                {
+                    'name' : 'lqmn: Associated Legendre functions of the second kind, $Q_{m,n}(z)$ and its derivative, $Q_{m,n}\'(z)$ of order $m$ and degree $n$',
+                    'snippet' : [
+                        'special.lqmn(m, n, z)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Ellipsoidal Harmonics',
+            'sub-menu' : [
+                {
+                    'name' : 'ellip_harm: Ellipsoidal harmonic functions $E^p_n(l)$',
+                    'snippet' : [
+                        'special.ellip_harm(h2, k2, n, p, s[, signm, signn])',
+                    ],
+                },
+
+                {
+                    'name' : 'ellip_harm_2: Ellipsoidal harmonic functions $F^p_n(l)$',
+                    'snippet' : [
+                        'special.ellip_harm_2(h2, k2, n, p, s)',
+                    ],
+                },
+
+                {
+                    'name' : 'ellip_normal: Ellipsoidal harmonic normalization constants $\\gamma^p_n$',
+                    'snippet' : [
+                        'special.ellip_normal(h2, k2, n, p)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Orthogonal polynomials',
+            'sub-menu' : [
+
+// The following functions evaluate values of orthogonal polynomials:
+                {
+                    'name' : 'assoc_laguerre: Returns the $n$th order generalized (associated) Laguerre polynomial.',
+                    'snippet' : [
+                        'special.assoc_laguerre(x, n)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_legendre: Evaluate Legendre polynomial at a point',
+                    'snippet' : [
+                        'special.eval_legendre(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_chebyt: Evaluate Chebyshev $T$ polynomial at a point',
+                    'snippet' : [
+                        'special.eval_chebyt(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_chebyu: Evaluate Chebyshev $U$ polynomial at a point',
+                    'snippet' : [
+                        'special.eval_chebyu(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_chebyc: Evaluate Chebyshev $C$ polynomial at a point',
+                    'snippet' : [
+                        'special.eval_chebyc(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_chebys: Evaluate Chebyshev $S$ polynomial at a point',
+                    'snippet' : [
+                        'special.eval_chebys(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_jacobi: Evaluate Jacobi polynomial at a point',
+                    'snippet' : [
+                        'special.eval_jacobi(n, alpha, beta, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_laguerre: Evaluate Laguerre polynomial at a point',
+                    'snippet' : [
+                        'special.eval_laguerre(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_genlaguerre: Evaluate generalized Laguerre polynomial at a point',
+                    'snippet' : [
+                        'special.eval_genlaguerre(n, alpha, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_hermite: Evaluate Hermite polynomial at a point',
+                    'snippet' : [
+                        'special.eval_hermite(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_hermitenorm: Evaluate normalized Hermite polynomial at a point',
+                    'snippet' : [
+                        'special.eval_hermitenorm(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_gegenbauer: Evaluate Gegenbauer polynomial at a point',
+                    'snippet' : [
+                        'special.eval_gegenbauer(n, alpha, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_sh_legendre: Evaluate shifted Legendre polynomial at a point',
+                    'snippet' : [
+                        'special.eval_sh_legendre(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_sh_chebyt: Evaluate shifted Chebyshev $T$ polynomial at a point',
+                    'snippet' : [
+                        'special.eval_sh_chebyt(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_sh_chebyu: Evaluate shifted Chebyshev $U$ polynomial at a point',
+                    'snippet' : [
+                        'special.eval_sh_chebyu(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'eval_sh_jacobi: Evaluate shifted Jacobi polynomial at a point',
+                    'snippet' : [
+                        'special.eval_sh_jacobi(n, p, q, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'legendre: Coefficients of the $n$th order Legendre polynomial, $P_n(x)$',
+                    'snippet' : [
+                        'special.legendre(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'chebyt: Coefficients of the $n$th order Chebyshev polynomial of first kind, $T_n(x)$',
+                    'snippet' : [
+                        'special.chebyt(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'chebyu: Coefficients of the $n$th order Chebyshev polynomial of second kind, $U_n(x)$',
+                    'snippet' : [
+                        'special.chebyu(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'chebyc: Coefficients of the $n$th order Chebyshev polynomial of first kind, $C_n(x)$',
+                    'snippet' : [
+                        'special.chebyc(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'chebys: Coefficients of the $n$th order Chebyshev polynomial of second kind, $S_n$(x)',
+                    'snippet' : [
+                        'special.chebys(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'jacobi: Coefficients of the $n$th order Jacobi polynomial, $P^(\\alpha,\\beta)_n(x)$ orthogonal over [-1,1] with weighting function $(1-x)^\\alpha (1+x)^\\beta$ with $\\alpha,\\beta > -1$',
+                    'snippet' : [
+                        'special.jacobi(n, alpha, beta[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'laguerre: Coefficients of the $n$th order Laguerre polynoimal, $L_n(x)$',
+                    'snippet' : [
+                        'special.laguerre(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'genlaguerre: Coefficients of the $n$th order generalized (associated) Laguerre polynomial,',
+                    'snippet' : [
+                        'special.genlaguerre(n, alpha[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'hermite: Coefficients of the $n$th order Hermite polynomial, $H_n(x)$, orthogonal over',
+                    'snippet' : [
+                        'special.hermite(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'hermitenorm: Coefficients of the $n$th order normalized Hermite polynomial, $He_n(x)$, orthogonal',
+                    'snippet' : [
+                        'special.hermitenorm(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'gegenbauer: Coefficients of the $n$th order Gegenbauer (ultraspherical) polynomial,',
+                    'snippet' : [
+                        'special.gegenbauer(n, alpha[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'sh_legendre: Coefficients of the $n$th order shifted Legendre polynomial, $P^\\ast_n(x)$',
+                    'snippet' : [
+                        'special.sh_legendre(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'sh_chebyt: Coefficients of $n$th order shifted Chebyshev polynomial of first kind, $T_n(x)$',
+                    'snippet' : [
+                        'special.sh_chebyt(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'sh_chebyu: Coefficients of the $n$th order shifted Chebyshev polynomial of second kind, $U_n(x)$',
+                    'snippet' : [
+                        'special.sh_chebyu(n[, monic])',
+                    ],
+                },
+
+                {
+                    'name' : 'sh_jacobi: Coefficients of the $n$th order Jacobi polynomial, $G_n(p,q,x)$ orthogonal over [0,1] with weighting function $(1-x)^{p-q} x^{q-1}$ with $p>q-1$ and $q > 0$',
+                    'snippet' : [
+                        'special.sh_jacobi(n, p, q[, monic])',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Hypergeometric Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'hyp2f1: Gauss hypergeometric function ${}_2F_1(a, b; c; z)$',
+                    'snippet' : [
+                        'special.hyp2f1(a, b, c, z)',
+                    ],
+                },
+
+                {
+                    'name' : 'hyp1f1: Confluent hypergeometric function ${}_1F_1(a, b; x)$',
+                    'snippet' : [
+                        'special.hyp1f1(a, b, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'hyperu: Confluent hypergeometric function $U(a, b, x)$ of the second kind',
+                    'snippet' : [
+                        'special.hyperu(a, b, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'hyp0f1: Confluent hypergeometric limit function ${}_0F_1$',
+                    'snippet' : [
+                        'special.hyp0f1(v, z)',
+                    ],
+                },
+
+                {
+                    'name' : 'hyp2f0: Hypergeometric function ${}_2F_0$ in $y$ and an error estimate',
+                    'snippet' : [
+                        'special.hyp2f0(a, b, x, type)',
+                    ],
+                },
+
+                {
+                    'name' : 'hyp1f2: Hypergeometric function ${}_1F_2$ and error estimate',
+                    'snippet' : [
+                        'special.hyp1f2(a, b, c, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'hyp3f0: Hypergeometric function ${}_3F_0$ in $y$ and an error estimate',
+                    'snippet' : [
+                        'special.hyp3f0(a, b, c, x)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Parabolic Cylinder Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'pbdv: Parabolic cylinder function $D$',
+                    'snippet' : [
+                        'special.pbdv(v, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pbvv: Parabolic cylinder function $V$',
+                    'snippet' : [
+                        'special.pbvv(v,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pbwa: Parabolic cylinder function $W$',
+                    'snippet' : [
+                        'special.pbwa(a,x)',
+                    ],
+                },
+
+// These are not universal functions:
+
+                {
+                    'name' : 'pbdv_seq: $D_{v_0}(x), ..., D_v(x)$ and $D_{v_0}\'(x), ..., D_v\'(x)$ with $v_0=v-\\lfloor v \\rfloor$',
+                    'snippet' : [
+                        'special.pbdv_seq(v, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pbvv_seq: $V_{v_0}(x), ..., V_v(x)$ and $V_{v_0}\'(x), ..., V_v\'(x)$ with $v_0=v-\\lfloor v \\rfloor$',
+                    'snippet' : [
+                        'special.pbvv_seq(v, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pbdn_seq: $D_0(x), ..., D_n(x)$ and $D_0\'(x), ..., D_n\'(x)$',
+                    'snippet' : [
+                        'special.pbdn_seq(n, z)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Mathieu and Related Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'mathieu_a: Characteristic value of even Mathieu functions',
+                    'snippet' : [
+                        'special.mathieu_a(m,q)',
+                    ],
+                },
+
+                {
+                    'name' : 'mathieu_b: Characteristic value of odd Mathieu functions',
+                    'snippet' : [
+                        'special.mathieu_b(m,q)',
+                    ],
+                },
+
+// These are not universal functions:
+
+                {
+                    'name' : 'mathieu_even_coef: Compute expansion coefficients for even Mathieu functions and modified Mathieu functions',
+                    'snippet' : [
+                        'special.mathieu_even_coef(m, q)',
+                    ],
+                },
+
+                {
+                    'name' : 'mathieu_odd_coef: Compute expansion coefficients for even Mathieu functions and modified Mathieu functions',
+                    'snippet' : [
+                        'special.mathieu_odd_coef(m, q)',
+                    ],
+                },
+
+// The following return both function and first derivative:
+
+                {
+                    'name' : 'mathieu_cem: Even Mathieu function and its derivative',
+                    'snippet' : [
+                        'special.mathieu_cem(m,q,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'mathieu_sem: Odd Mathieu function and its derivative',
+                    'snippet' : [
+                        'special.mathieu_sem(m, q, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'mathieu_modcem1: Even modified Mathieu function of the first kind and its derivative',
+                    'snippet' : [
+                        'special.mathieu_modcem1(m, q, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'mathieu_modcem2: Even modified Mathieu function of the second kind and its derivative',
+                    'snippet' : [
+                        'special.mathieu_modcem2(m, q, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'mathieu_modsem1: Odd modified Mathieu function of the first kind and its derivative',
+                    'snippet' : [
+                        'special.mathieu_modsem1(m,q,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'mathieu_modsem2: Odd modified Mathieu function of the second kind and its derivative',
+                    'snippet' : [
+                        'special.mathieu_modsem2(m, q, x)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Spheroidal Wave Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'pro_ang1: Prolate spheroidal angular function of the first kind and its derivative',
+                    'snippet' : [
+                        'special.pro_ang1(m,n,c,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pro_rad1: Prolate spheroidal radial function of the first kind and its derivative',
+                    'snippet' : [
+                        'special.pro_rad1(m,n,c,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pro_rad2: Prolate spheroidal radial function of the secon kind and its derivative',
+                    'snippet' : [
+                        'special.pro_rad2(m,n,c,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'obl_ang1: Oblate spheroidal angular function of the first kind and its derivative',
+                    'snippet' : [
+                        'special.obl_ang1(m, n, c, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'obl_rad1: Oblate spheroidal radial function of the first kind and its derivative',
+                    'snippet' : [
+                        'special.obl_rad1(m,n,c,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'obl_rad2: Oblate spheroidal radial function of the second kind and its derivative',
+                    'snippet' : [
+                        'special.obl_rad2(m,n,c,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pro_cv: Characteristic value of prolate spheroidal function',
+                    'snippet' : [
+                        'special.pro_cv(m,n,c)',
+                    ],
+                },
+
+                {
+                    'name' : 'obl_cv: Characteristic value of oblate spheroidal function',
+                    'snippet' : [
+                        'special.obl_cv(m, n, c)',
+                    ],
+                },
+
+                {
+                    'name' : 'pro_cv_seq: Compute a sequence of characteristic values for the prolate spheroidal wave functions for mode m and n’=m..n and spheroidal parameter c',
+                    'snippet' : [
+                        'special.pro_cv_seq(m, n, c)',
+                    ],
+                },
+
+                {
+                    'name' : 'obl_cv_seq: Compute a sequence of characteristic values for the oblate spheroidal wave functions for mode m and n’=m..n and spheroidal parameter c',
+                    'snippet' : [
+                        'special.obl_cv_seq(m, n, c)',
+                    ],
+                },
+
+// The following functions require pre-computed characteristic value:
+
+                {
+                    'name' : 'pro_ang1_cv: Prolate spheroidal angular function pro_ang1 for precomputed characteristic value',
+                    'snippet' : [
+                        'special.pro_ang1_cv(m,n,c,cv,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pro_rad1_cv: Prolate spheroidal radial function pro_rad1 for precomputed characteristic value',
+                    'snippet' : [
+                        'special.pro_rad1_cv(m,n,c,cv,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'pro_rad2_cv: Prolate spheroidal radial function pro_rad2 for precomputed characteristic value',
+                    'snippet' : [
+                        'special.pro_rad2_cv(m,n,c,cv,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'obl_ang1_cv: Oblate spheroidal angular function obl_ang1 for precomputed characteristic value',
+                    'snippet' : [
+                        'special.obl_ang1_cv(m, n, c, cv, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'obl_rad1_cv: Oblate spheroidal radial function obl_rad1 for precomputed characteristic value',
+                    'snippet' : [
+                        'special.obl_rad1_cv(m,n,c,cv,x)',
+                    ],
+                },
+
+                {
+                    'name' : 'obl_rad2_cv: Oblate spheroidal radial function obl_rad2 for precomputed characteristic value',
+                    'snippet' : [
+                        'special.obl_rad2_cv(m,n,c,cv,x)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Kelvin Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'kelvin: Kelvin functions as complex numbers',
+                    'snippet' : [
+                        'special.kelvin(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'kelvin_zeros: Compute nt zeros of all the Kelvin functions returned in a length 8 tuple of arrays of length nt',
+                    'snippet' : [
+                        'special.kelvin_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'ber: Kelvin function ber',
+                    'snippet' : [
+                        'special.ber(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'bei: Kelvin function bei',
+                    'snippet' : [
+                        'special.bei(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'berp: Derivative of the Kelvin function ber',
+                    'snippet' : [
+                        'special.berp(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'beip: Derivative of the Kelvin function bei',
+                    'snippet' : [
+                        'special.beip(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'ker: Kelvin function ker',
+                    'snippet' : [
+                        'special.ker(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'kei: Kelvin function ker',
+                    'snippet' : [
+                        'special.kei(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'kerp: Derivative of the Kelvin function ker',
+                    'snippet' : [
+                        'special.kerp(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'keip: Derivative of the Kelvin function kei',
+                    'snippet' : [
+                        'special.keip(x)',
+                    ],
+                },
+
+// These are not universal functions:
+
+                {
+                    'name' : 'ber_zeros: Compute nt zeros of the Kelvin function ber x',
+                    'snippet' : [
+                        'special.ber_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'bei_zeros: Compute nt zeros of the Kelvin function bei x',
+                    'snippet' : [
+                        'special.bei_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'berp_zeros: Compute nt zeros of the Kelvin function ber’ x',
+                    'snippet' : [
+                        'special.berp_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'beip_zeros: Compute nt zeros of the Kelvin function bei’ x',
+                    'snippet' : [
+                        'special.beip_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'ker_zeros: Compute nt zeros of the Kelvin function ker x',
+                    'snippet' : [
+                        'special.ker_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'kei_zeros: Compute nt zeros of the Kelvin function kei x',
+                    'snippet' : [
+                        'special.kei_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'kerp_zeros: Compute nt zeros of the Kelvin function ker’ x',
+                    'snippet' : [
+                        'special.kerp_zeros(nt)',
+                    ],
+                },
+
+                {
+                    'name' : 'keip_zeros: Compute nt zeros of the Kelvin function kei’ x',
+                    'snippet' : [
+                        'special.keip_zeros(nt)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Combinatorics',
+            'sub-menu' : [
+                {
+                    'name' : 'comb: The number of combinations of N things taken k at a time',
+                    'snippet' : [
+                        'special.comb(N, k, exact=False, repetition=False)',
+                    ],
+                },
+
+                {
+                    'name' : 'perm: Permutations of N things taken k at a time, i.e., k-permutations of N',
+                    'snippet' : [
+                        'special.perm(N, k, exact=False)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Other Special Functions',
+            'sub-menu' : [
+                {
+                    'name' : 'agm: Arithmetic, Geometric Mean',
+                    'snippet' : [
+                        'special.agm(a, b)',
+                    ],
+                },
+
+                {
+                    'name' : 'bernoulli: Return an array of the Bernoulli numbers $B_0$, ..., $B_n$ (inclusive)',
+                    'snippet' : [
+                        'special.bernoulli(n)',
+                    ],
+                },
+
+                {
+                    'name' : 'binom: Binomial coefficient',
+                    'snippet' : [
+                        'special.binom(n, k)',
+                    ],
+                },
+
+                {
+                    'name' : 'diric: Returns the periodic sinc function, also called the Dirichlet function',
+                    'snippet' : [
+                        'special.diric(x, n)',
+                    ],
+                },
+
+                {
+                    'name' : 'euler: Return an array of the Euler numbers $E_0$, ..., $E_n$ (inclusive)',
+                    'snippet' : [
+                        'special.euler(n)',
+                    ],
+                },
+
+                {
+                    'name' : 'expn: Exponential integral $E_n$',
+                    'snippet' : [
+                        'special.expn(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'exp1: Exponential integral $E_1$ of complex argument $z$',
+                    'snippet' : [
+                        'special.exp1(z)',
+                    ],
+                },
+
+                {
+                    'name' : 'expi: Exponential integral $\\mathrm{Ei}$',
+                    'snippet' : [
+                        'special.expi(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'factorial: The factorial function, $n! = \\Gamma(n+1)$',
+                    'snippet' : [
+                        'special.factorial(n, exact=False)',
+                    ],
+                },
+
+                {
+                    'name' : 'factorial2: Double factorial $n!!$',
+                    'snippet' : [
+                        'special.factorial2(n, exact=False)',
+                    ],
+                },
+
+                {
+                    'name' : 'factorialk: $n(!!...!)$ = multifactorial of order $k$',
+                    'snippet' : [
+                        'special.factorialk(n, k, exact=False)',
+                    ],
+                },
+
+                {
+                    'name' : 'shichi: Hyperbolic sine and cosine integrals',
+                    'snippet' : [
+                        'special.shichi(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sici: Sine and cosine integrals',
+                    'snippet' : [
+                        'special.sici(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'spence: Dilogarithm integral',
+                    'snippet' : [
+                        'special.spence(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'lambertw: Lambert $W$ function [R497]',
+                    'snippet' : [
+                        'special.lambertw(z[, k, tol])',
+                    ],
+                },
+
+                {
+                    'name' : 'zeta: Hurwitz $\\zeta$ function',
+                    'snippet' : [
+                        'special.zeta(x, q)',
+                    ],
+                },
+
+                {
+                    'name' : 'zetac: Riemann $\\zeta$ function minus 1',
+                    'snippet' : [
+                        'special.zetac(x)',
+                    ],
+                },
+
+            ],
+        },
+
+        {
+            'name' : 'Convenience Functions',
+            'sub-menu' : [
+
+                {
+                    'name' : 'cbrt: $\\sqrt[3]{x}$',
+                    'snippet' : [
+                        'special.cbrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'exp10: $10^x$',
+                    'snippet' : [
+                        'special.exp10(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'exp2: $2^x$',
+                    'snippet' : [
+                        'special.exp2(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'radian: Convert from degrees to radians',
+                    'snippet' : [
+                        'special.radian(d, m, s)',
+                    ],
+                },
+
+                {
+                    'name' : 'cosdg: Cosine of the angle given in degrees',
+                    'snippet' : [
+                        'special.cosdg(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sindg: Sine of angle given in degrees',
+                    'snippet' : [
+                        'special.sindg(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'tandg: Tangent of angle given in degrees',
+                    'snippet' : [
+                        'special.tandg(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'cotdg: Cotangent of the angle given in degrees',
+                    'snippet' : [
+                        'special.cotdg(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log1p: Calculates $\\log(1+x)$ for use when $x$ is near zero',
+                    'snippet' : [
+                        'special.log1p(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'expm1: $\\exp(x) - 1$ for use when $x$ is near zero',
+                    'snippet' : [
+                        'special.expm1(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'cosm1: $\\cos(x) - 1$ for use when $x$ is near zero',
+                    'snippet' : [
+                        'special.cosm1(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'round: Round to nearest integer',
+                    'snippet' : [
+                        'special.round(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'xlogy: Compute $x\\, \\log(y)$ so that the result is 0 if $x$ = 0',
+                    'snippet' : [
+                        'special.xlogy(x, y)',
+                    ],
+                },
+
+                {
+                    'name' : 'xlog1py: Compute $x\\, \\log(1+y)$ so that the result is 0 if $x$ = 0',
+                    'snippet' : [
+                        'special.xlog1py(x, y)',
+                    ],
+                },
+            ],
+        },
+
+    ],
+});