Add files using upload-large-folder tool

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

@@ -0,0 +1,1092 @@
+(requirejs.specified('base/js/namespace') ? define : function (deps, callback) {
+	// if here, the Jupyter namespace hasn't been specified to be loaded.
+	// This means that we're probably embedded in a page, so we need to make
+	// our definition with a specific module name
+	"use strict";
+	return define('nbextensions/collapsible_headings/main', deps, callback);
+})(['jquery', 'require'], function ($, requirejs) {
+	"use strict";
+
+	var mod_name = 'collapsible_headings';
+	var log_prefix = '[' + mod_name + ']';
+	var action_names = { // set on registration
+		insert_above: '',
+		insert_below: '',
+		collapse: '',
+		uncollapse: '',
+		select: ''
+	};
+	var select_reveals = true; // used as a flag to prevent selecting a heading section from also opening it
+
+	// define default values for config parameters
+	var params = {
+		add_button : false,
+		add_all_cells_button: false,
+		add_insert_header_buttons: false,
+		use_toggle_controls : true,
+		make_toggle_controls_buttons : false,
+		size_toggle_controls_by_level : true,
+		toggle_open_icon : 'fa-caret-down',
+		toggle_closed_icon : 'fa-caret-right',
+		toggle_color : '#aaaaaa',
+		use_shortcuts : true,
+		shortcuts: {
+			collapse: 'left',
+			collapse_all: 'ctrl-shift-left',
+			uncollapse: 'right',
+			uncollapse_all: 'ctrl-shift-right',
+			select: 'shift-right',
+			insert_above: 'shift-a',
+			insert_below: 'shift-b',
+		},
+		show_section_brackets : false,
+		section_bracket_width : 10,
+		show_ellipsis : true,
+		select_reveals : true,
+		collapse_to_match_toc: false,
+		indent_px: 8,
+	};
+
+	// ------------------------------------------------------------------------
+	// Jupyter is used when we're in a live notebook, but in non-live notebook
+	// settings, it remains undefined.
+	// It is declared here to allow us to keep logic for live/nonlive functions
+	// together.
+	var Jupyter;
+	// similarly, in a live notebook, events is the Jupyter global events
+	// object, but in a non-live notebook, we must construct our own version
+	var events;
+	try {
+		events = requirejs('base/js/events');
+	}
+	catch (err) {
+		// in non-live notebook, there's no events structure, so we make our own
+		if (window.events === undefined) {
+			var Events = function () {};
+			window.events = $([new Events()]);
+		}
+		events = window.events;
+	}
+
+	// global flag denoting whether we're in a live notebook or exported html.
+	// In a live notebook we operate on Cell instances, in exported html we
+	// operate on jQuery collections of '.cell' elements
+	var live_notebook = false;
+
+
+	//  Some functions providing things akin to Jupyter.notebook methods, but
+	//  which can work using jQuery collections in place of Cell instances.
+
+	/**
+	 *  Return all cells in the notebook (or cell elements if notebook not live)
+	 */
+	function _get_cells () {
+		return live_notebook ? Jupyter.notebook.get_cells() : $('#notebook-container > .cell');
+	}
+
+	/**
+	 *  Return cell at index index (or cell element if notebook not live)
+	 */
+	function _get_cell_at_index (index) {
+		return live_notebook ? Jupyter.notebook.get_cell(index) : $('.cell').eq(index);
+	}
+
+	/**
+	 *  Return the index of the given cell (or cell element if notebook not live)
+	 */
+	function _find_cell_index (cell) {
+		return live_notebook ? Jupyter.notebook.find_cell_index(cell) : $(cell).index();
+	}
+
+	// ------------------------------------------------------------------------
+
+	/**
+	 * Return the level of nbcell.
+	 * The cell level is an integer in the range 1-7 inclusive
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {Integer} cell level
+	 */
+	function get_cell_level (cell) {
+		// headings can have a level up to 6, so 7 is used for a non-heading
+		var level = 7;
+		if (cell === undefined) {
+			return level;
+		}
+		if (live_notebook) {
+			if ((typeof(cell) === 'object')  && (cell.cell_type === 'markdown')) {
+			level = cell.get_text().match(/^#*/)[0].length || level;
+			}
+		}
+		else {
+			// the jQuery pseudo-selector :header is useful for us, but is
+			// implemented in javascript rather than standard css selectors,
+			// which get implemented in native browser code.
+			// So we get best performance by using css-native first, then filtering
+			var only_child_header = $(cell).find(
+				'.inner_cell > .rendered_html > :only-child'
+			).filter(':header');
+			if (only_child_header.length > 0) {
+				level = Number(only_child_header[0].tagName.substring(1));
+			}
+		}
+		return Math.min(level, 7); // we rely on 7 being max
+	}
+
+	/**
+	 * Check if a cell is a heading cell.
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {Boolean}
+	 */
+	function is_heading (cell) {
+		return get_cell_level(cell) < 7;
+	}
+
+	/**
+	 *  Check if a heading cell is collapsed.
+	 *
+	 *  Should in general return false on non-heading cells, but this is
+	 *  dependent on metadata/css classes, so don't rely on it.
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {Boolean}
+	 */
+	function _is_collapsed (heading_cell) {
+		if (live_notebook) {
+			return heading_cell.metadata.heading_collapsed === true;
+		}
+		return $(heading_cell).hasClass('collapsible_headings_collapsed');
+	}
+
+	/**
+	 *  Alter cell so that _is_collapsed called on it will return set_collapsed
+	 */
+	function _set_collapsed (heading_cell, set_collapsed) {
+		set_collapsed = set_collapsed !== undefined ? set_collapsed : true;
+		if (live_notebook) {
+			if (set_collapsed) {
+				heading_cell.metadata.heading_collapsed = true;
+			}
+			else {
+				delete heading_cell.metadata.heading_collapsed;
+			}
+		}
+		else {
+			$(heading_cell).toggleClass('collapsible_headings_collapsed', set_collapsed);
+		}
+		return set_collapsed;
+	}
+
+	/**
+	 * Check if a cell is a collapsed heading cell.
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {Boolean}
+	 */
+	function is_collapsed_heading (cell) {
+		return is_heading(cell) && _is_collapsed(cell);
+	}
+
+	/**
+	 * Uncollapse any headings which are hiding the cell at index
+	 *
+	 * @param {Integer} index - index of cell to reveal
+	 */
+	function reveal_cell_by_index (index) {
+		// Restrict the search to cells that are of the same level and lower
+		// than the currently selected cell by index.
+		var ref_cell = _get_cell_at_index(index);
+		// ref_cell may be null, if we've attempted to extend selection beyond
+		// the existing cells
+		if (!ref_cell) {
+			return;
+		}
+		var pivot_level = get_cell_level(ref_cell);
+		var cells = _get_cells();
+		while (index > 0 && pivot_level > 1) {
+			index--;
+			var cell = cells[index];
+			var cell_level = get_cell_level(cell);
+			if (cell_level < pivot_level) {
+				if (is_collapsed_heading(cell)) {
+					toggle_heading(cell);
+				}
+				pivot_level = cell_level;
+			}
+		}
+	}
+
+	/**
+	 * Add or remove collapsed/uncollapsed classes & metadata to match the
+	 * cell's status as a non-heading or collapsed/uncollapsed heading
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {undefined}
+	 */
+	function update_heading_cell_status (cell) {
+		var level = get_cell_level(cell);
+		var cell_is_heading = level < 7;
+		var cell_elt = live_notebook ? cell.element : $(cell);
+		var cht = cell_elt.find('.input_prompt > .collapsible_headings_toggle');
+		if (cell_is_heading) {
+			var collapsed = _is_collapsed(cell);
+			cell_elt.toggleClass('collapsible_headings_collapsed', collapsed);
+			cell_elt.toggleClass('collapsible_headings_ellipsis', params.show_ellipsis);
+			if (params.use_toggle_controls) {
+				if (cht.length < 1) {
+					cht = $('<div/>')
+						.addClass('collapsible_headings_toggle')
+						.css('color', params.toggle_color)
+						.append('<div><i class="fa fa-fw"></i></div>')
+						.appendTo(cell_elt.find('.input_prompt'));
+					var clickable = cht.find('i');
+					if (params.make_toggle_controls_buttons) {
+						cht.addClass('btn btn-default');
+						clickable = cht;
+					}
+					if (live_notebook) {
+						clickable.on('click', function () { toggle_heading(cell); });
+					}
+					else {
+						// in non-live notebook, cell isn;t editable, so make it clickable also
+						var only_child_header = cell_elt.find(
+							'.inner_cell > .rendered_html > :only-child'
+						).filter(':header');
+						clickable.add(only_child_header)
+							.css('cursor', 'pointer')
+							.on('click', function (evt) {
+								// evt.target is what was clicked, not what the handler was attached to
+								if (!$(evt.target).hasClass('anchor-link')) {
+									toggle_heading(cell);
+								}
+							});
+					}
+				}
+				// Update the cell's toggle control classes
+				var hwrap = cht.children();
+				hwrap.find('.fa')
+					.toggleClass(params.toggle_closed_icon, collapsed)
+					.toggleClass(params.toggle_open_icon, !collapsed);
+				if (params.size_toggle_controls_by_level) {
+					for (var hh = 1; hh < 7; hh++) {
+						hwrap.toggleClass('h' + hh, hh == level);
+					}
+				}
+			}
+		}
+		else {
+			_set_collapsed(cell, false);
+			cell_elt.removeClass('collapsible_headings_collapsed');
+			cht.remove();
+		}
+	}
+
+	/**
+	 * find the closest header cell to input cell
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @param {Function} a function to filter which header cells can be
+	 *                   returned. Should take a notebook cell/jquer element as
+	 *                   input (depending on whether we're in a live notebook),
+	 *                   and return true if the given cell is acceptable.
+	 * @return {Object | undefined}
+	 */
+	function find_header_cell (cell, test_func) {
+		var index = _find_cell_index(cell);
+		for (; index >= 0; index--) {
+			cell = _get_cell_at_index(index);
+			if (is_heading(cell) && (test_func === undefined || test_func(cell))) {
+				return cell;
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 *  Select the section enclosed by the given heading cell.
+	 *
+	 *  Only callable from a live notebook, so require no special cell handling
+	 *
+	 *  @param {Object} head_cell Cell instance or jQuery collection of '.cell' elements
+	 *  @return {undefined}
+	 */
+	function select_heading_section(head_cell, extend) {
+		var head_lvl = get_cell_level(head_cell);
+		var ncells = Jupyter.notebook.ncells();
+		var head_ind = _find_cell_index(head_cell);
+		var tail_ind;
+		for (tail_ind = head_ind; tail_ind + 1 < ncells; tail_ind++) {
+			if (get_cell_level(_get_cell_at_index(tail_ind + 1)) <= head_lvl) {
+				break;
+			}
+		}
+		select_reveals = params.select_reveals;
+		if (extend) {
+			var ank_ind = Jupyter.notebook.get_anchor_index();
+			if (ank_ind <= head_ind) {
+				// keep current anchor, extend to head
+				Jupyter.notebook.select(tail_ind, false);
+				select_reveals = true;
+				return;
+			}
+			else if (ank_ind >= tail_ind) {
+				// keep current anchor, extend to tail
+				Jupyter.notebook.select(head_ind, false);
+				select_reveals = true;
+				return;
+			}
+			// head_ind < ank_ind < tail_ind i.e. anchor is inside section
+		}
+		// move_anchor to header cell
+		Jupyter.notebook.select(head_ind, true);
+		// don't move anchor, i.e. extend, to tail cell
+		Jupyter.notebook.select(tail_ind, false);
+		select_reveals = true;
+	}
+
+	/**
+	 *  Return all of the cell _elements _which are part of the section headed by
+	 *  the given cell
+	 *
+	 *  @param {Object} head_cell Cell instance or jQuery collection of '.cell' elements
+	 */
+	function get_jquery_bracket_section (head_cell) {
+		var head_lvl = get_cell_level(head_cell);
+		var cells = _get_cells();
+		var cell_elements = $(live_notebook ? head_cell.element : head_cell);
+		for (var ii = _find_cell_index(head_cell); ii < cells.length; ii++) {
+			var cell = live_notebook ? cells[ii] : cells.eq(ii);
+
+			if (get_cell_level(cell) <= head_lvl) {
+				break;
+			}
+			cell_elements = cell_elements.add(live_notebook ? cell.element : cell);
+		}
+		return cell_elements;
+	}
+
+	/**
+	 * Callback function attached to the bracket-containing div, should toggle
+	 * the relevant heading
+	 */
+	var bracket_callback_timeout_id;
+	function bracket_callback (evt) {
+		// prevent bubbling, otherwise when closing a section, the cell gets
+		// selected & re-revealed after being hidden
+		evt.preventDefault();
+		evt.stopPropagation();
+		// evt.target is what was clicked, not what the handler was attached to
+		var bracket = $(evt.target);
+		var bracket_level = Number(bracket.attr('data-bracket-level'));
+		if (bracket_level) {
+			var bracket_cell = live_notebook ? bracket.closest('.cell').data('cell') : bracket.closest('.cell');
+			var header_cell = find_header_cell(bracket_cell, function (cell) {
+				return get_cell_level(cell) == bracket_level;
+			});
+			switch (evt.type) {
+				case 'dblclick':
+					clearTimeout(bracket_callback_timeout_id);
+					bracket_callback_timeout_id = undefined;
+					toggle_heading(header_cell);
+					break;
+				case 'click':
+					if (live_notebook && (bracket_callback_timeout_id === undefined)) {
+						bracket_callback_timeout_id = setTimeout(function () {
+							select_heading_section(header_cell, evt.shiftKey);
+							bracket_callback_timeout_id = undefined;
+						}, 300);
+					}
+					break;
+				case 'mouseenter':
+				case 'mouseleave':
+					var in_section = get_jquery_bracket_section(header_cell)
+						.find('.chb div[data-bracket-level=' + bracket_level + ']');
+					$('.chb div').not(in_section).removeClass('chb-hover');
+					in_section.toggleClass('chb-hover', evt.type === 'mouseenter');
+					break;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Update the hidden/collapsed status of all the cells under
+	 * - the notebook, if param cell === undefined
+	 * - the heading which contains the specified cell (if cell !== undefined,
+	 *   but is also not a heading)
+	 * - the specified heading cell (if specified cell is a heading)
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {undefined}
+	 */
+	function update_collapsed_headings (cell) {
+		var index = 0;
+		var section_level = 0;
+		var show = true;
+		if (cell !== undefined && (cell = find_header_cell(cell)) !== undefined) {
+			index = _find_cell_index(cell) + 1;
+			section_level = get_cell_level(cell);
+			show = !_is_collapsed(cell);
+		}
+		var hide_above = 7;
+		var brackets_open = {};
+		var max_open = 0; // count max number open at one time to calc padding
+		for (var cells = _get_cells(); index < cells.length; index++) {
+			cell = cells[index];
+			var cell_elt = live_notebook ? cell.element : $(cell);
+			var level = get_cell_level(cell);
+			if (level <= section_level) {
+				break;
+			}
+			if (show && level <= hide_above) {
+				cell_elt.slideDown('fast');
+				hide_above = is_collapsed_heading(cell) ? level : 7;
+				if (live_notebook) {
+					delete cell.metadata.hidden;
+				}
+			}
+			else {
+				cell_elt.slideUp('fast');
+				if (live_notebook) {
+					cell.metadata.hidden = true;
+				}
+				continue;
+			}
+
+			if (params.show_section_brackets) {
+				var chb = cell_elt.find('.chb').empty();
+				if (chb.length < 1) {
+					chb = $('<div/>')
+						.addClass('chb')
+						.on('click dblclick', bracket_callback)
+						.appendTo(cell_elt);
+				}
+				var num_open = 0; // count number of brackets currently open
+				for (var jj = 1; jj < 7; jj++) {
+					if (brackets_open[jj] && level <= jj) {
+						brackets_open[jj].addClass('chb-end'); // closing, add class
+						delete brackets_open[jj]; // closed
+					}
+					var opening = level == jj;
+					if (brackets_open[jj] || opening) {
+						num_open++;
+						brackets_open[jj] = $('<div/>')
+							.on('mouseenter mouseleave', bracket_callback)
+							.attr('data-bracket-level', jj)
+							.appendTo(chb); // add bracket element
+						if (opening) { // opening, add class
+							brackets_open[jj].addClass('chb-start');
+						}
+					}
+				}
+				max_open = Math.max(num_open, max_open);
+			}
+		}
+		if (params.show_section_brackets) {
+			// close any remaining
+			for (var ii in brackets_open) {
+				brackets_open[ii].addClass('chb-end');
+			}
+			// adjust padding to fit in brackets
+			var bwidth = params.section_bracket_width;
+			var dwidth = max_open * (2 + bwidth);
+			$('#notebook-container').css('padding-right', (16 + dwidth) + 'px');
+			$('.chb')
+				.css('right', '-' + (3 + dwidth) + 'px')
+				.find('div')
+					.css('width', bwidth);
+		}
+	}
+
+	/**
+	 * Hide/reveal all cells in the section headed by cell.
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 */
+	function toggle_heading (cell, set_collapsed, trigger_event) {
+		if (is_heading(cell)) {
+			if (set_collapsed === undefined) {
+				set_collapsed = !_is_collapsed(cell);
+			}
+			_set_collapsed(cell, set_collapsed);
+			update_heading_cell_status(cell);
+			update_collapsed_headings(params.show_section_brackets ? undefined : cell);
+			console.log(log_prefix, set_collapsed ? 'collapsed' : 'expanded', 'cell', _find_cell_index(cell));
+			if (trigger_event !== false) {
+				events.trigger((set_collapsed ? '' : 'un') + 'collapse.CollapsibleHeading', {cell: cell});
+			}
+		}
+	}
+
+	/**
+	 *  Return a promise which resolves when the Notebook class methods have
+	 *  been appropriately patched.
+	 *  Patches methods
+	 *   - Notebook.select
+	 *   - Notebook.undelete
+	 *
+	 *  @return {Promise}
+	 */
+	function patch_Notebook () {
+		return new Promise(function (resolve, reject) {
+			requirejs(['notebook/js/notebook'], function on_success (notebook) {
+				console.debug(log_prefix, 'patching Notebook.protoype');
+
+				// we have to patch select, since the select.Cell event is only fired
+				// by cell click events, not by the notebook select method
+				var orig_notebook_select = notebook.Notebook.prototype.select;
+				notebook.Notebook.prototype.select = function (index, moveanchor) {
+					if (select_reveals) {
+						reveal_cell_by_index(index);
+					}
+					return orig_notebook_select.apply(this, arguments);
+				};
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error patching Notebook.protoype:', reason);
+		});
+	}
+
+	/**
+	 *  Return a promise which resolves when the TextCell class methods have
+	 *  been appropriately patched.
+	 *
+	 *  Patches TextCell.set_text to update headings.
+	 *  This is useful for undelete and copy/paste of cells, which don't fire
+	 *  markdown.
+	 *
+	 *  @return {Promise}
+	 */
+	function patch_TextCell () {
+		return new Promise(function (resolve, reject) {
+			requirejs(['notebook/js/textcell'], function on_success (textcell) {
+				console.debug(log_prefix, 'patching TextCell.protoype');
+				var orig_set_text = textcell.TextCell.prototype.set_text;
+				textcell.TextCell.prototype.set_text = function (text) {
+					var ret = orig_set_text.apply(this, arguments);
+					if (Jupyter.notebook._fully_loaded) {
+						update_heading_cell_status(this);
+						update_collapsed_headings();
+					}
+					return ret;
+				};
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error patching TextCell.protoype:', reason);
+		});
+	}
+
+	/**
+	 *  Return a promise which resolves when the Tooltip class methods have
+	 *  been appropriately patched.
+	 *
+	 *  For notebook 4.x, cells had css position:static, and changing them to
+	 *  relative to get heading brackets working broke the tooltip position
+	 *  calculation. In order to fix this, we patch the 4.x Tooltip._show
+	 *  method to temporarily reapply position:static while the tooltip
+	 *  position is calculated & the animation queued, before revertign to the
+	 *  css-appled position:relative.
+	 *	For notebook 5.x, cells are already position:relative, so the patch is
+	 *  unecessary.
+	 *
+	 *  @return {Promise}
+	 */
+	function patch_Tooltip () {
+		if (Number(Jupyter.version[0]) >= 5) {
+			return Promise.resolve();
+		}
+		return new Promise(function (resolve, reject) {
+			requirejs(['notebook/js/tooltip'], function on_success (tooltip) {
+				console.debug(log_prefix, 'patching Tooltip.prototype');
+
+				var orig_tooltip__show = tooltip.Tooltip.prototype._show;
+				tooltip.Tooltip.prototype._show = function (reply) {
+					var $cell = $(this.code_mirror.getWrapperElement()).closest('.cell');
+					$cell.css('position', 'static');
+					var ret = orig_tooltip__show.apply(this, arguments);
+					$cell.css('position', '');
+					return ret;
+				};
+
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error patching Tooltip.prototype:', reason);
+		});
+	}
+
+	/**
+	 *  Return a promise which resolves when the appropriate Jupyter actions
+	 *  have been patched correctly.
+	 *
+	 *  We patch the up/down arrow actions to skip selecting cells which are
+	 *  hidden by a collapsed heading
+	 *
+	 *  @return {Promise}
+	 */
+	function patch_actions () {
+		return new Promise(function (resolve, reject) {
+			requirejs(['notebook/js/tooltip'], function on_success (tooltip) {
+				console.debug(log_prefix, 'patching Jupyter up/down actions');
+
+				var kbm = Jupyter.keyboard_manager;
+
+				var action_up = kbm.actions.get("jupyter-notebook:select-previous-cell");
+				var orig_up_handler = action_up.handler;
+				action_up.handler = function (env) {
+					for (var index = env.notebook.get_selected_index() - 1; (index !== null) && (index >= 0); index--) {
+						if (env.notebook.get_cell(index).element.is(':visible')) {
+							env.notebook.select(index);
+							env.notebook.focus_cell();
+							return;
+						}
+					}
+					return orig_up_handler.apply(this, arguments);
+				};
+
+				var action_down = kbm.actions.get("jupyter-notebook:select-next-cell");
+				var orig_down_handler = action_down.handler;
+				action_down.handler = function (env) {
+					var ncells = env.notebook.ncells();
+					for (var index = env.notebook.get_selected_index() + 1; (index !== null) && (index < ncells); index++) {
+						if (env.notebook.get_cell(index).element.is(':visible')) {
+							env.notebook.select(index);
+							env.notebook.focus_cell();
+							return;
+						}
+					}
+					return orig_down_handler.apply(this, arguments);
+				};
+
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error patching Jupyter up/down actions:', reason);
+		});
+	}
+
+	/**
+	 * register actions to collapse and uncollapse the selected heading cell
+	 */
+	function register_new_actions () {
+		action_names.collapse = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					var cell = env.notebook.get_selected_cell();
+					var is_h = is_heading(cell);
+					if (is_h && !_is_collapsed(cell)) {
+						toggle_heading(cell, true);
+						return;
+					}
+					var filter_func;
+					if (is_h) {
+						var lvl = get_cell_level(cell);
+						filter_func = function (c) { return get_cell_level(c) < lvl; };
+					}
+					cell = find_header_cell(cell, filter_func);
+					if (cell !== undefined) {
+						Jupyter.notebook.select(Jupyter.notebook.find_cell_index(cell));
+						cell.focus_cell();
+					}
+				},
+				help : "Collapse the selected heading cell's section",
+				icon : params.toggle_closed_icon,
+				help_index: 'c1'
+			},
+			'collapse_heading', mod_name
+		);
+
+		action_names.collapse_all = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					env.notebook.get_cells().forEach(function (c, idx, arr) {
+						toggle_heading(c, true);
+					});
+					var cell = env.notebook.get_selected_cell();
+					if (cell.element.is(':hidden')) {
+						cell = find_header_cell(cell, function (c) { return c.element.is(':visible'); });
+						if (cell !== undefined) {
+							Jupyter.notebook.select(Jupyter.notebook.find_cell_index(cell));
+							cell.focus_cell();
+						}
+					}
+				},
+				help : "Collapse all heading cells' sections",
+				icon : params.toggle_closed_icon,
+				help_index: 'c2'
+			},
+			'collapse_all_headings', mod_name
+		);
+
+		action_names.uncollapse = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					var cell = env.notebook.get_selected_cell();
+					if (is_heading(cell)) {
+						toggle_heading(cell, false);
+					}
+					else {
+						var ncells = env.notebook.ncells();
+						for (var ii = env.notebook.find_cell_index(cell); ii < ncells; ii++) {
+							cell = env.notebook.get_cell(ii);
+							if (is_heading(cell)) {
+								env.notebook.select(ii);
+								cell.focus_cell();
+								break;
+							}
+						}
+					}
+				},
+				help : "Un-collapse (expand) the selected heading cell's section",
+				icon : params.toggle_open_icon,
+				help_index: 'c3'
+			},
+			'uncollapse_heading', mod_name
+		);
+
+		action_names.uncollapse_all = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					env.notebook.get_cells().forEach(function (c, idx, arr) {
+						toggle_heading(c, false);
+					});
+					env.notebook.get_selected_cell().focus_cell();
+				},
+				help : "Un-collapse (expand) all heading cells' sections",
+				icon : params.toggle_open_icon,
+				help_index: 'c4'
+			},
+			'uncollapse_all_headings', mod_name
+		);
+
+		action_names.toggle = Jupyter.keyboard_manager.actions.register ({
+				handler: function () {
+					var heading_cell = find_header_cell(Jupyter.notebook.get_selected_cell(), function (cell) {
+						return cell.element.is(':visible') && !_is_collapsed(cell);
+					});
+					if (is_heading(heading_cell)) {
+						toggle_heading(heading_cell, true);
+						Jupyter.notebook.select(Jupyter.notebook.find_cell_index(heading_cell));
+					}
+				},
+				help   : "Toggle closest heading's collapsed status",
+				icon   : 'fa-angle-double-up',
+			},
+			'toggle_collapse_heading', mod_name
+		);
+
+		action_names.toggle_all = Jupyter.keyboard_manager.actions.register ({
+				handler: function () {
+					var cells = Jupyter.notebook.get_cells();
+					for (var ii = 0; ii < cells.length; ii++) {
+						if (is_heading(cells[ii])) {
+							Jupyter.keyboard_manager.actions.call(action_names[
+								is_collapsed_heading(cells[ii]) ? 'uncollapse_all' : 'collapse_all']);
+							return;
+						}
+					}
+				},
+				help   : 'Collapse/uncollapse all headings based on the status of the first',
+				icon   : 'fa-angle-double-up',
+			},
+			'toggle_collapse_all_headings', mod_name
+		);
+
+		action_names.select = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					var cell = env.notebook.get_selected_cell();
+					if (is_heading(cell)) {
+						select_heading_section(cell, true);
+					}
+				},
+				help : "Select all cells in the selected heading cell's section",
+				help_index: 'c3'
+			},
+			'select_heading_section', mod_name
+		);
+
+		action_names.insert_above = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) { insert_heading_cell(true); },
+				help : "Insert a heading cell above the selected cell",
+				help_index: 'c4',
+				icon: 'fa-caret-up'
+			},
+			'insert_heading_above', mod_name
+		);
+
+		action_names.insert_below = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) { insert_heading_cell(false); },
+				help : "Insert a heading cell below the selected cell's section",
+				help_index: 'c5',
+				icon: 'fa-caret-down'
+			},
+			'insert_heading_below', mod_name
+		);
+	}
+
+	function imitate_hash_click ($element) {
+		var site = $('#site');
+		var adjust = $element.offset().top - site.offset().top;
+		site.animate({scrollTop: site.scrollTop() + adjust});
+	}
+
+	/**
+	 * Insert a new heading cell either above or below the current section.
+	 * only works in a live notebook.
+	 */
+	function insert_heading_cell (above) {
+		var selected_cell = Jupyter.notebook.get_selected_cell();
+		var ref_cell = find_header_cell(selected_cell) || selected_cell;
+		var level = get_cell_level(ref_cell);
+		level = (level == 7) ? 1 : level; // default to biggest level (1)
+		if (above) {
+			// if above, insert just above selected cell, but keep ref_cell's level
+			ref_cell = selected_cell;
+		}
+		var index = ref_cell.element.index();
+		if (!above) {
+			// below requires special handling, as we really want to put it
+			// below the currently selected heading's *content*
+			var cells = _get_cells();
+			for (index=index + 1; index < cells.length; index++) {
+				if (get_cell_level(cells[index]) <= level) {
+					break;
+				}
+			}
+			// if we make it here, index will be == cells.length, which is ok
+			// as it gets the new cell inserted at the bottom of the notebook
+		}
+		// we don't want our newly-inserted cell to trigger opening of headings
+		var cached_select_reveals = select_reveals;
+		select_reveals = false;
+		var new_cell = Jupyter.notebook.insert_cell_above('markdown', index);
+		var new_text = 'New heading';
+		new_cell.set_text(new_text);
+		new_cell.set_heading_level(level);
+		new_cell.code_mirror.setSelection({line:0, ch: level + 1}, {line:0, ch: level + 1 + new_text.length});
+		Jupyter.notebook.select(index, true);
+		// restore cached setting
+		select_reveals = cached_select_reveals;
+		Jupyter.notebook.focus_cell();
+		Jupyter.notebook.edit_mode();
+	}
+
+	function refresh_all_headings () {
+		var cells = _get_cells();
+		for (var ii=0; ii < cells.length; ii++) {
+			update_heading_cell_status(cells[ii]);
+		}
+		update_collapsed_headings();
+	}
+
+	function set_collapsible_headings_options (options) {
+		// options may be undefined here, but it's still handled ok by $.extend
+		$.extend(true, params, options);
+		// bind/unbind toc-collapse handler
+		events[params.collapse_to_match_toc ? 'on' : 'off']('collapse.Toc uncollapse.Toc', callback_toc_collapse);
+		// add css for indents
+		if (params.indent_px !== 0) {
+			var lines = [];
+			for (var hh = 1; hh <= 6; hh++) {
+				lines.push(
+					'.collapsible_headings_toggle .h' + hh +
+					' { margin-right: ' + ((6 - hh) * params.indent_px) + 'px; }'
+				);
+			}
+			$('<style id="collapsible_headings_indent_css"/>')
+				.html(lines.join('\n'))
+				.appendTo('head');
+		}
+		return params;
+	}
+
+	function add_buttons_and_shortcuts () {
+		// (Maybe) add buttons to the toolbar
+		if (params.add_button) {
+			Jupyter.toolbar.add_buttons_group([action_names.toggle]);
+		}
+		if (params.add_all_cells_button) {
+			Jupyter.toolbar.add_buttons_group([action_names.toggle_all]);
+		}
+		if (params.add_insert_header_buttons) {
+			Jupyter.toolbar.add_buttons_group([
+				action_names.insert_above, action_names.insert_below
+			],'insert_heading_cell_btns');
+		}
+		// add hashes
+		$('#insert_heading_cell_btns .btn').prepend('# ');
+
+		// (Maybe) register keyboard shortcuts
+		if (params.use_shortcuts) {
+			var cmd_shrts = Jupyter.keyboard_manager.command_shortcuts;
+			for (var act in action_names) {
+				if (action_names.hasOwnProperty(act) && params.shortcuts[act]) {
+					cmd_shrts.add_shortcut(params.shortcuts[act], action_names[act]);
+				}
+			}
+		}
+	}
+
+	var callback_toc_collapse = function (evt, data) {
+		// use trigger_event false to avoid re-triggering toc2
+		toggle_heading(data.cell, evt.type.indexOf('un') < 0, false);
+	}
+
+	/**
+	 *  Return a promise which resolves once event handlers have been bound
+	 *
+	 *  @return {Promise}
+	 */
+	function bind_events () {
+
+		// Callbacks bound to the create.Cell event can execute before the cell
+		// data has been loaded from JSON.
+		// So, we rely on rendered.MarkdownCell event to catch headings from
+		// JSON, and the only reason we use create.Cell is to update brackets
+		function callback_create_cell (evt, data) {
+			if (params.show_section_brackets) {
+				update_collapsed_headings();
+			}
+		}
+
+		function callback_delete_cell(evt, data) {
+			update_collapsed_headings();
+		}
+
+		function callback_markdown_rendered (evt, data) {
+			update_heading_cell_status(data.cell);
+			// we update all headings to avoid pasted headings ending up hidden
+			// by other pre-existing collapsed headings - see
+			//     https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/1082
+			// for details
+			update_collapsed_headings();
+		}
+
+		return new Promise (function (resolve, reject) {
+			requirejs(['base/js/events'], function on_success (events) {
+
+				// ensure events are detached while notebook loads, in order to
+				// speed up loading (otherwise headings are updated for every
+				// new cell in the notebook), then reattached when load is
+				// complete
+				function events_attach () {
+					refresh_all_headings();
+					events.on('create.Cell', callback_create_cell);
+					events.on('delete.Cell', callback_delete_cell);
+					events.on('rendered.MarkdownCell', callback_markdown_rendered);
+				}
+				function events_detach () {
+					events.off('create.Cell', callback_create_cell);
+					events.off('delete.Cell', callback_delete_cell);
+					events.off('rendered.MarkdownCell', callback_markdown_rendered);
+				}
+
+				if (Jupyter.notebook._fully_loaded) {
+					events_attach();
+				}
+				events.on('notebook_loaded.Notebook', events_attach);
+				events.on('notebook_loading.Notebook', events_detach);
+
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error binding events:', reason);
+		});
+	}
+
+	/**
+	 *  Return a menu list item with a link that calls the specified action
+	 *  name.
+	 *
+	 *  @param {String} action_name the name of the action which the menu item
+	 *                  should call
+	 *  @param {String} menu_item_html the html to use as the link's content
+	 *  @return {jQuery}
+	 */
+	function make_action_menu_item (action_name, menu_item_html) {
+		var act = Jupyter.menubar.actions.get(action_name);
+		var menu_item = $('<li/>');
+		$('<a/>')
+			.html(menu_item_html)
+			.attr({'title' : act.help, 'href' : '#'})
+			.on('click', function (evt) {
+				Jupyter.menubar.actions.call(action_name, evt);
+			})
+			.appendTo(menu_item);
+		return menu_item;
+	}
+
+	/**
+	 * Add any new items to the notebook menu
+	 */
+	function insert_menu_items () {
+		$('#insert_menu')
+			.append('<li class="divider"/>')
+			.append(make_action_menu_item(action_names.insert_above, 'Insert Heading Above'))
+			.append(make_action_menu_item(action_names.insert_below, 'Insert Heading Below'));
+	}
+
+	/**
+	 * Initialize the extension.
+	 */
+	function load_jupyter_extension () {
+		// Load css first
+		$('<link/>')
+			.attr({
+				id: 'collapsible_headings_css',
+				rel: 'stylesheet',
+				type: 'text/css',
+				href: requirejs.toUrl('./main.css')
+			})
+			.appendTo('head');
+
+		// ensure Jupyter module is defined before proceeding further
+		new Promise(function (resolve, reject) {
+			requirejs(['base/js/namespace'], function (Jupyter_mod) {
+				live_notebook = true;
+				Jupyter = Jupyter_mod;
+				resolve(Jupyter);
+			}, reject);
+		})
+
+		// load config & update params
+		.then(function (Jupyter) {
+			return Jupyter.notebook.config.loaded.catch(function on_err (reason) {
+				console.warn(log_prefix, 'error loading config:', reason);
+			}).then(function () {
+				// may be undefined, but that's ok.
+				return Jupyter.notebook.config.data.collapsible_headings;
+			});
+		})
+		// set values using resolution val of previous .then
+		.then(set_collapsible_headings_options)
+
+		// apply all promisory things in arbitrary order
+		.then(patch_actions)
+		.then(patch_Notebook)
+		.then(patch_TextCell)
+		.then(patch_Tooltip)
+		.then(bind_events)
+		// finally add user-interaction stuff
+		.then(function () {
+			register_new_actions();
+			insert_menu_items();
+			add_buttons_and_shortcuts();
+		})
+		.catch(function on_reject (reason) {
+			console.error(log_prefix, 'error:', reason);
+		});
+	}
+
+	/**
+	 * Export things
+	 */
+	return {
+		get_cell_level : get_cell_level,
+		reveal_cell_by_index : reveal_cell_by_index,
+		update_collapsed_headings : update_collapsed_headings,
+		set_collapsible_headings_options : set_collapsible_headings_options,
+		refresh_all_headings: refresh_all_headings,
+		load_jupyter_extension : load_jupyter_extension,
+		load_ipython_extension : load_jupyter_extension
+	};
+});

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

