Add files using upload-large-folder tool

.launchpadlib/api.launchpad.net/cache/api.launchpad.net,devel,~deadsnakes,name=%22ppa%22&ws.op=getPPAByName-application,json,bca461ac71b1143128b6fbebfcd56851

@@ -0,0 +1,22 @@
+status: 200
+date: Mon, 05 Feb 2024 23:25:35 GMT
+server: gunicorn
+x-powered-by: Zope (www.zope.org), Python (www.python.org)
+content-security-policy: frame-ancestors 'self';
+content-type: application/json
+strict-transport-security: max-age=15552000
+vary: Accept,Accept-Encoding
+x-content-type-options: nosniff
+x-frame-options: SAMEORIGIN
+x-launchpad-revision: 9643586c585856148a18782148972ae9c1179d06
+x-lazr-notifications: []
+x-xss-protection: 1; mode=block
+x-vcs-revision: 9643586c585856148a18782148972ae9c1179d06
+x-request-id: ee5c3fda-04a1-41df-8644-2766d8c98b27
+content-length: 4377
+-content-encoding: gzip
+content-location: https://api.launchpad.net/devel/~deadsnakes?name=%22ppa%22&ws.op=getPPAByName
+-varied-accept: application/json
+-varied-accept-encoding: gzip, deflate
+
+{"self_link": "https://api.launchpad.net/devel/~deadsnakes/+archive/ubuntu/ppa", "web_link": "https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa", "resource_type_link": "https://api.launchpad.net/devel/#archive", "owner_link": "https://api.launchpad.net/devel/~deadsnakes", "name": "ppa", "displayname": "New Python Versions", "reference": "~deadsnakes/ubuntu/ppa", "distribution_link": "https://api.launchpad.net/devel/ubuntu", "private": false, "suppress_subscription_notifications": false, "dependencies_collection_link": "https://api.launchpad.net/devel/~deadsnakes/+archive/ubuntu/ppa/dependencies", "description": "This PPA contains more recent Python versions packaged for Ubuntu.\n\nDisclaimer: there's no guarantee of timely updates in case of security problems or other issues. If you want to use them in a security-or-otherwise-critical environment (say, on a production server), you do so at your own risk.\n\nUpdate Note\n===========\nPlease use this repository instead of ppa:fkrull/deadsnakes.\n\nReporting Issues\n================\n\nIssues can be reported in the master issue tracker at:\nhttps://github.com/deadsnakes/issues/issues\n\nSupported Ubuntu and Python Versions\n====================================\n\n- Ubuntu 20.04 (focal) Python3.5 - Python3.7, Python3.9 - Python3.13\n- Ubuntu 22.04 (jammy) Python3.7 - Python3.9, Python3.11 - Python3.13\n- Note: Python2.7 (all), Python 3.8 (focal), Python 3.10 (jammy) are not provided by deadsnakes as upstream ubuntu provides those packages.\n\nWhy some packages aren't built:\n- Note: for focal, older python versions require libssl\u003c1.1 so they are not currently built\n- Note: for jammy, older python versions requre libssl\u003c3 so they are not currently built\n- If you need these, reach out to asottile to set up a private ppa\n\nThe packages may also work on other versions of Ubuntu or Debian, but that is not tested or supported.\n\nPackages\n========\n\nThe packages provided here are loosely based on the debian upstream packages with some modifications to make them more usable as non-default pythons and on ubuntu.  As such, the packages follow debian's patterns and often do not include a full python distribution with just `apt install python#.#`.  Here is a list of packages that may be useful along with the default install:\n\n- `python#.#-dev`: includes development headers for building C extensions\n- `python#.#-venv`: provides the standard library `venv` module\n- `python#.#-distutils`: provides the standard library `distutils` module\n- `python#.#-lib2to3`: provides the `2to3-#.#` utility as well as the standard library `lib2to3` module\n- `python#.#-gdbm`: provides the standard library `dbm.gnu` module\n- `python#.#-tk`: provides the standard library `tkinter` module\n\nThird-Party Python Modules\n==========================\n\nPython modules in the official Ubuntu repositories are packaged to work with the Python interpreters from the official repositories. Accordingly, they generally won't work with the Python interpreters from this PPA. As an exception, pure-Python modules for Python 3 will work, but any compiled extension modules won't.\n\nTo install 3rd-party Python modules, you should use the common Python packaging tools.  For an introduction into the Python packaging ecosystem and its tools, refer to the Python Packaging User Guide:\nhttps://packaging.python.org/installing/\n\nSources\n=======\nThe package sources are available at:\nhttps://github.com/deadsnakes/\n\nNightly Builds\n==============\n\nFor nightly builds, see ppa:deadsnakes/nightly https://launchpad.net/~deadsnakes/+archive/ubuntu/nightly", "signing_key_fingerprint": "F23C5A6CF475977595C89F51BA6932366A755776", "require_virtualized": true, "build_debug_symbols": false, "publish_debug_symbols": false, "permit_obsolete_series_uploads": false, "authorized_size": 10240, "status": "Active", "external_dependencies": null, "processors_collection_link": "https://api.launchpad.net/devel/~deadsnakes/+archive/ubuntu/ppa/processors", "enabled_restricted_processors_collection_link": "https://api.launchpad.net/devel/~deadsnakes/+archive/ubuntu/ppa/enabled_restricted_processors", "publishing_method": "Local", "repository_format": "Debian", "publish": true, "relative_build_score": 0, "http_etag": "\"e23cc285682ec6a9eb87828016a9b36731e6dc4d-841a2599806ee01fd2d7dc9450f94c9cd2dba95c\""}

.local/share/jupyter/nbextensions/rubberband/main.css

@@ -0,0 +1,12 @@
+.highlight-drag
+{
+    background-color: transparent;
+    border: dashed #ff3333 3px;
+    position: absolute;
+    display: none;
+}
+
+.cell.selected
+{
+    background-color: #fcfcfc;
+}

.local/share/jupyter/nbextensions/ruler/ruler_editor.yaml

@@ -0,0 +1,29 @@
+Type: IPython Notebook Extension
+Name: Ruler in Editor
+Description: This extension enables the Ruler feature in the editor
+Link: readme.md
+Icon: icon.png
+Main: edit.js
+Compatibility: 4.x, 5.x
+Parameters:
+
+- name: ruler_column
+  input_type: list
+  list_element:
+    input_type: number
+  description: Column where ruler is displayed
+  default: [78]
+
+- name: ruler_color
+  input_type: list
+  list_element:
+    input_type: color
+  description: Ruler color
+  default: ["#ff0000"]
+
+- name: ruler_linestyle
+  description: 'Ruler style, e.g. solid, dashed'
+  input_type: list
+  default: ['dashed']
+
+Section: edit

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

@@ -0,0 +1,27 @@
+.icon-run-from:before{content:"\f10c\f04b"}
+.icon-run-to:before{content:"\f04b\f10c"}
+.icon-run-all:before{content:"\f04b\f01e"}
+.icon-run-all-forced:before{content:"\f04b\f12a"}
+.icon-run-marked:before{content:"\f04b\f08d"}
+
+.icon-mark-all:before{content:"\f111"}
+.icon-mark-none:before{content:"\f10c"}
+.icon-mark-toggle:before{content:"\f08d"}
+
+.icon-hide-input:before{content:"\f039\f068"} 
+.icon-hide-output:before{content:"\f02f\f068"} 
+.icon-show-input:before{content:"\f039\f067"} 
+.icon-show-output:before{content:"\f02f\f067"} 
+
+#runtools-wrapper {
+  position: absolute;
+  width:340px;
+  top: 100px;
+  right: 0px;
+  float: right;
+  opacity: 1;
+  z-index: 100;
+  font-size: 12px;
+  font-weight: bold;
+  background-color: lightgrey;
+}

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