@@ -0,0 +1,125 @@
+Collapsible Headings
+====================
+
+Allows notebook to have collapsible sections, separated by headings.
+
+Any markdown heading cell (that is, one which begins with 1-6 `#` characters),
+becomes collapsible once rendered.
+
+The collapsed/expanded status of the headings is stored in the cell metadata,
+and reloaded on notebook load.
+
+![screenshot](screenshot.png)
+
+
+Options
+-------
+
+The extension offers a few options for how to display and toggle the collapsed
+status of headings, each of which can be enabled, disabled or configured from
+the nbextensions config page:
+
+* Command-mode keyboard shortcuts, (enabled by default, and set to left and
+  right arrow keys to collapse/expand sections, or go to the previous/next
+  heading, plus shift-right to select a heading cell's section, shift-a/b to
+  insert a heading above/below the current cell, ctrl-shift-left and
+  ctrl-shift-right to collapse/uncollapse all headings).
+  Bindings are also configurable from the config page
+* A toggle control in the input prompt area of each heading cell (as seen in
+  the screenshot below, enabled by default)
+  * Configurable icons and icon color for the toggle control (by default, grey
+    right/down carets are used)
+  * The option to make the toggle control into a button (by default it's just a
+    clickable icon)
+* Mathematica-style grouping brackets around each collapsible section on the
+  right of the notebook. Single-clicking a bracket will select all cells in the
+  section (hold shift to extend existing selection), while double-clicking the
+  bracket toggles the section's collpased/expanded status (disabled by default)
+  * Bracket width is configurable, defaults to 10 (px)
+* A gray bracketed ellipsis added to the end of each collapsed heading,
+  indicating hidden content (disabled by default)
+* A toolbar button to collapse the nearest heading to the curently selected
+  cell (disabled by default)
+* Collapse/uncollapse sections when ToC2 sections are collapsed/uncollapsed
+* A toolbar button to collapse/uncollapse all headings (disabled by default)
+* Shift more-significant headings' collapse controls further to the left
+
+
+css
+---
+
+The extension add the css class `collapsible_headings_collapsed` to each
+collapsed heading cell, which you could use for custom css rules, such as
+adding a bottom border to collapsed headings, to visually distinguish them a
+bit more.
+
+The toggle controls' icons currently spin by 360 degrees when the heading gets
+collapsed or uncollapsed, via a css transition property (not in IE).
+If this annoys you,
+you could turn it off using the following rule in your `custom.css`:
+
+```css
+.cell .collapsible_headings_toggle .fa {
+	transition: transform 0s;
+}
+```
+
+
+Internals
+---------
+
+Heading cells which are collapsed have a value set in the cell metadata, so
+that
+
+```javascript
+cell.metadata.heading_collapsed = true
+```
+
+The extension patches some Jupyter methods:
+* `TextCell.prototype.execute` is patched to add/remove the toggle buttons,
+  as well as update the visibility of any cells below the new one.
+* `Notebook.prototype.select` is patched to make sure any collapsed headings
+  which would be hiding the new selection get uncollapsed (expanded).
+* `Notebook.prototype.undelete` and `Notebook.prototype.delete_cells` are
+  patched to trigger an update of which cells should be visible or hidden.
+* `Tooltip._show` is patched to toggle the `div.cell { position:relative; }`
+  css rule of while the tooltip displays, as otherwise it interferes with the
+  tooltip's position-determining logic. Since this method is not part of the
+  public API (leading underscore), this may break in future, but it should
+  degrade in a non-catastrophic manner, with the result that the tooltip will
+  appear at the top of the notebook document, rather than where the cursor is
+  currently.
+
+The extension also patches two existing Jupyter actions: those triggered in
+command mode by the up/down arrow keys. Ordinarily, these select the cell
+above/below the current selection. Once patched by `collapsible_headings`, they
+have the same behaviour, but skip over any cells which have been hidden (by a
+collapsed heading, or, in fact, by any other mechanism).
+
+Finally, `collapsible_headings` registers two new actions, namely
+`collapsible_headings:collapse_heading` and
+`collapsible_headings:uncollapse_heading`, which are used by the keyboard
+shortcuts (if used), and can be called as with any other action.
+
+The previously-provided preprocessor has been retired in favour of an exporter
+which embeds functionality correctly. See the [exporting section] for details.
+If you have questions, comments, or would like alterations (particularly for
+nbconvert support, of which I don't have much experience), get in touch
+([@jcb91](https://github.com/jcb91))
+and I'll see what I can do :)
+
+
+Exporting
+---------
+
+It is possible to export most of the features of collapsible_headings to html.
+The process is to embed the relevant css & js files into the html output, with
+suitable functionality for a non-live notebook.
+
+This is accomplished through use of the `ExporterInliner` class and its
+associated `inliner.tpl` template, provided as part of the
+`jupyter_contrib_nbextensions.nbconvert_support` module.
+To convert to html embedding collapsible headings functionality, use `html_ch`
+exporter, with a command like
+
+    jupyter nbconvert --to html_ch FILE.ipynb

.local/share/jupyter/nbextensions/comment-uncomment/readme.md

@@ -0,0 +1,11 @@
+Comment/Uncomment
+=================
+
+Adds a new configurable hotkey binding to toggle comments on/off.
+
+Options
+-------
+
+**comment_uncomment_keybinding**: keybinding for toggling comments (default: Alt-c)
+
+***comment_uncomment_indent***: add comment at current indent level instead of at beginning of line

.local/share/jupyter/nbextensions/contrib_nbextensions_help_item/contrib_nbextensions_help_item.yaml

@@ -0,0 +1,7 @@
+Type: Jupyter Notebook Extension
+Name: contrib_nbextensions_help_item
+Description: The contrib_nbextensions_help_item is a tiny extension that just adds an item in the notebook's help menu, pointing to the jupyter_contrib_nbextensions at readthedocs.
+Link: README.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x, 5.x

.local/share/jupyter/nbextensions/equation-numbering/info.yaml

@@ -0,0 +1,7 @@
+Type: IPython Notebook Extension
+Name: Equation Auto Numbering
+Description: This extension enables equation autonumbering and resetting the equation count.
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x, 5.x

.local/share/jupyter/nbextensions/equation-numbering/main.js

@@ -0,0 +1,39 @@
+// Copyright (c) IPython-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'notebook/js/textcell',
+    'base/js/utils',
+],   function(Jupyter, $, requirejs, textcell, utils) {
+    "use strict";
+
+    var MathJax = window.MathJax;
+
+    var load_ipython_extension = function() {
+        var btn_grp = Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register ({
+                help   : 'Reset equation numbering',
+                icon   : 'fa-sort-numeric-asc',
+                handler: function () {
+                    MathJax.Hub.Queue(
+                        ["resetEquationNumbers", MathJax.InputJax.TeX],
+                        ["PreProcess", MathJax.Hub],
+                        ["Reprocess", MathJax.Hub]
+                    );
+                    $('#reset_numbering').blur();
+                }
+            }, 'reset-numbering', 'equation_numbering')
+        ]);
+        $(btn_grp).find('.btn').attr('id', 'reset_numbering');
+        MathJax.Hub.Config({
+          TeX: { equationNumbers: { autoNumber: "AMS" } }
+        });
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/execute_time/ExecuteTime.css

@@ -0,0 +1,6 @@
+.timing_area {
+    padding: 0 5px;
+    border: none;
+    border-top: 1px solid #CFCFCF;
+    font-size: 80%;
+}

.local/share/jupyter/nbextensions/execute_time/ExecuteTime.js

@@ -0,0 +1,349 @@
+
+//  Copyright (C) 2014  Jean-Christophe Jaskula
+//                2015  joshuacookebarnes@gmail.com
+//
+//  Distributed under the terms of the BSD License.
+// ---------------------------------------------------------------------------
+//
+// Execution timings:
+// display when a cell was last executed, and how long it took to run
+// A double click on the timing box makes it disappear
+
+define([
+    'require',
+    'jquery',
+    'moment',
+    'base/js/namespace',
+    'base/js/events',
+    'notebook/js/codecell'
+], function (
+    requirejs,
+    $,
+    moment,
+    Jupyter,
+    events,
+    codecell
+) {
+    'use strict';
+
+    var mod_name = 'ExecuteTime';
+    var log_prefix = '[' + mod_name + ']';
+
+    var CodeCell = codecell.CodeCell;
+
+    // defaults, overridden by server's config
+    var options = {
+        clear_timings_on_clear_output: false,
+        clear_timings_on_kernel_restart: false,
+        default_kernel_to_utc: true,
+        display_absolute_format: 'HH:mm:ss YYYY-MM-DD',
+        display_absolute_timings: true,
+        display_in_utc: false,
+        display_right_aligned: false,
+        highlight: {
+            use: true,
+            color: '#00bb00',
+        },
+        relative_timing_update_period: 10,
+        template: {
+            executed: 'executed in ${duration}, finished ${end_time}',
+            queued: 'execution queued ${start_time}',
+        },
+    };
+
+    function patch_CodeCell_get_callbacks () {
+        console.log(log_prefix, 'patching CodeCell.prototype.get_callbacks');
+        var old_get_callbacks = CodeCell.prototype.get_callbacks;
+        CodeCell.prototype.get_callbacks = function () {
+            var callbacks = old_get_callbacks.apply(this, arguments);
+
+            var cell = this;
+            var prev_reply_callback = callbacks.shell.reply;
+            callbacks.shell.reply = function (msg) {
+                if (msg.msg_type === 'execute_reply') {
+                    $.extend(true, cell.metadata, {
+                        ExecuteTime: {
+                            start_time: add_utc_offset(msg.metadata.started),
+                            end_time: add_utc_offset(msg.header.date),
+                        }
+                    });
+                    var timing_area = update_timing_area(cell);
+                    if ($.ui !== undefined && options.highlight.use) {
+                        timing_area.stop(true, true).show(0).effect('highlight', {color: options.highlight.color});
+                    }
+                }
+                else {
+                    console.log('msg_type', msg.msg_type);
+                }
+                return prev_reply_callback(msg);
+            };
+            return callbacks;
+        };
+    }
+
+    function patch_CodeCell_clear_output () {
+        console.log(log_prefix, 'Patching CodeCell.prototype.clear_output to clear timings also.');
+        var orig_clear_output = CodeCell.prototype.clear_output;
+        CodeCell.prototype.clear_output = function () {
+            var ret = orig_clear_output.apply(this, arguments);
+            clear_timing_data([this]);
+            return ret;
+        };
+    }
+
+    function toggle_timing_display (cells, vis) {
+        for (var i = 0; i < cells.length; i++) {
+            var cell = cells[i];
+            if (cell instanceof CodeCell) {
+                var ce = cell.element;
+                var timing_area = ce.find('.timing_area');
+                if (timing_area.length > 0) {
+                    if (vis === undefined) {
+                        vis = !timing_area.is(':visible');
+                    }
+                    timing_area.toggle(vis);
+                }
+            }
+        }
+        return vis;
+    }
+
+    function clear_timing_data (cells) {
+        cells.forEach(function (cell, idx, arr) {
+            delete cell.metadata.ExecuteTime;
+            cell.element.find('.timing_area').remove();
+        });
+        events.trigger('set_dirty.Notebook', {value: true});
+    }
+
+    function clear_timing_data_all () {
+        console.log(log_prefix, 'Clearing all timing data');
+        clear_timing_data(Jupyter.notebook.get_cells());
+    }
+
+    function create_menu () {
+        var timings_menu_item = $('<li/>')
+            .addClass('dropdown-submenu')
+            .append(
+                $('<a href="#">')
+                    .text('Execution Timings')
+                    .on('click', function (evt) { evt.preventDefault(); })
+            )
+            .appendTo($('#cell_menu'));
+
+        var timings_submenu = $('<ul/>')
+            .addClass('dropdown-menu')
+            .appendTo(timings_menu_item);
+
+        $('<li/>')
+            .attr('title', 'Toggle the timing box for the selected cell(s)')
+            .append(
+                $('<a href="#">')
+                    .text('Toggle visibility (selected)')
+                    .on('click', function (evt) {
+                        evt.preventDefault();
+                        toggle_timing_display(Jupyter.notebook.get_selected_cells());
+                    })
+            )
+            .appendTo(timings_submenu);
+
+        $('<li/>')
+            .attr('title', 'Toggle the timing box for all cells')
+            .append(
+                $('<a href="#">')
+                    .text('Toggle visibility (all)')
+                    .on('click', function (evt) {
+                        evt.preventDefault();
+                        toggle_timing_display(Jupyter.notebook.get_cells());
+                    })
+            )
+            .appendTo(timings_submenu);
+
+        $('<li/>')
+            .attr('title', 'Clear the selected cell(s) timing data')
+            .append(
+                $('<a href="#">')
+                    .text('Clear (selected)')
+                    .on('click', function (evt) {
+                        evt.preventDefault();
+                        clear_timing_data(Jupyter.notebook.get_selected_cells());
+                    })
+            )
+            .appendTo(timings_submenu);
+
+        $('<li/>')
+            .attr('title', 'Clear the timing data from all cells')
+            .append(
+                $('<a href="#">')
+                    .text('Clear (all)')
+                    .on('click', function (evt) {
+                        evt.preventDefault();
+                        clear_timing_data(Jupyter.notebook.get_cells());
+                    })
+            )
+            .appendTo(timings_submenu);
+    }
+
+    function excute_codecell_callback (evt, data) {
+        var cell = data.cell;
+        cell.metadata.ExecuteTime = {start_time: moment().toISOString()};
+
+        update_timing_area(cell);
+    }
+
+    function humanized_duration (duration_ms, item_count) {
+        if (duration_ms < 1000) { // < 1s, show ms directly
+            return Math.round(duration_ms) + 'ms';
+        }
+
+        var humanized = '';
+
+        var days = Math.floor(duration_ms / 86400000);
+        if (days) {
+            humanized += days + 'd ';
+        }
+        duration_ms %= 86400000;
+
+        var hours = Math.floor(duration_ms / 3600000);
+        if (days || hours) {
+            humanized += hours + 'h ';
+        }
+        duration_ms %= 3600000;
+
+        var mins = Math.floor(duration_ms / 60000);
+        if (days || hours || mins) {
+            humanized += mins + 'm';
+        }
+        duration_ms %= 60000;
+
+        var secs = duration_ms / 1000; // don't round!
+        if (!days) {
+            var decimals = (hours || mins > 1) ? 0 : (secs > 10 ? 1 : 2);
+            humanized += (humanized ? ' ' : '') + secs.toFixed(decimals) + 's';
+        }
+
+        return humanized;
+    }
+
+    // ISO8601 UTC offset is in format ±[hh]:[mm], ±[hh][mm], or ±[hh]
+    var rgx_has_timezone = new RegExp('Z|[\\-+\u2212]\\d\\d(?::?\\d\\d)?$');
+    function add_utc_offset (timestamp) {
+        if (options.default_kernel_to_utc && timestamp !== undefined && !rgx_has_timezone.test(timestamp)) {
+            return timestamp + 'Z';
+        }
+        return timestamp;
+    }
+
+    function format_moment (when) {
+        if (options.display_in_utc) {
+            when.utc();
+        }
+        if (options.display_absolute_timings) {
+            return when.format(options.display_absolute_format);
+        }
+        return when.fromNow();
+    }
+
+    function update_timing_area (cell) {
+        if (! (cell instanceof CodeCell) ||
+                 !cell.metadata.ExecuteTime ||
+                 !cell.metadata.ExecuteTime.start_time) {
+            return $();
+        }
+
+        var timing_area = cell.element.find('.timing_area');
+        if (timing_area.length < 1) {
+            timing_area = $('<div/>')
+                .addClass('timing_area' + (options.display_right_aligned ? ' text-right' : ''))
+                .on('dblclick', function (evt) { toggle_timing_display([cell]); })
+                .appendTo(cell.element.find('.input_area'));
+        }
+
+        var start_time = moment(cell.metadata.ExecuteTime.start_time),
+              end_time = cell.metadata.ExecuteTime.end_time;
+        var msg = options.template[end_time ? 'executed' : 'queued'];
+        msg = msg.replace('${start_time}', format_moment(start_time));
+        if (end_time) {
+            end_time = moment(end_time);
+            msg = msg.replace('${end_time}', format_moment(end_time));
+            var exec_time = -start_time.diff(end_time);
+            msg = msg.replace('${duration}', humanized_duration(exec_time));
+        }
+        timing_area.text(msg);
+        return timing_area;
+    }
+
+    function _update_all_timing_areas () {
+        Jupyter.notebook.get_cells().forEach(update_timing_area);
+    }
+
+    function update_all_timing_areas () {
+        console.debug(log_prefix, 'updating all timing areas');
+        _update_all_timing_areas();
+    }
+
+    function add_css(url) {
+        $('<link/>')
+            .attr({
+                rel: 'stylesheet',
+                href: requirejs.toUrl(url),
+                type: 'text/css'
+            })
+            .appendTo('head');
+    }
+
+    function load_jupyter_extension () {
+        // try to load jquery-ui
+        if ($.ui === undefined && options.highlight.use) {
+            requirejs(['jquery-ui'], function ($) {}, function (err) {
+                // try to load using the older, non-standard name (without hyphen)
+                requirejs(['jqueryui'], function ($) {}, function (err) {
+                    console.log(log_prefix, 'couldn\'t find jquery-ui, so no animations');
+                });
+            });
+        }
+
+        add_css('./ExecuteTime.css');
+
+        Jupyter.notebook.config.loaded.then(function on_config_loaded () {
+            $.extend(true, options, Jupyter.notebook.config.data[mod_name]);
+        }, function on_config_load_error (reason) {
+            console.warn(log_prefix, 'Using defaults after error loading config:', reason);
+        }).then(function do_stuff_with_config () {
+
+            patch_CodeCell_get_callbacks();
+            events.on('execute.CodeCell', excute_codecell_callback);
+
+            create_menu();
+
+            // add any existing timing info
+            events.on("notebook_loaded.Notebook", update_all_timing_areas);
+            if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+                // notebook already loaded, so we missed the event, so update all
+                update_all_timing_areas();
+            }
+
+            // setup optional clear-data calls
+            if (options.clear_timings_on_clear_output) {
+                patch_CodeCell_clear_output();
+            }
+            if (options.clear_timings_on_kernel_restart) {
+                console.log(log_prefix, 'Binding kernel_restarting.Kernel event to clear timings.');
+                events.on('kernel_restarting.Kernel', clear_timing_data_all);
+            }
+
+            // if displaying relative times, update them at intervals
+            if (!options.display_absolute_timings) {
+                var period_ms = 1000 * Math.max(1, options.relative_timing_update_period);
+                setInterval(_update_all_timing_areas, period_ms);
+            }
+        }).catch(function on_error (reason) {
+            console.error(log_prefix, 'Error:', reason);
+        });
+    }
+
+    return {
+        load_jupyter_extension : load_jupyter_extension,
+        load_ipython_extension : load_jupyter_extension
+    };
+});

.local/share/jupyter/nbextensions/execute_time/ExecuteTime.yaml

@@ -0,0 +1,88 @@
+Type: IPython Notebook Extension
+Name: ExecuteTime
+Description: Display when each cell has been executed and how long it took
+Link: readme.md
+Icon: icon.png
+Main: ExecuteTime.js
+Compatibility: 4.x, 5.x
+Parameters:
+
+- name: ExecuteTime.clear_timings_on_clear_output
+  description: |
+    When cells' outputs are cleared, also clear their timing data, e.g. when
+    using the "Kernel > Restart & Clear Output" menu item
+  input_type: checkbox
+  default: false
+
+- name: ExecuteTime.clear_timings_on_kernel_restart
+  description: |
+    Clear all cells' execution timing data on any kernel restart event
+  input_type: checkbox
+  default: false
+
+- name: ExecuteTime.display_absolute_timings
+  description: |
+    Display absolute timings for the start time of execution.
+    Setting false will display a relative timestamp like 'a few seconds ago'
+  default: true
+  input_type: checkbox
+
+- name: ExecuteTime.display_absolute_format
+  description: |
+    The format to use when displaying absolute timings (see above)
+  default: 'YYYY-MM-DD HH:mm:ss'
+  input_type: text
+
+- name: ExecuteTime.relative_timing_update_period
+  description: |
+    Seconds to wait between updating the relative timestamps, if using them
+    (see above)
+  default: 10
+  input_type: number
+  step: 1
+  min: 1
+  max: 600
+
+- name: ExecuteTime.display_in_utc
+  description: |
+    Display times in UTC, rather than in the local timezone set by the browser
+  default: false
+  input_type: checkbox
+
+- name: ExecuteTime.default_kernel_to_utc
+  description: |
+    For kernel timestamps which do not specify a timezone, assume UTC
+  default: true
+  input_type: checkbox
+
+- name: ExecuteTime.display_right_aligned
+  description: |
+    Right-align the text in the timing area under each cell
+  default: false
+  input_type: checkbox
+
+- name: ExecuteTime.highlight.use
+  description: |
+    Highlight the displayed execution time on completion of execution
+  default: true
+  input_type: checkbox
+
+- name: ExecuteTime.highlight.color
+  description: |
+    Color to use for highlighting the displayed execution time
+  default: '#00BB00'
+  input_type: color
+
+- name: ExecuteTime.template.executed
+  description: |
+    Template for the timing message for executed cells. See readme for
+    replacement tokens.
+  default: 'executed in ${duration}, finished ${end_time}'
+  input_type: text
+
+- name: ExecuteTime.template.queued
+  description: |
+    Template for the timing message for queued cells. See readme for
+    replacement tokens.
+  default: 'execution queued ${start_time}'
+  input_type: text

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

@@ -0,0 +1,206 @@
+Execute Time
+============
+
+This extension displays when the last execution of a code cell occurred, and
+how long it took.
+
+Every executed code cell is extended with a new area, attached at the bottom of
+the input area, that displays the time at which the user sent the cell to the
+kernel for execution.
+When the kernel finishes executing the cell, the area is updated with the
+duration of the execution.
+The timing information is stored in the cell metadata, and restored on notebook
+load.
+
+![](execution-timings-box.png)
+
+
+Toggling display
+----------------
+
+The timing area can be hidden by double clicking on it, or using the
+`Cell -> Toggle timings -> Selected`
+menu item.
+The menu item
+`Cell -> Toggle timings -> All`
+hides (shows) all the timing areas in the notebook, if the first cell is
+currently shown (hidden).
+
+![](execution-timings-menu.png)
+
+
+Options
+-------
+
+The nbextension offers a few options for how to display and interpret
+timestamps.
+Options are stored in the `notebook` section of the server's nbconfig, under
+the key `ExecuteTime`.
+The easiest way to configure these is using the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator),
+which if you got this nbextension in the usual way from
+[jupyter_contrib_nbextensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions),
+should also have been installed.
+
+Alternatively, you can also configure them directly with a few lines of python.
+For example, to alter the displayed message, use relative timestamps,
+and set them to update every 5 seconds, we can use the following python
+snippet:
+
+```python
+from notebook.services.config import ConfigManager
+ConfigManager().update('notebook', {'ExecuteTime': {
+   	'display_absolute_timestamps': False,
+    'relative_timing_update_period': 5,
+    'template': {
+    	'executed': 'started ${start_time}, finished in ${duration}',
+    }
+}})
+```
+
+The available options are:
+
+* `ExecuteTime.clear_timings_on_clear_output`: When cells' outputs are cleared,
+  also clear their timing data, e.g. when using the
+  `Kernel > Restart & Clear Output` menu item
+
+* `ExecuteTime.clear_timings_on_kernel_restart`: Clear all cells' execution
+  timing data on any kernel restart event
+
+* `ExecuteTime.display_absolute_timings`: Display absolute timings for the
+  start/end time of execution. Setting this `false` will result in the display
+  of a relative timestamp like 'a few seconds ago' (see the moment.js function
+  [fromNow](https://momentjs.com/docs/#/displaying/fromnow/)
+  for details). Defaults to `true`.
+
+* `ExecuteTime.display_absolute_format`: The format to use when displaying
+  absolute timings (see `ExecuteTime.display_absolute_timings`, above).
+  See the moment.js function
+  [format](https://momentjs.com/docs/#/displaying/format/)
+  for details of the template tokens available.
+  Defaults to `'YYYY-MM-DD HH:mm:ss'`.
+
+* `ExecuteTime.relative_timing_update_period`: Seconds to wait between updating
+  the relative timestamps, if using them (see
+  `ExecuteTime.display_absolute_timings`, above).
+  Defaults to `10`.
+
+* `ExecuteTime.display_in_utc`: Display times in UTC, rather than in the local
+  timezone set by the browser.
+  Defaults to `false`.
+
+* `ExecuteTime.default_kernel_to_utc`: For kernel timestamps which do not
+  specify a timezone, assume UTC.
+  Defaults to `true`.
+
+* `ExecuteTime.display_right_aligned`: Right-align the text in the timing area
+  under each cell.
+  Defaults to `false`.
+
+* `ExecuteTime.highlight.use`: Highlight the displayed execution time on
+  completion of execution.
+  Defaults to `true`.
+
+* `ExecuteTime.highlight.color`: Color to use for highlighting the displayed
+  execution time.
+  Defaults to `'#00BB00'`.
+
+* `ExecuteTime.template.executed`: Template for the timing message for executed
+  cells. See readme for     replacement tokens.
+  Defaults to `'executed in ${duration}, finished ${end_time}'`.
+
+* `ExecuteTime.template.queued`: Template for the timing message for queued
+  cells. The template uses an ES2015-like syntax, but replaces only the exact
+  strings `${start_time}`, plus (if defined) `${end_time}` and `${duration}`.
+  Defaults to `'execution queued ${start_time}'`.
+
+
+
+Limitations
+-----------
+
+
+### timezones
+
+As discussed in
+[ipython-contrib/jupyter_contrib_nbextensions#549](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/549),
+[ipython-contrib/jupyter_contrib_nbextensions#904](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/904),
+and
+[jupyter/jupyter_client#143](https://github.com/jupyter/jupyter_client/issues/143),
+although they are (now) supposed to, Jupyter kernels don't always specify a
+timezone for their timestamps, which can cause problems when the
+[moment.js](https://momentjs.com/)
+library assumes the local timezone, rather than UTC, which is what most kernels
+are actually using.
+To help to address this, see the [options](#Options) above, which can be used
+ to assume UTC for unzoned timestamps.
+
+
+### execution queues
+
+For a reason I don't understand, when multiple cells are queued for execution,
+the kernel doesn't send a reply immediately after finishing executing each
+cell.
+Some replies are delayed, and sent at the same time as later replies, meaning
+that the output of a cell can be updated with its finished value, before the
+notebook recieves the kernel execution reply.
+For the same reason, you can see this in the fact that the star for an
+executing cell can remain next to two cells at once, if several are queued to
+execute together.
+Since this extension uses the times in the kernel message (see internals,
+below), and these remain correct, the timings displayed are still accurate,
+but they may get displayed later due to this kernel issue.
+
+
+Installation
+------------
+
+Install the master version of the jupyter_contrib_nbextensions repository as
+explained in the docs at
+[jupyter-contrib-nbextensions.readthedocs.io](https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/install.html).
+
+Then you can use the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator)
+to enable/disable this extension for all notebooks.
+
+Internals
+---------
+
+The execution start and end times are stored in the cell metadata as ISO8601
+strings, for example:
+
+```json
+{
+	"ExecuteTime": {
+    	"start_time": "2016-02-11T18:51:18.536796",
+    	"end_time": "2016-02-11T18:51:35.806119"
+	}
+}
+```
+
+The times in the timing areas are formatted using the
+[moment.js](https://momentjs.com/) library (already included as part of
+Jupyter), but the durations use a custom formatting function, as
+I ([@jcb91](https://github.com/jcb91))
+couldn't find an existing one that I liked.
+
+The event `execute.CodeCell` is caught in order to create a start time, and add
+the timing area with its 'Execution queued at' message.
+The extension again uses [moment.js](https://momentjs.com/) for formatting this
+as an ISO string time.
+
+To determine the execution time, the extension patches the Jupyter class
+prototype `CodeCell.prototype.get_callbacks` from `notebook/js/codecell.js`.
+This patch then patches the `callbacks.shell.reply` function returned by the
+original `CodeCell.prototype.get_callbacks`, wrapping it in a function which
+reads the `msg.header.date` value from the kernel message, to provide the
+execution end time.
+This is more accurate than creating a new time, which can be affected by
+client-side variability.
+In addition, for accurate timings, the start time is also revised using
+the `msg.metadata.started` value supplied in the callback, which can be very
+different from the time the cell was queued for execution (as a result of
+other cells already being executed).
+The kernel reply message times are already ISO8601 strings, so no conversion is
+necessary, although again, [moment.js](https://momentjs.com/) is used for
+parsing and diff'ing them.

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

@@ -0,0 +1,43 @@
+execution_dependencies
+======================
+
+Writing extensive notebooks can become very complicated since many cells act as stepping stones to produce intermediate results for later cells. Thus, it becomes tedious to
+keep track of the cells that have to be run in order to run a certain cell. This extension simplifies handling the execution dependencies by introducing tag annotations to
+identify each cell and indicate a dependency on others. This improves on the current state which requires remembering all dependencies by heart or annotating the cells in the comments.
+
+If a cell with dependencies is run, the extension checks recursively for all dependencies of the cell, then executes them before executing the cell after all the dependencies have finished.
+Dependencies are definitely executed and not only once per kernel session.
+
+The two annotations are added to the tags of a cell and are as follows:
+
+ * add a hashmark (#) and an identification tag to the tags to identify a cell (e.g. #initializer-cell). The #identifiers must be unique among all cells.
+ * add an arrow (=>) and an identification tag to the tags to add a dependency on a certain cell (e.g. =>initializer-cell).
+
+Based on these dependencies, the kernel will now execute the dependencies before the cell that depends on them. If the cell's dependencies have further dependencies, these will in turn
+be executed before them. In conclusion, the kernel looks through the tree of dependencies of the cell executed by the user and executes its dependencies in their appropriate order, 
+then executes the cell.
+
+A more extensive example is described below:
+
+A cell A has the identifier #A.
+
+| Cell A [tags: #A]  |
+| ------------- | 
+| Content Cell  |
+| Content Cell  |
+
+
+A cell B has the identifier #B and depends on A (=>A).
+
+
+| Cell B [tags: #B, =>A]  |
+| ------------- | 
+| Content Cell  |
+| Content Cell  |
+
+If the user runs A, only A is executed, since it has no dependencies. On the other hand, if the user runs B, the kernel finds the dependency on A, and thus first runs A and then runs B.
+
+Running a cell C that is dependent on B and on A as well, the kernel then first runs A and then runs B before running C, avoiding to run cell A twice.
+
+
+If you are missing anything, open up an issue at the repository prepending [execute_dependencies] to the title.

.local/share/jupyter/nbextensions/execution_dependencies/execution_dependencies.js

@@ -0,0 +1,139 @@
+/**
+ * execution_dependencies.js
+ * Introduce tag annotations to identify each cell and indicate a dependency on others.
+ * Upon running a cell, its dependencies are run first to prepare all dependencies. 
+ * Then the cell triggered by the user is run as soon as all its dependencies are met.
+ *
+ *
+ * @version 0.1.0
+ * @author  Benjamin Ellenberger, https://github.com/benelot
+ * @updated 2018-01-31
+ *
+ *
+ */
+define([
+    'jquery',
+    'base/js/dialog',
+    'base/js/namespace',
+    'notebook/js/codecell'
+], function (
+    $,
+    dialog,
+    Jupyter,
+    codecell
+) {
+    "use strict";
+
+    var CodeCell = codecell.CodeCell;
+
+    return {
+        load_ipython_extension: function () {
+            console.log('[execution_dependencies] patching CodeCell.execute');
+            var orig_execute = codecell.CodeCell.prototype.execute;                                            // keep original cell execute function
+            CodeCell.prototype.execute = function (stop_on_error) {
+                var root_tags = this.metadata.tags || [];                                                      // get tags of the cell executed by the user (root cell)
+                if(root_tags.some(tag => /=>.*/.test(tag))) {                                                  // if the root cell contains any dependencies, resolve dependency tree
+                    var root_cell = this;
+                    var root_cell_id = root_cell.cell_id;
+                    var cells_with_id = Jupyter.notebook.get_cells().filter(function (cell, idx, cells) {      // ...get all cells which have at least one id (these are the only ones we could have in deps)
+                        var tags = cell.metadata.tags || [];                        
+                        return (cell === root_cell || tags.some(tag => /#.*/.test(tag)));
+                    });
+
+                    console.log('[execution_dependencies] collecting ids and dependencies...');
+                    var cell_map = {}  
+                    var dep_graph = {}
+                    cells_with_id.forEach(function (cell) {                                                    // ...get all identified cells (the ones that have at least one #tag)
+                        var tags = cell.metadata.tags || [];
+                        var cell_ids = tags.filter(tag => /#.*/.test(tag)).map(tag => tag.substring(1));       // ...get all identifiers of the current cell and drop the #
+                        if(cell === root_cell){                        
+                            if(cell_ids.length < 1) {
+                                cell_ids.push(root_cell.cell_id);                                              // ...use internal root cell id for internal usage
+                            }
+                            else {
+                                root_cell_id = cell_ids[0];                                                    // get any of the root cell ids
+                            }
+                        }
+
+                        var dep_ids = tags.filter(tag => /=>.*/.test(tag)).map(tag => tag.substring(2));       // ...get all dependencies and drop the =>
+                        
+                        cell_ids.forEach(function (id) {
+                          //console.log('ID:', id, 'deps: ', dep_ids.toString())
+                            cell_map[id] = cell;
+                            dep_graph[id] = dep_ids;
+
+                        });
+                    });
+
+                    if(dep_graph[root_cell_id].length > 0) {
+                        console.log('[execution_dependencies] collecting depdendency graph in-degrees...');
+                        var processing_queue = [root_cell_id];
+                        var processed_nodes = 0;
+                        var in_degree = {};                                                                    // ...collect in-degrees of nodes
+                        while(processing_queue.length > 0 && processed_nodes < Object.keys(dep_graph).length) {// ...stay processing deps while the queue contains nodes and the processed nodes are below total node quantity
+                            var id = processing_queue.shift();                                                 // .....pop front of queue and front-push it to the processing order
+                          //console.log("ID: ", id);
+                            for(var i=0, dep_qty=dep_graph[id].length; i < dep_qty; i++) {
+                                var dep = dep_graph[id][i];
+                          //    console.log('      dep: ', dep);
+                                in_degree[id] = in_degree[id] || 0;
+                                in_degree[dep] = in_degree[dep] === undefined ? 1 : ++in_degree[dep];
+                                processing_queue.unshift(dep);
+                            }
+                            processed_nodes++;
+                        }
+
+                        console.log('[execution_dependencies] starting topological sort...');
+                        processing_queue = [root_cell_id];                                                     // ...add root node with in-degree 0 to queue (this excludes all disconnected subgraphs)
+                        processed_nodes = 0;                                                                   // ...number of processed nodes (to detect circular dependencies)
+                        var processing_order = [];
+                        while(processing_queue.length > 0 && processed_nodes < Object.keys(dep_graph).length) {// ...stay processing deps while the queue contains nodes and the processed nodes are below total node quantity
+                            var id = processing_queue.shift();                                                 // .....pop front of queue and front-push it to the processing order
+                            processing_order.unshift(id);
+                          //console.log("ID: ", id);
+                            for(var i=0, dep_qty=dep_graph[id].length; i < dep_qty; i++) {                     // ......iterate over dependent nodes of current id and decrease their in-degree by 1
+                                var dep = dep_graph[id][i];
+                          //    console.log('      dep: ', dep);
+                                in_degree[dep]--;
+                                if(in_degree[dep] == 0) {                                                      // ......queue dependency if in-degree is 0
+                                    processing_queue.unshift(dep);
+                                }
+                            }
+                            processed_nodes++;
+                        }
+                        
+                        console.log('[execution_dependencies] checking for circular dependencies...');
+                        if(processed_nodes > Object.keys(dep_graph).length) {                                  // ...if more nodes where processed than the number of graph nodes, there is a circular dependency
+                            dialog.modal({ 
+                                 title : 'Circular dependencies in the execute dependencies of this cell', 
+                                 body : 'There is a circular dependency in this cell\'s execute dependencies. The cell will be run without dependencies. If this does not work, fix the dependencies and rerun the cell.', 
+                                 buttons: {'OK': {'class' : 'btn-primary'}}, 
+                                 notebook: Jupyter.notebook, 
+                                 keyboard_manager: Jupyter.keyboard_manager, 
+                             }); 
+                        }
+                        else if(!Jupyter.notebook.trusted) {                                                   // ...if the notebook is not trusted, we do not execute dependencies, but only print them out to the user
+                            dialog.modal({ 
+                                 title : 'Execute dependencies in untrusted notebook', 
+                                 body : 'This notebook is not trusted, so execute dependencies will not be automatically run. You can still run them manually, though. Run in order (the last one is the cell you wanted to execute): ' + processing_order, 
+                                 buttons: {'OK': {'class' : 'btn-primary'}}, 
+                                 notebook: Jupyter.notebook, 
+                                 keyboard_manager: Jupyter.keyboard_manager, 
+                            });
+                        }
+                        else{
+                            processing_order.pop()
+                            console.log('[execution_dependencies] executing dependency cells in order ', processing_order ,'...');
+                            var dependency_cells = processing_order.map(id =>cell_map[id]);                    // ...get dependent cells by their id
+                          //console.log("Execute cells..", dependency_cells)
+                            dependency_cells.forEach(cell => orig_execute.call(cell, stop_on_error));          // ...execute all dependent cells in sequence using the original execute method
+                        }
+                    }
+                }
+                console.log('[execution_dependencies] executing requested cell...');
+                orig_execute.call(this, stop_on_error);                                                    // execute original cell execute function
+            };
+            console.log('[execution_dependencies] loaded');
+        }
+    };
+});

.local/share/jupyter/nbextensions/exercise/history.md

@@ -0,0 +1,26 @@
+Exercise nbextension history
+----------------------------
+
+Update december 30, 2015:
+(@jfbercher) Updated to jupyter notebook 4.1.x
+
+Update december 22, 2015:
+(@jfbercher)
+  Added the metadata solution_first to mark the beginning of an exercise. It is now possible to have several consecutive exercises. 
+
+October 21-27,2015: 
+(@jfbercher)
+
+1- the extension now works with the multicell API, that is
+  - several cells can be selected either via the rubberband extension 
+  - or via Shift-J (select next) or Shift-K (select previous) keyboard shortcuts
+(probably Shit-up and down will work in a near future) 
+Note: previously, the extension required the selected cells to be marked with a "selected" key in metadata. This is no more necessary with the new API.
+Then clicking on the toolbar button turns these cells into a "solution" which is hidden by default ** Do not forget to keep the Shift key pressed down while clicking on the menu button (otherwise selected cells will be lost)** 
+2- the "state" of solutions, hidden or shown, is saved and restored at reload/restart. We use the "solution" metadata to store the current state.
+3- A small issue (infinite loop when a solution was defined at the bottom edge of the notebook have been corrected)
+4- Added a keyboard shortcut (Alt-S with S for solution]
+
+October-November 2014 (?):
+
+Several versions (@juhasch)

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

@@ -0,0 +1,169 @@
+// Copyright (c) IPython-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+
+// Hide or display solutions in a notebook
+
+/*
+December  6, 2017 @jcb91: use bootstrap 'hidden' class to play nicely with collapsible_headings
+December 30, 2015: update to 4.1
+Update december 22, 2015:
+  Added the metadata solution_first to mark the beginning of an exercise. It is now possible to have several consecutive exercises.
+Update october 21-27,2015:
+1- the extension now works with the multicell API, that is
+   - several cells can be selected either via the rubberband extension
+   - or via Shift-J (select next) or Shift-K (select previous) keyboard shortcuts
+    (probably Shit-up and down will work in a near future)
+    Note: previously, the extension required the selected cells to be marked with a "selected" key in metadata. This is no more necessary with the new API.
+Then clicking on the toolbar button transforms these cells into a "solution" which is hidden by default
+** Do not forget to keep the Shift key pressed down while clicking on the menu button
+(otherwise selected cells will be lost)**
+2- the "state" of solutions, hidden or shown, is saved and restored at reload/restart. We use the "solution" metadata to store the current state.
+3- A small issue (infinite loop when a solution was defined at the bottom edge of the notebook have been corrected)
+4- Added a keyboard shortcut (Alt-S) [S for solution]
+*/
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'base/js/events',
+], function(IPython, $, requirejs, events) {
+    "use strict";
+
+    var cfg = {
+        add_button: true,
+        use_hotkey: true,
+        hotkey: 'Alt-S',
+    };
+
+    /**
+     * handle click event
+     *
+     * @method click_solution_lock
+     * @param evt {Event} jquery event
+    */
+    function click_solution_lock(evt) {
+        var cell = IPython.notebook.get_selected_cell();
+        var is_locked = cell.metadata.solution === 'hidden';
+        cell.metadata.solution = is_locked ? 'shown' : 'hidden';
+        element_set_locked(cell, !is_locked);
+        cell = IPython.notebook.get_next_cell(cell);
+        while (cell !== null && cell.metadata.solution !== undefined && !cell.metadata.solution_first) {
+            cell.element.toggleClass('hidden', !is_locked);
+            cell.metadata.solution = is_locked ? 'shown' : 'hidden';
+            cell = IPython.notebook.get_next_cell(cell);
+        }
+    }
+
+    /**
+     * Create or Remove an exercise in selected cells
+     *
+     * @method create_remove_exercise
+     *
+     */
+    function create_remove_exercise() {
+        var lcells = IPython.notebook.get_selected_cells();
+        // It is possible that no cell is selected
+        if (lcells.length < 1) {
+            alert("Exercise extension:  \nPlease select some cells...");
+            return;
+        }
+
+        var cell = lcells[0];
+        if (cell.metadata.solution_first) {
+            remove_element(cell);
+            delete cell.metadata.solution_first;
+            while (cell !== null && cell.metadata.solution !== undefined && !cell.metadata.solution_first) {
+                delete cell.metadata.solution;
+                cell.element.removeClass('hidden');
+                cell = IPython.notebook.get_next_cell(cell);
+            }
+        }
+        else {
+            cell.metadata.solution_first = true;
+            cell.metadata.solution = 'hidden';
+            add_element(cell);
+            for (var k = 1; k < lcells.length; k++) {
+                cell = lcells[k];
+                cell.element.addClass('hidden');
+                cell.metadata.solution = 'hidden';
+            }
+        }
+    }
+
+    /**
+     *  Add a lock control to the given cell
+     */
+    function add_element(cell) {
+        var ctrl = cell.element.find('.exercise');
+        if (ctrl.length > 0) return ctrl;
+        var locked = cell.metadata.solution === 'hidden';
+        ctrl = $('<div class="exercise fa">')
+            .prependTo(cell.element)
+            .on('click', click_solution_lock);
+        element_set_locked(cell, locked);
+        return ctrl;
+    }
+
+    function remove_element(cell) {
+        cell.element.find('.exercise').remove();
+    }
+
+    function element_set_locked(cell, locked) {
+        return cell.element.find('.exercise')
+            .toggleClass('fa-plus-square-o', locked)
+            .toggleClass('fa-minus-square-o', !locked);
+    }
+
+    function refresh_exercises() {
+        var in_exercise = false;
+        IPython.notebook.get_cells().forEach(function(cell) {
+            if (in_exercise && cell.metadata.solution !== undefined && !cell.metadata.solution_first) {
+                cell.element.toggleClass('hidden', cell.metadata.solution  === 'hidden');
+            } else {
+                in_exercise = false;
+            }
+            if (!in_exercise && cell.metadata.solution !== undefined) {
+                in_exercise = true;
+                add_element(cell);
+            }
+        });
+    }
+
+    function load_ipython_extension() {
+        // add css
+        $('<link rel="stylesheet" type="text/css">')
+            .attr('href', requirejs.toUrl('./main.css'))
+            .appendTo('head');
+
+        // Hide/display existing solutions at startup
+        events.on('notebook_loaded.Notebook', refresh_exercises);
+        if (IPython.notebook._fully_loaded) refresh_exercises();
+
+        var action_name = IPython.keyboard_manager.actions.register({
+            help    : 'Exercise: Create/Remove exercise',
+            help_index: 'ht',
+            icon    : 'fa-mortar-board',
+            handler : create_remove_exercise
+        }, 'create_remove_exercise', 'exercise');
+
+        IPython.notebook.config.loaded.then(function() {
+            $.extend(true, cfg, IPython.notebook.config.data);
+
+            if (cfg.add_button) {
+                IPython.toolbar.add_buttons_group([action_name]);
+            }
+            if (cfg.use_hotkey && cfg.hotkey) {
+                var cmd_shrts = {};
+                cmd_shrts[cfg.hotkey] = action_name;
+                IPython.keyboard_manager.command_shortcuts.add_shortcuts(cmd_shrts);
+            }
+        }).catch(function(err) {
+            console.warn('[exercise] error:', err);
+        });
+    }
+
+    return {
+        load_ipython_extension: load_ipython_extension,
+    };
+});

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

@@ -0,0 +1,60 @@
+.exercise2 {
+    display: flex;
+    width: 100%;
+    flex-direction: row;
+    align-content: flex-end;
+}
+
+.onoffswitch {
+    display: inline;
+    position: relative; width: 167px;
+    margin-top:8px;
+    -webkit-user-select:none; -moz-user-select:none; -ms-user-select: none;
+}
+.onoffswitch-checkbox {
+    display: none;
+}
+.onoffswitch-label {
+    display: block; overflow: hidden; cursor: pointer;
+    border: 2px solid #999999; border-radius: 20px;
+    margin:0;
+}
+.onoffswitch-inner {
+    display: block; width: 200%; margin-left: -100%;
+    transition: margin 0.3s ease-in 0s;
+}
+.onoffswitch-inner:before, .onoffswitch-inner:after {
+    display: block; float: left; width: 50%; height: 30px; padding: 0; line-height: 30px;
+    font-size: 15px; color: white; font-family: Trebuchet, Arial, sans-serif; font-weight: bold;
+    box-sizing: border-box;
+}
+.onoffswitch-inner:before {
+    content: "Hide Solution";
+    padding-left: 10px;
+    background-color: #34A7C1; color: #FFFFFF;
+   }
+
+.onoffswitch-inner:after {
+    content: "Show Solution";
+    padding-right: 10px;
+    background-color: #73FA7E; color: #999999;
+    text-align: right;
+}
+.onoffswitch-switch {
+    display: block; width: 14px; margin: 6px;
+    padding-top: 0px;
+    background: #FFFFFF;
+    position: absolute; top: 0; bottom: 0;
+    text-align: center;
+    vertical-align: middle;
+    right: 133px;
+    border: 2px solid #999999; border-radius: 20px;
+    transition: all 0.25s ease-in 0s; 
+}
+.onoffswitch-checkbox:checked + .onoffswitch-label .onoffswitch-inner {
+    margin-left: 0;
+}
+.onoffswitch-checkbox:checked + .onoffswitch-label .onoffswitch-switch {
+    right: 0px; 
+}
+

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

@@ -0,0 +1,169 @@
+// Copyright (c) IPython-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+
+// Hide or display solutions in a notebook
+
+// dec 6, 2017 @jcb91: use bootstrap 'hidden' class to play nicely with collapsible_headings
+// december 30, 2015: update to notebook 4.1.x
+// updated on december 22, 2015 to allow consecutive exercises
+// exercise2: built by @jfbercher from an earlier work by @junasch october 2015) - see readme.md
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'base/js/events',
+], function(IPython, $, requirejs, events) {
+    "use strict";
+
+    var cfg = {
+        add_button: true,
+        use_hotkey: true,
+        hotkey: 'Alt-D',
+    };
+
+    /**
+     * handle click event
+     *
+     * @method click_solution_lock
+     * @param evt {Event} jquery event
+    */
+    function click_solution_lock(evt) {
+        var cell = IPython.notebook.get_selected_cell();
+        var is_locked = cell.metadata.solution2 === 'hidden';
+        cell.metadata.solution2 = is_locked ? 'shown' : 'hidden';
+        element_set_locked(cell, !is_locked);
+        cell = IPython.notebook.get_next_cell(cell);
+        while (cell !== null && cell.metadata.solution2 !== undefined && !cell.metadata.solution2_first) {
+            cell.element.toggleClass('hidden', !is_locked);
+            cell.metadata.solution2 = is_locked ? 'shown' : 'hidden';
+            cell = IPython.notebook.get_next_cell(cell);
+        }
+    }
+
+    /**
+     * Create or Remove an exercise in selected cells
+     *
+     * @method create_remove_exercise
+     *
+     */
+    function create_remove_exercise() {
+        var lcells = IPython.notebook.get_selected_cells();
+        // It is possible that no cell is selected
+        if (lcells.length < 1) {
+            alert("Exercise extension:  \nPlease select some cells...");
+            return;
+        }
+
+        var cell = lcells[0];
+        if (cell.metadata.solution2_first) {
+            remove_element(cell);
+            delete cell.metadata.solution2_first;
+            while (cell !== null && cell.metadata.solution2 !== undefined && !cell.metadata.solution2_first) {
+                delete cell.metadata.solution2;
+                cell.element.removeClass('hidden');
+                cell = IPython.notebook.get_next_cell(cell);
+            }
+        }
+        else {
+            cell.metadata.solution2_first = true;
+            cell.metadata.solution2 = 'hidden';
+            add_element(cell);
+            for (var k = 1; k < lcells.length; k++) {
+                cell = lcells[k];
+                cell.element.addClass('hidden');
+                cell.metadata.solution2 = 'hidden';
+            }
+        }
+    }
+
+    /**
+     *  Add a lock control to the given cell
+     */
+    var cbx = 0;
+    function add_element(cell) {
+        var ctrl = cell.element.find('.exercise');
+        if (ctrl.length > 0) return ctrl;
+        var locked = cell.metadata.solution2 === 'hidden';
+        cell.element.css('flex-wrap', 'wrap');
+        cbx += 1;
+        ctrl = $([
+            '<div class="exercise exercise2">',
+            '  <div class="prompt"></div>',
+            '  <div class="onoffswitch">',
+            '    <input class="onoffswitch-checkbox" type="checkbox" id="myCheck' + cbx + '">',
+            '    <label class="onoffswitch-label" for="myCheck' + cbx + '">',
+            '      <div class="onoffswitch-inner"></div>',
+            '      <div class="onoffswitch-switch"></div>',
+            '    </label>',
+            '  </div>',
+            '</div>'
+        ].join('\n'))
+            .appendTo(cell.element);
+        ctrl.find('input')
+            .on('click', click_solution_lock);
+        element_set_locked(cell, locked);
+        return ctrl;
+    }
+
+    function remove_element(cell) {
+        cell.element.find('.exercise').remove();
+    }
+
+    function element_set_locked(cell, locked) {
+        return cell.element.find('.exercise')
+            .prop('checked', !locked);
+    }
+
+    function refresh_exercises() {
+        var in_exercise = false;
+        IPython.notebook.get_cells().forEach(function(cell) {
+            if (in_exercise && cell.metadata.solution2 !== undefined && !cell.metadata.solution2_first) {
+                cell.element.toggleClass('hidden', cell.metadata.solution2  === 'hidden');
+            } else {
+                in_exercise = false;
+            }
+            if (!in_exercise && cell.metadata.solution2 !== undefined) {
+                in_exercise = true;
+                add_element(cell);
+            }
+        });
+    }
+
+    function load_ipython_extension() {
+        // add css
+        $('<link rel="stylesheet" type="text/css">')
+            .attr('href', requirejs.toUrl('./main.css'))
+            .appendTo('head');
+
+        // Hide/display existing solutions at startup
+        events.on('notebook_loaded.Notebook', refresh_exercises);
+        if (IPython.notebook._fully_loaded) refresh_exercises();
+
+        var action_name = IPython.keyboard_manager.actions.register({
+            help      : 'Exercise2: Create/Remove exercise',
+            help_index: 'ht',
+            icon      : 'fa-toggle-on',
+            handler   : create_remove_exercise,
+        }, 'create_remove_exercise', 'exercise2');
+
+        return IPython.notebook.config.loaded.then(function() {
+            $.extend(true, cfg, IPython.notebook.config.data.exercise2);
+
+            if (cfg.add_button) {
+                IPython.toolbar.add_buttons_group([action_name]);
+            }
+            if (cfg.use_hotkey && cfg.hotkey) {
+                var cmd_shrts = {};
+                cmd_shrts[cfg.hotkey] = action_name;
+                IPython.keyboard_manager.command_shortcuts.add_shortcuts(cmd_shrts);
+            }
+        }).catch(function(err) {
+            console.warn('[exercise2] error:', err);
+        });
+    }
+
+    return {
+        load_ipython_extension: load_ipython_extension,
+    };
+});

.local/share/jupyter/nbextensions/export_embedded/export_embedded.yaml

@@ -0,0 +1,7 @@
+Type: Jupyter Notebook Extension
+Compatibility: 5.x
+Main: main.js
+Name: Export Embedded HTML
+Description: Export to HTML with images embedded
+Icon: icon.png
+Link: readme.md

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

@@ -0,0 +1,56 @@
+// toggle display of all code cells' inputs
+
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/events'
+], function(
+    $,
+    Jupyter,
+    events
+) {
+    "use strict";
+
+    function initialize () {
+    }
+
+    var load_ipython_extension = function() {
+        
+        var v = Jupyter.version.split(".")
+        if(Number(v[0])*10+ Number(v[1]) < 51)
+        {
+          console.log('Notebook version 5.1.0 or higher required for this extension')
+          return
+        }
+        
+        /* Add an entry in the download menu */
+        var dwm = $("#download_menu")
+        var downloadEntry = $('<li id="download_html_embed"><a href="#">HTML Embedded (.html)</a></li>')
+        dwm.append(downloadEntry)
+        downloadEntry.click(function () {
+            Jupyter.menubar._nbconvert('html_embed', true);
+        });
+        
+        /* Add also a Button, currently disabled */
+        /*
+        Jupyter.toolbar.add_buttons_group([
+        Jupyter.keyboard_manager.actions.register ({
+            help   : 'Embedded HTML Export',
+            icon   : 'fa-save',
+            handler: function() {
+                Jupyter.menubar._nbconvert('html_embed', true);
+            }
+        }, 'export-embedded-html', 'export_embedded')
+        ]);
+        */
+        if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+            // notebook_loaded.Notebook event has already happened
+            initialize();
+        }
+        events.on('notebook_loaded.Notebook', initialize);
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

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

@@ -0,0 +1,7 @@
+Export HTML With Embedded Images
+================================
+This extension allows exporting an embedded HTML by an additional download option in File -> Download -> HTML Embedded, (works like: jupyter nbconvert --to html_embed notebook.ipynb)
+
+**Note**: This extension can so far only successfully read relative images paths in the markdown cells (e.g. `![](graphics/pic.png)`)  when jupyter is started in the same folder (working directory) where the relative paths can be resolved!
+ 
+

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

@@ -0,0 +1,20 @@
+Type: IPython Notebook Extension
+Name: Freeze
+Description: Freeze cells (forbid editing and executing) or make them read-only
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x, 5.x
+Parameters:
+- name: Freeze.readonly_color
+  description: |
+    Color to use for read-only cell
+  default: '#fffef0'
+  input_type: color
+
+- name: Freeze.frozen_color
+  description: |
+    Color to use for frozen cell
+  default: '#f0feff'
+  input_type: color
+

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

@@ -0,0 +1,205 @@
+define([
+    'base/js/namespace',
+    'base/js/events',
+    'notebook/js/codecell',
+    'notebook/js/textcell',
+    'jquery'
+], function (
+    Jupyter,
+    events,
+    codecell,
+    textcell,
+    $
+) {
+    'use strict';
+
+    var CodeCell = codecell.CodeCell;
+    var MarkdownCell = textcell.MarkdownCell;
+
+    var mod_name = 'Freeze';
+    var log_prefix = '[' + mod_name + ']';
+
+    // defaults, overridden by server's config
+    var options = {
+        readonly_color: '#fffef0',
+        frozen_color: '#f0feff'
+    };
+
+    function patch_MarkdownCell_unrender () {
+        console.log('[Freeze] patching MarkdownCell.prototype.unrender');
+        var old_unrender = MarkdownCell.prototype.unrender;
+
+        MarkdownCell.prototype.unrender = function () {
+            // console.log('[Freeze] patched unrender applied');
+            if (this.metadata.run_control === undefined ||
+                !this.metadata.run_control.frozen
+            ) {
+                old_unrender.apply(this, arguments);
+            }
+        };
+    }
+
+    function patch_CodeCell_execute () {
+        console.log('[Freeze] patching CodeCell.prototype.execute');
+        var old_execute = CodeCell.prototype.execute;
+
+        CodeCell.prototype.execute = function () {
+            if (this.metadata.run_control === undefined ||
+                !this.metadata.run_control.frozen
+            ) {
+                old_execute.apply(this, arguments);
+            }
+        };
+    }
+
+    // Migrate old metadata format to new notebook-defined metadata.editable
+    function migrate_state (cell) {
+        if (cell.metadata.run_control !== undefined) {
+            if (cell instanceof CodeCell || cell instanceof MarkdownCell) {
+                if (cell.metadata.run_control.read_only === true) {
+                    cell.metadata.editable = false;
+                }
+            }
+            else {
+                // remove metadata irrelevant to non-code/markdown cells
+                delete cell.metadata.run_control.frozen;
+            }
+            // remove old key replaced by metadata.editable
+            delete cell.metadata.run_control.read_only;
+            // remove whole object if it's now empty
+            if (Object.keys(cell.metadata.run_control).length === 0) {
+                delete cell.metadata.run_control;
+            }
+        }
+    }
+
+    function get_state (cell) {
+        if (cell.metadata.editable === false && (cell instanceof CodeCell || cell instanceof MarkdownCell)) {
+            if (cell.metadata.run_control !== undefined && cell.metadata.run_control.frozen) {
+                return 'frozen';
+            }
+            return 'readonly';
+        }
+        return 'normal';
+    }
+
+    function set_state(cell, state) {
+        if (!(cell instanceof CodeCell || cell instanceof MarkdownCell)) {
+            return;
+        }
+
+        state = state || 'normal';
+        var bg;
+        switch (state) {
+            case 'normal':
+                cell.metadata.editable = true;
+                cell.metadata.deletable = true;
+                if (cell.metadata.run_control !== undefined) {
+                    delete cell.metadata.run_control.frozen;
+                }
+                bg = "";
+                break;
+            case 'read_only':
+            case 'readonly':
+                cell.metadata.editable = false;
+                cell.metadata.deletable = false;
+                if (cell.metadata.run_control !== undefined) {
+                    delete cell.metadata.run_control.frozen;
+                }
+                bg = options.readonly_color;
+                break;
+            case 'frozen':
+                cell.metadata.editable = false;
+                cell.metadata.deletable = false;
+                $.extend(true, cell.metadata, {run_control: {frozen: true}});
+                bg = options.frozen_color;
+                break;
+        }
+        // remove whole object if it's now empty
+        if (cell.metadata.run_control !== undefined && Object.keys(cell.metadata.run_control).length === 0) {
+            delete cell.metadata.run_control;
+        }
+        cell.code_mirror.setOption('readOnly', !cell.metadata.editable);
+        var prompt = cell.element.find('div.input_area');
+        prompt.css("background-color", bg);
+    }
+
+    function set_state_selected (state) {
+        var cells = Jupyter.notebook.get_selected_cells();
+        for (var i = 0; i < cells.length; i++) {
+            set_state(cells[i], state);
+        }
+    }
+
+    function button_callback(state) {
+        set_state_selected(state);
+        var dirty_state = {value: true};
+        events.trigger("set_dirty.Notebook", dirty_state);
+    }
+
+    function make_normal_selected () {
+        button_callback('normal');
+    }
+
+    function make_read_only_selected () {
+        button_callback('read_only');
+    }
+
+    function make_frozen_selected () {
+        button_callback('frozen');
+    }
+
+    function initialize_states () {
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < cells.length; i++) {
+            var cell = cells[i];
+            migrate_state(cell);
+            var state = get_state(cell);
+            set_state(cell, state);
+        }
+    }
+
+    function load_extension () {
+        Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register ({
+                help : 'lift restrictions from selected cells',
+                icon : 'fa-unlock-alt',
+                handler : make_normal_selected
+            }, 'make-cells-normal', mod_name),
+            Jupyter.keyboard_manager.actions.register({
+                help : 'make selected cells read-only',
+                icon: 'fa-lock',
+                handler : make_read_only_selected
+            }, 'make-cells-read-only', mod_name),
+            Jupyter.keyboard_manager.actions.register({
+                help : 'freeze selected cells',
+                icon : 'fa-asterisk',
+                handler : make_frozen_selected
+            }, 'freeze-cells', mod_name)
+        ]);
+
+        patch_CodeCell_execute();
+        patch_MarkdownCell_unrender();
+
+        Jupyter.notebook.config.loaded.then(function on_config_loaded () {
+            $.extend(true, options, Jupyter.notebook.config.data[mod_name]);
+        }, function on_config_load_error (reason) {
+            console.warn(log_prefix, 'Using defaults after error loading config:', reason);
+        }).then(function do_stuff_with_config () {
+            events.on("notebook_loaded.Notebook", initialize_states);
+            if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+                // notebook already loaded, so we missed the event, so update all
+                initialize_states();
+            }
+        }).catch(function on_error (reason) {
+            console.error(log_prefix, 'Error:', reason);
+        });
+    }
+
+    return {
+        get_state : get_state,
+        set_state : set_state,
+        load_jupyter_extension : load_extension,
+        load_ipython_extension : load_extension
+    };
+});

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

@@ -0,0 +1,24 @@
+# Freeze
+
+This extension allows to make cells read-only or frozen. It provides three buttons:
+* unlock
+* read-only
+* frozen
+
+
+For **code-cells**:<br>
+_read-only_:  it can be executed, but its input cannot be changed.<br>
+_frozen_: It cannot be either altered or executed.
+
+For **markdown-cells**:<br>
+_read-only_: It's input can be viewed by double-clicking on it, but cannot be changed.<br>
+_frozen_:  Input cannot be viewed by double-clicking.
+
+To change the state of a selected cell, press the corresponding button.
+
+The individual cell's state is stored in its metadata and is applied to the cell if the extension is loaded.
+
+## Internals
+
+The _read-only_ state is stored in the `cell.metadata.editable` attribute. Cells are editable by default.
+The _frozen_ state is stored in the `cell.metadata.run_control.frozen`attribute.

.local/share/jupyter/nbextensions/gist_it/gist_it.yaml

@@ -0,0 +1,18 @@
+Type: IPython Notebook Extension
+Compatibility: 3.x, 4.x, 5.x
+Name: Gist-it
+Main: main.js
+Description: Adds a button to publish the current notebook as a gist. See the readme for description of the authentication options and relevant parameters.
+Link: readme.md
+Icon: icon.png
+Parameters:
+- name: gist_it_personal_access_token
+  description: Github personal access token. To write gists on a user's behalf, you need a token with the <a href="https://developer.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/">gist OAuth scope</a>.
+  input_type: text
+- name: gist_it_default_to_public
+  description: Gists default to public. If using a personal access token, gists will default to private. Set this to have them default to being public instead.
+  input_type: checkbox
+- name: github_endpoint
+  description: Github endpoint. Defaults to 'github.com'. Change this to publish to your enterprise github endpoint.
+  input_type: text
+  default: 'github.com'

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

@@ -0,0 +1,481 @@
+/**
+ *
+// Avoid server side code :
+// https://github.com/ipython/ipython/issues/2780
+ *
+ * This essentially boils down to the following:
+ * Github authentication requires some server-side code for any 'app' which
+ * wants to authenticate over the Github API.
+ * When registering an app with Github, Github provides the app with what they
+ * call a 'client secret'.
+ * The client secret is then incorporated into the app, and the app sends it to
+ * Github as part of the authentication process, thus proving to Github's
+ * servers that the communicating app was written by someone with appropriate
+ * credentials.
+ *
+ * The issue with writing a single Github app for Gist-ing notebooks, is that
+ * it would need to include such a client secret. Since this would be part of
+ * the extension source code, anyone could use the client secret, potentially
+ * gaining the permissions that any given user has granted to the app.
+ *
+ * As a result, we only support:
+ * - anonymous (non-authenticated) API usage
+ * - client-side authentication using a personal access token
+ *   (see https://github.com/settings/tokens)
+ */
+
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/dialog'
+], function (
+    $,
+    Jupyter,
+    dialog
+) {
+    "use strict";
+
+    // define default values for config parameters
+    var params = {
+        gist_it_default_to_public: false,
+        gist_it_personal_access_token: '',
+        github_endpoint: 'github.com'
+    };
+
+    var initialize = function () {
+        update_params();
+        Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register ({
+                help   : 'Create/Edit Gist of Notebook',
+                icon   : 'fa-github',
+                handler: show_gist_editor_modal
+            }, 'create-gist-from-notebook', 'gist_it')
+        ]);
+    };
+
+    // update params with any specified in the server's config file
+    var update_params = function() {
+        var config = Jupyter.notebook.config;
+        for (var key in params) {
+            if (config.data.hasOwnProperty(key))
+                params[key] = config.data[key];
+        }
+        default_metadata.data.public = Boolean(config.data.gist_it_default_to_public);
+    };
+
+    var default_metadata = {
+        id: '',
+        data: {
+            description: Jupyter.notebook.notebook_path,
+            public: false
+        }
+    };
+
+    function ensure_default_metadata () {
+        Jupyter.notebook.metadata.gist = $.extend(
+            true, // deep-copy
+            default_metadata, //defaults
+            Jupyter.notebook.metadata.gist // overrides
+        );
+    }
+
+    var add_auth_token = function add_auth_token (xhr) {
+        var token = '';
+        if (params.gist_it_personal_access_token !== '') {
+            token = params.gist_it_personal_access_token;
+        }
+        if (token !== '') {
+            xhr.setRequestHeader("Authorization", "token " + token);
+        }
+    };
+
+    function build_alert(alert_class) {
+        return $('<div/>')
+            .addClass('alert alert-dismissable')
+            .addClass(alert_class)
+            .append(
+                $('<button class="close" type="button" data-dismiss="alert" aria-label="Close"/>')
+                    .append($('<span aria-hidden="true"/>').html('&times;'))
+            );
+    }
+
+    function gist_error (jqXHR, textStatus, errorThrown) {
+        console.log('github ajax error:', jqXHR, textStatus, errorThrown);
+        var alert = build_alert('alert-danger')
+            .hide()
+            .append(
+                $('<p/>').text('The ajax request to Github went wrong:')
+            )
+            .append(
+                $('<pre/>').text(jqXHR.responseJSON ? JSON.stringify(jqXHR.responseJSON, null, 2) : errorThrown)
+            );
+        $('#gist_modal').find('.modal-body').append(alert);
+        alert.slideDown('fast');
+    }
+
+    function gist_success (response, textStatus, jqXHR) {
+        // if (Jupyter.notebook.metadata.gist.id === response.id) return;
+
+        Jupyter.notebook.metadata.gist.id = response.id;
+        Jupyter.notebook.metadata._draft = $.extend(
+            true, // deep copy
+            Jupyter.notebook.metadata._draft, // defaults
+            {nbviewer_url: response.html_url} // overrides
+        );
+
+        var d = new Date();
+        var msg_head = d.toLocaleString() + ': Gist ';
+        var msg_tail = response.history.length === 1 ? ' published' : ' updated to revision ' + response.history.length;
+        var alert = build_alert('alert-success')
+            .hide()
+            .append(msg_head)
+            .append(
+                $('<a/>')
+                    .attr('href', response.html_url)
+                    .attr('target', '_blank')
+                    .text(response.id)
+            )
+            .append(msg_tail);
+        $('#gist_modal').find('.modal-body').append(alert);
+        alert.slideDown('fast');
+    }
+
+    function get_github_endpoint() {
+        return params.github_endpoint !== '' ? params.github_endpoint : 'github.com';
+    }
+
+    function get_api_endpoint() {
+        const github_endpoint = get_github_endpoint();
+        if (github_endpoint === 'github.com') {
+            return 'https://api.'+ github_endpoint;
+        } else {
+            // Github Enterprise
+            // https://developer.github.com/enterprise/2.18/v3/enterprise-admin/#endpoint-urls
+            return 'https://' + github_endpoint + '/api/v3'
+        }
+    }
+
+    function gist_id_updated_callback(gist_editor) {
+        if (gist_editor === undefined) gist_editor = $('#gist_editor');
+
+        var id_input = gist_editor.find('#gist_id');
+        var id = id_input.val();
+
+        var help_block  = gist_editor.find('#gist_id ~ .help-block');
+        var help_block_base_text = 'Set the gist id to update an existing gist, ' +
+            'or leave blank to create a new one.';
+
+        var gist_it_button = $('#gist_modal').find('.btn-primary');
+
+        id_input.parent()
+            .removeClass('has-success has-error has-warning')
+            .find('#gist_id ~ .form-control-feedback > i.fa')
+            .removeClass('fa-pencil-square fa-exclamation-circle fa-question-circle');
+
+        if (id === '') {
+            $('#gist_id ~ .form-control-feedback > i.fa')
+                .addClass('fa-plus-circle');
+            help_block.html(
+                '<p>' + help_block_base_text + '</p>' +
+                '<p><i class="fa fa-plus-circle"></i> a new gist will be created</p>'
+            );
+            gist_it_button.prop('disabled', false);
+        }
+        else {
+            $('#gist_id ~ .form-control-feedback > i.fa')
+                .addClass('fa-circle-o-notch fa-spin');
+            // List commits as a way of checking whether the gist exists.
+            // Listing commits appears to give the most concise response.
+
+            $.ajax({
+                url: get_api_endpoint() +'/gists/' + id + '/commits',
+                dataType: 'json',
+                beforeSend: add_auth_token,
+                error: function(jqXHR, textStatus, errorThrown) {
+                    jqXHR.errorThrown = errorThrown;
+                },
+                complete: function(jqXHR, textStatus) {
+                    var success = textStatus === 'success';
+                    var error = !success && jqXHR.status === 404 && jqXHR.responseJSON !== undefined;
+                    var warning = !success && !error;
+
+                    var help_block_html = '<p>' + help_block_base_text + '</p>';
+
+                    gist_it_button.prop('disabled', error);
+                    if (success) {
+                        var single = (jqXHR.responseJSON.length === 1);
+                        help_block_html += '<p>' +
+                            '<i class="fa fa-pencil-square"></i>' +
+                            ' gist ' +
+                            '<a href="https://'+ get_github_endpoint() + '/gist/' + id +
+                            '" target="_blank">' + id + '</a> will be updated' +
+                            ' (' + jqXHR.responseJSON.length +
+                            ' revision' + (single ? '' : 's') +
+                            ' exist' + (single ? 's' : '') + ' so far)' +
+                            '</p>';
+                    }
+                    else if (error) {
+                        help_block_html += '<p>' +
+                            '<i class="fa fa-exclamation-circle"></i>' +
+                            ' no gist exists with the specified id (given current access token)'+
+                            '</p>';
+                    }
+                    else {
+                        help_block_html += '<p>' +
+                            '<i class="fa fa-question-circle"></i>' +
+                            ' can\'t list commits for the specified gist id - you may have problems updating it!' +
+                            '</p>';
+                        help_block_html += '<p>The ajax request to Github went wrong:<p/>' +
+                            '<pre>';
+                        if (jqXHR.responseJSON) {
+                            help_block_html += JSON.stringify(jqXHR.responseJSON, null, 2);
+                        }
+                        else {
+                            help_block_html += jqXHR.errorThrown || textStatus;
+                        }
+                        help_block_html += '</pre>';
+                        console.log('non-404 github ajax error:', jqXHR, textStatus);
+                    }
+                    help_block.html(help_block_html);
+
+                    id_input.parent()
+                        .toggleClass('has-success', success)
+                        .toggleClass('has-error', error)
+                        .toggleClass('has-warning', warning)
+                        .find('#gist_id ~ .form-control-feedback > i.fa')
+                        .removeClass('fa-circle-o-notch fa-spin')
+                        .toggleClass('fa-pencil-square', success)
+                        .toggleClass('fa-exclamation-circle', error)
+                        .toggleClass('fa-question-circle', warning);
+                }
+            });
+        }
+    }
+
+    function update_gist_editor (gist_editor) {
+        if (gist_editor === undefined) gist_editor = $('#gist_editor');
+
+        var id_input = gist_editor.find('#gist_id');
+
+        var have_auth = params.gist_it_personal_access_token !== '';
+        var id = '';
+        var is_public = true;
+        if (have_auth) {
+            id = Jupyter.notebook.metadata.gist.id;
+            is_public = Jupyter.notebook.metadata.gist.data.public;
+            id_input.val(id);
+        }
+        id_input.closest('.form-group').toggle(have_auth);
+
+        gist_editor.find('#gist_public')
+            .prop('checked', is_public)
+            .prop('readonly', !have_auth);
+
+        gist_editor.find('#gist_description')
+            .val(Jupyter.notebook.metadata.gist.data.description);
+
+        if (have_auth) {
+            gist_id_updated_callback(gist_editor);
+        }
+    }
+
+    function build_gist_editor () {
+        ensure_default_metadata();
+
+        var gist_editor = $('#gist_editor');
+
+        if (gist_editor.length > 0) return gist_editor;
+
+        gist_editor = $('<div/>').attr('id', 'gist_editor').append(controls);
+
+        var id = params.gist_it_personal_access_token !== '' ? Jupyter.notebook.metadata.gist.id : '';
+        var controls = $('<form/>')
+            .appendTo(gist_editor)
+            .addClass('form-horizontal');
+
+        $('<div/>')
+            .addClass('has-feedback')
+            .hide()
+            .appendTo(controls)
+            .append(
+                $('<label/>')
+                    .attr('for', 'gist_id')
+                    .text('Gist id')
+            )
+            .append(
+                $('<input/>')
+                    .addClass('form-control')
+                    .attr('id', 'gist_id')
+                    .val(Jupyter.notebook.metadata.gist.id)
+            )
+            .append(
+                $('<span/>')
+                    .addClass('form-control-feedback')
+                    .append(
+                        $('<i/>')
+                            .addClass('fa fa-lg')
+                    )
+            )
+            .append(
+                $('<span/>')
+                    .addClass('help-block')
+            );
+        $('<div/>')
+            .appendTo(controls)
+            .append(
+                $('<div/>')
+                    .addClass('checkbox')
+                    .append(
+                        $('<label>')
+                            .text('Make the gist public')
+                            .prepend(
+                                $('<input/>')
+                                    .attr('type', 'checkbox')
+                                    .attr('id', 'gist_public')
+                                    .prop('checked', Jupyter.notebook.metadata.gist.data.public)
+                                    .prop('readonly', id === '')
+                            )
+                    )
+            )
+            .append(
+                $('<label/>')
+                    .attr('for', 'gist_public')
+                    .text('public')
+            );
+        $('<div/>')
+            .appendTo(controls)
+            .append(
+                $('<label/>')
+                    .attr('for', 'gist_description')
+                    .text('description')
+            )
+            .append(
+                $('<input/>')
+                    .addClass('form-control')
+                    .attr('id', 'gist_description')
+                    .attr('type', 'textarea')
+                    .val(Jupyter.notebook.metadata.gist.data.description)
+            );
+
+        var form_groups = controls.children('div').addClass('form-group');
+        form_groups
+            .children('label')
+                .addClass('col-sm-2 control-label')
+                .css('padding-right', '1em');
+        form_groups
+            .each(function (index, elem) {
+                $('<div/>')
+                    .appendTo(elem)
+                    .addClass('col-sm-10')
+                    .append($(elem).children(':not(label)'));
+            });
+
+        update_gist_editor(gist_editor);
+
+        // bind events for id changing
+        var id_input = gist_editor.find('#gist_id');
+        // Save current value of element
+        id_input.data('oldVal', id_input.val());
+        // Look for changes in the value
+        id_input.bind("change click keyup input paste", function(event) {
+            // If value has changed...
+            if (id_input.data('oldVal') !== id_input.val()) {
+                // Updated stored value
+                id_input.data('oldVal', id_input.val());
+                // Do action
+                gist_id_updated_callback(gist_editor);
+            }
+        });
+
+        return gist_editor;
+    }
+
+    function show_gist_editor_modal () {
+        var modal;
+        modal = dialog.modal({
+            show: false,
+            title: 'Share on Github',
+            notebook: Jupyter.notebook,
+            keyboard_manager: Jupyter.notebook.keyboard_manager,
+            body: build_gist_editor(),
+            buttons: {
+                ' Gist it!': {
+                    class : 'btn-primary',
+                    click: function() {
+                        modal.find('.btn').prop('disabled', true);
+                        var new_data = {
+                            public: $('#gist_public').prop('checked'),
+                            description: $('#gist_description').val()
+                        };
+                        $.extend(
+                            true,
+                            Jupyter.notebook.metadata.gist.data,
+                            new_data
+                        );
+                        // prevent the modal from closing. See github.com/twbs/bootstrap/issues/1202
+                        modal.data('bs.modal').isShown = false;
+                        var spinner = modal.find('.btn-primary .fa-github').addClass('fa-spin');
+                        make_gist(function (jqXHR, textStatus) {
+                            modal.find('.btn').prop('disabled', false);
+                            // allow the modal to close again. See github.com/twbs/bootstrap/issues/1202
+                            modal.data('bs.modal').isShown = true;
+                            spinner.removeClass('fa-spin');
+                        });
+                    }
+                },
+                done: {}
+            }
+        })
+        .attr('id', 'gist_modal')
+        .on('shown.bs.modal', function (evt) {
+            var err = modal.find('#gist_id').parent().hasClass('has-error');
+            modal.find('.btn-primary').prop('disabled', err);
+        });
+
+        modal.find('.btn-primary').prepend(
+            $('<i/>')
+                .addClass('fa fa-lg fa-github')
+        );
+
+        modal.modal('show');
+    }
+
+    var make_gist = function make_gist (complete_callback) {
+        ensure_default_metadata();
+
+        var data = $.extend(
+            true, // deep-copy
+            { files: {} }, // defaults
+            Jupyter.notebook.metadata.gist.data // overrides
+        );
+        var filename = Jupyter.notebook.notebook_name;
+        data.files[filename] = {
+            content: JSON.stringify(Jupyter.notebook.toJSON(), null, 2)
+        };
+
+        var id_input = $('#gist_id');
+        var id = params.gist_it_personal_access_token !== '' ? id_input.val() : '';
+        var method = id ? 'PATCH' : 'POST';
+
+        // Create/edit the Gist
+        $.ajax({
+            url: get_api_endpoint() +'/gists' + (id ? '/' + id : ''),
+            type: method,
+            dataType: 'json',
+            data: JSON.stringify(data),
+            beforeSend: add_auth_token,
+            success: gist_success,
+            error: gist_error,
+            complete: complete_callback
+        });
+    };
+
+    function load_jupyter_extension () {
+        return Jupyter.notebook.config.loaded.then(initialize);
+    }
+
+    return {
+        load_jupyter_extension: load_jupyter_extension,
+        load_ipython_extension: load_jupyter_extension
+    };
+});

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

@@ -0,0 +1,22 @@
+Go to Running Cell
+==================
+
+This is an extension allows you to jump to the current running cell. You can also activate this functionality automatically, i.e., your view is always scolling to the current cell.
+
+Button: A button with eye icon that you can go to the first running cell.  
+![button](anchor.png)
+
+Keyboard shortcuts:  
+-------------------
+__*Alt-I*__ (Jump to first running cell)  
+__*Meta-[*__ (Follow executing cell On)  
+__*Meta-]*__(Follow executing cell Off)  
+
+Demo
+----
+### Jump to first running cell
+![button](jump_to_cell.gif)
+
+### Follow executing cell
+
+![button](auto_focus.gif)

.local/share/jupyter/nbextensions/go_to_current_running_cell/go_to_current_running_cell.yaml

@@ -0,0 +1,26 @@
+Type: Jupyter Notebook Extension
+Name: Go to Current Running Cells
+Description: Go to Running cell and always scroll into current running cell view
+Link: README.md
+Main: main.js
+Compatibility: 4.x, 5.x
+
+Parameters:
+- name: is_follow_cell
+  description: Activate follow executing cells, default behavior is false.
+  input_type: checkbox
+- name: go_to_running_cell_shortcut
+  description: Go to first running cell
+  input_type: input
+  default: Alt-I
+- name: follow_cell_on_shortcut
+  description: Enable following running cell
+  input_type: input
+  default: Alt-;
+- name: follow_cell_off_shortcut
+  description: Disable following running cell
+  input_type: input
+  default: Alt-'
+- name: button_icon
+  description: Button for go to first running cell
+  default: fa-anchor