@@ -0,0 +1,119 @@
+Runtools
+========
+Runtools provide a number of additional functions for working with code cells in the IPython notebook:
+
+Code Cell Execution
+-------------------
+
+* Execute a single cell
+* Execute from top cell to currently selected cell
+* Execute from currently selected cell to bottom cell
+* Execute all cells
+* Execute all cells, ignore exceptions (requires [ipython/pull/6521](https://github.com/ipython/ipython/pull/6521))
+* Execute marked code cells (cells with green gutter area are marked)
+* Stop execution (duplicate to standard toolbar button)
+
+When executing marked cells, they are put in a execution list, and
+executed in order. The execution list can be modified by unmarking
+a cell not yet run. The execution list can be stopped by clicking on
+`stop execution`. Execution of the currently running cell can be stopped
+by pressing `stop execution` twice.
+
+Code Cell Marking
+-----------------
+
+* Mark one or more code cell
+
+
+Code Cell Display
+-----------------
+
+* Hide or show input (i.e. the source code) of marked code cells
+* Hide or show output of marked code cells
+
+
+Description
+-----------
+
+The *runtools* extension adds a button to turn on/off a floating toolbar:   
+![](icon.png)
+
+This adds Code execution buttons:   
+![](runtools_execute.png)
+
+Codecells can be marked by clicking on the gutter of a codecell or by clicking on the markers toolbar:   
+![](runtools_marker.png)
+
+Marked codecells can be locked to read-only mode and moved upd and down:   
+![](runtools_lock.png)
+
+The input and output areas of marked codecells can be hidden:   
+![](runtools_show_hide.png)
+
+A IPython notebook with marked cells looks like this:
+![](runtools_nb.png)
+
+
+Demo
+----
+
+![](demo.gif)
+
+
+Internals
+---------
+
+New metadata elements added to each cell:
+* `cell.metadata.hide_input` - hide input field of the cell
+* `cell.metadata.hide_output` - hide output field of the cell
+* `cell.metadata.run_control.marked` - mark a codecell
+
+To export a notebook with hidden input/output fields, the custom template `hide_input_output.tpl` is required.
+It should have been installed in the `templates` folder.
+You can find the `templates` folder of `jupyter_contrib_nbextensions` from python using
+
+```python
+from jupyter_contrib_nbextensions.nbconvert_support import templates_directory
+print(templates_directory())
+```
+
+The template needs to be in a path where nbconvert can find it. This can be your local path or specified in 
+`jupyter_nbconvert_config` or `jupyter_notebook_config` as `c.Exporter.extra_template_paths`, see [Jupyter docs](https://jupyter-notebook.readthedocs.io/en/latest/config.html).
+
+For HTML export a template is provided as `nbextensions.tpl` in the `jupyter_contrib_nbextensions` templates directory. Alternatively you can create your own template:
+```
+{%- extends 'full.tpl' -%}
+
+{% block input_group -%}
+{%- if cell.metadata.hide_input -%}
+{%- else -%}
+{{ super() }}
+{%- endif -%}
+{% endblock input_group %}
+
+{% block output_group -%}
+{%- if cell.metadata.hide_output -%}
+{%- else -%}
+{{ super() }}
+{%- endif -%}
+{% endblock output_group %}
+```
+
+For LaTeX export a different template is required, which is included as `nbextensions.tplx` in the `jupyter_contrib_nbextensions` templates directory. Alternatively you can create your own template:
+```
+((- extends 'report.tplx' -))
+
+((* block input_group -))
+((- if cell.metadata.hide_input -))
+((- else -))
+((( super() )))
+((- endif -))
+(( endblock input_group *))
+
+((* block output_group -))
+((- if cell.metadata.hide_output -))
+((- else -))
+((( super() )))
+((- endif -))
+(( endblock output_group *))
+```

.local/share/jupyter/nbextensions/scratchpad/scratchpad.yaml

@@ -0,0 +1,6 @@
+Type: Jupyter Notebook Extension
+Name: Scratchpad
+Description: Adds a scratchpad cell to Jupyter notebook.
+Link: README.md
+Main: main.js
+Compatibility: 4.x, 5.x

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

@@ -0,0 +1,57 @@
+define([
+    'jquery',
+    'base/js/namespace',
+], function (
+    $,
+    Jupyter
+) {
+    'use strict';
+
+    var params = {
+        scrollDownIsEnabled: false
+    };
+
+    var initialize = function () {
+        $.extend(true, params, Jupyter.notebook.config.data);
+        setButtonColor();
+    };
+
+    function toggleScrollDown() {
+        params.scrollDownIsEnabled = !params.scrollDownIsEnabled;
+        Jupyter.notebook.config.update(params);
+        setButtonColor();
+    }
+
+    function setButtonColor() {
+        $("#toggle_scroll_down").toggleClass('active', params.scrollDownIsEnabled);
+    }
+
+    function load_extension() {
+        $(Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register({
+                help   : 'toggle automatic scrolling down',
+                icon   : 'fa-angle-double-down ',
+                handler: toggleScrollDown
+            }, 'toggle-auto-scroll-down', 'scroll_down')
+        ])).find('.btn').attr('id', 'toggle_scroll_down');
+
+        console.log("[ScrollDown] is loaded");
+
+        // the event was renamed from 'resize' to 'resizeOutput' in
+        // https://github.com/jupyter/notebook/commit/b4928d481abd9f7cd996fd4b24078a55880d21e6
+        $(document).on("resize resizeOutput", ".output", function () {
+            if (!params.scrollDownIsEnabled) return;
+            var output = $(this);
+            setTimeout(function () {
+                output.scrollTop(output.prop("scrollHeight"));
+            }, 0);
+        });
+
+        return Jupyter.notebook.config.loaded.then(initialize);
+    }
+
+    return {
+        load_jupyter_extension: load_extension,
+        load_ipython_extension: load_extension
+    };
+});

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

@@ -0,0 +1,13 @@
+# ScrollDown
+
+When enabled, this nbextension scrolls cells' outputs down automatically as
+they are enlarged. It can be enabled and disabled using the toolbar button:
+
+![](icon.png)
+
+
+Options
+-------
+
+The enabled status is toggleable with the toolbar button, which sets the option
+option `scrollDownIsEnabled` in the notebook config section.

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

@@ -0,0 +1,14 @@
+Select CodeMirror Keymap
+=======
+
+This extension lets you choose between the available CodeMirror keymaps: default, emacs, vim, and sublime.
+
+There's a chance that this might cause key conflicts, especially with other extensions.
+
+Most browsers consume some of the global keybindings like `Ctrl+n`. [The Menu Wizard add-on for Firefox](https://addons.mozilla.org/en-US/firefox/addon/s3menu-wizard/) allows you to disable some of the global key shortcuts, thus passing the keys through to CodeMirror.
+
+![Demo](select_keymap.png)
+
+Based on:
+ * [jupyter-emacskeys](https://github.com/rmcgibbo/jupyter-emacskeys)
+ * [notebook_input_mode](https://github.com/asford/notebook_input_mode)

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

@@ -0,0 +1,371 @@
+// change the mode of all current and future CodeMirror instances
+
+define([
+    "base/js/namespace",
+    "notebook/js/cell",
+    "codemirror/lib/codemirror",
+    "codemirror/keymap/emacs",
+    "codemirror/keymap/vim",
+    "codemirror/keymap/sublime",
+    "codemirror/mode/meta",
+    "codemirror/addon/comment/comment",
+    "codemirror/addon/dialog/dialog",
+    "codemirror/addon/edit/closebrackets",
+    "codemirror/addon/edit/matchbrackets",
+    "codemirror/addon/search/searchcursor",
+    "codemirror/addon/search/search",
+], function(
+    Jupyter,
+    Cell,
+    CodeMirror
+    // other stuff is loaded, but not used
+) {
+    "use_strict";
+
+    var previous_mode = "";
+
+    var available_keymaps = [
+        "default",
+        "emacs",
+        "vim",
+        "sublime"
+    ];
+
+    /* Values to use for config keys that are note defined in server config */
+    var default_config = {
+        line_wrap: true,
+        local_storage: true,
+    };
+
+    var starting_state = {
+        extraKeys: {},
+        edit_shortcuts: {},
+        command_shortcuts: {}
+    };
+
+    var cm_default = Cell.Cell.options_default.cm_config;
+    var edit_shortcuts = Jupyter.keyboard_manager.edit_shortcuts;
+    var command_shortcuts = Jupyter.keyboard_manager.command_shortcuts;
+
+    var mods = {
+        vim: {
+            add: {
+                extraKeys: {
+                    "Esc": "leave_current_mode",
+                    "Ctrl-[": "leave_current_mode"
+                },
+                command_shortcuts: {
+                    "Ctrl-c": "jupyter-notebook:interrupt-kernel",
+                    "Ctrl-z": "jupyter-notebook:restart-kernel",
+
+                    "d,d": "jupyter-notebook:cut-cell",
+                    "y,y": "jupyter-notebook:copy-cell",
+                    "u": "jupyter-notebook:undo-cell-deletion",
+
+                    "p": "jupyter-notebook:paste-cell-below",
+                    "Shift-P": "jupyter-notebook:paste-cell-above",
+
+                    "o": "jupyter-notebook:insert-cell-below",
+                    "Shift-O": "jupyter-notebook:insert-cell-above",
+
+                    "i": "jupyter-notebook:enter-edit-mode",
+                    "Enter": "jupyter-notebook:enter-edit-mode",
+
+                    "Shift-J": "jupyter-notebook:move-cell-down",
+                    "Shift-K": "jupyter-notebook:move-cell-up",
+
+                    "Shift-/": "jupyter-notebook:show-keyboard-shortcuts",
+                    "h": "jupyter-notebook:toggle-cell-output-collapsed",
+                    "Shift-H": "jupyter-notebook:toggle-cell-output-scrolled",
+
+                    "`": "jupyter-notebook:change-cell-to-code",
+                    "0": "jupyter-notebook:change-cell-to-markdown"
+                },
+                edit_shortcuts: {
+                    "Shift-Esc": "jupyter-notebook:enter-command-mode"
+                }
+            },
+            remove: {
+                edit_shortcuts: ["Esc"]
+            },
+            custom: function() {
+                disable_keyboard_manager_in_dialog(this);
+            },
+            custom_teardown: function() {
+                reenable_keyboard_manager_in_dialog(this);
+            }
+        },
+        emacs: {
+            add: {
+                extraKeys: {
+                    "Ctrl-Y": "yank_no_selection"
+                },
+                command_shortcuts: {
+                    "Ctrl-N": "jupyter-notebook:select-next-cell",
+                    "Ctrl-P": "jupyter-notebook:select-previous-cell",
+                    "Alt-X": "jupyter-notebook:show-command-palette"
+
+                },
+                edit_shortcuts: {
+                    "Alt-X": "jupyter-notebook:show-command-palette"
+                }
+            },
+            remove: {
+                edit_shortcuts: ["Ctrl-Shift-Minus"],
+                keyMap: ["Ctrl-V"]
+            },
+            custom: function() {
+                disable_keyboard_manager_in_dialog(this);
+            },
+            custom_teardown: function() {
+                reenable_keyboard_manager_in_dialog(this);
+            }
+        }
+    };
+
+    function disable_keyboard_manager_in_dialog(_this) {
+        // Disable keyboard manager for code mirror dialogs, handles ':'
+        // triggered ex-mode dialog box in vim mode.
+        // Manager is re-enabled by re-entry into notebook edit mode +
+        // cell normal mode after dialog closes
+        _this.openDialog = CodeMirror.prototype.openDialog;
+
+        function openDialog_keymap_wrapper(target, template, callback, options) {
+            Jupyter.keyboard_manager.disable();
+            return target.call(this, template, callback, options);
+        }
+
+        CodeMirror.defineExtension("openDialog", _.wrap(_this.openDialog,
+            openDialog_keymap_wrapper));
+    }
+
+    function reenable_keyboard_manager_in_dialog(_this) {
+        CodeMirror.defineExtension("openDialog", _this.openDialog);
+    }
+
+    var server_config = Jupyter.notebook.config;
+    // make sure config is loaded before making initial changes
+    var initialize = function () {
+        save_starting_state();
+        // initialize last stored value or default
+        switch_keymap(get_stored_keymap());
+    };
+
+    function get_config(key) {
+        if (server_config.data.hasOwnProperty("select_keymap_" + key)) {
+            return server_config.data["select_keymap_" + key];
+        }
+        return default_config[key];
+    }
+
+    function get_stored_keymap() {
+        var keymap;
+        if (get_config("local_storage")) {
+            keymap = window.localStorage.getItem("jupyter_keymap");
+        } else {
+            keymap = server_config.data.stored_keymap;
+        }
+        return keymap || "default";
+    }
+
+    function store_keymap(mode) {
+        if (get_config("local_storage")) {
+            window.localStorage.setItem("jupyter_keymap", mode);
+        } else {
+            server_config.update({
+                stored_keymap: mode
+            });
+        }
+    }
+
+    function flatten_shortcuts(shortcut_tree) {
+        var result = {};
+        for (var p in shortcut_tree) {
+            if (typeof(shortcut_tree[p]) == "string") {
+                result[p] = shortcut_tree[p];
+            } else {
+                var subresult = flatten_shortcuts(shortcut_tree[p]);
+                for (var subp in subresult) {
+                    result[p + "," + subp] = subresult[subp];
+                }
+            }
+        }
+        return result;
+    }
+
+    function update_shortcuts(shortcut_manager, updated_shortcuts) {
+        var current_shortcuts = _.invert(flatten_shortcuts(shortcut_manager._shortcuts));
+
+        for (var shortcut_action in _.invert(updated_shortcuts)) {
+            if (_.has(current_shortcuts, shortcut_action) &&
+                shortcut_manager.get_shortcut(current_shortcuts[shortcut_action])) {
+
+                shortcut_manager.remove_shortcut(current_shortcuts[shortcut_action]);
+            }
+        }
+
+        shortcut_manager.add_shortcuts(updated_shortcuts);
+    }
+
+    // start custom CodeMirror command definitions
+    function leave_current_mode(cm) {
+        if (cm.state.vim.insertMode) {
+            // Move from insert mode into command mode.
+            CodeMirror.keyMap["vim-insert"].call("Esc", cm);
+        } else if (cm.state.vim.visualMode) {
+            // Move from visual mode to command mode.
+            CodeMirror.keyMap["vim"].call("Esc", cm);
+        } else {
+            // Move to notebook command mode.
+            Jupyter.notebook.command_mode();
+            Jupyter.notebook.focus_cell();
+        }
+    };
+
+    var orig_ctrl_y = CodeMirror.keyMap.emacs["Ctrl-Y"];
+
+    function yank_no_selection(cm) {
+        orig_ctrl_y(cm);
+        // remove selection after yank
+        cm.setSelection(cm.getCursor(), cm.getCursor());
+    };
+
+    CodeMirror.commands.yank_no_selection = yank_no_selection;
+    CodeMirror.commands.leave_current_mode = leave_current_mode;
+    // end custom CodeMirror command definitions
+
+    function create_menu() {
+        var menu = [
+            "<li class='divider''></li>",
+            "<li class='dropdown-submenu'>",
+            "<a href='#'>Keymaps</a>",
+            "<ul class='dropdown-menu'' id='keymap_menu'>"
+        ];
+
+        available_keymaps.forEach(function(keymap) {
+            menu.push(`<li><a id="keymap-${keymap}" href="#" title="Toggle ${keymap} keybindings" onClick="switch_keymap('${keymap}')" style="text-transform: capitalize;">${keymap}</a></li>`);
+        });
+
+        menu.push("</ul></li>");
+
+        $("#move_cell_down").after(menu.join("\n"));
+    }
+
+    function update_cm_instance_to_defaults(cell) {
+        var cm = cell.code_mirror;
+        cm.setOption("vimMode", cm_default["vimMode"]);
+        cm.setOption("lineWrapping", cm_default["lineWrapping"]);
+        cm.setOption("keyMap", cm_default["keyMap"]);
+        cm.setOption("extraKeys", cm_default["extraKeys"]);
+    };
+
+    function highlight_selection(mode) {
+        $("[id^=keymap]").css("font-weight", "normal");
+        $("[id=keymap-" + mode + "]").css("font-weight", "bold");
+    }
+
+    function reset_state() {
+        // FIXME: if this extension loads before other extensions that alter
+        // key shortcuts, this will probably reset those as well
+        cm_default.extraKeys = _.clone(starting_state.extraKeys);
+        update_shortcuts(edit_shortcuts, starting_state.edit_shortcuts);
+        update_shortcuts(command_shortcuts, starting_state.command_shortcuts);
+
+        // if changing from another mode, run the teardown function
+        var prev_mode_mods = mods[previous_mode];
+        if (prev_mode_mods && prev_mode_mods.custom_teardown) {
+            prev_mode_mods.custom_teardown();
+        }
+    }
+
+    function save_starting_state() {
+        starting_state.extraKeys = _.clone(cm_default.extraKeys);
+        starting_state.edit_shortcuts = flatten_shortcuts(edit_shortcuts._shortcuts);
+        starting_state.command_shortcuts = flatten_shortcuts(command_shortcuts._shortcuts);
+    }
+
+    function add_bindings(add, mode) {
+        _.extend(CodeMirror.keyMap[mode], add.keyMap);
+        _.extend(cm_default.extraKeys, add.extraKeys);
+
+        if (add.command_shortcuts) {
+            update_shortcuts(command_shortcuts, add.command_shortcuts);
+        }
+
+        if (add.edit_shortcuts) {
+            update_shortcuts(edit_shortcuts, add.edit_shortcuts);
+        }
+    }
+
+    function remove_bindings(remove, mode) {
+        _.forEach(remove.keyMap, function(key) {
+            delete CodeMirror.keyMap[mode][key];
+        });
+
+        _.forEach(remove.extraKeys, function(key) {
+            delete cm_default.extraKeys[key];
+        });
+
+        _.forEach(remove.edit_shortcuts, function(key) {
+            edit_shortcuts.remove_shortcut(key);
+        });
+
+        _.forEach(remove.command_shortcuts, function(key) {
+            command_shortcuts.remove_shortcut(key);
+        });
+    }
+
+    function change_notebook_defaults(mode) {
+        // make changes to cm defaults
+        cm_default.keyMap = mode;
+        cm_default.vimMode = mode == "vim";
+        cm_default.lineWrapping = get_config('line_wrap');
+
+        var mode_mods = mods[mode];
+        if (mode_mods) {
+            if (mode_mods.add) {
+                add_bindings(mode_mods.add, mode);
+            }
+
+            if (mode_mods.remove) {
+                remove_bindings(mode_mods.remove, mode);
+            }
+
+            if (mode_mods.custom) {
+                mode_mods.custom();
+            }
+        }
+    }
+
+    function change_cells_to_defaults() {
+        Jupyter.notebook.get_cells().map(update_cm_instance_to_defaults);
+    }
+
+    function switch_keymap(mode) {
+        // don't run if selecting currently selected mode
+        if (mode == previous_mode) return;
+
+        // store selection only when it changes
+        if (previous_mode) store_keymap(mode);
+
+        reset_state();
+
+        change_notebook_defaults(mode);
+
+        change_cells_to_defaults();
+
+        highlight_selection(mode);
+
+        previous_mode = mode;
+    }
+
+    window.switch_keymap = switch_keymap;
+
+    return {
+        load_ipython_extension: function () {
+            return Jupyter.notebook.config.loaded
+                .then(initialize)
+                .then(create_menu);
+        }
+    };
+});

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

@@ -0,0 +1,15 @@
+# SKILL for Codemirror
+This extension provides a *SKILL* mode for CodeMirror editor.
+
+The extension adds a MIME type `x-skill` and a mode `skill` that can be
+used with CodeMirror.  
+
+## About SKILL
+From [Wikipedia](https://en.wikipedia.org/wiki/Cadence_SKILL):
+SKILL is a Lisp dialect used as a scripting language and PCell (parameterized
+cells) description language used in many EDA software suites by Cadence Design
+Systems (e.g. Cadence Allegro and Cadence Virtuoso)
+
+## Notes
+This extension was written to enhance the Virtuoso kernel for Jupyter
+(https://github.com/benvarkey/JuVi).

.local/share/jupyter/nbextensions/skill/skill.yaml

@@ -0,0 +1,6 @@
+Type: IPython Notebook Extension
+Name: SKILL Syntax
+Description: Enable SKILL syntax support for CodeMirror
+Link: README.md
+Main: main.js
+Compatibility: 4.x, 5.x

.local/share/jupyter/nbextensions/skip-traceback/main.js

@@ -0,0 +1,204 @@
+// Copyright (c) IPython-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'notebook/js/outputarea',
+], function (
+    Jupyter,
+    $,
+    requirejs,
+    outputarea
+) {
+    "use strict";
+
+    var mod_name = 'skip-traceback';
+    var log_prefix = '[' + mod_name + ']';
+
+    var cfg = {
+        enable: true,
+        use_toolbar_button: false,
+        button_icon: 'fa-warning',
+        animation_duration: 100,
+        show_copy_buttons: true,
+    };
+
+    // this will be filled as they're registered
+    var actions = {};
+
+    var apply_patches = function () {
+
+        outputarea.OutputArea.prototype.append_error = function (json) {
+            // firts part is just a copy of the original, but keeping a reference to inserted_text
+            var inserted_text;
+            var tb = json.traceback;
+            if (tb !== undefined && tb.length > 0) {
+                var s = '';
+                var len = tb.length;
+                for (var i = 0; i < len; i++) {
+                    s = s + tb[i] + '\n';
+                }
+                s = s + '\n';
+                var toinsert = this.create_output_area();
+                var append_text = outputarea.OutputArea.append_map['text/plain'];
+                if (append_text) {
+                    inserted_text = append_text.apply(this, [s, {}, toinsert]).addClass('output_error');
+                }
+                this._safe_append(toinsert);
+
+                // now we add our header at the top of the inserted_text
+                if (!inserted_text) {
+                    return;
+                }
+                var copy_btn = $('<i class="fa fa-fw fa-copy" title="Copy full traceback to clipboard"/>')
+                    .on('click', function (evt) {
+                        // prevent event bubbling up to collapse/uncollapse traceback
+                        evt.stopPropagation();
+                        var $copy_btn = $(this)
+                            .tooltip({track: false, trigger: 'manual', placement: 'bottom'});
+                        // create temporary off-screen textarea for copying text
+                        var $copy_txt_area = $('<textarea>')
+                            .css({position: 'absolute', left: '-10000px', top: '-10000px'})
+                            .appendTo('body');
+                        // remember this for later
+                        var was_focussed = document.activeElement;
+                        var msg = 'Failed to copy traceback to clipboard';
+                        try {
+                            $copy_txt_area[0].value = $copy_btn.closest('.skip-traceback-summary').siblings().text();
+                            $copy_txt_area[0].select();
+                            var successful = document.execCommand('copy');
+                            if (successful) {
+                                msg = 'Copied traceback to clipboard!';
+                                console.log(log_prefix, msg);
+                            }
+                            else {
+                                console.warn(log_prefix, msg);
+                            }
+                        }
+                        catch (err) {
+                            console.warn(log_prefix, msg + ':', err);
+                        }
+                        finally {
+                            $copy_txt_area.remove();
+                            was_focussed.focus();
+                            // this tooltip bit relies on jqueryui tooltip, but
+                            // it may have been overwritten by bootstrap tooltip (if loaded).
+                            try {
+                                $copy_btn
+                                    .tooltip('option', 'content', msg)
+                                    .tooltip('open');
+                                setTimeout(function () {
+                                    $copy_btn.tooltip('disable');
+                                }, 1000);
+                            }
+                            catch (err) {
+                                console.warn(log_prefix, err);
+                            }
+                        }
+                    });
+                var sum = $('<pre/>')
+                    .addClass('skip-traceback-summary')
+                    .css('cursor', 'pointer')
+                    .text(': ' + json.evalue + ' ')
+                    .prepend($('<span class=ansired/>').text(json.ename));
+
+                if (cfg.show_copy_buttons) {
+                    sum.prepend(' ').prepend(copy_btn);
+                }
+                sum
+                    .append('<i class="fa fa-caret-right" title="Expand traceback"/>')
+                    .append('\n')
+                    .on('click', function (evt) {
+                        var summary = $(this);
+                        var icon = summary.find('.fa-caret-right,.fa-caret-down');
+                        var show = icon.hasClass('fa-caret-right');
+                        icon
+                            .toggleClass('fa-caret-down', show)
+                            .toggleClass('fa-caret-right', !show)
+                            .attr('title', show ? 'Collapse traceback' : 'Expand traceback');
+                        summary.siblings()[show ? 'slideDown' : 'slideUp'](cfg.animation_duration || 100);
+                    })
+                    .prependTo(inserted_text);
+                if (cfg.enable) {
+                    sum.siblings().css('display', 'none');
+                }
+                else {
+                    sum.css('display', 'none');
+                }
+            }
+        };
+    };
+
+    var toggle_traceback = function (set_on) {
+        if (set_on === undefined) {
+            set_on = !cfg.enable;
+        }
+        // update config
+        if (set_on !== cfg.enable) {
+            cfg.enable = set_on;
+            var conf_update = {};
+            conf_update[mod_name] = {enable: set_on};
+            Jupyter.notebook.config.update(conf_update);
+            console.log(log_prefix, 'toggled', set_on ? 'on' : 'off');
+        }
+        // update button looks
+        $('#toggle_traceback_btns > .btn').toggleClass('active', set_on).blur();
+        // update existing OutputAreas
+        $('.cell .output_area .output_error .skip-traceback-summary').each(function (idx, el) {
+            var $summary = $(el);
+            $summary.css('display', set_on ? '' : 'none');
+            if ($summary.find('.fa').hasClass(set_on ? 'fa-caret-down' : 'fa-caret-right')) {
+                $summary.click();
+            }
+        });
+    };
+
+    var register_new_actions = function () {
+        actions.toggle = {
+            help : 'Toggle Hiding Traceback',
+            help_index: 'zz',
+            icon : cfg.button_icon || 'fa-warning',
+            handler : function (env) { toggle_traceback(); },
+        };
+        actions.toggle.name = Jupyter.keyboard_manager.actions.register(
+            actions.toggle, 'toggle', mod_name);
+    };
+
+    var add_toolbar_button = function () {
+        if (cfg.use_toolbar_button) {
+            Jupyter.toolbar.add_buttons_group([actions.toggle.name], 'toggle_traceback_btns');
+        }
+    };
+
+    var load_ipython_extension = function () {
+        apply_patches();
+
+        Jupyter.notebook.config.loaded
+        .then(function () {
+            $.extend(true, cfg, Jupyter.notebook.config.data[mod_name]);
+            register_new_actions();
+            add_toolbar_button();
+            toggle_traceback(cfg.enable);
+            // update any OutputArea created before our patch)
+            $('.cell .output_area .output_error').each(function (idx, el) {
+                var $el = $(el);
+                if ($el.children('.skip-traceback-summary').length < 1) {
+                    var oa = $el.closest('.cell').data('cell').output_area;
+                    var json_outputs = oa.toJSON();
+                    // clear; do not wait, ignore queue
+                    oa.clear_output(false, true);
+                    oa.fromJSON(json_outputs);
+                }
+            });
+        })
+        .catch(function (reason) {
+            console.error(log_prefix, 'Error loading:', reason);
+        });
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

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

@@ -0,0 +1,61 @@
+Snippets
+========
+
+Code cell snippets.
+
+This extension adds a drop-down menu to the IPython toolbar that allows easy
+insertion of code snippet cells into the current notebook. The code snippets
+are defined in a JSON file in `nbextensions/snippets/snippets.json` and an
+example snippet is included with this extension.
+
+![](snippets-demo.gif)
+
+Adding new snippets
+-------------------
+
+Snippets are specified by adding a new JSON block to the list of existing snippets in `$(jupyter --data-dir)/nbextensions/snippets/snippets.json`. For example, to add a new snippet that imports numpy, matplotlib, and a print statement, the JSON file should be modified from:
+
+```json
+{
+    "snippets" : [
+        {
+            "name" : "example",
+            "code" : [
+                "# This is an example snippet!",
+                "# To create your own, add a new snippet block to the",
+                "# snippets.json file in your jupyter data directory under nbextensions:",
+                "# $(jupyter --data-dir)/nbextensions/snippets/snippets.json",
+                "import this"
+            ]
+        }
+    ]
+}
+```
+
+to this:
+
+```json
+{
+    "snippets" : [
+        {
+            "name" : "example",
+            "code" : [
+                "# This is an example snippet!",
+                "# To create your own, add a new snippet block to the",
+                "# snippets.json file in your jupyter data directory under nbextensions:",
+                "# $(jupyter --data-dir)/nbextensions/snippets/snippets.json",
+                "import this"
+            ]
+        },
+        {
+            "name" : "some imports",
+            "code" : [
+                "import numpy as np",
+                "import matplotlib as mpl",
+                "print('spam')"
+            ]
+        }
+    ]
+}
+```
+You may need to restart your notebook for the changes to take effect.

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

@@ -0,0 +1,70 @@
+// Code cell snippets
+
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/dialog'
+], function(
+    $,
+    Jupyter,
+    dialog
+) {
+    "use strict";
+
+    var initialize = function () {
+        var dropdown = $("<select></select>").attr("id", "snippet_picker")
+                                             .css("margin-left", "0.75em")
+                                             .attr("class", "form-control select-xs")
+                                             .change(insert_cell);
+        Jupyter.toolbar.element.append(dropdown);
+    };
+
+    // will be called when the nbextension is loaded
+    function load_extension() {
+        Jupyter.notebook.config.loaded.then(initialize); // trigger loading config parameters
+
+        $.getJSON(Jupyter.notebook.base_url+"nbextensions/snippets/snippets.json", function(data) {
+            // Add the header as the top option, does nothing on click
+            var option = $("<option></option>")
+                         .attr("id", "snippet_header")
+                         .text("Snippets");
+            $("select#snippet_picker").append(option);
+
+            // Add options for each code snippet in the snippets.json file
+            $.each(data['snippets'], function(key, snippet) {
+                var option = $("<option></option>")
+                             .attr("value", snippet['name'])
+                             .text(snippet['name'])
+                             .attr("code", snippet['code'].join('\n'));
+                $("select#snippet_picker").append(option);
+            });
+        })
+        .error(function(jqXHR, textStatus, errorThrown) {
+            // Add an error message if the JSON fails to load
+            var option = $("<option></option>")
+                         .attr("value", 'ERROR')
+                         .text('Error: failed to load snippets!')
+                         .attr("code", "");
+            $("select#snippet_picker").append(option);
+        });
+
+    };
+
+    var insert_cell = function() {
+        var selected_snippet = $("select#snippet_picker").find(":selected");
+
+        if (selected_snippet.attr("name") != 'header') {
+            var code = selected_snippet.attr("code");
+            var new_cell = Jupyter.notebook.insert_cell_above('code');
+            new_cell.set_text(code);
+            new_cell.focus_cell();
+
+            $("option#snippet_header").prop("selected",true);
+        }
+    };
+
+    // return public methods
+    return {
+        load_ipython_extension : load_extension
+    };
+});

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

@@ -0,0 +1,123 @@
+Type: Jupyter Notebook Extension
+Name: Snippets Menu
+Link: readme.md
+Description: |
+  Add a customizable menu item to insert code and markdown snippets.
+  Comes with extensive defaults for popular python modules, including fairly
+  complete listings of many important functions and constants, to save
+  searching through documentation.
+Main: main.js
+Icon: thumbnail.png
+Compatibility: 4.x, 5.x
+Parameters:
+
+- name: snippets.insert_as_new_cell
+  description: "Insert snippets as new cells, rather than at cursor inside current cell"
+  input_type: checkbox
+  default: false
+
+- name: snippets.include_custom_menu
+  description: "Include custom menu content parsed from JSON string below"
+  input_type: checkbox
+  default: false
+
+- name: snippets.custom_menu_content
+  description: |
+    JSON string parsed to define custom menus (only used if the option above is
+    checked)
+  input_type: textarea
+  default: |
+    {
+        "name" : "My favorites",
+        "sub-menu" : [
+            {
+                "name" : "Menu item text",
+                "snippet" : ["import something",
+                             "",
+                             "new_command(3.14)",
+                             "other_new_code_on_new_line('with a string!')",
+                             "stringy(\"if you need them, escape double quotes with a single backslash\")",
+                             "backslashy('This \\ appears as just one backslash in the output')",
+                             "backslashy2('Here \\\\ are two backslashes')"]
+            },
+            {
+                "name" : "TeX can be written in menu labels $\\alpha_W e\\int_0 \\mu \\epsilon$",
+                "snippet" : ["another_new_command(2.78)"]
+            }
+        ]
+    }
+
+- name: snippets.sibling_selector
+  description: |
+    A JQuery selector for a sibling element next to whose parent element the
+    new menu(s) will be inserted. Other suitable examples include '#file_menu',
+    '#edit_menu', '#view_menu', '#insert_menu', '#cell_menu', and
+    '#kernel_menu'. To append the new menu as a submenu to the 'insert' menu
+    itself, you could use '#insert_menu>:last-child'.
+  input_type: text
+  default: '#help_menu'
+
+- name: snippets.insert_before_sibling
+  description: |
+    Insert the new menu(s) before their sibling (the default value of false
+    means they are inserted after the sibling)
+  input_type: checkbox
+  default: false
+
+- name: snippets.top_level_submenu_goes_left
+  description: |
+    Snippets menus are often quite big, and positioned at the right side of the
+    menu bar, so by default they open to the left of the menu. Set this to
+    false to get them to open to the right as normal.
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.numpy
+  description: "Include numpy sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.scipy
+  description: "Include scipy sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.matplotlib
+  description: "Include matplotlib sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.sympy
+  description: "Include sympy sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.pandas
+  description: "Include pandas sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.astropy
+  description: "Include astropy sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.h5py
+  description: "Include h5py sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.numba
+  description: "Include numba sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.python
+  description: "Include python sub-menu"
+  input_type: checkbox
+  default: true
+
+- name: snippets.include_submenu.markdown
+  description: "Include markdown sub-menu"
+  input_type: checkbox
+  default: true

.local/share/jupyter/nbextensions/snippets_menu/examples_for_custom.js

@@ -0,0 +1,187 @@
+// The following are various examples taken from README.md.  Each section
+// contains code that you could place into your own custom.js file.  Note that
+// only one of these should be used, though you might want to combine ideas
+// from the various examples.
+
+
+//// 1. Simple "My favorites" menu inserted at the *bottom* of "Snippets", with horizontal-line separator
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var my_favorites = {
+        'name' : 'My favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Menu item text',
+                'snippet' : ['new_command(3.14)',],
+            },
+            {
+                'name' : 'Another menu item',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'] = snippets_menu.default_menus;
+    snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line);
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+//// 2. "My favorites" menu with lots of stringy goodness
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var my_favorites = {
+        'name' : 'My $\\nu$ favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Multi-line snippet',
+                'snippet' : ['new_command(3.14)',
+                             'other_new_code_on_new_line("with a string!")',
+                             'stringy(\'escape single quotes once\')',
+                             "stringy2('or use single quotes inside of double quotes')",
+                             'backslashy("This \\ appears as just one backslash in the output")',
+                             'backslashy2("Here are \\\\ two backslashes")',],
+            },
+            {
+                'name' : 'TeX appears correctly $\\alpha_W e\\int_0 \\mu \\epsilon$',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line);
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 3. Delete "Matplotlib"'s "Setup for scripts" item
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.python.matplotlib['sub-menu'].splice(1, 1); // Delete 1 element starting at position 1 of the sub-menu
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 4. Swap setup items in "Matplotlib" sub-menu
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var tmp = snippets_menu.python.matplotlib['sub-menu'][0];
+    snippets_menu.python.matplotlib['sub-menu'][0] = snippets_menu.python.matplotlib['sub-menu'][1];
+    snippets_menu.python.matplotlib['sub-menu'][1] = tmp;
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 5. Insert "My favorites" as a new top-level menu before "Snippets", instead of inside "Snippets"
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var my_favorites = {
+        'name' : 'My favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Menu item text',
+                'snippet' : ['new_command(3.14)',],
+            },
+            {
+                'name' : 'Another menu item',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'].push(my_favorites);
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 6. Insert "My favorites" as a new top-level menu after "Snippets", instead of inside "Snippets"
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var my_favorites = {
+        'name' : 'My favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Menu item text',
+                'snippet' : ['new_command(3.14)',],
+            },
+            {
+                'name' : 'Another menu item',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    snippets_menu.options['menus'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 7. Place "Snippets" before "Help" menu
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.options['insert_before_sibling'] = true;
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 8. Move SymPy and Numpy to navbar and delete pandas
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.default_menus[0]['sub-menu'].splice(3, 2); // Remove SymPy and pandas
+    snippets_menu.python.sympy['sub-menu-direction'] = 'left'; // Point new SymPy menus to left
+    snippets_menu.python.numpy['sub-menu-direction'] = 'left'; // Point new Numpy menus to left
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]); // Start with the remaining "Snippets" menu
+    snippets_menu.options['menus'].push(snippets_menu.python.sympy); // Follow that with a new SymPy menu
+    snippets_menu.options['menus'].push(snippets_menu.python.numpy); // Follow that with a new Numpy menu
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 9. Change direction of sub-menus under "Snippets"
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.options['direction_of_top_level_submenu'] = 'right';
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 10. Place "Snippets" inside "Insert" menu
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.default_menus[0]['menu-direction'] = 'left'; // Open top-level menu to the left...
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right'; // ...and sub-menus to the right.
+    snippets_menu.options['menus'].push('---', snippets_menu.default_menus[0]); // Add horizontal line and default menus
+    snippets_menu.options['sibling'] = $("#insert_cell_below"); // Find the place at which to insert the new menus
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 11. Multiple menus in different places
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var sympy_menu = [snippets_menu.python.sympy,];
+    sympy_menu[0]['sub-menu-direction'] = 'left';
+    snippets_menu.options['menus'] = sympy_menu;
+    snippets_menu.default_menus[0]['sub-menu'].splice(3, 1); // Remove SymPy from defaults
+    snippets_menu.default_menus[0]['menu-direction'] = 'left';
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right';
+    var sibling = $("#insert_cell_below");
+    var inserted_menu = [
+        '---',
+        snippets_menu.default_menus[0],
+    ];
+    snippets_menu.menu_setup(inserted_menu, sibling, false);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});

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

@@ -0,0 +1,292 @@
+define([
+    "require",
+    "jquery",
+    "base/js/namespace",
+    "./snippets_submenu_python",
+    "./snippets_submenu_markdown",
+], function (requirejs, $, Jupyter, python, markdown) {
+    "use strict";
+
+    var mod_name = 'snippets_menu';
+    var mod_log_prefix = mod_name + '[' + mod_name + ']';
+
+    var python_menus = [
+        python.numpy,
+        python.scipy,
+        python.matplotlib,
+        python.sympy,
+        python.pandas,
+        python.astropy,
+        python.h5py,
+        python.numba,
+        python.python,
+    ];
+
+    var default_menus = [
+        {
+            'name' : 'Snippets',
+            'sub-menu-direction' : 'left',
+            'sub-menu' : python_menus.concat([markdown]),
+        },
+    ];
+    var options = {
+        sibling: undefined, // if undefined, set by cfg.sibling_selector
+        menus : [],
+        hooks: {
+            pre_config: undefined,
+            post_config: undefined,
+        }
+    };
+
+    var includable_submenu_keys = [
+        "numpy",
+        "scipy",
+        "matplotlib",
+        "sympy",
+        "pandas",
+        "astropy",
+        "h5py",
+        "numba",
+        "python",
+        "markdown",
+    ];
+    // default parameters
+    var cfg = {
+        insert_as_new_cell: false,
+        insert_before_sibling: false,
+        include_custom_menu: false,
+        include_submenu: {}, // default set after this definition
+        sibling_selector: '#help_menu',
+        top_level_submenu_goes_left: true,
+        // The default has to be included here as well as config.yaml
+        // because the configurator will not store the default given
+        // in config.yaml unless it is changed.  That means that this
+        // should be kept up-to-date with whatever goes in
+        // config.yaml.
+        custom_menu_content: JSON.stringify({
+            "name" : "My favorites",
+            "sub-menu" : [{
+                "name" : "Menu item text",
+                "snippet" : [
+                    "import something",
+                    "",
+                    "new_command(3.14)",
+                    "other_new_code_on_new_line('with a string!')",
+                    "stringy(\"if you need them, escape double quotes with a single backslash\")",
+                    "backslashy('This \\ appears as just one backslash in the output')",
+                    "backslashy2('Here \\\\ are two backslashes')"
+                ]}, {
+                    "name" : "TeX can be written in menu labels $\\alpha_W e\\int_0 \\mu \\epsilon$",
+                    "snippet" : [
+                        "another_new_command(2.78)"
+                    ]
+                }
+            ]
+        })
+    };
+    for (var ii=0; ii< includable_submenu_keys.length; ii++) {
+        cfg.include_submenu[includable_submenu_keys[ii]] = true;
+    }
+
+    function config_loaded_callback () {
+        if (options['pre_config_hook'] !== undefined) {
+            options['pre_config_hook']();
+        }
+
+        // true => deep
+        cfg = $.extend(true, cfg, Jupyter.notebook.config.data.snippets);
+
+        if (cfg.insert_as_new_cell) {
+            console.log(mod_log_prefix, "Insertions will insert new cell");
+        }
+
+        // If `options.menus` had elements added in custom.js, skip all of this and ignore all remaining options
+        if (options.menus.length > 0) {
+            console.log(mod_log_prefix, '`options.menus` was created in custom.js; skipping all other configuration.');
+        }
+        else {
+            options.menus = [
+                {
+                    'name' : 'Snippets',
+                    'sub-menu-direction' : cfg.top_level_submenu_goes_left ? 'left' : 'right',
+                    'sub-menu' : [],
+                },
+            ];
+
+            if (cfg.include_custom_menu) {
+                var custom_menu_content = JSON.parse(cfg.custom_menu_content);
+                console.log(mod_log_prefix,
+                            "Inserting custom", custom_menu_content.name, "sub-menu");
+                options.menus[0]['sub-menu'].push(custom_menu_content);
+            }
+
+            for (var ii=0; ii < includable_submenu_keys.length; ii++) {
+                var key = includable_submenu_keys[ii];
+                if (cfg.include_submenu[key]) {
+                    console.log(mod_log_prefix,
+                                "Inserting default", key, "sub-menu");
+                    options.menus[0]['sub-menu'].push(key === "markdown" ? markdown : python[key]);
+                }
+            }
+        }
+
+        if (options.hooks.post_config !== undefined) {
+            options.hooks.post_config();
+        }
+
+        // select correct sibling
+        if (options.sibling === undefined) {
+            options.sibling = $(cfg.sibling_selector).parent();
+            if (options.sibling.length < 1) {
+                options.sibling = $("#help_menu").parent();
+            }
+        }
+    }
+
+    function insert_snippet_code (snippet_code) {
+        if (cfg.insert_as_new_cell) {
+            var new_cell = Jupyter.notebook.insert_cell_above('code');
+            new_cell.set_text(snippet_code);
+            new_cell.focus_cell();
+        }
+        else {
+            var selected_cell = Jupyter.notebook.get_selected_cell();
+            Jupyter.notebook.edit_mode();
+            selected_cell.code_mirror.replaceSelection(snippet_code, 'around');
+        }
+    }
+
+    function callback_insert_snippet (evt) {
+        // this (or event.currentTarget, see below) always refers to the DOM
+        // element the listener was attached to - see
+        // http://stackoverflow.com/questions/12077859
+        insert_snippet_code($(evt.currentTarget).data('snippet-code'));
+    }
+
+    function build_menu_element (menu_item_spec, direction) {
+        // Create the menu item html element
+        var element = $('<li/>');
+
+        if (typeof menu_item_spec == 'string') {
+            if (menu_item_spec != '---') {
+                console.log(mod_log_prefix,
+                    'Don\'t understand sub-menu string "' + menu_item_spec + '"');
+                return null;
+            }
+            return element.addClass('divider');
+        }
+
+        var a = $('<a/>')
+            .attr('href', '#')
+            .html(menu_item_spec.name)
+            .appendTo(element);
+        if (menu_item_spec.hasOwnProperty('snippet')) {
+            var snippet = menu_item_spec.snippet;
+            if (typeof snippet == 'string' || snippet instanceof String) {
+                snippet = [snippet];
+            }
+            a.attr({
+                'title' : "", // Do not remove this, even though it's empty!
+                'data-snippet-code' : snippet.join('\n'),
+            })
+            .on('click', callback_insert_snippet)
+            .addClass('snippet');
+        }
+        else if (menu_item_spec.hasOwnProperty('internal-link')) {
+            a.attr('href', menu_item_spec['internal-link']);
+        }
+        else if (menu_item_spec.hasOwnProperty('external-link')) {
+            a.empty();
+            a.attr({
+                'target' : '_blank',
+                'title' : 'Opens in a new window',
+                'href' : menu_item_spec['external-link'],
+            });
+            $('<i class="fa fa-external-link menu-icon pull-right"/>').appendTo(a);
+            $('<span/>').html(menu_item_spec.name).appendTo(a);
+        }
+
+        if (menu_item_spec.hasOwnProperty('sub-menu')) {
+            element
+                .addClass('dropdown-submenu')
+                .toggleClass('dropdown-submenu-left', direction === 'left');
+            var sub_element = $('<ul class="dropdown-menu"/>')
+                .toggleClass('dropdown-menu-compact', menu_item_spec.overlay === true) // For space-saving menus
+                .appendTo(element);
+
+            var new_direction = (menu_item_spec['sub-menu-direction'] === 'left') ? 'left' : 'right';
+            for (var j=0; j<menu_item_spec['sub-menu'].length; ++j) {
+                var sub_menu_item_spec = build_menu_element(menu_item_spec['sub-menu'][j], new_direction);
+                if(sub_menu_item_spec !== null) {
+                    sub_menu_item_spec.appendTo(sub_element);
+                }
+            }
+        }
+
+        return element;
+    }
+
+    function menu_setup (menu_item_specs, sibling, insert_before_sibling) {
+        for (var i=0; i<menu_item_specs.length; ++i) {
+            var menu_item_spec;
+            if (insert_before_sibling) {
+                menu_item_spec = menu_item_specs[i];
+            } else {
+                menu_item_spec = menu_item_specs[menu_item_specs.length-1-i];
+            }
+            var direction = (menu_item_spec['menu-direction'] == 'left') ? 'left' : 'right';
+            var menu_element = build_menu_element(menu_item_spec, direction);
+            // We need special properties if this item is in the navbar
+            if ($(sibling).parent().is('ul.nav.navbar-nav')) {
+                menu_element
+                    .addClass('dropdown')
+                    .removeClass('dropdown-submenu dropdown-submenu-left');
+                menu_element.children('a')
+                    .addClass('dropdown-toggle')
+                    .attr({
+                        'data-toggle' : 'dropdown',
+                        'aria-expanded' : 'false'
+                    });
+            }
+
+            // Insert the menu element into DOM
+            menu_element[insert_before_sibling ? 'insertBefore': 'insertAfter'](sibling);
+
+            // Make sure MathJax will typeset this menu
+            window.MathJax.Hub.Queue(["Typeset", window.MathJax.Hub, menu_element[0]]);
+        }
+    }
+
+    function load_ipython_extension () {
+        // Add our css to the notebook's head
+        $('<link/>', {
+            rel: 'stylesheet',
+            type:'text/css',
+            href: requirejs.toUrl('./snippets_menu.css')
+        }).appendTo('head');
+
+        // Arrange the menus as given by the configuration
+        Jupyter.notebook.config.loaded.then(
+            config_loaded_callback
+        ).then(function () {
+            // Parse and insert the menu items
+            menu_setup(options.menus, options.sibling, cfg.insert_before_sibling);
+        });
+    }
+
+    return {
+        // Handy functions
+        load_ipython_extension : load_ipython_extension,
+        menu_setup : menu_setup,
+
+        // Default menus
+        python : python,
+        python_menus : python_menus,
+        markdown : markdown,
+        default_menus : default_menus,
+
+        // Items that could be useful for customization
+        options : options,
+    };
+
+});

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

@@ -0,0 +1,633 @@
+Jupyter notebook snippets menu
+==============================
+
+Adds a customizable menu item to Jupyter notebooks to insert
+snippets, boilerplate, and examples of code.
+
+![Open snippets menu](screenshot1.png)
+
+This notebook extension adds a menu item (or multiple menu items, if
+desired) after the `Help` menu in Jupyter notebooks.  This new menu
+contains little snippets of code that we all forget from time to time
+but don't want to google, or are just too lazy to type, or simply
+didn't know about.  It can also be helpful for people just starting
+out with a programming language, who need some ideas for what to do
+next — like importing a module, defining variables, or calling
+functions.
+
+The new menu comes with a default value relevant for python
+programming — especially scientific computing — though this is fully
+user-configurable as detailed below.  The default menu is named
+`Snippets`, and contains sub-menus with snippets for a few popular
+python packages, as well as python itself, and some notebook markdown.
+(Note that some of the menus are so large that it is necessary to move
+the first-level menus to the left so that lower-level menus will fit
+on the screen.  This behavior is also user-configurable, as discussed
+in detail [below](#change-direction-of-sub-menus).)
+
+So, for example, if you are editing a code cell and want to import
+matplotlib for use in the notebook, you can just click the `Snippets`
+menu, then mouse over "Matplotlib".  This will open up a new sub-menu,
+with an item "Setup for notebook".  Clicking on that item will insert
+the code snippet at the point where your cursor was just before you
+clicked on the menu.  In particular, for this `matplotlib` example,
+the following code gets inserted:
+
+```python
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+%matplotlib inline
+```
+
+The inserted text will be selected, so that you can delete it by
+pressing backspace or delete, or you can just select another snippet
+to replace it -- and just to highlight what was inserted.
+
+Note that many of the snippets involve variable names prefixed with
+`bp_`.  For example, a new numpy array is created as `bp_new_array`.
+These are intentionally dumb names that you really should replace.
+Failing to do so could lead to ugly bugs in your code if you use
+multiple boilerplate snippets with clashing variable names.
+
+Similarly, some strings are intended to be replaced, such as the axis
+labels in plots.  These are there to show you what can be done, and to
+remind you to put informative labels in your plots.  If you don't
+want, e.g., a title on your plot, just remove that line.
+
+
+Installation
+------------
+To install this extension alone (without the [main collection of nbextensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions)), run the following from the command line:
+
+```bash
+git clone git://github.com/moble/jupyter_boilerplate
+jupyter nbextension install jupyter_boilerplate
+jupyter nbextension enable jupyter_boilerplate/main
+```
+
+You can then disable the extension if you want with
+```bash
+jupyter nbextension disable jupyter_boilerplate/main
+```
+
+
+Basic menu customization
+------------------------
+
+The default menu might have too many irrelevant items for you, or may
+not have something you would find useful.  You can easily customize it
+in the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator#usage),
+which you almost certainly have if you installed this extension the
+normal way,
+through
+[jupyter_contrib_nbextensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions).
+Usually, you can get to the configurator by pointing your browser to
+http://127.0.0.1:8888/nbextensions, though you may have to modify the
+URL if you use a more complicated jupyter server.
+
+On the configurator page, you will see a number of options (as well as
+this README) that should be fairly self-explanatory, allowing you to
+remove any of the default menu items, or add a custom menu within the
+"Snippets" menu.  The custom menu is written in JSON, and a simple
+(and useless) example is given that should be easy to modify as
+needed.
+
+
+
+Advanced menu customization
+---------------------------
+
+It is also possible to extensively customize the menus in far more
+complex ways using your `custom.js` file.  For example, you can change
+the order of menu items, add more custom sub-menus under the
+"Snippets" menu, and custom menus alongside "Snippets" in the menu
+bar, or even add menus in other places, like inside the "Insert" menu.
+
+You can find the path to `custom.js` by running the command
+
+```bash
+echo $(jupyter --config-dir)/custom/custom.js
+```
+
+For Mac and linux users, the result is probably
+`~/.jupyter/custom/custom.js`.  If this file or the directory
+containing it do not exist, you can simply create them.
+
+The customization process is best explained through examples, which
+are available in the `examples_for_custom.js` file in this directory.
+Note that there's a lot of explanation here, but it's all actually
+pretty simple.  Give it a try, and you'll pick it up quickly.  Note
+that using this method can make it so that options selected in the
+configurator are ignored.
+
+The theory behind this customization is that the menu is represented
+by a nested JavaScript array (which is just like a python list).  So
+to change the menu, you just need to change that array.  And each menu
+*item* inside this array is represented by
+a [JavaScript "object"](https://api.jquery.com/Types/#Object) (which is
+just like a python dictionary).  So to change a menu item, you just
+have to change that object.
+
+Again, this makes more sense when looking at example, as follows.
+
+
+### Add a custom sub-menu with simple snippets
+
+Suppose you want to make a new sub-menu with your favorite snippets at
+the bottom of `Snippets`.  You create a new object for the menu item,
+and then just "push" it onto the default menu.  Do this by inserting
+some lines into your `custom.js`, so that it looks like this:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var my_favorites = {
+        'name' : 'My favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Menu item text',
+                'snippet' : ['new_command(3.14)',],
+            },
+            {
+                'name' : 'Another menu item',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'] = snippets_menu.default_menus;
+    snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line);
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+Now, if you refresh your notebook, you'll see a new menu item named "My
+favorites".  Hover over it, and it will pop up a sub-menu with two more
+options.  Click the first one, and it will insert `new_command(3.14)` into
+your notebook wherever the cursor was.
+
+We discuss how all this works below.  But first, we need to slightly generalize
+the example above to work with more complicated snippets.
+
+
+### More complicated snippets
+
+The example above inserted simple one-line snippets of code.  Those snippets
+didn't have any quotation marks (single or double), backslashes, or newlines,
+which made everything easy.  Unfortunately, JavaScript doesn't deal too well
+with strings.  (There are no raw triple-quoted strings, like in python.)  So
+there are just three things to remember when writing snippets.
+
+  1. Quotation marks can be a tiny bit tricky.  There are a few options:
+    1. The obvious option is to enclose your snippets in single quotation marks
+       (`'`), and use only double quotation marks (`"`) within the snippet
+       itself.
+    2. Just as easy is to enclose your snippets in double quotation marks
+       (`"`), and use only single quotation marks (`'`) within the snippet
+       itself.
+    3. You can also escape single quotation marks inside single quotation marks
+       as `\'`.
+
+  2. Newlines are even trickier, but the extension takes care of this for you
+     as long as you put separate lines of code as separate elements of the
+     `snippet` array.  Generally, there's no reason to put a literal newline in
+     your snippets.
+
+  3. JavaScript will treat backslashes as if they're trying to escape whatever
+     comes after them.  So if you want one backslash in your output code,
+     you'll need to put two backslashes in.
+
+This is all best described with another example.  Let's change the first
+function above, to give it some more lines and some quotes:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var my_favorites = {
+        'name' : 'My $\\nu$ favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Multi-line snippet',
+                'snippet' : ['new_command(3.14)',
+                             'other_new_code_on_new_line("with a string!")',
+                             'stringy(\'escape single quotes once\')',
+                             "stringy2('or use single quotes inside of double quotes')",
+                             'backslashy("This \\ appears as just one backslash in the output")',
+                             'backslashy2("Here are \\\\ two backslashes")',],
+            },
+            {
+                'name' : 'TeX appears correctly $\\alpha_W e\\int_0 \\mu \\epsilon$',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line);
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+Note the code output by the first item contains all sorts of interesting
+strings.  Also, the menu title of the second item contains TeX, which will
+display correctly, and is used in some of the default menus to show the
+standard symbols for physical constants.  For more examples, look at the
+default menus stored in the `snippets_menu` directory -- mostly under `python`.
+
+
+### How it works: Creating new menu items
+
+Each of the menu items above is a JavaScript object (like a python `dict`),
+with some attributes -- `name` and `sub-menu` for the main menu item, and
+`name` and `snippet` for the sub-menu items.  In general, any menu object can
+have any of the following properties:
+
+  1. `name`: Text that appears in the menu.  Note that this can include latex,
+     as the menus are processed by MathJax after being loaded.
+  2. `sub-menu`: An array of more menu items
+  3. `snippet`: An array of strings turned into code when the menu item is
+     clicked
+  4. `internal-link`: Link to some place on the present page.  For example,
+     this could be `#References`, to link to the `References` section of any
+     notebook you're in.
+  5. `external-link`: This just a link to some external web page, which will be
+     identified with a little icon, just like in the standard notebook "Help"
+     menu.  When clicked, the link will open in a new window/tab.
+  6. `menu-direction`: If the value of this property is `left`, this menu's
+     sub-menus open on the left.  This is useful when the top-level menu is
+     inserted as an item within other menu items.  See
+     [below](#change-direction-of-sub-menus) for examples.
+  7. `sub-menu-direction`: If the value of this property is `left`, sub-menus
+     within this menu's sub-menus open on the left.  This is used by default
+     for items under the `Snippets` menu to help ensure that nested menus
+     don't become too large to fit on the screen.  See
+     [below](#change-direction-of-sub-menus) for examples.
+
+The `name` property is the only required one, though you'll probably want at
+least one other property.  The `sub-menu` contains menu objects that again may
+have any of these properties, so you can easily nest menus.  You can also
+combine a `snippet` with a `sub-menu`, so that there's a default value as well
+as a sub-menu.  However, the last three are mutually exclusive: `snippet` will
+override any `-link`; an `internal-link` will override an `external-link`.
+
+
+### How it works: Splicing new menu items into the old
+
+Besides just creating the menu items, we may want to join together previously
+created items.  That's the purpose of this line in the code above:
+
+```javascript
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+```
+
+This uses
+the [JavaScript `push`](https://www.w3schools.com/jsref/jsref_push.asp)
+function to insert the new menu `my_favorites` menu into the last slot
+of `snippets_menu.options['menus'][0]['sub-menu']`, which is the set
+of menus under the heading `Snippets`.
+
+If you think about this last point, you'll realize that `Snippets` is
+just the `0` slot of an array of menus.  If you want a new menu right
+in the menu bar, you could add `my_favorites` right to that top-level
+array, with something like this:
+
+```javascript
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    snippets_menu.options['menus'].push(my_favorites);
+```
+
+This would place your favorites after the default `Snippets` menu; to
+put it before, just swap the order in which you `push`:
+
+```javascript
+    snippets_menu.options['menus'].push(my_favorites);
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+```
+
+(In general, to add a new element at a given index of an array, you
+could also just use
+the [splice](https://www.w3schools.com/jsref/jsref_splice.asp)
+function.)
+
+This might be useful if you have one set of very frequently used
+commands, and want immediate access, without going through various
+levels of the usual menu.  A useful example of this is
+shown [below](#starting-over-with-the-menus).  The `splice` function
+can also be used to delete items from the array, as
+described [next](#deleting-menu-items).
+
+
+### Other menu manipulations
+
+To rearrange menu items, just use standard JavaScript techniques.  The two most
+likely examples are deleting and rearranging menu items, but we'll also see
+that other manipulations are easy.  We can also change where the new menus go,
+and what they look like.
+
+#### Deleting menu items
+
+To delete an item, just `splice` nothing into it.  Let's suppose, for example,
+that you want to remove the option to set up matplotlib for a script, which is
+the `1` item of the "Matplotlib" menu:
+
+```javascript
+snippets_menu.python.matplotlib['sub-menu']
+```
+
+Remember that `[1]` is the second element of "Matplotlib"'s sub-menu
+list.  So the following code will do the trick
+
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.python.matplotlib['sub-menu'].splice(1, 1); // Delete 1 element starting at position 1 of the sub-menu
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+The first `1` in the argument to `splice` says to work on the element at
+position 1; the second `1` says to delete 1 element of the array.
+
+
+#### Rearranging menu items
+
+Following the example above, suppose you don't want to delete the second setup
+item under "Matplotlib", but instead want to swap those first two items.  To
+make this swap, you need to do the usual trick of storing one element in a
+temporary variable, and then reassign appropriately.  The following code
+achieves this purpose:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var tmp = snippets_menu.python.matplotlib['sub-menu'][0];
+    snippets_menu.python.matplotlib['sub-menu'][0] = snippets_menu.python.matplotlib['sub-menu'][1];
+    snippets_menu.python.matplotlib['sub-menu'][1] = tmp;
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+#### Change direction of sub-menus
+
+Each sub-menu may be placed to the right or left side of the menu item
+containing it.  This is controlled by the `menu-direction` and
+`sub-menu-direction` properties of the container.  By default, both are set to
+`right` for all menus, but `sub-menu-direction` is set to `left` for the
+default `Snippets` menu, which means that all of its sub-menus open to the
+left side.  This is important because the menus may be nested quite deeply, and
+need to fit on the screen.  For example, the SciPy CODATA constants and SymPy's
+orthogonal functions will easily extend far past the right-hand edge of the
+notebook without this feature.  That means the window size would abruptly
+increase when you mouse over these menus, and would abruptly collapse when you
+mouse out of them.  So by opening them to the left, we gain enough space to
+keep everything on the screen.
+
+But these are configurable properties.  If, for example, you want to change the
+default menus to open on the right (which would be the more standard behavior),
+you can use this:
+
+```javascript
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right';
+```
+
+This may be particularly useful if we change the position of the menus, as in
+the next examples.
+
+
+#### Starting over with the menus
+
+Each of the menu items under the default `Snippets` menu is
+individually available as part of the `snippets_menu` object defined
+in our JavaScript examples.  So if you want, you could just use them
+to build your own version of the menu.  For example, suppose use SymPy
+and Numpy most frequently, so you want easy access to their menus,
+without having to click `Snippets` first.  And then suppose you still
+want most of the other `Snippets` items, but less frequently so they
+can stay in their menu, except that you really never use pandas.  You
+can create your own menu as follows:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.default_menus[0]['sub-menu'].splice(3, 2); // Remove SymPy and pandas
+    snippets_menu.python.sympy['sub-menu-direction'] = 'left'; // Point new SymPy menus to left
+    snippets_menu.python.numpy['sub-menu-direction'] = 'left'; // Point new Numpy menus to left
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]); // Start with the remaining "Snippets" menu
+    snippets_menu.options['menus'].push(snippets_menu.python.sympy); // Follow that with a new SymPy menu
+    snippets_menu.options['menus'].push(snippets_menu.python.numpy); // Follow that with a new Numpy menu
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+The default menu group is `snippets_menu.default_menus`, and the SymPy sub-menu
+is `snippets_menu.python.sympy`.  You can see that we've manipulated them above
+by removing two elements from the default menu, using the `splice` command.
+We've also added a new property to the SymPy menu to make its sub-menus open to
+the left, instead of the right -- which is necessary to keep all of SymPy's
+extensively nested menus on the screen.  (In fact, the list of orthogonal
+polynomials under "Special functions" in the SymPy menu are some of the widest
+menus in the default set.)  Finally, we've combined the modified default menu
+with the modified SymPy menu into one new list.
+
+This gives us the original `Snippets` menu with SymPy and pandas removed, as
+well as new menus devoted to just SymPy and Numpy right in the menu bar:
+
+![Opened snippets menu after adjustments](screenshot2.png)
+
+You can see that the two items are indeed removed from `Snippets`, and
+"SymPy" and "Numpy" now have places of honor right in the menu bar.
+You can, of course, swap their order in the code above, or make any
+number of further alterations.
+
+
+#### Changing the insertion point
+
+You might want to change the order of the menus in the navbar (that
+top-level bar with "File", etc.).  For example, it might feel
+particularly natural to have "Help" as the last item, so maybe you'd
+prefer to put the `Snippets` menu *before* the "Help" menu.  Or you
+may prefer to maintain the structure of the menus in the navbar, and
+would rather have the `Snippets` menu *inside* of some other top-level
+menu -- like the "Insert" menu.  Personally, I prefer to have the
+`Snippets` menu in its default position for easy access.  But it's
+certainly possible to put it other places.
+
+To help do this, there are two additional options available, which can
+be set either in the configurator or in `custom.js`.  Their default
+values give us the usual placement of the `Snippets` menu; by giving
+them different values, we can change the placement.  These options are
+
+  1. `sibling`: This is an HTML node next to our new menu,
+     presumably
+     [selected with `jQuery`](https://learn.jquery.com/using-jquery-core/selecting-elements/).
+     The default value is `$("#help_menu").parent()`, which is the
+     "Help" menu.  For the configurator, `.parent()` is automatically
+     appended.
+  2. `insert_before_sibling`: This is just a string controlling where
+     the new menu will be inserted relative to its sibling. The
+     default value is `false`.  If you change it to `true`, the new
+     menu will be inserted before the sibling.
+
+So placing the `Snippets` menu *before* the "Help" menu is as easy as
+checking the box for that second option.  For more complicated uses,
+you may need to set these values from `custom.js`.  For example, f you
+want to put the new `Snippets` menu as an item inside the standard
+"Insert" menu, and include an additional horizontal divider, you can
+use this:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.default_menus[0]['menu-direction'] = 'left'; // Open top-level menu to the left...
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right'; // ...and sub-menus to the right.
+    snippets_menu.options['menus'].push('---', snippets_menu.default_menus[0]); // Add horizontal line and default menus
+    snippets_menu.options['sibling'] = $("#insert_cell_below"); // Find the place at which to insert the new menus
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+Here's what that looks like:
+
+![Opened snippets menu under "Insert" menu](screenshot3.png)
+
+And of course, you can combine this selection of the insertion point with other
+techniques above, where you change the content of the menus.
+
+
+#### Multiple menus in separate locations
+
+Finally, we have one more interesting example that brings together various
+threads from the previous examples.  It is possible to place multiple menus in
+different locations.  For example, suppose we want to combine two of the examples
+above, where [(1)](#starting-over-with-the-menus) we separated "SymPy" into its
+own menu on the navbar, and [(2)](#changing-the-insertion-point) we placed the
+`Snippets` menu inside the "Insert" menu.  That is, you might want "SymPy"
+to be conveniently placed, but you want the rest of the `Snippets` to stay
+under the "Insert" menu.
+
+To add these two separate menus, we place the first with the usual
+approach, and then place the second with another function,
+`snippets_menu.menu_setup`.  The former is mostly just a wrapper to
+the latter, except that it also inserts JavaScript and CSS elements
+into the notebook.  Note that `menu_setup` does not have any default
+values; you must always pass the `sibling` and `insert_before_sibling`
+arguments.
+
+So, putting it all together, the code needed for this arrangement is as
+follows:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var sympy_menu = [snippets_menu.python.sympy,];
+    sympy_menu[0]['sub-menu-direction'] = 'left';
+    snippets_menu.options['menus'] = sympy_menu;
+    snippets_menu.default_menus[0]['sub-menu'].splice(3, 1); // Remove SymPy from defaults
+    snippets_menu.default_menus[0]['menu-direction'] = 'left';
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right';
+    var sibling = $("#insert_cell_below");
+    var inserted_menu = [
+        '---',
+        snippets_menu.default_menus[0],
+    ];
+    snippets_menu.menu_setup(inserted_menu, sibling, 'after');
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+
+Troubleshooting
+---------------
+
+The first step is to make sure that the default setup can be loaded.
+Comment out whatever you've got in `custom.js`, and add in the simple
+configuration from [the beginning](#installation).  If that doesn't
+work, try the following steps
+suggested
+[here](http://jupyter-contrib-nbextensions.readthedocs.io/en/latest/troubleshooting.html):
+
+  1. Clear your browser cache or start a private browser tab.
+  2. Verify your `custom.js` is the one the notebook is seeing, by opening it
+     in the browser: <http://127.0.0.1:8888/static/custom/custom.js> (as
+     opposed to looking at the file directly outside of your browser, which may
+     not be the `custom.js` loaded if you are using a `virtualenv`).
+  3. Verify the extension can be loaded by the Jupyter notebook, for example:
+     <http://127.0.0.1:8888/nbextensions/snippets_menu/main.js>.  You
+     should see a page with lots of JavaScript code, and should *not*
+     see a 404 error.
+  4. Check for error messages in the JavaScript console.
+
+Now, assuming the basic installation works, it must be something wrong
+in your customization.  (Or maybe a new bug you've uncovered...)
+
+Sometimes, the menu(s) might simply not appear.  This is most likely
+due to a syntax error in your menu.  You can find out in Chrome by
+going to "View" -> "Developer" -> "JavaScript console".  You'll see a
+bunch of output.  Red lines are usually errors (some of which are
+probably *not* due to your menu error).  On the right side of those
+lines, you'll see the file where the error came from, and possibly
+even the line number that's causing the trouble.  Find an error that
+links to either `snippets_menu/main.js` or `custom.js`, and click on
+it.  Then try to figure out what went wrong.  The most common error
+I've encountered is "Unexpected string", which might indicate a
+missing comma, or an improperly escaped quote.  Note that sometimes
+the error will point to the first thing *after* the real problem.
+
+Or maybe the menu did appear, but it doesn't work properly.  You can
+also inspect the actual elements that were inserted.  Click on
+"Elements" in that Developer Tools tab that opened at the bottom of
+your window.  Then click the magnifying glass, and click on the
+`Snippets` menu.  This will jump the Developer Tools to the part of
+the source with that menu.  Scroll through to find the menu item
+that's not working correctly, and take a look at it.  The text in the
+`data-snippet-code` attribute is especially important, since that's
+what gets inserted into the notebook.
+
+
+TODO
+----
+
+There's a bunch of stuff I still need to do, listed in
+the
+[issue tracker](https://github.com/moble/jupyter_boilerplate/issues).
+If you find a bug or have an idea for a good snippet that you think
+should be added to the defaults, feel free
+to
+[open a new issue](https://github.com/moble/jupyter_boilerplate/issues/new).
+
+In particular, I don't use Julia or R, so I welcome suggestions for
+default snippets for those languages.
+
+
+
+Reasons for using this extension
+--------------------------------
+
+This is just a nice place to collect thoughts about why anyone might
+find this to be a useful extension:
+
+  * Introducing beginners to coding.  It's helpful for the beginner to have a
+    list of useful possibilities (with correct syntax!) lined up right where
+    the programming is happening.  It's like "Hello world" on steroids.
+  * Introducing the Jupyter notebook.  It can be useful to have some nice
+    things to do in the notebook to demonstrate the possibilities.  For
+    example, you might suggest that someone new to the notebook run the
+    Matplotlib setup and then make an example plot.
+  * Convenience for lazy people like me.  For example, I usually don't want to
+    bother with all the typing involved in setting up the nice (but important)
+    parts of a plot, like the axis labels and legend.  But by inserting the
+    template, all I have to do is change the relevant values.
+  * Reminders about useful things that could be done.  For example,
+    when I'm manipulating expressions in SymPy, I'll frequently forget
+    that I can simplify, expand, collect, etc., in all sorts of ways.
+    The Snippets menu reminds me of that.
+  * Convenient reference for massive libraries.  For example, SciPy contains
+    lots of constants.  You could certainly go to the web page describing these
+    various constants to find the one you need, or you could just explore them
+    right in the browser.  The same is true of SymPy's collection of special
+    functions.

.local/share/jupyter/nbextensions/snippets_menu/snippets_menu.css

@@ -0,0 +1,72 @@
+/*
+
+  The left-side dropdown submenu is adapted from the usual right-side code at
+  <https://github.com/ipython/ipython/blob/master/IPython/html/static/style/style.min.css#L10664>
+
+*/
+.dropdown-submenu-left > .dropdown-menu {
+  left: auto;
+  right: 100%;
+}
+
+/* For space-saving menus */
+.dropdown-submenu > .dropdown-menu.dropdown-menu-compact {
+  left: 50%;
+  top: 100%;
+}
+.dropdown-submenu-left > .dropdown-menu.dropdown-menu-compact {
+  left: auto;
+  right: 50%;
+}
+
+.dropdown-submenu-left > a:after {
+  visibility: hidden;
+}
+.dropdown-submenu-left > a:before {
+  display: inline-block;
+  font: normal normal normal 14px/1 FontAwesome;
+  font-size: inherit;
+  text-rendering: auto;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  transform: translate(0, 0);
+  display: block;
+  content: "\f0d9";
+  float: left;
+  color: #333333;
+  margin-top: 2px;
+  margin-left: -10px;
+}
+
+
+/*
+
+  The following allows for control of the "tooltip" that shows the code to be
+  inserted when the item is clicked.  Without this, the tooltip might wrap the
+  code, making it hard to read; will cut off some of the code; won't be
+  monospaced; etc.  Note that these CSS selectors select any <a/> element with
+  an attribute `data-snippet-code`.  This attribute is necessary and sufficient
+  for us to add the pop-up.
+
+*/
+a[data-snippet-code]:after {
+    content: attr(data-snippet-code); /* Read from the data-snippet-code attribute */
+    font-family: monospace;
+    font-size: 75%;
+    position: absolute;
+    width: auto;
+    display: table;
+    left: 50%;
+    white-space: pre;
+    z-index: 10000;
+    background: #E8E8E8;
+    padding: 4px;
+    border-color : #AAA;
+    border-style: solid;
+    border-width: 1px;
+    visibility: hidden;
+}
+a[data-snippet-code]:hover:after {
+    visibility: visible;
+    transition: all 0s ease 1s;
+}

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

@@ -0,0 +1,51 @@
+define({
+    'name' : 'numba',
+    'sub-menu' : [
+        {
+            'name' : 'Setup',
+            'snippet' : [
+                'from __future__ import print_function, division',
+                'import sys',
+                'if sys.version_info[0] >= 3:',
+                '    xrange = range  # Must always iterate with xrange in njit functions',
+                'import numba',
+            ],
+        },
+        {
+            'name' : 'Documentation',
+            'external-link' : 'http://numba.pydata.org/numba-doc/dev/index.html',
+        },
+        '---',
+        {
+            'name' : 'Jit function',
+            'snippet'  : [
+                '@numba.njit',
+                'def bp_func(x):',
+                '    r"""Some function',
+                '    ',
+                '    Does some stuff.',
+                '    ',
+                '    """',
+                '    return x**2',
+            ],
+        },
+
+        {
+            'name' : 'Jit function with specified signature',
+            'snippet'  : [
+                '@numba.njit(f8, f8[:])',
+                'def bp_func(x, y):',
+                '    r"""Some function',
+                '    ',
+                '    Parameters',
+                '    ----------',
+                '    x : float',
+                '    y : float array',
+                '    ',
+                '    """',
+                '    for j in xrange(y.size):',
+                '        y[j] *= x',
+            ],
+        },
+    ],
+});

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

@@ -0,0 +1,618 @@
+define([
+    "require",
+    "./numpy_ufuncs",
+    "./numpy_polynomial",
+], function (requirejs, numpy_ufuncs, numpy_polynomial) {
+    return {
+        'name' : 'NumPy',
+        'sub-menu' : [
+            {
+                'name' : 'Setup',
+                'snippet' : [
+                    'from __future__ import print_function, division',
+                    'import numpy as np',
+                ],
+            },
+            {
+                'name' : 'Documentation',
+                'external-link' : 'http://docs.scipy.org/doc/numpy/index.html',
+            },
+            '---',
+            {
+                'name' : 'Creating arrays',
+                'sub-menu' : [
+                    {
+                        'name' : 'New array of given shape',
+                        'snippet' : ['new_array = np.zeros((4,3,), dtype=complex)',],
+                    },
+                    {
+                        'name' : 'New array shaped like another',
+                        'snippet' : ['new_array = np.zeros_like(old_array, dtype=complex)',],
+                    },
+                    {
+                        'name' : 'Copy of existing data',
+                        'snippet' : ['new_array = np.copy(old_array)',],
+                    },
+                    {
+                        'name' : 'Array from list of data',
+                        'snippet' : ['new_array = np.array([1.2, 3.4, 5.6])',],
+                    },
+                    {
+                        'name' : 'Evenly spaced values within a given interval',
+                        'snippet' : ['new_array = np.arange(1, 10, 2)'],
+                    },
+                    {
+                        'name' : 'Evenly spaced numbers over a specified interval',
+                        'snippet' : ['new_array = np.linspace(1., 10., num=120, endpoint=True)'],
+                    },
+                    {
+                        'name' : 'Numbers spaced evenly on a log scale',
+                        'snippet' : ['new_array = np.logspace(1., 10., num=120, endpoint=True, base=2)'],
+                    },
+                    {
+                        'name' : 'Coordinate matrices from coordinate vectors',
+                        'snippet' : [
+                            'x = np.linspace(0, 1, 7)',
+                            'y = np.linspace(0, 1, 11)',
+                            'xx, yy = np.meshgrid(x, y)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return views of the data, split into $N$ groups',
+                        'snippet' : [
+                            'x = np.arange(12)',
+                            'a,b,c = np.split(x, 3)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return views of the data, split at given indices along given axis',
+                        'snippet' : [
+                            'x = np.arange(27).reshape((3,9))',
+                            'a,b,c = np.split(x, [2,6], axis=1)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return copy of arrays, combined into one',
+                        'snippet' : [
+                            'a = np.arange(30).reshape((2,3,5))',
+                            'b = np.arange(42).reshape((2,3,7))',
+                            'c = np.concatenate((a, b), axis=1)',
+                        ],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Reshaping and viewing arrays',
+                'sub-menu' : [
+                    {
+                        'name' : 'Return a view of the data, with a different shape',
+                        'snippet' : ['np.arange(6).reshape((3, 2))'],
+                    },
+                    {
+                        'name' : 'Return a view of the data, with an extra axis',
+                        'snippet' : ['a[:, np.newaxis]'],
+                    },
+                    {
+                        'name' : 'Return a view of the data, flattened to 1-D',
+                        'snippet' : ['a.ravel()'],
+                    },
+                    {
+                        'name' : 'Return a copy of the data, flattened to 1-D',
+                        'snippet' : ['a.flatten()'],
+                    },
+                    {
+                        'name' : 'Return a view of the data, with a different dtype',
+                        'snippet' : ['np.linspace(0, 10, num=50).view(complex)'],
+                        'sub-menu' : [
+                            {
+                                'name' : 'View real array as complex',
+                                'snippet' : [
+                                    'r = np.linspace(0, 10, num=100).reshape((25,4))',
+                                    'c = r.view(complex)',
+                                ],
+                            },
+                            {
+                                'name' : 'View complex array as real with extra dimension',
+                                'snippet' : [
+                                    'c = (np.linspace(0, 10, num=50) + 1j*np.linspace(0, 10, num=50))',
+                                    'cv = c.view(float)',
+                                    'r = cv.reshape(c.shape + (2,))',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Return a copy of the data, cast to a different dtype',
+                        'snippet' : ['np.linspace(0, 10, num=50).astype(complex)'],
+                    },
+                    {
+                        'name' : 'Return a view of the data with indices reversed (transposed)',
+                        'snippet' : ['np.arange(210).reshape((2,3,5,7)).transpose()'],
+                    },
+                    {
+                        'name' : 'Return a view of the data with indices permuted',
+                        'snippet' : ['np.arange(210).reshape((2,3,5,7)).transpose((2,1,0,3))'],
+                    },
+                    {
+                        'name' : 'Exchange two axes in an array',
+                        'snippet' : ['np.arange(210).reshape((2,3,5,7)).swapaxes(1,3)'],
+                    },
+                    {
+                        'name' : 'Permute axes, bringing given axis into new position',
+                        'snippet' : ['np.rollaxis(np.arange(210).reshape((2,3,5,7)), 2, 0)'],
+                    },
+                    {
+                        'name' : 'Permute indices by a given amount along the given axis',
+                        'snippet' : ['np.roll(np.arange(10).reshape((2,5)), 2, axis=1)'],
+                    },
+                    {
+                        'name' : 'Return views of the data, split into $N$ groups',
+                        'snippet' : [
+                            'x = np.arange(12)',
+                            'a,b,c = np.split(x, 3)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return views of the data, split at given indices along given axis',
+                        'snippet' : [
+                            'x = np.arange(27).reshape((3,9))',
+                            'a,b,c = np.split(x, [2,6], axis=1)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return copy of arrays, combined into one',
+                        'snippet' : [
+                            'a = np.arange(30).reshape((2,3,5))',
+                            'b = np.arange(42).reshape((2,3,7))',
+                            'c = np.concatenate((a, b), axis=1)',
+                        ],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Indexing and testing arrays',
+                'sub-menu' : [
+                    {
+                        'name' : 'Indexing documentation',
+                        'external-link' : 'http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html',
+                    },
+                    '---',
+                    {
+                        'name' : 'Test if array is empty',
+                        'snippet' : [
+                            'if a.size > 0:  # Never use `if a` or `if len(a)` for numpy arrays',
+                            '    print(a)',
+                        ],
+                    },
+                    {
+                        'name' : 'Get number of dimensions of array',
+                        'snippet' : ['a.ndim'],
+                    },
+                    {
+                        'name' : 'Get shape of array',
+                        'snippet' : ['a.shape'],
+                    },
+                    {
+                        'name' : 'Index a one-dimensional array',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Get one element',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[3]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get first $N$ elements',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[:3]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get last $N$ elements',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[-3:]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements $N$ to $M$',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[3:6]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements satisfying a condition',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[a>5]'
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Index a multi-dimensional array',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Get one element',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[1, 2, 4]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get first $N$ elements along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[:, :, :4]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get last $N$ elements along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[:, :, -3:]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements $N$ to $M$ along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[:, :, 3:5]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements satisfying a condition (flattened result)',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[a>5]'
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Index an array of unknown dimension',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Get first $N$ elements along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[..., :4]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get last $N$ elements along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[..., -3:]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements $N$ to $M$ along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[..., 3:5]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements satisfying a condition (flattened result)',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[a>5]'
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : '',
+                        'snippet' : [
+                            ''
+                        ],
+                    },
+                ],
+            },
+
+            numpy_ufuncs,
+
+            numpy_polynomial,
+
+            // {
+            //     'name' : 'Polynomials',
+            //     'external-link' : 'http://docs.scipy.org/doc/numpy/reference/routines.polynomials.html',
+            //     // 'sub-menu' : [
+                    
+            //     // ],
+            // },
+
+            {
+                'name' : 'Pretty printing',
+                'sub-menu' : [
+                    {
+                        'name' : 'Context manager',
+                        'snippet' : [
+                            'import contextlib',
+                            '@contextlib.contextmanager',
+                            'def printoptions(*args, **kwargs):',
+                            '    original = np.get_printoptions()',
+                            '    np.set_printoptions(*args, **kwargs)',
+                            '    yield',
+                            '    np.set_printoptions(**original)',
+                        ],
+                    },
+                    '---',
+                    {
+                        'name' : 'Print to given precision',
+                        'snippet' : [
+                            'with printoptions(precision=5):',
+                            '    print(np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Summarize arrays with more than $N+1$ elements',
+                        'snippet' : [
+                            'with printoptions(threshold=5):',
+                            '    print(np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Print $N$ elements at each end of a summary',
+                        'snippet' : [
+                            'with printoptions(threshold=5, edgeitems=4):',
+                            '    print(np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Set number of characters per line',
+                        'snippet' : [
+                            'with printoptions(linewidth=100):',
+                            '    print(np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Suppress printing of small values',
+                        'snippet' : [
+                            'with printoptions(suppress=True):',
+                            '    print(1e-8*np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Set string with which to represent nan',
+                        'snippet' : [
+                            "with printoptions(nanstr='NaN!'):",
+                            '    print(np.array([1, np.nan, 3]))',
+                        ],
+                    },
+                    {
+                        'name' : 'Set string with which to represent infinity',
+                        'snippet' : [
+                            "with printoptions(infstr='oo'):",
+                            '    print(np.array([1, np.inf, 3]))',
+                        ],
+                    },
+                    {
+                        'name' : 'Formatting functions for specific dtypes',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Set formatter for `bool` type',
+                                'snippet' : [
+                                    "def format_bool(x):",
+                                    "    if x:",
+                                    "        return 'TRUE'",
+                                    "    else:",
+                                    "        return 'FALSE'",
+                                    "with printoptions(formatter={'bool': format_bool}):",
+                                    "    print(np.random.randint(0,2,10).astype(bool))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `int` type',
+                                'snippet' : [
+                                    "def format_int(x):",
+                                    "    return 'int({0})'.format(x)",
+                                    "with printoptions(formatter={'int': format_int}):",
+                                    "    print(np.random.randint(-3, 4, 10))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `timedelta` type',
+                                'snippet' : [
+                                    "def format_timedelta(delta):",
+                                    "    days = delta.astype('timedelta64[D]').astype(int)",
+                                    "    hours = delta.astype('timedelta64[h]').astype(int) - 24*days",
+                                    "    minutes = delta.astype('timedelta64[m]').astype(int) - 60*(24*days+hours)",
+                                    "    seconds = delta.astype('timedelta64[s]').astype(int) - 60*(60*(24*days+hours)+minutes)",
+                                    "    return '{0}days,{1}hours,{2}minutes,{3}seconds'.format(days, hours, minutes, seconds)",
+                                    "with printoptions(formatter={'timedelta': format_timedelta}):",
+                                    "    print(np.array([np.timedelta64(int(sec), 's') for sec in np.random.randint(0, 1000000, 10)]))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `datetime` type',
+                                'snippet' : [
+                                    "def format_datetime(date):",
+                                    "    year = date.astype('datetime64[Y]').astype(int) + 1970",
+                                    "    month = date.astype('datetime64[M]').astype(int) % 12 + 1",
+                                    "    day = (date - date.astype('datetime64[M]')).astype(int) + 1",
+                                    "    return 'Y{0}:M{1}:D{2}'.format(year, month, day)",
+                                    "with printoptions(formatter={'datetime': format_datetime}):",
+                                    "    days = np.random.randint(0, 20000, 10)",
+                                    "    dates = np.array([np.datetime64(int(d), 'D') for d in days])",
+                                    "    print(dates)",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `float` type',
+                                'snippet' : [
+                                    "def format_float(x):",
+                                    "    return '{0:+0.2f}'.format(x)",
+                                    "with printoptions(formatter={'float': format_float}):",
+                                    "    print(np.random.random(10)-0.5)",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `longfloat` type',
+                                'snippet' : [
+                                    "def format_longfloat(x):",
+                                    "    return 'long{0}'.format(x)",
+                                    "with printoptions(formatter={'longfloat': format_longfloat}):",
+                                    "    print(np.random.random(10).astype(np.longfloat))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `complexfloat` type',
+                                'snippet' : [
+                                    "def format_complexfloat(x):",
+                                    "    return '{0.real}+1j*{0.imag}'.format(x)",
+                                    "with printoptions(formatter={'complexfloat': format_complexfloat}):",
+                                    "    print(np.random.random(5)+1j*np.random.random(5))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `longcomplexfloat` type',
+                                'snippet' : [
+                                    "def format_longcomplexfloat(x):",
+                                    "    return '{0.real}+1j*{0.imag}'.format(x)",
+                                    "with printoptions(formatter={'longcomplexfloat': format_longcomplexfloat}):",
+                                    "    print(np.random.random(5).astype(np.longfloat)+1j*np.random.random(5).astype(np.longfloat))",
+                                ],
+                            },
+                            // {
+                            //     'name' : 'Set formatter for `numpy_str` type',
+                            //     'snippet' : [
+                            //         "def format_numpy_str(x):",
+                            //         "    return 'n\"{0}\"'.format(x)",
+                            //         "with printoptions(formatter={'numpy_str': format_numpy_str}):",
+                            //         "    print(np.random.random(10))",
+                            //     ],
+                            // },
+                            // {
+                            //     'name' : 'Set formatter for `str` type',
+                            //     'snippet' : [
+                            //         "def format_str(x):",
+                            //         "    return '\"{0}\"'.format(x)",
+                            //         "with printoptions(formatter={'str': format_str}):",
+                            //         "    print(np.random.random(10))",
+                            //     ],
+                            // },
+                            '---',
+                            {
+                                'name' : 'Set formatter for all types',
+                                'snippet' : [
+                                    "def format_all(x):",
+                                    "    return 'repr({0})'.format(repr(x))",
+                                    "with printoptions(formatter={'all': format_all}):",
+                                    "    print(np.array([3, 8]))",
+                                    "    print(np.array([0.1, 0.5]))",
+                                    "    print(np.array([1.4+2.3j, 2.8+4.6j]))",
+                                    "    print(np.array(['abc', 'xyz']))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for all `int` types',
+                                'snippet' : [
+                                    "def format_int_kind(x):",
+                                    "    return 'int({0})'.format(x)",
+                                    "with printoptions(formatter={'int_kind': format_int_kind}):",
+                                    "    print(np.random.randint(-100, 100, 10))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for all `float` types',
+                                'snippet' : [
+                                    "def format_float_kind(x):",
+                                    "    return '{0:.2%}'.format(x)",
+                                    "with printoptions(formatter={'float_kind': format_float_kind}):",
+                                    "    print(np.random.random(10))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for all `complex` types',
+                                'snippet' : [
+                                    "def format_complex_kind(x):",
+                                    "    return '{0.real}+1j*{0.imag}'.format(x)",
+                                    "with printoptions(formatter={'complex_kind': format_complex_kind}):",
+                                    "    print(np.random.random(5)+1j*np.random.random(5))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for all `str` types',
+                                'snippet' : [
+                                    "def format_str_kind(x):",
+                                    "    return 'str({0})'.format(x)",
+                                    "with printoptions(formatter={'str_kind': format_str_kind}):",
+                                    "    print(np.array(['abc', 'xyz']))",
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'File I/O',
+                'sub-menu' : [
+                    {
+                        'name' : 'Read data from simple text file',
+                        'snippet' : [
+                            'data = np.loadtxt(filename)',
+                        ],
+                    },
+                    {
+                        'name' : 'Read data from text file with missing values',
+                        'snippet' : [
+                            'data = np.genfromtxt(filename)',
+                        ],
+                    },
+                    {
+                        'name' : 'Read data from .npy or .npz file',
+                        'snippet' : [
+                            'data = np.load(filename)',
+                        ],
+                    },
+                    '---',
+                    {
+                        'name' : 'Write single array to text file',
+                        'snippet' : [
+                            'np.savetxt(filename, x)',
+                        ],
+                    },
+                    {
+                        'name' : 'Write multiple arrays to text file',
+                        'snippet' : [
+                            'np.savetxt(filename, np.transpose((x, y, z)))',
+                        ],
+                    },
+                    {
+                        'name' : 'Write single array to single .npy file',
+                        'snippet' : [
+                            'np.save(filename, x)',
+                        ],
+                    },
+                    {
+                        'name' : 'Write multiple arrays to single .npy file',
+                        'snippet' : [
+                            'np.save(filename, np.transpose((x, y, z)))',
+                        ],
+                    },
+                    {
+                        'name' : 'Write multiple arrays to single .npz file',
+                        'snippet' : [
+                            'np.savez(filename, x, y, z)',
+                        ],
+                    },
+                    {
+                        'name' : 'Write multiple arrays to single compressed .npz file',
+                        'snippet' : [
+                            'np.savez_compressed(filename, x, y, z)',
+                        ],
+                    },
+                ],
+            },
+        ]
+    }
+}
+);

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

@@ -0,0 +1,129 @@
+define({
+    'name' : 'Polynomials',
+    'sub-menu' : [
+        {
+            'name' : 'Setup',
+            'snippet' : [
+                'import numpy as np',
+                'from numpy.polynomial import Polynomial as P',
+                'from numpy.polynomial import Chebyshev as T',
+                'from numpy.polynomial import Legendre as Le',
+                'from numpy.polynomial import Laguerre as La',
+                'from numpy.polynomial import Hermite as H',
+                'from numpy.polynomial import HermiteE as HE',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Instantiate from coefficients',
+            'snippet' : [
+                'poly = P([1, 2, 3])',
+            ],
+        },
+        {
+            'name' : 'Instantiate from roots',
+            'snippet' : [
+                'poly = P.fromroots([1, 2, 3])',
+            ],
+        },
+        {
+            'name' : 'Instantiate from basis element $n$',
+            'snippet' : [
+                'poly = P.basis(n)',
+            ],
+        },
+        {
+            'name' : 'Convert between types',
+            'snippet' : [
+                'from numpy.polynomial import Chebyshev',
+                'polyT = poly.convert(kind=Chebyshev)',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Get coefficients (constant at index 0, higher indices for higher orders)',
+            'snippet' : [
+                'poly.coeff',
+            ],
+        },
+        {
+            'name' : 'Get domain (scaled and offset domain of function for fitting)',
+            'snippet' : [
+                'poly.domain',
+            ],
+        },
+        {
+            'name' : 'Get window (natural domain of basis functions)',
+            'snippet' : [
+                'poly.window',
+            ],
+        },
+        {
+            'name' : 'Get degree of polynomial (one less than number of coefficients)',
+            'snippet' : [
+                'poly.degree()',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Evaluate polynomial at given points',
+            'snippet' : [
+                'x = np.linspace(0, 3.14)',
+                'poly(x)',
+            ],
+        },
+        {
+            'name' : 'Return $n$ equally spaced $(x,y)$ values',
+            'snippet' : [
+                'x, y = poly.linspace(n=100)',
+            ],
+        },
+        {
+            'name' : 'Find roots',
+            'snippet' : [
+                'poly.roots()',
+            ],
+        },
+        {
+            'name' : 'Differentiate once',
+            'snippet' : [
+                'poly.deriv()',
+            ],
+        },
+        {
+            'name' : 'Differentiate $n$ times',
+            'snippet' : [
+                'poly.deriv(n)',
+            ],
+        },
+        {
+            'name' : 'Integrate once',
+            'snippet' : [
+                'poly.integ()',
+            ],
+        },
+        {
+            'name' : 'Integrate $n$ times',
+            'snippet' : [
+                'poly.integ(n)',
+            ],
+        },
+        {
+            'name' : 'Integrate with given lower bound and integration constant $k$',
+            'snippet' : [
+                'poly.integ(lbnd=0.1, k=-2.34',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Fit to data with series of degree $n$',
+            'snippet' : [
+                'np.random.seed(11)',
+                'x = np.linspace(0, 2*np.pi, 20)',
+                'y = np.sin(x) + np.random.normal(scale=.1, size=x.shape)',
+                'n = 5',
+                'p = T.fit(x, y, n)',
+            ],
+        },
+    ],
+});

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

@@ -0,0 +1,1068 @@
+define({
+    // See <http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs> for a full list
+    'name' : 'Vectorized (universal) functions',
+    'sub-menu' : [
+        {
+            'name' : 'Characterizing arrays',
+            'sub-menu' : [
+                {
+                    'name' : 'max: Return the maximum along a given axis.',
+                    'snippet' : [
+                        'np.max(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'argmax: Return indices of the maximum values along the given axis.',
+                    'snippet' : [
+                        'np.argmax(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'min: Return the minimum along a given axis.',
+                    'snippet' : [
+                        'np.min(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'argmin: Return indices of the minimum values along the given axis of a.',
+                    'snippet' : [
+                        'np.argmin(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'ptp: Peak-to-peak (maximum - minimum) value along a given axis.',
+                    'snippet' : [
+                        'np.ptp(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'trace: Return the sum along diagonals of the array.',
+                    'snippet' : [
+                        'np.trace(a, axis1, axis2)',
+                    ],
+                },
+
+                {
+                    'name' : 'mean: Returns the average of the array elements along given axis.',
+                    'snippet' : [
+                        'np.mean(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'var: Returns the variance of the array elements, along given axis.',
+                    'snippet' : [
+                        'np.var(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'std: Returns the standard deviation of the array elements along given axis.',
+                    'snippet' : [
+                        'np.std(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'all: Returns True if all elements evaluate to True.',
+                    'snippet' : [
+                        'np.all(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'any: Returns True if any of the elements of a evaluate to True.',
+                    'snippet' : [
+                        'np.any(a, axis=0)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Sums, products, differences within array',
+            'sub-menu' : [
+                {
+                    'name' : 'prod: Product of array elements over a given axis',
+                    'snippet' : [
+                        'np.prod(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'sum: Sum of array elements over a given axis',
+                    'snippet' : [
+                        'np.sum(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'nansum: Sum of array elements over a given axis treating NaNs as zero',
+                    'snippet' : [
+                        'np.nansum(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'cumprod: Cumulative product of elements along a given axis',
+                    'snippet' : [
+                        'np.cumprod(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'cumsum: Cumulative sum of the elements along a given axis',
+                    'snippet' : [
+                        'np.cumsum(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'diff: Calculate the n-th order discrete difference along given axis',
+                    'snippet' : [
+                        'np.diff(a, n, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'ediff1d: Differences between consecutive elements of an array',
+                    'snippet' : [
+                        'np.ediff1d(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'gradient: Gradient of an N-dimensional array',
+                    'snippet' : [
+                        'np.gradient(f, *varargs, **kwargs)',
+                    ],
+                },
+
+                {
+                    'name' : 'trapz: Integrate along the given axis using the composite trapezoidal rule',
+                    'snippet' : [
+                        'np.trapz(y, x, dx, axis)',
+                    ],
+                },
+
+                {
+                    'name' : 'convolve: Discrete, linear convolution of two one-dimensional sequences',
+                    'snippet' : [
+                        'np.convolve(a, v)',
+                    ],
+                },
+
+                {
+                    'name' : 'interp: One-dimensional linear interpolation',
+                    'snippet' : [
+                        'np.interp(x, xp, fp)',
+                    ],
+                },
+            ],
+        },
+
+
+        {
+            'name' : 'Logarithms and exponentials',
+            'sub-menu' : [
+                {
+                    'name' : 'logaddexp: Logarithm of the sum of exponentiations of the inputs',
+                    'snippet' : [
+                        'np.logaddexp(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logaddexp2: Logarithm of the sum of exponentiations of the inputs in base-2',
+                    'snippet' : [
+                        'np.logaddexp2(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'power: First array elements raised to powers from second array, element-wise',
+                    'snippet' : [
+                        'np.power(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'power: First array elements raised to powers from second array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.power when input dtypes are float, but may contain negatives',
+                        'np.emath.power(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'exp: Calculate the exponential of all elements in the input array',
+                    'snippet' : [
+                        'np.exp(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'exp2: Calculate $2^p$ for all $p$ in the input array',
+                    'snippet' : [
+                        'np.exp2(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log: Natural logarithm, element-wise',
+                    'snippet' : [
+                        'np.log(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log: Natural logarithm, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.log when input dtype is float, but may contain negatives',
+                        'np.emath.log(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log2: Base-2 logarithm of $x$',
+                    'snippet' : [
+                        'np.log2(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log2: Base-2 logarithm of $x$ with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.log2 when input dtype is float, but may contain negatives',
+                        'np.emath.log2(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log10: Return the base 10 logarithm of the input array, element-wise',
+                    'snippet' : [
+                        'np.log10(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log10: Return the base 10 logarithm of the input array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.log10 when input dtype is float, but may contain negatives',
+                        'np.emath.log10(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'logn: Return the base $n$ logarithm of the input array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# np.emath.logn allows for inputs with dtype float but possibly containing negatives',
+                        'np.emath.logn(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'expm1: Calculate $\\exp(x) - 1$ for all elements in the array',
+                    'snippet' : [
+                        'np.expm1(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log1p: Calculate $\\log(1+x)$ for all elements in the array',
+                    'snippet' : [
+                        'np.log1p(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sqrt: Return the positive square-root of an array, element-wise',
+                    'snippet' : [
+                        'np.sqrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sqrt: Return the positive square-root of an array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.sqrt when argument may contain negative real numbers',
+                        'np.emath.sqrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'square: Return the element-wise square of the input',
+                    'snippet' : [
+                        'np.square(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'reciprocal: Return the reciprocal of the argument, element-wise',
+                    'snippet' : [
+                        'np.reciprocal(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Trigonometric and hyperbolic functions',
+            'sub-menu' : [
+                {
+                    'name' : 'sin: Trigonometric sine, element-wise',
+                    'snippet' : [
+                        'np.sin(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'cos: Cosine element-wise',
+                    'snippet' : [
+                        'np.cos(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'tan: Compute tangent element-wise',
+                    'snippet' : [
+                        'np.tan(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arcsin: Trigonometric inverse sine, element-wise',
+                    'snippet' : [
+                        'np.arcsin(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arcsin: Trigonometric inverse sine, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.arcsin when input dtype is float, but may contain values outside of [-1,1]',
+                        'np.emath.arcsin(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arccos: Trigonometric inverse cosine, element-wise',
+                    'snippet' : [
+                        'np.arccos(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arccos: Trigonometric inverse cosine, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.arccos when input dtype is float, but may contain values outside of [-1,1]',
+                        'np.emath.arccos(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arctan: Trigonometric inverse tangent, element-wise',
+                    'snippet' : [
+                        'np.arctan(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arctan2: Element-wise arc tangent of $x_1/x_2$ choosing the quadrant correctly',
+                    'snippet' : [
+                        'np.arctan2(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'hypot: Given the “legs” of a right triangle, return its hypotenuse',
+                    'snippet' : [
+                        'np.hypot(x1, x2)',
+                    ],
+                },
+
+                '---',
+                
+                {
+                    'name' : 'sinh: Hyperbolic sine, element-wise',
+                    'snippet' : [
+                        'np.sinh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'cosh: Hyperbolic cosine, element-wise',
+                    'snippet' : [
+                        'np.cosh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'tanh: Compute hyperbolic tangent element-wise',
+                    'snippet' : [
+                        'np.tanh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arcsinh: Inverse hyperbolic sine element-wise',
+                    'snippet' : [
+                        'np.arcsinh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arccosh: Inverse hyperbolic cosine, element-wise',
+                    'snippet' : [
+                        'np.arccosh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arctanh: Inverse hyperbolic tangent, element-wise',
+                    'snippet' : [
+                        'np.arctanh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arctanh: Inverse hyperbolic tangent, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.arctanh when input dtype is float, but may contain values outside of (-1,1)',
+                        'np.emath.arctanh(x)',
+                    ],
+                },
+
+                '---',
+
+                {
+                    'name' : 'deg2rad: Convert angles from degrees to radians',
+                    'snippet' : [
+                        'np.deg2rad(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'rad2deg: Convert angles from radians to degrees',
+                    'snippet' : [
+                        'np.rad2deg(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'unwrap: Unwrap radian phase by changing jumps greater than $\\pi$ to their $2\\pi$ complement',
+                    'snippet' : [
+                        'np.unwrap(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Complex numbers',
+            'sub-menu' : [
+                {
+                    'name' : 'real: Real part of the elements of the array',
+                    'snippet' : [
+                        'np.real(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'imag: Imaginary part of the elements of the array',
+                    'snippet' : [
+                        'np.imag(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'conj: Complex conjugate, element-wise',
+                    'snippet' : [
+                        'np.conj(a)',
+                    ],
+                },
+                
+                {
+                    'name' : 'angle: Angle of the complex argument',
+                    'snippet' : [
+                        'np.angle(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'unwrap: Unwrap radian phase by changing jumps greater than $\\pi$ to their $2\\pi$ complement',
+                    'snippet' : [
+                        'np.unwrap(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Rounding and clipping',
+            'sub-menu' : [
+                {
+                    'name' : 'around: Evenly round to the given number of decimals',
+                    'snippet' : [
+                        'np.around(a, decimals=2)',
+                    ],
+                },
+
+                {
+                    'name' : 'rint: Round elements of the array to the nearest integer',
+                    'snippet' : [
+                        'np.rint(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'fix: Round to nearest integer towards zero',
+                    'snippet' : [
+                        'np.fix(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'floor: Floor of the input, element-wise',
+                    'snippet' : [
+                        'np.floor(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'ceil: Ceiling of the input, element-wise',
+                    'snippet' : [
+                        'np.ceil(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'trunc: Truncated value of the input, element-wise',
+                    'snippet' : [
+                        'np.trunc(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'clip: Clip (limit) the values in an array',
+                    'snippet' : [
+                        'np.clip(a, a_min, a_max)',
+                    ],
+                },
+
+                {
+                    'name' : 'nan_to_num: Replace NaNs with zero and inf with finite numbers',
+                    'snippet' : [
+                        'np.nan_to_num(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'real_if_close: Truncate complex parts if within `tol` times machine epsilon of zero',
+                    'snippet' : [
+                        'np.real_if_close(a, tol=100)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Float functions',
+            'sub-menu' : [
+                {
+                    'name' : 'isreal: Returns a bool array, where True if input element is real',
+                    'snippet' : [
+                        'np.isreal(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'iscomplex: Returns a bool array, where True if input element is complex',
+                    'snippet' : [
+                        'np.iscomplex(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'isfinite: Test element-wise for finiteness (not infinity and not NaN)',
+                    'snippet' : [
+                        'np.isfinite(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'isinf: Test element-wise for positive or negative infinity',
+                    'snippet' : [
+                        'np.isinf(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'isnan: Test element-wise for NaN and return result as a boolean array',
+                    'snippet' : [
+                        'np.isnan(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'signbit: Returns element-wise True where signbit is set (less than zero)',
+                    'snippet' : [
+                        'np.signbit(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'copysign: Change the sign of $x_1$ to that of $x_2$, element-wise',
+                    'snippet' : [
+                        'np.copysign(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'nextafter: Return the next floating-point value after $x_1$ towards $x_2$, element-wise',
+                    'snippet' : [
+                        'np.nextafter(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'modf: Return the fractional and integral parts of an array, element-wise',
+                    'snippet' : [
+                        'np.modf(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'ldexp: Returns $x_1\\, 2^{x_2}$, element-wise',
+                    'snippet' : [
+                        'np.ldexp(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'frexp: Decompose the elements of $x$ into mantissa and twos exponent',
+                    'snippet' : [
+                        'np.frexp(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'fmod: Return the element-wise remainder of division',
+                    'snippet' : [
+                        'np.fmod(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'floor: Return the floor of the input, element-wise',
+                    'snippet' : [
+                        'np.floor(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'ceil: Return the ceiling of the input, element-wise',
+                    'snippet' : [
+                        'np.ceil(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'trunc: Return the truncated value of the input, element-wise',
+                    'snippet' : [
+                        'np.trunc(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Bit-twiddling functions',
+            'sub-menu' : [
+                {
+                    'name' : 'bitwise_and: Compute the bit-wise AND of two arrays element-wise',
+                    'snippet' : [
+                        'np.bitwise_and(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'bitwise_or: Compute the bit-wise OR of two arrays element-wise',
+                    'snippet' : [
+                        'np.bitwise_or(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'bitwise_xor: Compute the bit-wise XOR of two arrays element-wise',
+                    'snippet' : [
+                        'np.bitwise_xor(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'invert: Compute bit-wise inversion, or bit-wise NOT, element-wise',
+                    'snippet' : [
+                        'np.invert(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'left_shift: Shift the bits of an integer to the left',
+                    'snippet' : [
+                        'np.left_shift(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'right_shift: Shift the bits of an integer to the right',
+                    'snippet' : [
+                        'np.right_shift(x1, x2)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Special functions (see scipy.special)',
+            'sub-menu' : [
+                {
+                    'name' : 'i0: Modified Bessel function of the first kind, order 0',
+                    'snippet' : [
+                        'np.i0(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sinc: Return the sinc function',
+                    'snippet' : [
+                        'np.sinc(x)',
+                    ],
+                },
+            ],
+        },
+
+        '---',
+
+        {
+            'name' : 'Arithmetic',
+            'sub-menu' : [
+                {
+                    'name' : 'add: Add arguments element-wise',
+                    'snippet' : [
+                        'np.add(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'subtract: Subtract arguments, element-wise',
+                    'snippet' : [
+                        'np.subtract(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'multiply: Multiply arguments element-wise',
+                    'snippet' : [
+                        'np.multiply(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'divide: Divide arguments element-wise',
+                    'snippet' : [
+                        'np.divide(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'true_divide: Returns a true division of the inputs, element-wise',
+                    'snippet' : [
+                        'np.true_divide(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'floor_divide: Return the largest integer smaller or equal to the division of the inputs',
+                    'snippet' : [
+                        'np.floor_divide(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'negative: Numerical negative, element-wise',
+                    'snippet' : [
+                        'np.negative(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'remainder: Return element-wise remainder of integer division',
+                    'snippet' : [
+                        'np.remainder(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'mod: Return element-wise remainder of integer division',
+                    'snippet' : [
+                        'np.mod(x1, x2) # identical to np.remainder',
+                    ],
+                },
+
+                {
+                    'name' : 'fmod: Return element-wise remainder of float division',
+                    'snippet' : [
+                        'np.fmod(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'modf: Return the fractional and integral parts of an array, element-wise',
+                    'snippet' : [
+                        'np.modf(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'absolute: Calculate the absolute value element-wise',
+                    'snippet' : [
+                        'np.absolute(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'rint: Round elements of the array to the nearest integer',
+                    'snippet' : [
+                        'np.rint(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sign: Returns an element-wise indication of the sign of a number',
+                    'snippet' : [
+                        'np.sign(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'conj: Return the complex conjugate, element-wise',
+                    'snippet' : [
+                        'np.conj(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sqrt: Return the positive square-root of an array, element-wise',
+                    'snippet' : [
+                        'np.sqrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sqrt: Return the positive square-root of an array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.sqrt when argument may contain negative real numbers',
+                        'np.emath.sqrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'square: Return the element-wise square of the input',
+                    'snippet' : [
+                        'np.square(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'reciprocal: Return the reciprocal of the argument, element-wise',
+                    'snippet' : [
+                        'np.reciprocal(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Matrix and vector products',
+            'sub-menu' : [
+                {
+                    'name' : 'tensordot: Tensor dot product over last $n$ axes of a and first $n$ of b',
+                    'snippet' : [
+                        'a = np.arange(60).reshape((5,3,4))',
+                        'b = np.arange(84).reshape((3,4,7))',
+                        'n = 2',
+                        'np.tensordot(a, b, n)',
+                    ],
+                },
+                {
+                    'name' : 'tensordot: Tensor dot product over given pairs of axes',
+                    'snippet' : [
+                        'a = np.arange(24).reshape((3,4,2))',
+                        'axes_a = (2, 0)',
+                        'b = np.arange(30).reshape((2,3,5))',
+                        'axes_b = (0, 1)',
+                        'np.tensordot(a, b, (axes_a, axes_b)',
+                    ],
+                },
+                {
+                    'name' : 'einsum: Evaluate Einstein summation convention on operands',
+                    'snippet' : [
+                        'a = np.arange(6).reshape((3,2))',
+                        'b = np.arange(12).reshape((4,3))',
+                        "np.einsum('ki,jk->ij', a, b)",
+                    ],
+                },
+                {
+                    'name' : 'inner: Inner product, summing over last two axes',
+                    'snippet' : [
+                        'a = np.arange(24).reshape((2,3,4))',
+                        'b = np.arange(4)',
+                        'np.inner(a, b)',
+                    ],
+                },
+                {
+                    'name' : 'outer: Compute outer product of two vectors (automatically flattened)',
+                    'snippet' : [
+                        'a = np.ones((5,))',
+                        'b = np.linspace(-2, 2, 5)',
+                        'np.outer(a, b)',
+                    ],
+                },
+                {
+                    'name' : 'kron: Kronecker product of arrays',
+                    'snippet' : [
+                        'np.kron(np.eye(2), np.ones((2,2)))',
+                    ],
+                },
+                {
+                    'name' : 'vdot: Dot product of two complex vectors, conjugating the first',
+                    'snippet' : [
+                        '',
+                    ],
+                },
+                {
+                    'name' : 'dot: Dot product of two arrays over last and second-to-last dimensions, respectively',
+                    'snippet' : [
+                        '',
+                    ],
+                },
+                {
+                    'name' : 'cross: Cross product of two (arrays of) vectors',
+                    'snippet' : [
+                        'np.cross(a, b)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Comparisons between two arrays',
+            'sub-menu' : [
+                {
+                    'name' : 'greater: Return the truth value of $(x_1 > x_2)$ element-wise',
+                    'snippet' : [
+                        'np.greater(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'greater_equal: Return the truth value of $(x_1 \\geq x_2)$ element-wise',
+                    'snippet' : [
+                        'np.greater_equal(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'less: Return the truth value of $(x_1 < x_2)$ element-wise',
+                    'snippet' : [
+                        'np.less(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'less_equal: Return the truth value of $(x_1 \\leq x_2)$ element-wise',
+                    'snippet' : [
+                        'np.less_equal(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'not_equal: Return $(x_1 != x_2)$ element-wise',
+                    'snippet' : [
+                        'np.not_equal(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'equal: Return $(x_1 == x_2)$ element-wise',
+                    'snippet' : [
+                        'np.equal(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logical_and: Compute the truth value of $x_1$ AND $x_2$ element-wise',
+                    'snippet' : [
+                        'np.logical_and(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logical_or: Compute the truth value of $x_1$ OR $x_2$ element-wise',
+                    'snippet' : [
+                        'np.logical_or(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logical_xor: Compute the truth value of $x_1$ XOR $x_2$, element-wise',
+                    'snippet' : [
+                        'np.logical_xor(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logical_not: Compute the truth value of NOT $x$ element-wise',
+                    'snippet' : [
+                        'np.logical_not(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'maximum: Element-wise maximum of array elements',
+                    'snippet' : [
+                        'np.maximum(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'minimum: Element-wise minimum of array elements',
+                    'snippet' : [
+                        'np.minimum(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'fmax: Element-wise maximum of array elements',
+                    'snippet' : [
+                        'np.fmax(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'fmin: Element-wise minimum of array elements',
+                    'snippet' : [
+                        'np.fmin(x1, x2)',
+                    ],
+                },
+            ],
+        },
+
+    ],
+});

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

@@ -0,0 +1,3 @@
+# Split Cells
+
+Enter command mode (esc), use shift-s to toggle the current cell to either a split cell or full width.

.local/share/jupyter/nbextensions/splitcell/splitcell.yaml

@@ -0,0 +1,8 @@
+Type: IPython Notebook Extension
+Name: Split Cells Notebook
+Description: Enable split cells in Jupyter notebooks
+Main: splitcell.js
+Link: readme.md
+Icon: icon.png
+Compatibility: Jupyter (4.x, 5.x)
+

.local/share/jupyter/nbextensions/table_beautifier/table_beautifier.yaml

@@ -0,0 +1,6 @@
+Type: IPython Notebook Extension
+Name: table_beautifier
+Link: README.md
+Description: Add bootstrap styling to tables in markdown cells and in html/md output
+Main: main.js
+Compatibility: 4.x, 5.x

.local/share/jupyter/nbextensions/toc2/main.css

@@ -0,0 +1,183 @@
+/*
+
+originally extracted from https://gist.github.com/magican/5574556
+
+Most colors defined here are overridden by javascript which adds css based on
+values in the server config file notebook.json, which can be edited directly,
+or colors can be selected in the nbextensions_configurator
+*/
+
+
+
+/*background color for links when you mouse over it */
+#toc-wrapper li > span:hover {
+  background-color: #DAA520;
+}
+
+#toc a {
+  color: #333333;  /* default - alterable via nbextension-configurator */
+  text-decoration: none;
+}
+#navigate_menu li > span:hover {background-color: #f1f1f1}
+
+
+/* Move menus and tooolbar to the left, following @Kevin-McIsaac suggestion
+This is now done in javascript, if the relevant option is selected
+div#menubar-container, div#header-container {
+width: auto;
+padding-left: 20px;
+}*/
+
+#navigate_menu {
+  list-style-type: none;
+  max-width: 800px;
+  min-width: 100px;
+  width: 250px;
+  overflow: auto;
+}
+
+
+#navigate_menu a {
+  list-style-type: none;
+  color: #333333;    /* default - alterable via nbextension-configurator */
+  text-decoration: none;
+}
+
+#navigate_menu li  {
+  padding-left: 0px;
+  clear: both;
+  list-style-type: none;
+}
+
+#navigate_menu > .toc-item,
+#navigate_menu ul {
+  padding-left: 0px;
+}
+
+.toc {
+  padding: 0px;
+  overflow-y: auto;
+  font-weight: normal;
+  color: #333333;    /* default - alterable via nbextension-configurator */
+  white-space: nowrap;
+  overflow-x: auto;
+}
+
+.text_cell .toc {
+  margin-top: 1em;
+}
+
+.toc ul.toc-item {
+    list-style-type: none;
+    padding: 0;
+    margin:  0;
+}
+
+#toc-wrapper {
+  z-index: 90;
+  position: fixed !important;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  padding: 10px;
+  border-style: solid;
+  border-width: thin;
+  background-color: #fff;   /* default - alterable via nbextension-configurator */
+}
+
+#toc-wrapper .toc {
+  flex-grow: 1;
+}
+
+.float-wrapper {
+  border-color: rgba(0, 0, 0, 0.38);
+  border-radius: 5px;
+  opacity: .8;
+}
+
+.sidebar-wrapper {
+  top: 0;
+  bottom: 0;
+    width: 212px;
+    border-color: #eeeeee;  /* default - alterable via nbextension-configurator */
+}
+
+.sidebar-wrapper .ui-resizable-se {
+  display: none;
+}
+
+.sidebar-wrapper .ui-resizable-e {
+  position: absolute;
+  top: calc(50% - 8px);
+}
+
+#toc-wrapper.closed {
+  min-width: 100px;
+  width: auto;
+  transition: width;
+}
+#toc-wrapper:hover{
+  opacity: 1;
+}
+#toc-wrapper .header {
+  font-size: 18px;
+  font-weight: bold;
+}
+
+.sidebar-wrapper .hide-btn {
+  display:none;
+}
+
+#toc-wrapper .hide-btn:before {
+  content: "\f147";
+}
+
+#toc-wrapper.closed .hide-btn:before {
+  content: "\f196";
+}
+
+#toc-header .fa {
+  font-size: 14px;
+  text-decoration: none;
+}
+
+/* on scroll style */
+.highlight_on_scroll {
+    border-left: solid 4px blue;
+}
+
+.toc-item li { margin:0; padding:0; color:black }
+.toc-item li > span { display:block }
+.toc-item li > span { padding-left:0em }
+.toc-item li li > span { padding-left:1em }
+.toc-item li li li > span { padding-left:2em }
+.toc-item li li li li > span { padding-left:3em }
+.toc-item li li li li li > span { padding-left:4em }
+.toc-item li li li li li li > span { padding-left:5em }
+
+
+#toc-wrapper .toc-item-num {
+    font-family: Georgia, Times New Roman, Times, serif;
+    color: black;  /* default - alterable via nbextension-configurator */
+}
+
+/*
+These colors are now specified in js, after reading the extension's config stored in system
+and updated using the nbextension-configurator
+.toc-item-highlight-select  {background-color: Gold}
+.toc-item-highlight-execute  {background-color: red}
+.toc-item-highlight-execute.toc-item-highlight-select   {background-color: Gold} */
+
+#toc-header .fa ,
+.toc-item .fa-fw:first-child {
+  cursor: pointer;
+}
+
+#toc-header,
+.modal-header {
+  cursor: move;
+}
+
+.tocSkip {
+  display: none;
+}

.local/share/jupyter/nbextensions/tree-filter/index.js

@@ -0,0 +1,132 @@
+/*
+ * Based on https://github.com/jdfreder/jupyter-tree-filter.git
+ */
+
+define([
+    'require',
+    'jquery',
+    'base/js/namespace',
+    'base/js/utils',
+    'services/config'
+], function (
+    requirejs,
+    $,
+    Jupyter,
+    utils,
+    configmod
+) {
+    'use strict';
+
+    var base_url = utils.get_body_data("baseUrl");
+    var config = new configmod.ConfigSection('tree', {base_url: base_url});
+
+    config.loaded.then(function() {
+        if (config.data.hasOwnProperty('filter_keyword')) {
+            var filter_keyword = config.data.filter_keyword;
+            if (filter_keyword) {
+                console.log("filter_keyword:", filter_keyword);
+                $('#filterkeyword').val(filter_keyword);
+                filterRows(filter_keyword);
+            }
+        }
+    });
+
+    function filterRows (filterText, caseSensitive, useRegex) {
+        var input = $('#filterkeyword');
+        var btnRegex = $('#filterisreg');
+
+        filterText = filterText !== undefined ? filterText : input.val();
+        useRegex = useRegex !== undefined ? useRegex : btnRegex.attr('aria-pressed') === 'true';
+        caseSensitive = caseSensitive !== undefined ? caseSensitive : $('#filtercase').attr('aria-pressed') === 'true';
+
+        if (!useRegex) {
+            // escape any regex special chars
+            filterText = filterText.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+        }
+        var matchExpr;
+        try {
+            matchExpr = new RegExp(filterText, caseSensitive ? '' : 'i');
+        }
+        catch (err) {
+            // do nothing, error is handled based on undefined matchExpr
+        }
+
+        var invalidRegex = matchExpr === undefined;
+        btnRegex.toggleClass('btn-danger', invalidRegex);
+        btnRegex.toggleClass('btn-default', !invalidRegex);
+        btnRegex.closest('.form-group').toggleClass('has-error has-feedback', invalidRegex);
+
+        var rows = Array.prototype.concat.apply([], document.querySelectorAll('.list_item.row'));
+        rows.forEach(function (row) {
+            if (!filterText || row.querySelector('.item_name').textContent.search(matchExpr) !== -1) {
+                row.style.display = '';
+            } else {
+                row.style.display = 'none';
+            }
+        });
+    }
+
+    function filterRowsDefaultParams () {
+        return filterRows();
+    }
+
+    function load_ipython_extension () {
+
+        var form = $('<form/>')
+            .css('padding', '0 7px 4px')
+            .appendTo('#notebook_list_header');
+
+        var frm_grp = $('<div/>')
+            .addClass('form-group')
+            .css('margin-bottom', 0)
+            .appendTo(form);
+
+        var grp = $('<div/>')
+            .addClass('input-group')
+            .appendTo(frm_grp);
+
+        $('<input/>')
+            .attr('type', 'text')
+            .addClass('form-control input-sm')
+            .attr('title', 'Keyword for filtering tree')
+            .attr('id', 'filterkeyword')
+            .attr('placeholder', 'Filter')
+            .css('font-weight', 'bold')
+            .appendTo(grp);
+
+        var btns = $('<div/>')
+            .addClass('input-group-btn')
+            .appendTo(grp);
+
+        $('<button/>')
+            .attr('type', 'button')
+            .attr('id', 'filterisreg')
+            .addClass('btn btn-default btn-sm')
+            .attr('data-toggle', 'button')
+            .css('font-weight', 'bold')
+            .attr('title', 'Use regex (JavaScript regex syntax)')
+            .text('.*')
+            .on('click', function (evt) { setTimeout(filterRowsDefaultParams); })
+            .appendTo(btns);
+
+        $('<button/>')
+            .attr('type', 'button')
+            .attr('id', 'filtercase')
+            .addClass('btn btn-default btn-sm')
+            .attr('data-toggle', 'button')
+            .attr('tabindex', '0')
+            .attr('title', 'Match case')
+            .css('font-weight', 'bold')
+            .text('Aa')
+            .on('click', function (evt) { setTimeout(filterRowsDefaultParams); })
+            .appendTo(btns);
+
+        $('#filterkeyword').on('keyup', filterRowsDefaultParams);
+        config.load();
+    }
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+
+});

.local/share/jupyter/nbextensions/tree-filter/readme.md

@@ -0,0 +1,8 @@
+Tree-filter
+===========
+
+An extension that allows you to filter by filename in the Jupyter notebook file tree (aka dashboard) page.
+Based on [jdfreder/jupyter-tree-filter](https://github.com/jdfreder/jupyter-tree-filter)
+
+![](demo.gif)
+

.local/share/jupyter/nbextensions/tree-filter/tree-filter.yaml

@@ -0,0 +1,12 @@
+Type: IPython Notebook Extension
+Name: Tree Filter
+Description: An extension that allows you to filter by filename in the Jupyter notebook file tree (aka dashboard) page.
+Link: readme.md
+Main: index.js
+Section: tree
+Compatibility: 4.x, 5.x
+Parameters:
+- name: filter_keyword
+  input_type: string
+  description: Filter keyword
+  default: ""

.local/share/jupyter/nbextensions/varInspector/tablesorter_LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Christian Bach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.