├── .gitignore ├── thumbnail.png ├── screenshot1.png ├── screenshot2.png ├── screenshot3.png ├── snippets_submenu_python.js ├── snippets_submenus_python ├── h5py.js ├── numba.js ├── sympy_assumptions.js ├── numpy_polynomial.js ├── pandas.js ├── astropy.js ├── matplotlib.js ├── python.js ├── python_regex.js ├── sympy_functions.js ├── numpy.js └── scipy.js ├── LICENSE ├── snippets_menu.css ├── snippets_submenu_markdown.js ├── config.yaml ├── examples_for_custom.js ├── main.js └── readme.md /.gitignore: -------------------------------------------------------------------------------- 1 | Test*.ipynb -------------------------------------------------------------------------------- /thumbnail.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moble/jupyter_boilerplate/HEAD/thumbnail.png -------------------------------------------------------------------------------- /screenshot1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moble/jupyter_boilerplate/HEAD/screenshot1.png -------------------------------------------------------------------------------- /screenshot2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moble/jupyter_boilerplate/HEAD/screenshot2.png -------------------------------------------------------------------------------- /screenshot3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moble/jupyter_boilerplate/HEAD/screenshot3.png -------------------------------------------------------------------------------- /snippets_submenu_python.js: -------------------------------------------------------------------------------- 1 | define([ 2 | "require", 3 | "./snippets_submenus_python/numpy", 4 | "./snippets_submenus_python/scipy", 5 | "./snippets_submenus_python/matplotlib", 6 | "./snippets_submenus_python/sympy", 7 | "./snippets_submenus_python/pandas", 8 | "./snippets_submenus_python/astropy", 9 | "./snippets_submenus_python/h5py", 10 | "./snippets_submenus_python/numba", 11 | "./snippets_submenus_python/python", 12 | ], function (require, numpy, scipy, matplotlib, sympy, pandas, astropy, h5py, numba, python) { 13 | return { 14 | numpy:numpy, 15 | scipy:scipy, 16 | matplotlib:matplotlib, 17 | sympy:sympy, 18 | pandas:pandas, 19 | astropy:astropy, 20 | h5py:h5py, 21 | numba:numba, 22 | python:python, 23 | }; 24 | }); 25 | -------------------------------------------------------------------------------- /snippets_submenus_python/h5py.js: -------------------------------------------------------------------------------- 1 | define({ 2 | 'name' : 'h5py', 3 | 'sub-menu' : [ 4 | { 5 | 'name' : 'Setup', 6 | 'snippet' : [ 7 | 'from __future__ import print_function, division', 8 | 'import h5py', 9 | ], 10 | }, 11 | { 12 | 'name' : 'Documentation', 13 | 'external-link' : 'http://docs.h5py.org/en/latest/', 14 | }, 15 | '---', 16 | { 17 | 'name' : 'Open a file', 18 | 'snippet' : ['bp_f = h5py.File("path/to/file.h5")',], 19 | }, 20 | 21 | { 22 | 'name' : 'Close a file', 23 | 'snippet' : ['bp_f.close()',], 24 | }, 25 | 26 | { 27 | 'name' : 'Get array', 28 | 'snippet' : ['bp_array = bp_f["bp_array_item"][:]',], 29 | }, 30 | 31 | { 32 | 'name' : 'Get scalar', 33 | 'snippet' : ['bp_scalar = bp_f["bp_scalar_item"][()]',], 34 | }, 35 | ], 36 | }); 37 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Mike Boyle 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /snippets_submenus_python/numba.js: -------------------------------------------------------------------------------- 1 | define({ 2 | 'name' : 'numba', 3 | 'sub-menu' : [ 4 | { 5 | 'name' : 'Setup', 6 | 'snippet' : [ 7 | 'from __future__ import print_function, division', 8 | 'import sys', 9 | 'if sys.version_info[0] >= 3:', 10 | ' xrange = range # Must always iterate with xrange in njit functions', 11 | 'import numba', 12 | ], 13 | }, 14 | { 15 | 'name' : 'Documentation', 16 | 'external-link' : 'http://numba.pydata.org/numba-doc/dev/index.html', 17 | }, 18 | '---', 19 | { 20 | 'name' : 'Jit function', 21 | 'snippet' : [ 22 | '@numba.njit', 23 | 'def bp_func(x):', 24 | ' r"""Some function', 25 | ' ', 26 | ' Does some stuff.', 27 | ' ', 28 | ' """', 29 | ' return x**2', 30 | ], 31 | }, 32 | 33 | { 34 | 'name' : 'Jit function with specified signature', 35 | 'snippet' : [ 36 | '@numba.njit(f8, f8[:])', 37 | 'def bp_func(x, y):', 38 | ' r"""Some function', 39 | ' ', 40 | ' Parameters', 41 | ' ----------', 42 | ' x : float', 43 | ' y : float array', 44 | ' ', 45 | ' """', 46 | ' for j in xrange(y.size):', 47 | ' y[j] *= x', 48 | ], 49 | }, 50 | ], 51 | }); 52 | -------------------------------------------------------------------------------- /snippets_menu.css: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | The left-side dropdown submenu is adapted from the usual right-side code at 4 | 5 | 6 | */ 7 | .dropdown-submenu-left > .dropdown-menu { 8 | left: auto; 9 | right: 100%; 10 | } 11 | 12 | /* For space-saving menus */ 13 | .dropdown-submenu > .dropdown-menu.dropdown-menu-compact { 14 | left: 50%; 15 | top: 100%; 16 | } 17 | .dropdown-submenu-left > .dropdown-menu.dropdown-menu-compact { 18 | left: auto; 19 | right: 50%; 20 | } 21 | 22 | .dropdown-submenu-left > a:after { 23 | visibility: hidden; 24 | } 25 | .dropdown-submenu-left > a:before { 26 | display: inline-block; 27 | font: normal normal normal 14px/1 FontAwesome; 28 | font-size: inherit; 29 | text-rendering: auto; 30 | -webkit-font-smoothing: antialiased; 31 | -moz-osx-font-smoothing: grayscale; 32 | transform: translate(0, 0); 33 | display: block; 34 | content: "\f0d9"; 35 | float: left; 36 | color: #333333; 37 | margin-top: 2px; 38 | margin-left: -10px; 39 | } 40 | 41 | 42 | /* 43 | 44 | The following allows for control of the "tooltip" that shows the code to be 45 | inserted when the item is clicked. Without this, the tooltip might wrap the 46 | code, making it hard to read; will cut off some of the code; won't be 47 | monospaced; etc. Note that these CSS selectors select any element with 48 | an attribute `data-snippet-code`. This attribute is necessary and sufficient 49 | for us to add the pop-up. 50 | 51 | */ 52 | a[data-snippet-code]:after { 53 | content: attr(data-snippet-code); /* Read from the data-snippet-code attribute */ 54 | font-family: monospace; 55 | font-size: 75%; 56 | position: absolute; 57 | width: auto; 58 | display: table; 59 | left: 50%; 60 | white-space: pre; 61 | z-index: 10000; 62 | background: #E8E8E8; 63 | padding: 4px; 64 | border-color : #AAA; 65 | border-style: solid; 66 | border-width: 1px; 67 | visibility: hidden; 68 | } 69 | a[data-snippet-code]:hover:after { 70 | visibility: visible; 71 | transition: all 0s ease 1s; 72 | } 73 | -------------------------------------------------------------------------------- /snippets_submenus_python/sympy_assumptions.js: -------------------------------------------------------------------------------- 1 | define({ 2 | 'name' : 'List of assumptions', 3 | 'sub-menu' : [ 4 | { 5 | 'name' : 'Bounded', 6 | 'snippet' : ['Q.bounded(x)',], 7 | }, 8 | { 9 | 'name' : 'Commutative', 10 | 'snippet' : ['Q.commutative(x)',], 11 | }, 12 | { 13 | 'name' : 'Complex', 14 | 'snippet' : ['Q.complex(x)',], 15 | }, 16 | { 17 | 'name' : 'Imaginary', 18 | 'snippet' : ['Q.imaginary(x)',], 19 | }, 20 | { 21 | 'name' : 'Real', 22 | 'snippet' : ['Q.real(x)',], 23 | }, 24 | { 25 | 'name' : 'Extended real', 26 | 'snippet' : ['Q.extended_real(x)',], 27 | }, 28 | { 29 | 'name' : 'Integer', 30 | 'snippet' : ['Q.integer(x)',], 31 | }, 32 | { 33 | 'name' : 'Odd', 34 | 'snippet' : ['Q.odd(x)',], 35 | }, 36 | { 37 | 'name' : 'Even', 38 | 'snippet' : ['Q.even(x)',], 39 | }, 40 | { 41 | 'name' : 'Prime', 42 | 'snippet' : ['Q.prime(x)',], 43 | }, 44 | { 45 | 'name' : 'Composite', 46 | 'snippet' : ['Q.composite(x)',], 47 | }, 48 | { 49 | 'name' : 'Zero', 50 | 'snippet' : ['Q.zero(x)',], 51 | }, 52 | { 53 | 'name' : 'Nonzero', 54 | 'snippet' : ['Q.nonzero(x)',], 55 | }, 56 | { 57 | 'name' : 'Rational', 58 | 'snippet' : ['Q.rational(x)',], 59 | }, 60 | { 61 | 'name' : 'Algebraic', 62 | 'snippet' : ['Q.algebraic(x)',], 63 | }, 64 | { 65 | 'name' : 'Transcendental', 66 | 'snippet' : ['Q.transcendental(x)',], 67 | }, 68 | { 69 | 'name' : 'Irrational', 70 | 'snippet' : ['Q.irrational(x)',], 71 | }, 72 | { 73 | 'name' : 'Finite', 74 | 'snippet' : ['Q.finite(x)',], 75 | }, 76 | { 77 | 'name' : 'Infinite', 78 | 'snippet' : ['Q.infinite(x)',], 79 | }, 80 | { 81 | 'name' : 'Infinitesimal', 82 | 'snippet' : ['Q.infinitesimal(x)',], 83 | }, 84 | { 85 | 'name' : 'Negative', 86 | 'snippet' : ['Q.negative(x)',], 87 | }, 88 | { 89 | 'name' : 'Nonnegative', 90 | 'snippet' : ['Q.nonnegative(x)',], 91 | }, 92 | { 93 | 'name' : 'Positive', 94 | 'snippet' : ['Q.positive(x)',], 95 | }, 96 | { 97 | 'name' : 'Nonpositive', 98 | 'snippet' : ['Q.nonpositive(x)',], 99 | }, 100 | { 101 | 'name' : 'Hermitian', 102 | 'snippet' : ['Q.hermitian(x)',], 103 | }, 104 | { 105 | 'name' : 'Antihermitian', 106 | 'snippet' : ['Q.antihermitian(x)',], 107 | }, 108 | ], 109 | }); 110 | -------------------------------------------------------------------------------- /snippets_submenu_markdown.js: -------------------------------------------------------------------------------- 1 | define({ 2 | 'name' : 'Markdown', 3 | 'sub-menu' : [ 4 | { 5 | 'name' : 'Documentation', 6 | 'external-link' : 'https://help.github.com/articles/github-flavored-markdown/', 7 | }, 8 | '---', 9 | 10 | { 11 | 'name' : 'Insert itemized list', 12 | 'snippet' : [ 13 | '* One', 14 | ' - Sublist', 15 | ' - This', 16 | ' - Sublist', 17 | ' - That', 18 | ' - The other thing', 19 | '* Two', 20 | ' - Sublist', 21 | '* Three', 22 | ' - Sublist', 23 | ], 24 | }, 25 | 26 | { 27 | 'name' : 'Insert enumerated list', 28 | 'snippet' : [ 29 | '1. Here we go', 30 | ' 1. Sublist', 31 | ' 2. Sublist', 32 | '2. There we go', 33 | '3. Now this', 34 | ], 35 | }, 36 | 37 | { 38 | 'name' : 'Insert table', 39 | 'snippet' : [ 40 | '', 41 | ' ', 42 | ' ', 43 | ' ', 44 | ' ', 45 | ' ', 46 | ' ', 47 | ' ', 48 | ' ', 49 | ' ', 50 | ' ', 51 | ' ', 52 | ' ', 53 | '
Header 1Header 2
row 1, cell 1row 1, cell 2
row 2, cell 1row 2, cell 2
', 54 | ], 55 | }, 56 | 57 | { 58 | 'name' : 'Insert local image', 59 | 'snippet' : [ 60 | '', 61 | ], 62 | }, 63 | 64 | { 65 | 'name' : 'Insert local video', 66 | 'snippet' : [ 67 | '
  • '); 169 | 170 | if (typeof menu_item_spec == 'string') { 171 | if (menu_item_spec != '---') { 172 | console.log(mod_log_prefix, 173 | 'Don\'t understand sub-menu string "' + menu_item_spec + '"'); 174 | return null; 175 | } 176 | return element.addClass('divider'); 177 | } 178 | 179 | var a = $('') 180 | .attr('href', '#') 181 | .html(menu_item_spec.name) 182 | .appendTo(element); 183 | if (menu_item_spec.hasOwnProperty('snippet')) { 184 | var snippet = menu_item_spec.snippet; 185 | if (typeof snippet == 'string' || snippet instanceof String) { 186 | snippet = [snippet]; 187 | } 188 | a.attr({ 189 | 'title' : "", // Do not remove this, even though it's empty! 190 | 'data-snippet-code' : snippet.join('\n'), 191 | }) 192 | .on('click', callback_insert_snippet) 193 | .addClass('snippet'); 194 | } 195 | else if (menu_item_spec.hasOwnProperty('internal-link')) { 196 | a.attr('href', menu_item_spec['internal-link']); 197 | } 198 | else if (menu_item_spec.hasOwnProperty('external-link')) { 199 | a.empty(); 200 | a.attr({ 201 | 'target' : '_blank', 202 | 'title' : 'Opens in a new window', 203 | 'href' : menu_item_spec['external-link'], 204 | }); 205 | $('').appendTo(a); 206 | $('').html(menu_item_spec.name).appendTo(a); 207 | } 208 | 209 | if (menu_item_spec.hasOwnProperty('sub-menu')) { 210 | element 211 | .addClass('dropdown-submenu') 212 | .toggleClass('dropdown-submenu-left', direction === 'left'); 213 | var sub_element = $('
      ') 214 | .toggleClass('dropdown-menu-compact', menu_item_spec.overlay === true) // For space-saving menus 215 | .appendTo(element); 216 | 217 | var new_direction = (menu_item_spec['sub-menu-direction'] === 'left') ? 'left' : 'right'; 218 | for (var j=0; j', { 263 | rel: 'stylesheet', 264 | type:'text/css', 265 | href: require.toUrl('./snippets_menu.css') 266 | }).appendTo('head'); 267 | 268 | // Arrange the menus as given by the configuration 269 | Jupyter.notebook.config.loaded.then( 270 | config_loaded_callback 271 | ).then(function () { 272 | // Parse and insert the menu items 273 | menu_setup(options.menus, options.sibling, cfg.insert_before_sibling); 274 | }); 275 | } 276 | 277 | return { 278 | // Handy functions 279 | load_ipython_extension : load_ipython_extension, 280 | menu_setup : menu_setup, 281 | 282 | // Default menus 283 | python : python, 284 | python_menus : python_menus, 285 | markdown : markdown, 286 | default_menus : default_menus, 287 | 288 | // Items that could be useful for customization 289 | options : options, 290 | }; 291 | 292 | }); 293 | -------------------------------------------------------------------------------- /snippets_submenus_python/python_regex.js: -------------------------------------------------------------------------------- 1 | define({ 2 | 'name' : 'Regular expressions', 3 | 'sub-menu' : [ 4 | { 5 | 'name' : 'Setup', 6 | 'snippet' : [ 7 | 'import re', 8 | ], 9 | }, 10 | '---', 11 | { 12 | 'name' : 'Basic search for pattern anywhere in string', 13 | 'snippet' : [ 14 | 'string = " abc def "', 15 | 'pattern = re.compile(r"[a-z]+")', 16 | 'result = re.search(pattern, string)', 17 | 'if result is not None:', 18 | ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))', 19 | ], 20 | }, 21 | { 22 | 'name' : 'Basic search (match) for exact pattern at beginning of string', 23 | 'snippet' : [ 24 | 'string = " abc def "', 25 | 'pattern = re.compile(r".*[a-z]+")', 26 | 'result = re.match(pattern, string)', 27 | 'if result is not None:', 28 | ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))', 29 | ], 30 | }, 31 | { 32 | 'name' : 'Basic substitution', 33 | 'snippet' : [ 34 | 'string = " abc def "', 35 | 'pattern = re.compile(r"[a-z]+")', 36 | 'new_string = re.sub(pattern, "something", string)', 37 | 'print("New string is \'{0}\'".format(new_string))', 38 | ], 39 | }, 40 | { 41 | 'name' : 'Substitution with backreferences', 42 | 'snippet' : [ 43 | 'string = "John Doe lives at 221B Baker Street."', 44 | 'pattern = re.compile(r"""', 45 | ' ([a-zA-Z ]+) # Save as many letters and spaces as possible to group 1', 46 | ' \\ lives\\ at\\ # Match " lives at "', 47 | ' (?P
      .*) # Save everything in between as a group named `address`', 48 | ' \\. # Match the period at the end', 49 | '""", re.VERBOSE)', 50 | 'new_string = re.sub(pattern, r"\\g
      is occupied by \\1.", string)', 51 | 'print("New string is \'{0}\'".format(new_string))', 52 | ], 53 | }, 54 | '---', 55 | { 56 | 'name' : 'Escaped special characters', 57 | 'sub-menu' : [ 58 | { 59 | 'name' : '.', 60 | 'snippet' : ['\\.',], 61 | }, 62 | { 63 | 'name' : '^', 64 | 'snippet' : ['\\^',], 65 | }, 66 | { 67 | 'name' : '$', 68 | 'snippet' : ['\\$',], 69 | }, 70 | { 71 | 'name' : '*', 72 | 'snippet' : ['\\*',], 73 | }, 74 | { 75 | 'name' : '+', 76 | 'snippet' : ['\\+',], 77 | }, 78 | { 79 | 'name' : '?', 80 | 'snippet' : ['\\?',], 81 | }, 82 | { 83 | 'name' : '{', 84 | 'snippet' : ['\\{',], 85 | }, 86 | { 87 | 'name' : '}', 88 | 'snippet' : ['\\}',], 89 | }, 90 | { 91 | 'name' : '[', 92 | 'snippet' : ['\\[',], 93 | }, 94 | { 95 | 'name' : ']', 96 | 'snippet' : ['\\]',], 97 | }, 98 | { 99 | 'name' : '\\', 100 | 'snippet' : ['\\\\',], 101 | }, 102 | { 103 | 'name' : '|', 104 | 'snippet' : ['\\|',], 105 | }, 106 | { 107 | 'name' : '(', 108 | 'snippet' : ['\\(',], 109 | }, 110 | { 111 | 'name' : ')', 112 | 'snippet' : ['\\)',], 113 | }, 114 | ], 115 | }, 116 | 117 | { 118 | 'name' : 'Character classes and alternatives', 119 | 'sub-menu' : [ 120 | { 121 | 'name' : 'Standard character-class abbreviations', 122 | 'sub-menu' : [ 123 | { 124 | 'name' : 'Any decimal digit', 125 | 'snippet' : ['\\d',], 126 | }, 127 | { 128 | 'name' : 'Any non-digit character', 129 | 'snippet' : ['\\D',], 130 | }, 131 | { 132 | 'name' : 'Any whitespace character', 133 | 'snippet' : ['\\s',], 134 | }, 135 | { 136 | 'name' : 'Any non-whitespace character', 137 | 'snippet' : ['\\S',], 138 | }, 139 | { 140 | 'name' : 'Any alphanumeric character', 141 | 'snippet' : ['\\w',], 142 | }, 143 | { 144 | 'name' : 'Any non-alphanumeric character', 145 | 'snippet' : ['\\W',], 146 | }, 147 | ], 148 | }, 149 | { 150 | 'name' : 'Inclusive character classes', 151 | 'snippet' : [ 152 | '[a-zA-Z0-9 \\t\\n\\r\\f\\v]', 153 | ], 154 | }, 155 | { 156 | 'name' : 'Exclusive character classes', 157 | 'snippet' : [ 158 | '[^a-zA-Z0-9]', 159 | ], 160 | }, 161 | { 162 | 'name' : 'Alternatives', 163 | 'snippet' : [ 164 | '(?:abc|def)', 165 | ], 166 | }, 167 | 168 | ], 169 | }, 170 | 171 | { 172 | 'name' : 'Repetition', 173 | 'sub-menu' : [ 174 | { 175 | 'name' : 'Match 0 or more repetitions of the preceding, greedily', 176 | 'snippet' : ['*',], 177 | }, 178 | { 179 | 'name' : 'Match 1 or more repetitions of the preceding, greedily', 180 | 'snippet' : ['+',], 181 | }, 182 | { 183 | 'name' : 'Match 0 or 1 repetitions of the preceding, greedily', 184 | 'snippet' : ['?',], 185 | }, 186 | '---', 187 | { 188 | 'name' : 'Match 0 or more repetitions of the preceding, non-greedily', 189 | 'snippet' : ['*?',], 190 | }, 191 | { 192 | 'name' : 'Match 1 or more repetitions of the preceding, non-greedily', 193 | 'snippet' : ['+?',], 194 | }, 195 | { 196 | 'name' : 'Match 0 or 1 repetitions of the preceding, non-greedily', 197 | 'snippet' : ['??',], 198 | }, 199 | '---', 200 | { 201 | 'name' : 'Match exactly n repeititions of the preceding', 202 | 'snippet' : ['{3}',], 203 | }, 204 | { 205 | 'name' : 'Match between m and n repetions of the preceding, greedily', 206 | 'snippet' : ['{3,5}',], 207 | }, 208 | { 209 | 'name' : 'Match between m and n repetions of the preceding, non-greedily', 210 | 'snippet' : ['{3,5}?',], 211 | }, 212 | ], 213 | }, 214 | 215 | // { 216 | // 'name' : '', 217 | // 'sub-menu' : [ 218 | 219 | // ], 220 | // }, 221 | 222 | // { 223 | // 'name' : '', 224 | // 'sub-menu' : [ 225 | 226 | // ], 227 | // }, 228 | 229 | { 230 | 'name' : 'Lookahead/behind', 231 | 'sub-menu' : [ 232 | { 233 | 'name' : 'Positive lookahead', 234 | 'snippet' : [ 235 | 'string = "Isaac Asimov"', 236 | 'pattern = re.compile(r"Isaac(?= Asimov)") # Only match "Isaac Asimov", but drop the " Asimov"', 237 | 'result = re.match(pattern, string)', 238 | 'if result is not None:', 239 | ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))', 240 | ], 241 | }, 242 | { 243 | 'name' : 'Negative lookahead', 244 | 'snippet' : [ 245 | 'string = "Isaac Newton"', 246 | 'pattern = re.compile(r"Isaac(?! Asimov)") # Match any Isaac except Asimov, and only keep the "Isaac"', 247 | 'result = re.match(pattern, string)', 248 | 'if result is not None:', 249 | ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))', 250 | ], 251 | }, 252 | { 253 | 'name' : 'Positive lookbehind', 254 | 'snippet' : [ 255 | 'string = "Janet Asimov"', 256 | 'pattern = re.compile(r"(?<=Janet )Asimov") # Only match "Janet Asimov", but drop the "Janet "', 257 | 'result = re.search(pattern, string)', 258 | 'if result is not None:', 259 | ' print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))', 260 | ], 261 | }, 262 | { 263 | 'name' : 'Negative lookbehind', 264 | 'snippet' : [ 265 | 'string = "Janet Asimov"', 266 | 'pattern = re.compile(r"(? for a full list 3 | 'name' : 'Functions', 4 | 'sub-menu' : [ 5 | { 6 | 'name' : 'Elementary functions', 7 | 'sub-menu' : [ 8 | { 9 | 'name' : 'Abs', 10 | 'snippet' : ['Abs(-1)',], 11 | }, 12 | { 13 | 'name' : 'acos', 14 | 'snippet' : ['acos(S(1)/2)',], 15 | }, 16 | { 17 | 'name' : 'acosh', 18 | 'snippet' : ['acosh(S(1)/2)',], 19 | }, 20 | { 21 | 'name' : 'acot', 22 | 'snippet' : ['acot(1)',], 23 | }, 24 | { 25 | 'name' : 'acoth', 26 | 'snippet' : ['acoth(I)',], 27 | }, 28 | { 29 | 'name' : 'arg', 30 | 'snippet' : ['arg(exp(pi*I))',], 31 | }, 32 | { 33 | 'name' : 'asin', 34 | 'snippet' : ['asin(S(1)/2)',], 35 | }, 36 | { 37 | 'name' : 'asinh', 38 | 'snippet' : ['asinh(I)',], 39 | }, 40 | { 41 | 'name' : 'atan', 42 | 'snippet' : ['atan(1)',], 43 | }, 44 | { 45 | 'name' : 'atan2', 46 | 'snippet' : ['atan2(1,sqrt(3))',], 47 | }, 48 | { 49 | 'name' : 'atanh', 50 | 'snippet' : ['atanh(I)',], 51 | }, 52 | { 53 | 'name' : 'ceiling', 54 | 'snippet' : ['ceiling(S(3)/2)',], 55 | }, 56 | { 57 | 'name' : 'conjugate', 58 | 'snippet' : ['conjugate(1+I)',], 59 | }, 60 | { 61 | 'name' : 'cos', 62 | 'snippet' : ['cos(2*pi/3)',], 63 | }, 64 | { 65 | 'name' : 'cosh', 66 | 'snippet' : ['cosh(pi*I/3)',], 67 | }, 68 | { 69 | 'name' : 'cot', 70 | 'snippet' : ['cot(pi/4)',], 71 | }, 72 | { 73 | 'name' : 'coth', 74 | 'snippet' : ['coth(pi*I/4)',], 75 | }, 76 | { 77 | 'name' : 'exp', 78 | 'snippet' : ['exp(1+I)',], 79 | }, 80 | { 81 | 'name' : 'floor', 82 | 'snippet' : ['floor(S(3)/2)',], 83 | }, 84 | { 85 | 'name' : 'Identity function', 86 | 'snippet' : ['Id(x)',], 87 | }, 88 | { 89 | 'name' : 'im', 90 | 'snippet' : ['im(2+3*I)',], 91 | }, 92 | { 93 | 'name' : 'Lambert W (a.k.a. product logarithm)', 94 | 'snippet' : ['LambertW(x, n)',], 95 | }, 96 | { 97 | 'name' : 'log', 98 | 'snippet' : ['log(x)',], 99 | }, 100 | { 101 | 'name' : 'Min', 102 | 'snippet' : [ 103 | 'p = Symbol("p", negative=True)', 104 | 'q = Symbol("q", positive=True)', 105 | 'Min(p, q)', 106 | ], 107 | }, 108 | { 109 | 'name' : 'Max', 110 | 'snippet' : [ 111 | 'p = Symbol("p", negative=True)', 112 | 'q = Symbol("q", positive=True)', 113 | 'Max(p, q)', 114 | ], 115 | }, 116 | { 117 | 'name' : 'Piecewise', 118 | 'snippet' : ['Piecewise((0, x<1), (x**2, x>=5), (log(x), True))',], 119 | }, 120 | { 121 | 'name' : 'Product logarithm', 122 | 'snippet' : ['LambertW(x)',], 123 | }, 124 | { 125 | 'name' : 're', 126 | 'snippet' : ['re(2+I)',], 127 | }, 128 | { 129 | 'name' : 'root', 130 | 'snippet' : ['root(-8, 3)',], 131 | }, 132 | { 133 | 'name' : 'sin', 134 | 'snippet' : ['sin(pi/4)',], 135 | }, 136 | { 137 | 'name' : 'sinh', 138 | 'snippet' : ['sinh(pi*I/2)',], 139 | }, 140 | { 141 | 'name' : 'sqrt', 142 | 'snippet' : ['sqrt(4)',], 143 | }, 144 | { 145 | 'name' : 'sign', 146 | 'snippet' : ['sign(-3)',], 147 | }, 148 | { 149 | 'name' : 'tan', 150 | 'snippet' : ['tan(pi/4)',], 151 | }, 152 | { 153 | 'name' : 'tanh', 154 | 'snippet' : ['tanh(pi*I/4)',], 155 | }, 156 | ], 157 | }, 158 | { 159 | 'name' : 'Combinatorial functions', 160 | 'sub-menu' : [ 161 | { 162 | 'name' : 'Bell number', 163 | 'snippet' : ['bell(n)',], 164 | }, 165 | { 166 | 'name' : 'Bell polynomial', 167 | 'snippet' : ['bell(n, k)',], 168 | }, 169 | { 170 | 'name' : 'Bell polynomial of the second kind', 171 | 'snippet' : [ 172 | 'n = 6', 173 | 'k = 2', 174 | 'x_j = symbols("x:{0}".format(n-k+1))', 175 | 'bell(n, k, x_j)', 176 | ], 177 | }, 178 | { 179 | 'name' : 'Bernoulli number', 180 | 'snippet' : ['bernoulli(n)',], 181 | }, 182 | { 183 | 'name' : 'Bernoulli polynomial', 184 | 'snippet' : ['bernoulli(n, x)',], 185 | }, 186 | { 187 | 'name' : 'Binomial coefficient (nCk)', 188 | 'snippet' : ['binomial(n, k)',], 189 | }, 190 | { 191 | 'name' : 'Catalan number', 192 | 'snippet' : ['catalan(n)',], 193 | }, 194 | { 195 | 'name' : 'Euler number', 196 | 'snippet' : ['euler(n)',], 197 | }, 198 | { 199 | 'name' : 'Factorial', 200 | 'snippet' : ['factorial(n)',], 201 | }, 202 | { 203 | 'name' : 'Double factorial', 204 | 'snippet' : ['factorial2(n)',], 205 | }, 206 | { 207 | 'name' : 'Falling factorial', 208 | 'snippet' : ['ff(x, k)',], 209 | }, 210 | { 211 | 'name' : 'Fibonacci number', 212 | 'snippet' : ['fibonacci(n)',], 213 | }, 214 | { 215 | 'name' : 'Fibonacci polynomial', 216 | 'snippet' : ['fibonacci(n, x)',], 217 | }, 218 | { 219 | 'name' : 'Harmonic number', 220 | 'snippet' : ['harmonic(n)',], 221 | }, 222 | { 223 | 'name' : 'Generalized harmonic number', 224 | 'snippet' : ['harmonic(n, m)',], 225 | }, 226 | { 227 | 'name' : 'Lucas number', 228 | 'snippet' : ['lucas(n)',], 229 | }, 230 | { 231 | 'name' : 'Rising factorial', 232 | 'snippet' : ['rf(x, k)',], 233 | }, 234 | { 235 | 'name' : 'Stirling number of the second kind', 236 | 'snippet' : ['stirling(n, k)',], 237 | }, 238 | { 239 | 'name' : 'Stirling number of the first kind', 240 | 'snippet' : ['stirling(n, k, kind=1, signed=False)',], 241 | }, 242 | { 243 | 'name' : 'Reduced Stirling number of the second kind', 244 | 'snippet' : ['stirling(n, k, d)',], 245 | }, 246 | { 247 | 'name' : 'Number of combinations of length k among n items', 248 | 'snippet' : ['nC(n, k)',], 249 | }, 250 | { 251 | 'name' : 'Number of permutations of length k among n items', 252 | 'snippet' : ['nP(n, k)',], 253 | }, 254 | { 255 | 'name' : 'Number of partitions of length k among n items', 256 | 'snippet' : ['nT(n, k)',], 257 | }, 258 | ], 259 | }, 260 | { 261 | 'name' : 'Special functions', 262 | 'sub-menu' : [ 263 | { 264 | 'name' : 'Dirac delta function', 265 | 'snippet' : ['DiracDelta(x)',], 266 | }, 267 | { 268 | 'name' : 'Derivative of Dirac delta function', 269 | 'snippet' : ['DiracDelta(x, k)',], 270 | }, 271 | { 272 | 'name' : 'Heaviside function', 273 | 'snippet' : ['Heaviside(X)',], 274 | }, 275 | { 276 | 'name' : 'Gamma, Beta and related Functions', 277 | 'sub-menu' : [ 278 | { 279 | 'name' : 'Gamma function', 280 | 'snippet' : ['gamma(x)',], 281 | }, 282 | { 283 | 'name' : 'Lower incomplete gamma function', 284 | 'snippet' : ['lowergamma(s, x)',], 285 | }, 286 | { 287 | 'name' : 'Upper incomplete gamma function', 288 | 'snippet' : ['uppergamma(s, x)',], 289 | }, 290 | { 291 | 'name' : 'Polygamma function', 292 | 'snippet' : ['polygamma(n, z)',], 293 | }, 294 | { 295 | 'name' : 'Log Gamma function', 296 | 'snippet' : ['loggamma(x)',], 297 | }, 298 | { 299 | 'name' : 'Digamma function', 300 | 'snippet' : ['digamma(x)',], 301 | }, 302 | { 303 | 'name' : 'Trigamma function', 304 | 'snippet' : ['trigamma(x)',], 305 | }, 306 | { 307 | 'name' : 'Euler Beta function', 308 | 'snippet' : ['beta(x, y)',], 309 | }, 310 | ], 311 | }, 312 | { 313 | 'name' : 'Error Functions and Fresnel Integrals', 314 | 'sub-menu' : [ 315 | { 316 | 'name' : 'Gauss error function', 317 | 'snippet' : ['erf(x)',], 318 | }, 319 | { 320 | 'name' : 'Complementary error function', 321 | 'snippet' : ['erfc(x)',], 322 | }, 323 | { 324 | 'name' : 'Imaginary error function', 325 | 'snippet' : ['erfi(x)',], 326 | }, 327 | { 328 | 'name' : 'Two-argument error function', 329 | 'snippet' : ['erf2(x, y)',], 330 | }, 331 | { 332 | 'name' : 'Inverse error function', 333 | 'snippet' : ['erfinv(y)',], 334 | }, 335 | { 336 | 'name' : 'Inverse complementary error function', 337 | 'snippet' : ['erfcinv(y)',], 338 | }, 339 | { 340 | 'name' : 'Inverse two-argument error function', 341 | 'snippet' : ['erf2inv(x, y)',], 342 | }, 343 | { 344 | 'name' : 'Fresnel integral S', 345 | 'snippet' : ['fresnels(z)',], 346 | }, 347 | { 348 | 'name' : 'Fresnel integral C', 349 | 'snippet' : ['fresnelc(z)',], 350 | }, 351 | ], 352 | }, 353 | { 354 | 'name' : 'Exponential, Logarithmic and Trigonometric Integrals', 355 | 'sub-menu' : [ 356 | { 357 | 'name' : 'Exponential integral', 358 | 'snippet' : ['Ei(x)',], 359 | }, 360 | { 361 | 'name' : 'Generalised exponential integral', 362 | 'snippet' : ['expint(x, z)',], 363 | }, 364 | { 365 | 'name' : 'Special case of the generalised exponential integral', 366 | 'snippet' : ['E1(z)',], 367 | }, 368 | { 369 | 'name' : 'Classical logarithmic integral', 370 | 'snippet' : ['li(x)',], 371 | }, 372 | { 373 | 'name' : 'Offset logarithmic integral', 374 | 'snippet' : ['Li(x)',], 375 | }, 376 | { 377 | 'name' : 'Sine integral', 378 | 'snippet' : ['Si(z)',], 379 | }, 380 | { 381 | 'name' : 'Cosine integral', 382 | 'snippet' : ['Ci(z)',], 383 | }, 384 | { 385 | 'name' : 'Hyperbolic sine integral', 386 | 'snippet' : ['Shi(z)',], 387 | }, 388 | { 389 | 'name' : 'Hyperbolic cosine integral', 390 | 'snippet' : ['Chi(z)',], 391 | }, 392 | ], 393 | }, 394 | { 395 | 'name' : 'Bessel Type Functions', 396 | 'sub-menu' : [ 397 | { 398 | 'name' : 'Bessel function of the first kind', 399 | 'snippet' : ['besselj(n, z)',], 400 | }, 401 | { 402 | 'name' : 'Bessel function of the second kind', 403 | 'snippet' : ['bessely(n, z)',], 404 | }, 405 | { 406 | 'name' : 'Modified Bessel function of the first kind', 407 | 'snippet' : ['besseli(n, z)',], 408 | }, 409 | { 410 | 'name' : 'Modified Bessel function of the second kind', 411 | 'snippet' : ['besselk(n, z)',], 412 | }, 413 | { 414 | 'name' : 'Hankel function of the first kind', 415 | 'snippet' : ['hankel1(n, z)',], 416 | }, 417 | { 418 | 'name' : 'Hankel function of the second kind', 419 | 'snippet' : ['hankel2(n, z)',], 420 | }, 421 | { 422 | 'name' : 'Spherical Bessel function of the first kind', 423 | 'snippet' : ['jn(n, z)',], 424 | }, 425 | { 426 | 'name' : 'Spherical Bessel function of the second kind', 427 | 'snippet' : ['yn(n, z)',], 428 | }, 429 | { 430 | 'name' : 'Zeros of the spherical Bessel function of the first kind', 431 | 'snippet' : ['jn_zeros(n, k)',], 432 | }, 433 | ], 434 | }, 435 | { 436 | 'name' : 'Airy Functions', 437 | 'sub-menu' : [ 438 | { 439 | 'name' : 'Airy function of the first kind', 440 | 'snippet' : ['airyai(z)',], 441 | }, 442 | { 443 | 'name' : 'Airy function of the second kind', 444 | 'snippet' : ['airybi(z)',], 445 | }, 446 | { 447 | 'name' : 'Derivative of the Airy function of the first kind', 448 | 'snippet' : ['airyaiprime(z)',], 449 | }, 450 | { 451 | 'name' : 'Derivative of the Airy function of the second kind', 452 | 'snippet' : ['airybiprime(z)',], 453 | }, 454 | ], 455 | }, 456 | { 457 | 'name' : 'B-Splines', 458 | 'sub-menu' : [ 459 | { 460 | 'name' : 'The n-th B-spline at x of degree d with given knots', 461 | 'snippet' : [ 462 | 'd = 3', 463 | 'knots = range(5)', 464 | 'n = 0', 465 | 'bspline_basis(d, knots, n, x, close=True)', 466 | ], 467 | }, 468 | { 469 | 'name' : 'The B-splines at x of degree d with given knots', 470 | 'snippet' : ['bspline_basis_set(d, knots, x)',], 471 | }, 472 | ], 473 | }, 474 | { 475 | 'name' : 'Riemann Zeta and Related Functions', 476 | 'sub-menu' : [ 477 | { 478 | 'name' : 'Riemann zeta function', 479 | 'snippet' : ['zeta(s, 1)',], 480 | }, 481 | { 482 | 'name' : 'Hurwitz zeta function', 483 | 'snippet' : ['zeta(s, a)',], 484 | }, 485 | { 486 | 'name' : 'Dirichlet eta function', 487 | 'snippet' : ['eta(s)',], 488 | }, 489 | { 490 | 'name' : 'Polylogarithm function', 491 | 'snippet' : ['polylog(s, z)',], 492 | }, 493 | { 494 | 'name' : 'Lerch transcendent (Lerch phi function)', 495 | 'snippet' : ['lerchphi(z, s, a)',], 496 | }, 497 | ], 498 | }, 499 | { 500 | 'name' : 'Hypergeometric Functions', 501 | 'sub-menu' : [ 502 | { 503 | 'name' : 'Generalized hypergeometric function', 504 | 'snippet' : [ 505 | 'p = 3', 506 | 'q = 2', 507 | 'a_j = symbols("a:{0}".format(p)) # numerator parameters', 508 | 'b_k = symbols("b:{0}".format(q)) # denominator parameters', 509 | 'hyper(a_j, b_k)', 510 | ], 511 | }, 512 | { 513 | 'name' : 'Meijer G-function', 514 | 'snippet' : [ 515 | 'm,n = 1,2', 516 | 'p,q = 4,1', 517 | 'a_j = symbols("a:{0}".format(p)) # numerator parameters', 518 | 'b_k = symbols("b:{0}".format(q)) # denominator parameters', 519 | 'meijerg(a_j[:n], a_j[n:p], b_k[:m], b_k[m:q], x)', 520 | ], 521 | }, 522 | ], 523 | }, 524 | { 525 | 'name' : 'Elliptic integrals', 526 | 'sub-menu' : [ 527 | { 528 | 'name' : 'Complete elliptic integral of the first kind', 529 | 'snippet' : ['elliptic_k(z)',], 530 | }, 531 | { 532 | 'name' : 'Legendre incomplete elliptic integral of the first kind', 533 | 'snippet' : ['elliptic_f(z, m)',], 534 | }, 535 | { 536 | 'name' : 'Legendre incomplete elliptic integral of the second kind', 537 | 'snippet' : ['elliptic_e(z, m)',], 538 | }, 539 | { 540 | 'name' : 'Legendre incomplete elliptic integral of the third kind', 541 | 'snippet' : ['elliptic_pi(n, z, m)',], 542 | }, 543 | ], 544 | }, 545 | { 546 | 'name' : 'Orthogonal Polynomials', 547 | 'sub-menu' : [ 548 | { 549 | 'name' : 'Jacobi polynomial', 550 | 'snippet' : ['jacobi(n, a, b, x)',], 551 | }, 552 | { 553 | 'name' : 'Normalized Jacobi polynomial', 554 | 'snippet' : ['jacobi_normalized(n, a, b, x)',], 555 | }, 556 | { 557 | 'name' : 'Gegenbauer polynomial', 558 | 'snippet' : ['gegenbauer(n, a, x)',], 559 | }, 560 | { 561 | 'name' : 'Chebyshev polynomial of the first kind', 562 | 'snippet' : ['chebyshevt(n, x)',], 563 | }, 564 | { 565 | 'name' : 'Chebyshev polynomial of the second kind', 566 | 'snippet' : ['chebyshevu(n, x)',], 567 | }, 568 | { 569 | 'name' : 'Root k of the nth Chebyshev polynomial of the first kind', 570 | 'snippet' : ['chebyshevt_root(n, k)',], 571 | }, 572 | { 573 | 'name' : 'Root k of the nth Chebyshev polynomial of the second kind', 574 | 'snippet' : ['chebyshevu_root(n, k)',], 575 | }, 576 | { 577 | 'name' : 'Legendre polynomial', 578 | 'snippet' : ['legendre(n, x)',], 579 | }, 580 | { 581 | 'name' : 'Associated Legendre polynomial', 582 | 'snippet' : ['assoc_legendre(n, m, x)',], 583 | }, 584 | { 585 | 'name' : 'Hermite polynomial', 586 | 'snippet' : ['hermite(n, x)',], 587 | }, 588 | { 589 | 'name' : 'Laguerre polynomial', 590 | 'snippet' : ['laguerre(n, x)',], 591 | }, 592 | { 593 | 'name' : 'Generalized (associated) Laguerre polynomial', 594 | 'snippet' : ['assoc_laguerre(n, a, x)',], 595 | }, 596 | ], 597 | }, 598 | { 599 | 'name' : 'Spherical Harmonics', 600 | 'sub-menu' : [ 601 | { 602 | 'name' : 'Spherical harmonics', 603 | 'snippet' : [ 604 | 'vartheta, varphi = symbols("vartheta, varphi", real=True)', 605 | 'Ynm(n, m, vartheta, varphi)', 606 | ], 607 | }, 608 | { 609 | 'name' : 'Conjugate spherical harmonics', 610 | 'snippet' : [ 611 | 'vartheta, varphi = symbols("vartheta, varphi", real=True)', 612 | 'Ynm_c(n, m, vartheta, varphi)', 613 | ], 614 | }, 615 | { 616 | 'name' : 'Real spherical harmonics', 617 | 'snippet' : [ 618 | 'vartheta, varphi = symbols("vartheta, varphi", real=True)', 619 | 'Znm(n, m, vartheta, varphi)', 620 | ], 621 | }, 622 | ], 623 | }, 624 | { 625 | 'name' : 'Tensor Functions', 626 | 'sub-menu' : [ 627 | { 628 | 'name' : 'Levi-Civita symbol', 629 | 'snippet' : ['LeviCivita(0,1,2,3)',], 630 | }, 631 | { 632 | 'name' : 'Kronecker delta', 633 | 'snippet' : ['KroneckerDelta(1,2)',], 634 | }, 635 | ], 636 | }, 637 | ], 638 | }, 639 | ], 640 | }); 641 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | Jupyter notebook snippets menu 2 | ============================== 3 | 4 | Adds a customizable menu item to Jupyter notebooks to insert 5 | snippets, boilerplate, and examples of code. 6 | 7 | ![Open snippets menu](screenshot1.png) 8 | 9 | This notebook extension adds a menu item (or multiple menu items, if 10 | desired) after the `Help` menu in Jupyter notebooks. This new menu 11 | contains little snippets of code that we all forget from time to time 12 | but don't want to google, or are just too lazy to type, or simply 13 | didn't know about. It can also be helpful for people just starting 14 | out with a programming language, who need some ideas for what to do 15 | next — like importing a module, defining variables, or calling 16 | functions. 17 | 18 | The new menu comes with a default value relevant for python 19 | programming — especially scientific computing — though this is fully 20 | user-configurable as detailed below. The default menu is named 21 | `Snippets`, and contains sub-menus with snippets for a few popular 22 | python packages, as well as python itself, and some notebook markdown. 23 | (Note that some of the menus are so large that it is necessary to move 24 | the first-level menus to the left so that lower-level menus will fit 25 | on the screen. This behavior is also user-configurable, as discussed 26 | in detail [below](#change-direction-of-sub-menus).) 27 | 28 | So, for example, if you are editing a code cell and want to import 29 | matplotlib for use in the notebook, you can just click the `Snippets` 30 | menu, then mouse over "Matplotlib". This will open up a new sub-menu, 31 | with an item "Setup for notebook". Clicking on that item will insert 32 | the code snippet at the point where your cursor was just before you 33 | clicked on the menu. In particular, for this `matplotlib` example, 34 | the following code gets inserted: 35 | 36 | ```python 37 | import numpy as np 38 | import matplotlib as mpl 39 | import matplotlib.pyplot as plt 40 | %matplotlib inline 41 | ``` 42 | 43 | The inserted text will be selected, so that you can delete it by 44 | pressing backspace or delete, or you can just select another snippet 45 | to replace it -- and just to highlight what was inserted. 46 | 47 | Note that many of the snippets involve variable names prefixed with 48 | `bp_`. For example, a new numpy array is created as `bp_new_array`. 49 | These are intentionally dumb names that you really should replace. 50 | Failing to do so could lead to ugly bugs in your code if you use 51 | multiple boilerplate snippets with clashing variable names. 52 | 53 | Similarly, some strings are intended to be replaced, such as the axis 54 | labels in plots. These are there to show you what can be done, and to 55 | remind you to put informative labels in your plots. If you don't 56 | want, e.g., a title on your plot, just remove that line. 57 | 58 | 59 | Installation 60 | ------------ 61 | To install this extension alone (without the [main collection of nbextensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions)), run the following from the command line: 62 | 63 | ```bash 64 | git clone https://github.com/moble/jupyter_boilerplate 65 | jupyter nbextension install jupyter_boilerplate 66 | jupyter nbextension enable jupyter_boilerplate/main 67 | ``` 68 | 69 | You can then disable the extension if you want with 70 | ```bash 71 | jupyter nbextension disable jupyter_boilerplate/main 72 | ``` 73 | 74 | 75 | Basic menu customization 76 | ------------------------ 77 | 78 | The default menu might have too many irrelevant items for you, or may 79 | not have something you would find useful. You can easily customize it 80 | in the 81 | [jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator#usage), 82 | which you almost certainly have if you installed this extension the 83 | normal way, 84 | through 85 | [jupyter_contrib_nbextensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions). 86 | Usually, you can get to the configurator by pointing your browser to 87 | http://127.0.0.1:8888/nbextensions, though you may have to modify the 88 | URL if you use a more complicated jupyter server. 89 | 90 | On the configurator page, you will see a number of options (as well as 91 | this README) that should be fairly self-explanatory, allowing you to 92 | remove any of the default menu items, or add a custom menu within the 93 | "Snippets" menu. The custom menu is written in JSON, and a simple 94 | (and useless) example is given that should be easy to modify as 95 | needed. 96 | 97 | 98 | 99 | Advanced menu customization 100 | --------------------------- 101 | 102 | It is also possible to extensively customize the menus in far more 103 | complex ways using your `custom.js` file. For example, you can change 104 | the order of menu items, add more custom sub-menus under the 105 | "Snippets" menu, and custom menus alongside "Snippets" in the menu 106 | bar, or even add menus in other places, like inside the "Insert" menu. 107 | 108 | You can find the path to `custom.js` by running the command 109 | 110 | ```bash 111 | echo $(jupyter --config-dir)/custom/custom.js 112 | ``` 113 | 114 | For Mac and linux users, the result is probably 115 | `~/.jupyter/custom/custom.js`. If this file or the directory 116 | containing it do not exist, you can simply create them. 117 | 118 | The customization process is best explained through examples, which 119 | are available in the `examples_for_custom.js` file in this directory. 120 | Note that there's a lot of explanation here, but it's all actually 121 | pretty simple. Give it a try, and you'll pick it up quickly. Note 122 | that using this method can make it so that options selected in the 123 | configurator are ignored. 124 | 125 | The theory behind this customization is that the menu is represented 126 | by a nested JavaScript array (which is just like a python list). So 127 | to change the menu, you just need to change that array. And each menu 128 | *item* inside this array is represented by 129 | a [JavaScript "object"](http://api.jquery.com/Types/#Object) (which is 130 | just like a python dictionary). So to change a menu item, you just 131 | have to change that object. 132 | 133 | Again, this makes more sense when looking at example, as follows. 134 | 135 | 136 | ### Add a custom sub-menu with simple snippets 137 | 138 | Suppose you want to make a new sub-menu with your favorite snippets at 139 | the bottom of `Snippets`. You create a new object for the menu item, 140 | and then just "push" it onto the default menu. Do this by inserting 141 | some lines into your `custom.js`, so that it looks like this: 142 | 143 | ```javascript 144 | require(["nbextensions/snippets_menu/main"], function (snippets_menu) { 145 | console.log('Loading `snippets_menu` customizations from `custom.js`'); 146 | var horizontal_line = '---'; 147 | var my_favorites = { 148 | 'name' : 'My favorites', 149 | 'sub-menu' : [ 150 | { 151 | 'name' : 'Menu item text', 152 | 'snippet' : ['new_command(3.14)',], 153 | }, 154 | { 155 | 'name' : 'Another menu item', 156 | 'snippet' : ['another_new_command(2.78)',], 157 | }, 158 | ], 159 | }; 160 | snippets_menu.options['menus'] = snippets_menu.default_menus; 161 | snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line); 162 | snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites); 163 | console.log('Loaded `snippets_menu` customizations from `custom.js`'); 164 | }); 165 | ``` 166 | 167 | Now, if you refresh your notebook, you'll see a new menu item named "My 168 | favorites". Hover over it, and it will pop up a sub-menu with two more 169 | options. Click the first one, and it will insert `new_command(3.14)` into 170 | your notebook wherever the cursor was. 171 | 172 | We discuss how all this works below. But first, we need to slightly generalize 173 | the example above to work with more complicated snippets. 174 | 175 | 176 | ### More complicated snippets 177 | 178 | The example above inserted simple one-line snippets of code. Those snippets 179 | didn't have any quotation marks (single or double), backslashes, or newlines, 180 | which made everything easy. Unfortunately, JavaScript doesn't deal too well 181 | with strings. (There are no raw triple-quoted strings, like in python.) So 182 | there are just three things to remember when writing snippets. 183 | 184 | 1. Quotation marks can be a tiny bit tricky. There are a few options: 185 | 1. The obvious option is to enclose your snippets in single quotation marks 186 | (`'`), and use only double quotation marks (`"`) within the snippet 187 | itself. 188 | 2. Just as easy is to enclose your snippets in double quotation marks 189 | (`"`), and use only single quotation marks (`'`) within the snippet 190 | itself. 191 | 3. You can also escape single quotation marks inside single quotation marks 192 | as `\'`. 193 | 194 | 2. Newlines are even trickier, but the extension takes care of this for you 195 | as long as you put separate lines of code as separate elements of the 196 | `snippet` array. Generally, there's no reason to put a literal newline in 197 | your snippets. 198 | 199 | 3. JavaScript will treat backslashes as if they're trying to escape whatever 200 | comes after them. So if you want one backslash in your output code, 201 | you'll need to put two backslashes in. 202 | 203 | This is all best described with another example. Let's change the first 204 | function above, to give it some more lines and some quotes: 205 | 206 | ```javascript 207 | require(["nbextensions/snippets_menu/main"], function (snippets_menu) { 208 | console.log('Loading `snippets_menu` customizations from `custom.js`'); 209 | var horizontal_line = '---'; 210 | var my_favorites = { 211 | 'name' : 'My $\\nu$ favorites', 212 | 'sub-menu' : [ 213 | { 214 | 'name' : 'Multi-line snippet', 215 | 'snippet' : ['new_command(3.14)', 216 | 'other_new_code_on_new_line("with a string!")', 217 | 'stringy(\'escape single quotes once\')', 218 | "stringy2('or use single quotes inside of double quotes')", 219 | 'backslashy("This \\ appears as just one backslash in the output")', 220 | 'backslashy2("Here are \\\\ two backslashes")',], 221 | }, 222 | { 223 | 'name' : 'TeX appears correctly $\\alpha_W e\\int_0 \\mu \\epsilon$', 224 | 'snippet' : ['another_new_command(2.78)',], 225 | }, 226 | ], 227 | }; 228 | snippets_menu.options['menus'].push(snippets_menu.default_menus[0]); 229 | snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line); 230 | snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites); 231 | console.log('Loaded `snippets_menu` customizations from `custom.js`'); 232 | }); 233 | ``` 234 | 235 | Note the code output by the first item contains all sorts of interesting 236 | strings. Also, the menu title of the second item contains TeX, which will 237 | display correctly, and is used in some of the default menus to show the 238 | standard symbols for physical constants. For more examples, look at the 239 | default menus stored in the `snippets_menu` directory -- mostly under `python`. 240 | 241 | 242 | ### How it works: Creating new menu items 243 | 244 | Each of the menu items above is a JavaScript object (like a python `dict`), 245 | with some attributes -- `name` and `sub-menu` for the main menu item, and 246 | `name` and `snippet` for the sub-menu items. In general, any menu object can 247 | have any of the following properties: 248 | 249 | 1. `name`: Text that appears in the menu. Note that this can include latex, 250 | as the menus are processed by MathJax after being loaded. 251 | 2. `sub-menu`: An array of more menu items 252 | 3. `snippet`: An array of strings turned into code when the menu item is 253 | clicked 254 | 4. `internal-link`: Link to some place on the present page. For example, 255 | this could be `#References`, to link to the `References` section of any 256 | notebook you're in. 257 | 5. `external-link`: This just a link to some external web page, which will be 258 | identified with a little icon, just like in the standard notebook "Help" 259 | menu. When clicked, the link will open in a new window/tab. 260 | 6. `menu-direction`: If the value of this property is `left`, this menu's 261 | sub-menus open on the left. This is useful when the top-level menu is 262 | inserted as an item within other menu items. See 263 | [below](#change-direction-of-sub-menus) for examples. 264 | 7. `sub-menu-direction`: If the value of this property is `left`, sub-menus 265 | within this menu's sub-menus open on the left. This is used by default 266 | for items under the `Snippets` menu to help ensure that nested menus 267 | don't become too large to fit on the screen. See 268 | [below](#change-direction-of-sub-menus) for examples. 269 | 270 | The `name` property is the only required one, though you'll probably want at 271 | least one other property. The `sub-menu` contains menu objects that again may 272 | have any of these properties, so you can easily nest menus. You can also 273 | combine a `snippet` with a `sub-menu`, so that there's a default value as well 274 | as a sub-menu. However, the last three are mutually exclusive: `snippet` will 275 | override any `-link`; an `internal-link` will override an `external-link`. 276 | 277 | 278 | ### How it works: Splicing new menu items into the old 279 | 280 | Besides just creating the menu items, we may want to join together previously 281 | created items. That's the purpose of this line in the code above: 282 | 283 | ```javascript 284 | snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites); 285 | ``` 286 | 287 | This uses 288 | the [JavaScript `push`](http://www.w3schools.com/jsref/jsref_push.asp) 289 | function to insert the new menu `my_favorites` menu into the last slot 290 | of `snippets_menu.options['menus'][0]['sub-menu']`, which is the set 291 | of menus under the heading `Snippets`. 292 | 293 | If you think about this last point, you'll realize that `Snippets` is 294 | just the `0` slot of an array of menus. If you want a new menu right 295 | in the menu bar, you could add `my_favorites` right to that top-level 296 | array, with something like this: 297 | 298 | ```javascript 299 | snippets_menu.options['menus'].push(snippets_menu.default_menus[0]); 300 | snippets_menu.options['menus'].push(my_favorites); 301 | ``` 302 | 303 | This would place your favorites after the default `Snippets` menu; to 304 | put it before, just swap the order in which you `push`: 305 | 306 | ```javascript 307 | snippets_menu.options['menus'].push(my_favorites); 308 | snippets_menu.options['menus'].push(snippets_menu.default_menus[0]); 309 | ``` 310 | 311 | (In general, to add a new element at a given index of an array, you 312 | could also just use 313 | the [splice](http://www.w3schools.com/jsref/jsref_splice.asp) 314 | function.) 315 | 316 | This might be useful if you have one set of very frequently used 317 | commands, and want immediate access, without going through various 318 | levels of the usual menu. A useful example of this is 319 | shown [below](#starting-over-with-the-menus). The `splice` function 320 | can also be used to delete items from the array, as 321 | described [next](#deleting-menu-items). 322 | 323 | 324 | ### Other menu manipulations 325 | 326 | To rearrange menu items, just use standard JavaScript techniques. The two most 327 | likely examples are deleting and rearranging menu items, but we'll also see 328 | that other manipulations are easy. We can also change where the new menus go, 329 | and what they look like. 330 | 331 | #### Deleting menu items 332 | 333 | To delete an item, just `splice` nothing into it. Let's suppose, for example, 334 | that you want to remove the option to set up matplotlib for a script, which is 335 | the `1` item of the "Matplotlib" menu: 336 | 337 | ```javascript 338 | snippets_menu.python.matplotlib['sub-menu'] 339 | ``` 340 | 341 | Remember that `[1]` is the second element of "Matplotlib"'s sub-menu 342 | list. So the following code will do the trick 343 | 344 | 345 | ```javascript 346 | require(["nbextensions/snippets_menu/main"], function (snippets_menu) { 347 | console.log('Loading `snippets_menu` customizations from `custom.js`'); 348 | snippets_menu.python.matplotlib['sub-menu'].splice(1, 1); // Delete 1 element starting at position 1 of the sub-menu 349 | console.log('Loaded `snippets_menu` customizations from `custom.js`'); 350 | }); 351 | ``` 352 | 353 | The first `1` in the argument to `splice` says to work on the element at 354 | position 1; the second `1` says to delete 1 element of the array. 355 | 356 | 357 | #### Rearranging menu items 358 | 359 | Following the example above, suppose you don't want to delete the second setup 360 | item under "Matplotlib", but instead want to swap those first two items. To 361 | make this swap, you need to do the usual trick of storing one element in a 362 | temporary variable, and then reassign appropriately. The following code 363 | achieves this purpose: 364 | 365 | ```javascript 366 | require(["nbextensions/snippets_menu/main"], function (snippets_menu) { 367 | console.log('Loading `snippets_menu` customizations from `custom.js`'); 368 | var tmp = snippets_menu.python.matplotlib['sub-menu'][0]; 369 | snippets_menu.python.matplotlib['sub-menu'][0] = snippets_menu.python.matplotlib['sub-menu'][1]; 370 | snippets_menu.python.matplotlib['sub-menu'][1] = tmp; 371 | console.log('Loaded `snippets_menu` customizations from `custom.js`'); 372 | }); 373 | ``` 374 | 375 | #### Change direction of sub-menus 376 | 377 | Each sub-menu may be placed to the right or left side of the menu item 378 | containing it. This is controlled by the `menu-direction` and 379 | `sub-menu-direction` properties of the container. By default, both are set to 380 | `right` for all menus, but `sub-menu-direction` is set to `left` for the 381 | default `Snippets` menu, which means that all of its sub-menus open to the 382 | left side. This is important because the menus may be nested quite deeply, and 383 | need to fit on the screen. For example, the SciPy CODATA constants and SymPy's 384 | orthogonal functions will easily extend far past the right-hand edge of the 385 | notebook without this feature. That means the window size would abruptly 386 | increase when you mouse over these menus, and would abruptly collapse when you 387 | mouse out of them. So by opening them to the left, we gain enough space to 388 | keep everything on the screen. 389 | 390 | But these are configurable properties. If, for example, you want to change the 391 | default menus to open on the right (which would be the more standard behavior), 392 | you can use this: 393 | 394 | ```javascript 395 | snippets_menu.default_menus[0]['sub-menu-direction'] = 'right'; 396 | ``` 397 | 398 | This may be particularly useful if we change the position of the menus, as in 399 | the next examples. 400 | 401 | 402 | #### Starting over with the menus 403 | 404 | Each of the menu items under the default `Snippets` menu is 405 | individually available as part of the `snippets_menu` object defined 406 | in our JavaScript examples. So if you want, you could just use them 407 | to build your own version of the menu. For example, suppose use SymPy 408 | and Numpy most frequently, so you want easy access to their menus, 409 | without having to click `Snippets` first. And then suppose you still 410 | want most of the other `Snippets` items, but less frequently so they 411 | can stay in their menu, except that you really never use pandas. You 412 | can create your own menu as follows: 413 | 414 | ```javascript 415 | require(["nbextensions/snippets_menu/main"], function (snippets_menu) { 416 | console.log('Loading `snippets_menu` customizations from `custom.js`'); 417 | snippets_menu.default_menus[0]['sub-menu'].splice(3, 2); // Remove SymPy and pandas 418 | snippets_menu.python.sympy['sub-menu-direction'] = 'left'; // Point new SymPy menus to left 419 | snippets_menu.python.numpy['sub-menu-direction'] = 'left'; // Point new Numpy menus to left 420 | snippets_menu.options['menus'].push(snippets_menu.default_menus[0]); // Start with the remaining "Snippets" menu 421 | snippets_menu.options['menus'].push(snippets_menu.python.sympy); // Follow that with a new SymPy menu 422 | snippets_menu.options['menus'].push(snippets_menu.python.numpy); // Follow that with a new Numpy menu 423 | console.log('Loaded `snippets_menu` customizations from `custom.js`'); 424 | }); 425 | ``` 426 | 427 | The default menu group is `snippets_menu.default_menus`, and the SymPy sub-menu 428 | is `snippets_menu.python.sympy`. You can see that we've manipulated them above 429 | by removing two elements from the default menu, using the `splice` command. 430 | We've also added a new property to the SymPy menu to make its sub-menus open to 431 | the left, instead of the right -- which is necessary to keep all of SymPy's 432 | extensively nested menus on the screen. (In fact, the list of orthogonal 433 | polynomials under "Special functions" in the SymPy menu are some of the widest 434 | menus in the default set.) Finally, we've combined the modified default menu 435 | with the modified SymPy menu into one new list. 436 | 437 | This gives us the original `Snippets` menu with SymPy and pandas removed, as 438 | well as new menus devoted to just SymPy and Numpy right in the menu bar: 439 | 440 | ![Opened snippets menu after adjustments](screenshot2.png) 441 | 442 | You can see that the two items are indeed removed from `Snippets`, and 443 | "SymPy" and "Numpy" now have places of honor right in the menu bar. 444 | You can, of course, swap their order in the code above, or make any 445 | number of further alterations. 446 | 447 | 448 | #### Changing the insertion point 449 | 450 | You might want to change the order of the menus in the navbar (that 451 | top-level bar with "File", etc.). For example, it might feel 452 | particularly natural to have "Help" as the last item, so maybe you'd 453 | prefer to put the `Snippets` menu *before* the "Help" menu. Or you 454 | may prefer to maintain the structure of the menus in the navbar, and 455 | would rather have the `Snippets` menu *inside* of some other top-level 456 | menu -- like the "Insert" menu. Personally, I prefer to have the 457 | `Snippets` menu in its default position for easy access. But it's 458 | certainly possible to put it other places. 459 | 460 | To help do this, there are two additional options available, which can 461 | be set either in the configurator or in `custom.js`. Their default 462 | values give us the usual placement of the `Snippets` menu; by giving 463 | them different values, we can change the placement. These options are 464 | 465 | 1. `sibling`: This is an HTML node next to our new menu, 466 | presumably 467 | [selected with `jQuery`](http://learn.jquery.com/using-jquery-core/selecting-elements/). 468 | The default value is `$("#help_menu").parent()`, which is the 469 | "Help" menu. For the configurator, `.parent()` is automatically 470 | appended. 471 | 2. `insert_before_sibling`: This is just a string controlling where 472 | the new menu will be inserted relative to its sibling. The 473 | default value is `false`. If you change it to `true`, the new 474 | menu will be inserted before the sibling. 475 | 476 | So placing the `Snippets` menu *before* the "Help" menu is as easy as 477 | checking the box for that second option. For more complicated uses, 478 | you may need to set these values from `custom.js`. For example, f you 479 | want to put the new `Snippets` menu as an item inside the standard 480 | "Insert" menu, and include an additional horizontal divider, you can 481 | use this: 482 | 483 | ```javascript 484 | require(["nbextensions/snippets_menu/main"], function (snippets_menu) { 485 | console.log('Loading `snippets_menu` customizations from `custom.js`'); 486 | snippets_menu.default_menus[0]['menu-direction'] = 'left'; // Open top-level menu to the left... 487 | snippets_menu.default_menus[0]['sub-menu-direction'] = 'right'; // ...and sub-menus to the right. 488 | snippets_menu.options['menus'].push('---', snippets_menu.default_menus[0]); // Add horizontal line and default menus 489 | snippets_menu.options['sibling'] = $("#insert_cell_below"); // Find the place at which to insert the new menus 490 | console.log('Loaded `snippets_menu` customizations from `custom.js`'); 491 | }); 492 | ``` 493 | 494 | Here's what that looks like: 495 | 496 | ![Opened snippets menu under "Insert" menu](screenshot3.png) 497 | 498 | And of course, you can combine this selection of the insertion point with other 499 | techniques above, where you change the content of the menus. 500 | 501 | 502 | #### Multiple menus in separate locations 503 | 504 | Finally, we have one more interesting example that brings together various 505 | threads from the previous examples. It is possible to place multiple menus in 506 | different locations. For example, suppose we want to combine two of the examples 507 | above, where [(1)](#starting-over-with-the-menus) we separated "SymPy" into its 508 | own menu on the navbar, and [(2)](#changing-the-insertion-point) we placed the 509 | `Snippets` menu inside the "Insert" menu. That is, you might want "SymPy" 510 | to be conveniently placed, but you want the rest of the `Snippets` to stay 511 | under the "Insert" menu. 512 | 513 | To add these two separate menus, we place the first with the usual 514 | approach, and then place the second with another function, 515 | `snippets_menu.menu_setup`. The former is mostly just a wrapper to 516 | the latter, except that it also inserts JavaScript and CSS elements 517 | into the notebook. Note that `menu_setup` does not have any default 518 | values; you must always pass the `sibling` and `insert_before_sibling` 519 | arguments. 520 | 521 | So, putting it all together, the code needed for this arrangement is as 522 | follows: 523 | 524 | ```javascript 525 | require(["nbextensions/snippets_menu/main"], function (snippets_menu) { 526 | console.log('Loading `snippets_menu` customizations from `custom.js`'); 527 | var sympy_menu = [snippets_menu.python.sympy,]; 528 | sympy_menu[0]['sub-menu-direction'] = 'left'; 529 | snippets_menu.options['menus'] = sympy_menu; 530 | snippets_menu.default_menus[0]['sub-menu'].splice(3, 1); // Remove SymPy from defaults 531 | snippets_menu.default_menus[0]['menu-direction'] = 'left'; 532 | snippets_menu.default_menus[0]['sub-menu-direction'] = 'right'; 533 | var sibling = $("#insert_cell_below"); 534 | var inserted_menu = [ 535 | '---', 536 | snippets_menu.default_menus[0], 537 | ]; 538 | snippets_menu.menu_setup(inserted_menu, sibling, 'after'); 539 | console.log('Loaded `snippets_menu` customizations from `custom.js`'); 540 | }); 541 | ``` 542 | 543 | 544 | Troubleshooting 545 | --------------- 546 | 547 | The first step is to make sure that the default setup can be loaded. 548 | Comment out whatever you've got in `custom.js`, and add in the simple 549 | configuration from [the beginning](#installation). If that doesn't 550 | work, try the following steps 551 | suggested 552 | [here](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/wiki#troubleshooting): 553 | 554 | 1. Clear your browser cache or start a private browser tab. 555 | 2. Verify your `custom.js` is the one the notebook is seeing, by opening it 556 | in the browser: (as 557 | opposed to looking at the file directly outside of your browser, which may 558 | not be the `custom.js` loaded if you are using a `virtualenv`). 559 | 3. Verify the extension can be loaded by the Jupyter notebook, for example: 560 | . You 561 | should see a page with lots of JavaScript code, and should *not* 562 | see a 404 error. 563 | 4. Check for error messages in the JavaScript console. 564 | 565 | Now, assuming the basic installation works, it must be something wrong 566 | in your customization. (Or maybe a new bug you've uncovered...) 567 | 568 | Sometimes, the menu(s) might simply not appear. This is most likely 569 | due to a syntax error in your menu. You can find out in Chrome by 570 | going to "View" -> "Developer" -> "JavaScript console". You'll see a 571 | bunch of output. Red lines are usually errors (some of which are 572 | probably *not* due to your menu error). On the right side of those 573 | lines, you'll see the file where the error came from, and possibly 574 | even the line number that's causing the trouble. Find an error that 575 | links to either `snippets_menu/main.js` or `custom.js`, and click on 576 | it. Then try to figure out what went wrong. The most common error 577 | I've encountered is "Unexpected string", which might indicate a 578 | missing comma, or an improperly escaped quote. Note that sometimes 579 | the error will point to the first thing *after* the real problem. 580 | 581 | Or maybe the menu did appear, but it doesn't work properly. You can 582 | also inspect the actual elements that were inserted. Click on 583 | "Elements" in that Developer Tools tab that opened at the bottom of 584 | your window. Then click the magnifying glass, and click on the 585 | `Snippets` menu. This will jump the Developer Tools to the part of 586 | the source with that menu. Scroll through to find the menu item 587 | that's not working correctly, and take a look at it. The text in the 588 | `data-snippet-code` attribute is especially important, since that's 589 | what gets inserted into the notebook. 590 | 591 | 592 | TODO 593 | ---- 594 | 595 | There's a bunch of stuff I still need to do, listed in 596 | the 597 | [issue tracker](https://github.com/moble/jupyter_boilerplate/issues). 598 | If you find a bug or have an idea for a good snippet that you think 599 | should be added to the defaults, feel free 600 | to 601 | [open a new issue](https://github.com/moble/jupyter_boilerplate/issues/new). 602 | 603 | In particular, I don't use Julia or R, so I welcome suggestions for 604 | default snippets for those languages. 605 | 606 | 607 | 608 | Reasons for using this extension 609 | -------------------------------- 610 | 611 | This is just a nice place to collect thoughts about why anyone might 612 | find this to be a useful extension: 613 | 614 | * Introducing beginners to coding. It's helpful for the beginner to have a 615 | list of useful possibilities (with correct syntax!) lined up right where 616 | the programming is happening. It's like "Hello world" on steroids. 617 | * Introducing the Jupyter notebook. It can be useful to have some nice 618 | things to do in the notebook to demonstrate the possibilities. For 619 | example, you might suggest that someone new to the notebook run the 620 | Matplotlib setup and then make an example plot. 621 | * Convenience for lazy people like me. For example, I usually don't want to 622 | bother with all the typing involved in setting up the nice (but important) 623 | parts of a plot, like the axis labels and legend. But by inserting the 624 | template, all I have to do is change the relevant values. 625 | * Reminders about useful things that could be done. For example, 626 | when I'm manipulating expressions in SymPy, I'll frequently forget 627 | that I can simplify, expand, collect, etc., in all sorts of ways. 628 | The Snippets menu reminds me of that. 629 | * Convenient reference for massive libraries. For example, SciPy contains 630 | lots of constants. You could certainly go to the web page describing these 631 | various constants to find the one you need, or you could just explore them 632 | right in the browser. The same is true of SymPy's collection of special 633 | functions. 634 | -------------------------------------------------------------------------------- /snippets_submenus_python/numpy.js: -------------------------------------------------------------------------------- 1 | define([ 2 | "require", 3 | "./numpy_ufuncs", 4 | "./numpy_polynomial", 5 | ], function (require, numpy_ufuncs, numpy_polynomial) { 6 | return { 7 | 'name' : 'NumPy', 8 | 'sub-menu' : [ 9 | { 10 | 'name' : 'Setup', 11 | 'snippet' : [ 12 | 'from __future__ import print_function, division', 13 | 'import numpy as np', 14 | ], 15 | }, 16 | { 17 | 'name' : 'Documentation', 18 | 'external-link' : 'http://docs.scipy.org/doc/numpy/index.html', 19 | }, 20 | '---', 21 | { 22 | 'name' : 'Creating arrays', 23 | 'sub-menu' : [ 24 | { 25 | 'name' : 'New array of given shape', 26 | 'snippet' : ['new_array = np.zeros((4,3,), dtype=complex)',], 27 | }, 28 | { 29 | 'name' : 'New array shaped like another', 30 | 'snippet' : ['new_array = np.zeros_like(old_array, dtype=complex)',], 31 | }, 32 | { 33 | 'name' : 'Copy of existing data', 34 | 'snippet' : ['new_array = np.copy(old_array)',], 35 | }, 36 | { 37 | 'name' : 'Array from list of data', 38 | 'snippet' : ['new_array = np.array([1.2, 3.4, 5.6])',], 39 | }, 40 | { 41 | 'name' : 'Evenly spaced values within a given interval', 42 | 'snippet' : ['new_array = np.arange(1, 10, 2)'], 43 | }, 44 | { 45 | 'name' : 'Evenly spaced numbers over a specified interval', 46 | 'snippet' : ['new_array = np.linspace(1., 10., num=120, endpoint=True)'], 47 | }, 48 | { 49 | 'name' : 'Numbers spaced evenly on a log scale', 50 | 'snippet' : ['new_array = np.logspace(1., 10., num=120, endpoint=True, base=2)'], 51 | }, 52 | { 53 | 'name' : 'Coordinate matrices from coordinate vectors', 54 | 'snippet' : [ 55 | 'x = np.linspace(0, 1, 7)', 56 | 'y = np.linspace(0, 1, 11)', 57 | 'xx, yy = np.meshgrid(x, y)', 58 | ], 59 | }, 60 | { 61 | 'name' : 'Return views of the data, split into $N$ groups', 62 | 'snippet' : [ 63 | 'x = np.arange(12)', 64 | 'a,b,c = np.split(x, 3)', 65 | ], 66 | }, 67 | { 68 | 'name' : 'Return views of the data, split at given indices along given axis', 69 | 'snippet' : [ 70 | 'x = np.arange(27).reshape((3,9))', 71 | 'a,b,c = np.split(x, [2,6], axis=1)', 72 | ], 73 | }, 74 | { 75 | 'name' : 'Return copy of arrays, combined into one', 76 | 'snippet' : [ 77 | 'a = np.arange(30).reshape((2,3,5))', 78 | 'b = np.arange(42).reshape((2,3,7))', 79 | 'c = np.concatenate((a, b), axis=1)', 80 | ], 81 | }, 82 | ], 83 | }, 84 | 85 | { 86 | 'name' : 'Reshaping and viewing arrays', 87 | 'sub-menu' : [ 88 | { 89 | 'name' : 'Return a view of the data, with a different shape', 90 | 'snippet' : ['np.arange(6).reshape((3, 2))'], 91 | }, 92 | { 93 | 'name' : 'Return a view of the data, with an extra axis', 94 | 'snippet' : ['a[:, np.newaxis]'], 95 | }, 96 | { 97 | 'name' : 'Return a view of the data, flattened to 1-D', 98 | 'snippet' : ['a.ravel()'], 99 | }, 100 | { 101 | 'name' : 'Return a copy of the data, flattened to 1-D', 102 | 'snippet' : ['a.flatten()'], 103 | }, 104 | { 105 | 'name' : 'Return a view of the data, with a different dtype', 106 | 'snippet' : ['np.linspace(0, 10, num=50).view(complex)'], 107 | 'sub-menu' : [ 108 | { 109 | 'name' : 'View real array as complex', 110 | 'snippet' : [ 111 | 'r = np.linspace(0, 10, num=100).reshape((25,4))', 112 | 'c = r.view(complex)', 113 | ], 114 | }, 115 | { 116 | 'name' : 'View complex array as real with extra dimension', 117 | 'snippet' : [ 118 | 'c = (np.linspace(0, 10, num=50) + 1j*np.linspace(0, 10, num=50))', 119 | 'cv = c.view(float)', 120 | 'r = cv.reshape(c.shape + (2,))', 121 | ], 122 | }, 123 | ], 124 | }, 125 | { 126 | 'name' : 'Return a copy of the data, cast to a different dtype', 127 | 'snippet' : ['np.linspace(0, 10, num=50).astype(complex)'], 128 | }, 129 | { 130 | 'name' : 'Return a view of the data with indices reversed (transposed)', 131 | 'snippet' : ['np.arange(210).reshape((2,3,5,7)).transpose()'], 132 | }, 133 | { 134 | 'name' : 'Return a view of the data with indices permuted', 135 | 'snippet' : ['np.arange(210).reshape((2,3,5,7)).transpose((2,1,0,3))'], 136 | }, 137 | { 138 | 'name' : 'Exchange two axes in an array', 139 | 'snippet' : ['np.arange(210).reshape((2,3,5,7)).swapaxes(1,3)'], 140 | }, 141 | { 142 | 'name' : 'Permute axes, bringing given axis into new position', 143 | 'snippet' : ['np.rollaxis(np.arange(210).reshape((2,3,5,7)), 2, 0)'], 144 | }, 145 | { 146 | 'name' : 'Permute indices by a given amount along the given axis', 147 | 'snippet' : ['np.roll(np.arange(10).reshape((2,5)), 2, axis=1)'], 148 | }, 149 | { 150 | 'name' : 'Return views of the data, split into $N$ groups', 151 | 'snippet' : [ 152 | 'x = np.arange(12)', 153 | 'a,b,c = np.split(x, 3)', 154 | ], 155 | }, 156 | { 157 | 'name' : 'Return views of the data, split at given indices along given axis', 158 | 'snippet' : [ 159 | 'x = np.arange(27).reshape((3,9))', 160 | 'a,b,c = np.split(x, [2,6], axis=1)', 161 | ], 162 | }, 163 | { 164 | 'name' : 'Return copy of arrays, combined into one', 165 | 'snippet' : [ 166 | 'a = np.arange(30).reshape((2,3,5))', 167 | 'b = np.arange(42).reshape((2,3,7))', 168 | 'c = np.concatenate((a, b), axis=1)', 169 | ], 170 | }, 171 | ], 172 | }, 173 | 174 | { 175 | 'name' : 'Indexing and testing arrays', 176 | 'sub-menu' : [ 177 | { 178 | 'name' : 'Indexing documentation', 179 | 'external-link' : 'http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html', 180 | }, 181 | '---', 182 | { 183 | 'name' : 'Test if array is empty', 184 | 'snippet' : [ 185 | 'if a.size > 0: # Never use `if a` or `if len(a)` for numpy arrays', 186 | ' print(a)', 187 | ], 188 | }, 189 | { 190 | 'name' : 'Get number of dimensions of array', 191 | 'snippet' : ['a.ndim'], 192 | }, 193 | { 194 | 'name' : 'Get shape of array', 195 | 'snippet' : ['a.shape'], 196 | }, 197 | { 198 | 'name' : 'Index a one-dimensional array', 199 | 'sub-menu' : [ 200 | { 201 | 'name' : 'Get one element', 202 | 'snippet' : [ 203 | 'a = np.arange(10)', 204 | 'a[3]' 205 | ], 206 | }, 207 | { 208 | 'name' : 'Get first $N$ elements', 209 | 'snippet' : [ 210 | 'a = np.arange(10)', 211 | 'a[:3]' 212 | ], 213 | }, 214 | { 215 | 'name' : 'Get last $N$ elements', 216 | 'snippet' : [ 217 | 'a = np.arange(10)', 218 | 'a[-3:]' 219 | ], 220 | }, 221 | { 222 | 'name' : 'Get elements $N$ to $M$', 223 | 'snippet' : [ 224 | 'a = np.arange(10)', 225 | 'a[3:6]' 226 | ], 227 | }, 228 | { 229 | 'name' : 'Get elements satisfying a condition', 230 | 'snippet' : [ 231 | 'a = np.arange(10)', 232 | 'a[a>5]' 233 | ], 234 | }, 235 | ], 236 | }, 237 | { 238 | 'name' : 'Index a multi-dimensional array', 239 | 'sub-menu' : [ 240 | { 241 | 'name' : 'Get one element', 242 | 'snippet' : [ 243 | 'a = np.arange(30).reshape((2,3,5))', 244 | 'a[1, 2, 4]' 245 | ], 246 | }, 247 | { 248 | 'name' : 'Get first $N$ elements along each final axis', 249 | 'snippet' : [ 250 | 'a = np.arange(30).reshape((2,3,5))', 251 | 'a[:, :, :4]' 252 | ], 253 | }, 254 | { 255 | 'name' : 'Get last $N$ elements along each final axis', 256 | 'snippet' : [ 257 | 'a = np.arange(30).reshape((2,3,5))', 258 | 'a[:, :, -3:]' 259 | ], 260 | }, 261 | { 262 | 'name' : 'Get elements $N$ to $M$ along each final axis', 263 | 'snippet' : [ 264 | 'a = np.arange(30).reshape((2,3,5))', 265 | 'a[:, :, 3:5]' 266 | ], 267 | }, 268 | { 269 | 'name' : 'Get elements satisfying a condition (flattened result)', 270 | 'snippet' : [ 271 | 'a = np.arange(30).reshape((2,3,5))', 272 | 'a[a>5]' 273 | ], 274 | }, 275 | ], 276 | }, 277 | { 278 | 'name' : 'Index an array of unknown dimension', 279 | 'sub-menu' : [ 280 | { 281 | 'name' : 'Get first $N$ elements along each final axis', 282 | 'snippet' : [ 283 | 'a = np.arange(30).reshape((2,3,5))', 284 | 'a[..., :4]' 285 | ], 286 | }, 287 | { 288 | 'name' : 'Get last $N$ elements along each final axis', 289 | 'snippet' : [ 290 | 'a = np.arange(30).reshape((2,3,5))', 291 | 'a[..., -3:]' 292 | ], 293 | }, 294 | { 295 | 'name' : 'Get elements $N$ to $M$ along each final axis', 296 | 'snippet' : [ 297 | 'a = np.arange(30).reshape((2,3,5))', 298 | 'a[..., 3:5]' 299 | ], 300 | }, 301 | { 302 | 'name' : 'Get elements satisfying a condition (flattened result)', 303 | 'snippet' : [ 304 | 'a = np.arange(30).reshape((2,3,5))', 305 | 'a[a>5]' 306 | ], 307 | }, 308 | ], 309 | }, 310 | { 311 | 'name' : '', 312 | 'snippet' : [ 313 | '' 314 | ], 315 | }, 316 | ], 317 | }, 318 | 319 | numpy_ufuncs, 320 | 321 | numpy_polynomial, 322 | 323 | // { 324 | // 'name' : 'Polynomials', 325 | // 'external-link' : 'http://docs.scipy.org/doc/numpy/reference/routines.polynomials.html', 326 | // // 'sub-menu' : [ 327 | 328 | // // ], 329 | // }, 330 | 331 | { 332 | 'name' : 'Pretty printing', 333 | 'sub-menu' : [ 334 | { 335 | 'name' : 'Context manager', 336 | 'snippet' : [ 337 | 'import contextlib', 338 | '@contextlib.contextmanager', 339 | 'def printoptions(*args, **kwargs):', 340 | ' original = np.get_printoptions()', 341 | ' np.set_printoptions(*args, **kwargs)', 342 | ' yield', 343 | ' np.set_printoptions(**original)', 344 | ], 345 | }, 346 | '---', 347 | { 348 | 'name' : 'Print to given precision', 349 | 'snippet' : [ 350 | 'with printoptions(precision=5):', 351 | ' print(np.random.random(10))', 352 | ], 353 | }, 354 | { 355 | 'name' : 'Summarize arrays with more than $N+1$ elements', 356 | 'snippet' : [ 357 | 'with printoptions(threshold=5):', 358 | ' print(np.random.random(10))', 359 | ], 360 | }, 361 | { 362 | 'name' : 'Print $N$ elements at each end of a summary', 363 | 'snippet' : [ 364 | 'with printoptions(threshold=5, edgeitems=4):', 365 | ' print(np.random.random(10))', 366 | ], 367 | }, 368 | { 369 | 'name' : 'Set number of characters per line', 370 | 'snippet' : [ 371 | 'with printoptions(linewidth=100):', 372 | ' print(np.random.random(10))', 373 | ], 374 | }, 375 | { 376 | 'name' : 'Suppress printing of small values', 377 | 'snippet' : [ 378 | 'with printoptions(suppress=True):', 379 | ' print(1e-8*np.random.random(10))', 380 | ], 381 | }, 382 | { 383 | 'name' : 'Set string with which to represent nan', 384 | 'snippet' : [ 385 | "with printoptions(nanstr='NaN!'):", 386 | ' print(np.array([1, np.nan, 3]))', 387 | ], 388 | }, 389 | { 390 | 'name' : 'Set string with which to represent infinity', 391 | 'snippet' : [ 392 | "with printoptions(infstr='oo'):", 393 | ' print(np.array([1, np.inf, 3]))', 394 | ], 395 | }, 396 | { 397 | 'name' : 'Formatting functions for specific dtypes', 398 | 'sub-menu' : [ 399 | { 400 | 'name' : 'Set formatter for `bool` type', 401 | 'snippet' : [ 402 | "def format_bool(x):", 403 | " if x:", 404 | " return 'TRUE'", 405 | " else:", 406 | " return 'FALSE'", 407 | "with printoptions(formatter={'bool': format_bool}):", 408 | " print(np.random.randint(0,2,10).astype(bool))", 409 | ], 410 | }, 411 | { 412 | 'name' : 'Set formatter for `int` type', 413 | 'snippet' : [ 414 | "def format_int(x):", 415 | " return 'int({0})'.format(x)", 416 | "with printoptions(formatter={'int': format_int}):", 417 | " print(np.random.randint(-3, 4, 10))", 418 | ], 419 | }, 420 | { 421 | 'name' : 'Set formatter for `timedelta` type', 422 | 'snippet' : [ 423 | "def format_timedelta(delta):", 424 | " days = delta.astype('timedelta64[D]').astype(int)", 425 | " hours = delta.astype('timedelta64[h]').astype(int) - 24*days", 426 | " minutes = delta.astype('timedelta64[m]').astype(int) - 60*(24*days+hours)", 427 | " seconds = delta.astype('timedelta64[s]').astype(int) - 60*(60*(24*days+hours)+minutes)", 428 | " return '{0}days,{1}hours,{2}minutes,{3}seconds'.format(days, hours, minutes, seconds)", 429 | "with printoptions(formatter={'timedelta': format_timedelta}):", 430 | " print(np.array([np.timedelta64(int(sec), 's') for sec in np.random.randint(0, 1000000, 10)]))", 431 | ], 432 | }, 433 | { 434 | 'name' : 'Set formatter for `datetime` type', 435 | 'snippet' : [ 436 | "def format_datetime(date):", 437 | " year = date.astype('datetime64[Y]').astype(int) + 1970", 438 | " month = date.astype('datetime64[M]').astype(int) % 12 + 1", 439 | " day = (date - date.astype('datetime64[M]')).astype(int) + 1", 440 | " return 'Y{0}:M{1}:D{2}'.format(year, month, day)", 441 | "with printoptions(formatter={'datetime': format_datetime}):", 442 | " days = np.random.randint(0, 20000, 10)", 443 | " dates = np.array([np.datetime64(int(d), 'D') for d in days])", 444 | " print(dates)", 445 | ], 446 | }, 447 | { 448 | 'name' : 'Set formatter for `float` type', 449 | 'snippet' : [ 450 | "def format_float(x):", 451 | " return '{0:+0.2f}'.format(x)", 452 | "with printoptions(formatter={'float': format_float}):", 453 | " print(np.random.random(10)-0.5)", 454 | ], 455 | }, 456 | { 457 | 'name' : 'Set formatter for `longfloat` type', 458 | 'snippet' : [ 459 | "def format_longfloat(x):", 460 | " return 'long{0}'.format(x)", 461 | "with printoptions(formatter={'longfloat': format_longfloat}):", 462 | " print(np.random.random(10).astype(np.longfloat))", 463 | ], 464 | }, 465 | { 466 | 'name' : 'Set formatter for `complexfloat` type', 467 | 'snippet' : [ 468 | "def format_complexfloat(x):", 469 | " return '{0.real}+1j*{0.imag}'.format(x)", 470 | "with printoptions(formatter={'complexfloat': format_complexfloat}):", 471 | " print(np.random.random(5)+1j*np.random.random(5))", 472 | ], 473 | }, 474 | { 475 | 'name' : 'Set formatter for `longcomplexfloat` type', 476 | 'snippet' : [ 477 | "def format_longcomplexfloat(x):", 478 | " return '{0.real}+1j*{0.imag}'.format(x)", 479 | "with printoptions(formatter={'longcomplexfloat': format_longcomplexfloat}):", 480 | " print(np.random.random(5).astype(np.longfloat)+1j*np.random.random(5).astype(np.longfloat))", 481 | ], 482 | }, 483 | // { 484 | // 'name' : 'Set formatter for `numpy_str` type', 485 | // 'snippet' : [ 486 | // "def format_numpy_str(x):", 487 | // " return 'n\"{0}\"'.format(x)", 488 | // "with printoptions(formatter={'numpy_str': format_numpy_str}):", 489 | // " print(np.random.random(10))", 490 | // ], 491 | // }, 492 | // { 493 | // 'name' : 'Set formatter for `str` type', 494 | // 'snippet' : [ 495 | // "def format_str(x):", 496 | // " return '\"{0}\"'.format(x)", 497 | // "with printoptions(formatter={'str': format_str}):", 498 | // " print(np.random.random(10))", 499 | // ], 500 | // }, 501 | '---', 502 | { 503 | 'name' : 'Set formatter for all types', 504 | 'snippet' : [ 505 | "def format_all(x):", 506 | " return 'repr({0})'.format(repr(x))", 507 | "with printoptions(formatter={'all': format_all}):", 508 | " print(np.array([3, 8]))", 509 | " print(np.array([0.1, 0.5]))", 510 | " print(np.array([1.4+2.3j, 2.8+4.6j]))", 511 | " print(np.array(['abc', 'xyz']))", 512 | ], 513 | }, 514 | { 515 | 'name' : 'Set formatter for all `int` types', 516 | 'snippet' : [ 517 | "def format_int_kind(x):", 518 | " return 'int({0})'.format(x)", 519 | "with printoptions(formatter={'int_kind': format_int_kind}):", 520 | " print(np.random.randint(-100, 100, 10))", 521 | ], 522 | }, 523 | { 524 | 'name' : 'Set formatter for all `float` types', 525 | 'snippet' : [ 526 | "def format_float_kind(x):", 527 | " return '{0:.2%}'.format(x)", 528 | "with printoptions(formatter={'float_kind': format_float_kind}):", 529 | " print(np.random.random(10))", 530 | ], 531 | }, 532 | { 533 | 'name' : 'Set formatter for all `complex` types', 534 | 'snippet' : [ 535 | "def format_complex_kind(x):", 536 | " return '{0.real}+1j*{0.imag}'.format(x)", 537 | "with printoptions(formatter={'complex_kind': format_complex_kind}):", 538 | " print(np.random.random(5)+1j*np.random.random(5))", 539 | ], 540 | }, 541 | { 542 | 'name' : 'Set formatter for all `str` types', 543 | 'snippet' : [ 544 | "def format_str_kind(x):", 545 | " return 'str({0})'.format(x)", 546 | "with printoptions(formatter={'str_kind': format_str_kind}):", 547 | " print(np.array(['abc', 'xyz']))", 548 | ], 549 | }, 550 | ], 551 | }, 552 | ], 553 | }, 554 | 555 | { 556 | 'name' : 'File I/O', 557 | 'sub-menu' : [ 558 | { 559 | 'name' : 'Read data from simple text file', 560 | 'snippet' : [ 561 | 'data = np.loadtxt(filename)', 562 | ], 563 | }, 564 | { 565 | 'name' : 'Read data from text file with missing values', 566 | 'snippet' : [ 567 | 'data = np.genfromtxt(filename)', 568 | ], 569 | }, 570 | { 571 | 'name' : 'Read data from .npy or .npz file', 572 | 'snippet' : [ 573 | 'data = np.load(filename)', 574 | ], 575 | }, 576 | '---', 577 | { 578 | 'name' : 'Write single array to text file', 579 | 'snippet' : [ 580 | 'np.savetxt(filename, x)', 581 | ], 582 | }, 583 | { 584 | 'name' : 'Write multiple arrays to text file', 585 | 'snippet' : [ 586 | 'np.savetxt(filename, np.transpose((x, y, z)))', 587 | ], 588 | }, 589 | { 590 | 'name' : 'Write single array to single .npy file', 591 | 'snippet' : [ 592 | 'np.save(filename, x)', 593 | ], 594 | }, 595 | { 596 | 'name' : 'Write multiple arrays to single .npy file', 597 | 'snippet' : [ 598 | 'np.save(filename, np.transpose((x, y, z)))', 599 | ], 600 | }, 601 | { 602 | 'name' : 'Write multiple arrays to single .npz file', 603 | 'snippet' : [ 604 | 'np.savez(filename, x, y, z)', 605 | ], 606 | }, 607 | { 608 | 'name' : 'Write multiple arrays to single compressed .npz file', 609 | 'snippet' : [ 610 | 'np.savez_compressed(filename, x, y, z)', 611 | ], 612 | }, 613 | ], 614 | }, 615 | ] 616 | } 617 | } 618 | ); 619 | -------------------------------------------------------------------------------- /snippets_submenus_python/scipy.js: -------------------------------------------------------------------------------- 1 | define([ 2 | "require", 3 | "./scipy_constants", 4 | "./scipy_special", 5 | ], function (require, scipy_constants, scipy_special) { 6 | return { 7 | 'name' : 'SciPy', 8 | 'sub-menu' : [ 9 | { 10 | 'name' : 'Setup', 11 | 'snippet' : [ 12 | 'from __future__ import print_function, division', 13 | 'import numpy as np', 14 | 'import scipy as sp', 15 | ], 16 | }, 17 | 18 | { 19 | 'name' : 'Documentation', 20 | 'external-link' : 'http://docs.scipy.org/doc/scipy/reference/', 21 | }, 22 | 23 | '---', 24 | 25 | // { 26 | // 'name' : 'Clustering algorithms', 27 | // 'sub-menu' : [ 28 | // { 29 | // 'name' : 'Setup', 30 | // 'snippet' : ['from scipy import cluster',], 31 | // }, 32 | // ], 33 | // }, 34 | 35 | scipy_constants, 36 | 37 | { 38 | 'name' : 'Fast Fourier Transform routines', 39 | 'sub-menu' : [ 40 | { 41 | 'name' : 'Setup', 42 | 'snippet' : ['from scipy import fftpack',], 43 | }, 44 | '---', 45 | { 46 | 'name' : 'Docs', 47 | 'external-link' : 'http://docs.scipy.org/doc/scipy-0.15.1/reference/fftpack.html' 48 | }, 49 | ], 50 | }, 51 | 52 | { 53 | 'name' : 'Integration and ODE solvers', 54 | 'sub-menu' : [ 55 | { 56 | 'name' : 'Setup', 57 | 'snippet' : ['from scipy import integrate',], 58 | }, 59 | '---', 60 | { 61 | 'name' : 'Integrate given function object', 62 | 'sub-menu' : [ 63 | { 64 | 'name' : 'General-purpose integration', 65 | 'snippet' : [ 66 | 'from scipy import integrate', 67 | 'def f(x, a, b):', 68 | ' return a * x + b', 69 | 'integral,error = integrate.quad(f, 0, 4.5, args=(2,1)) # integrates 2*x+1', 70 | 'print(integral, error)', 71 | ], 72 | }, 73 | { 74 | 'name' : 'General purpose double integration', 75 | 'snippet' : [ 76 | 'from scipy import integrate', 77 | 'def integrand(y, x):', 78 | ' return x * y**2', 79 | 'x_lower_lim, x_upper_lim = 0.0, 0.5', 80 | 'y_lower_lim, y_upper_lim = lambda x:0.0, lambda x:1.0-2.0*x', 81 | '# int_{x=0}^{0.5} int_{y=0}^{1-2x} x y dx dy', 82 | 'integral,error = integrate.dblquad(integrand,', 83 | ' x_lower_lim, x_upper_lim,', 84 | ' y_lower_lim, y_upper_lim)', 85 | 'print(integral, error)', 86 | ], 87 | }, 88 | { 89 | 'name' : 'General purpose triple integration', 90 | 'snippet' : [ 91 | 'from scipy import integrate', 92 | 'def integrand(z, y, x):', 93 | ' return x * y**2 + z', 94 | 'x_lower_lim, x_upper_lim = 0.0, 0.5', 95 | 'y_lower_lim, y_upper_lim = lambda x:0.0, lambda x:1.0-2.0*x', 96 | 'z_lower_lim, z_upper_lim = lambda x,y:-1.0, lambda x,y:1.0+2.0*x-y', 97 | '# int_{x=0}^{0.5} int_{y=0}^{1-2x} int_{z=-1}^{1+2x-y} (x y**2 + z) dz dy dx', 98 | 'integral,error = integrate.tplquad(integrand,', 99 | ' x_lower_lim, x_upper_lim,', 100 | ' y_lower_lim, y_upper_lim,', 101 | ' z_lower_lim, z_upper_lim)', 102 | 'print(integral, error)', 103 | ], 104 | }, 105 | { 106 | 'name' : 'General purpose n-fold integration', 107 | 'snippet' : [ 108 | 'from scipy import integrate', 109 | 'def integrand(x0, x1, x2):', 110 | ' return x2 * x1**2 + x0', 111 | 'x2_lim = (0.0, 0.5)', 112 | 'x1_lim = lambda x2:(0.0, 1.0-2.0*x2)', 113 | 'x0_lim = lambda x1,x2:(-1.0, 1.0+2.0*x2-x1)', 114 | '# int_{x2=0}^{0.5} int_{x1=0}^{1-2x2} int_{x0=-1}^{1+2x2-x1} (x2 x1**2 + x0) dx0 dx1 dx2', 115 | 'integral,error = integrate.nquad(integrand, [x0_lim, x1_lim, x2_lim])', 116 | 'print(integral, error)', 117 | ], 118 | }, 119 | { 120 | 'name' : 'Integrate func(x) using Gaussian quadrature of order $n$', 121 | 'snippet' : [ 122 | 'gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)', 123 | 'a,b = 0,1 # limits of integration', 124 | 'result,err = integrate.fixed_quad(gaussian, a, b, n=5)', 125 | ], 126 | }, 127 | { 128 | 'name' : 'Integrate with given tolerance using Gaussian quadrature', 129 | 'snippet' : [ 130 | 'gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)', 131 | 'a,b = 0,1 # limits of integration', 132 | 'result,err = integrate.quadrature(gaussian, a, b, tol=1e-8, rtol=1e-8)', 133 | ], 134 | }, 135 | { 136 | 'name' : 'Integrate using Romberg integration', 137 | 'snippet' : [ 138 | 'gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)', 139 | 'a,b = 0,1 # limits of integration', 140 | 'result = integrate.romberg(gaussian, a, b, tol=1e-8, rtol=1e-8)', 141 | ], 142 | }, 143 | ], 144 | }, 145 | { 146 | 'name' : 'Integrate given fixed samples', 147 | 'sub-menu' : [ 148 | { 149 | 'name' : 'Trapezoidal rule to compute integral from samples', 150 | 'snippet' : [ 151 | 'x = np.linspace(1, 5, num=100)', 152 | 'y = 3*x**2 + 1', 153 | 'integrate.trapz(y, x) # Exact value is 128', 154 | ], 155 | }, 156 | { 157 | 'name' : 'Trapezoidal rule to cumulatively compute integral from samples', 158 | 'snippet' : [ 159 | 'x = np.linspace(1, 5, num=100)', 160 | 'y = 3*x**2 + 1', 161 | 'integrate.cumtrapz(y, x) # Should range from ~0 to ~128', 162 | ], 163 | }, 164 | { 165 | 'name' : "Simpson's rule to compute integral from samples", 166 | 'snippet' : [ 167 | 'x = np.linspace(1, 5, num=100)', 168 | 'y = 3*x**2 + 1', 169 | 'integrate.simps(y, x) # Exact value is 128', 170 | ], 171 | }, 172 | { 173 | 'name' : 'Romberg Integration to compute integral from $2^k + 1$ evenly spaced samples', 174 | 'snippet' : [ 175 | 'x = np.linspace(1, 5, num=2**7+1)', 176 | 'y = 3*x**2 + 1', 177 | 'integrate.romb(y, x) # Exact value is 128', 178 | ], 179 | }, 180 | ], 181 | }, 182 | { 183 | 'name' : 'Numerically integrate ODE systems', 184 | 'sub-menu' : [ 185 | { 186 | 'name' : 'General integration of ordinary differential equations', 187 | 'snippet' : [ 188 | 'from scipy.special import gamma, airy', 189 | 'def func(y, t):', 190 | ' return [t*y[1], y[0]]', 191 | 'x = np.arange(0, 4.0, 0.01)', 192 | 'y_0 = [-1.0 / 3**(1.0/3.0) / gamma(1.0/3.0), 1.0 / 3**(2.0/3.0) / gamma(2.0/3.0)]', 193 | 'Ai, Aip, Bi, Bip = airy(x)', 194 | 'y = odeint(func, y_0, x, rtol=1e-12, atol=1e-12) # Exact answer: (Aip, Ai)', 195 | ], 196 | }, 197 | { 198 | 'name' : 'General integration of ordinary differential equations with known gradient', 199 | 'snippet' : [ 200 | 'from scipy.special import gamma, airy', 201 | 'def func(y, t):', 202 | ' return [t*y[1], y[0]]', 203 | 'def gradient(y, t):', 204 | ' return [[0,t], [1,0]]', 205 | 'x = np.arange(0, 4.0, 0.01)', 206 | 'y_0 = [-1.0 / 3**(1.0/3.0) / gamma(1.0/3.0), 1.0 / 3**(2.0/3.0) / gamma(2.0/3.0)]', 207 | 'Ai, Aip, Bi, Bip = airy(x)', 208 | 'y = odeint(func, y_0, x, rtol=1e-12, atol=1e-12, Dfun=gradient) # Exact answer: (Aip, Ai)', 209 | ], 210 | }, 211 | { 212 | 'name' : 'Integrate ODE using VODE and ZVODE routines', 213 | 'snippet' : [ 214 | "def f(t, y, arg1):", 215 | " return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]", 216 | "def jac(t, y, arg1):", 217 | " return [[1j*arg1, 1], [0, -arg1*2*y[1]]]", 218 | "y0 = [1.0j, 2.0]", 219 | "t0, t1, dt = 0.0, 10.0, 1.0", 220 | "r = integrate.ode(f, jac).set_integrator('zvode', method='bdf')", 221 | "r.set_initial_value(y0, t0)", 222 | "r.set_f_params(2.0)", 223 | "r.set_jac_params(2.0)", 224 | "while r.successful() and r.t < t1:", 225 | " r.integrate(r.t+dt)", 226 | " print('{0}: {1}'.format(r.t, r.y))", 227 | ], 228 | }, 229 | // { 230 | // 'name' : 'Integrate complex ODE using VODE and ZVODE routines', 231 | // 'snippet' : [ 232 | // 'integrate.complex_ode', 233 | // ], 234 | // }, 235 | ], 236 | }, 237 | ], 238 | }, 239 | 240 | { 241 | 'name' : 'Interpolation and smoothing splines', 242 | 'sub-menu' : [ 243 | { 244 | 'name' : 'Setup', 245 | 'snippet' : ['from scipy import interpolate',], 246 | }, 247 | '---', 248 | { 249 | 'name' : 'interp1d', 250 | 'snippet' : [ 251 | '# NOTE: `interp1d` is very slow; prefer `InterpolatedUnivariateSpline`', 252 | 'x = np.linspace(0, 10, 10)', 253 | 'y = np.cos(-x**2/8.0)', 254 | "f = interpolate.interp1d(x, y, kind='cubic')", 255 | 'X = np.linspace(0, 10, 100)', 256 | 'Y = f(X)', 257 | ], 258 | }, 259 | { 260 | 'name' : 'splrep / splrev', 261 | 'snippet' : [ 262 | 'x = np.arange(0, 2*np.pi+np.pi/4, 2*np.pi/8)', 263 | 'y = np.sin(x)', 264 | 'tck = interpolate.splrep(x, y, s=0)', 265 | 'xnew = np.arange(0,2*np.pi,np.pi/50)', 266 | 'ynew = interpolate.splev(xnew, tck, der=0)', 267 | ], 268 | }, 269 | { 270 | 'name' : 'InterpolatedUnivariateSpline', 271 | 'snippet' : [ 272 | 'x = np.arange(0, 2*np.pi+np.pi/4, 2*np.pi/8)', 273 | 'y = np.sin(x)', 274 | 's = interpolate.InterpolatedUnivariateSpline(x, y)', 275 | 'xnew = np.arange(0, 2*np.pi, np.pi/50)', 276 | 'ynew = s(xnew)', 277 | ], 278 | }, 279 | { 280 | 'name' : 'Multivariate interpolation', 281 | 'sub-menu' : [ 282 | 283 | ], 284 | }, 285 | { 286 | 'name' : '2-D Splines', 287 | 'sub-menu' : [ 288 | 289 | ], 290 | }, 291 | { 292 | 'name' : 'Radial basis functions', 293 | 'sub-menu' : [ 294 | 295 | ], 296 | }, 297 | ], 298 | }, 299 | 300 | // { 301 | // 'name' : 'Input and Output', 302 | // 'sub-menu' : [ 303 | // { 304 | // 'name' : 'Setup', 305 | // 'snippet' : ['from scipy import io',], 306 | // }, 307 | // '---', 308 | // ], 309 | // }, 310 | 311 | { 312 | 'name' : 'Linear algebra', 313 | 'sub-menu' : [ 314 | { 315 | 'name' : 'Setup', 316 | 'snippet' : ['from scipy import linalg',], 317 | }, 318 | '---', 319 | { 320 | 'name' : 'Docs', 321 | 'external-link' : 'http://docs.scipy.org/doc/scipy-0.15.1/reference/linalg.html' 322 | }, 323 | ], 324 | }, 325 | 326 | // { 327 | // 'name' : 'Maximum entropy methods', 328 | // 'sub-menu' : [ 329 | // { 330 | // 'name' : 'Setup', 331 | // 'snippet' : ['from scipy import maxentropy',], 332 | // }, 333 | // '---', 334 | // ], 335 | // }, 336 | 337 | // { 338 | // 'name' : 'N-dimensional image processing', 339 | // 'sub-menu' : [ 340 | // { 341 | // 'name' : 'Setup', 342 | // 'snippet' : ['from scipy import ndimage',], 343 | // }, 344 | // '---', 345 | // ], 346 | // }, 347 | 348 | // { 349 | // 'name' : 'Orthogonal distance regression', 350 | // 'sub-menu' : [ 351 | // { 352 | // 'name' : 'Setup', 353 | // 'snippet' : ['from scipy import odr',], 354 | // }, 355 | // '---', 356 | // ], 357 | // }, 358 | 359 | { 360 | 'name' : 'Optimization and root-finding routines', 361 | 'sub-menu' : [ 362 | { 363 | 'name' : 'Setup', 364 | 'snippet' : [ 365 | 'from scipy import optimize', 366 | ], 367 | }, 368 | '---', 369 | { 370 | 'name' : 'Scalar function minimization', 371 | 'sub-menu' : [ 372 | { 373 | 'name' : 'Unconstrained minimization', 374 | 'snippet' : [ 375 | 'f = lambda x: (x - 2) * (x + 1)**2', 376 | "res = optimize.minimize_scalar(f, method='brent')", 377 | 'print(res.x)', 378 | ], 379 | }, 380 | { 381 | 'name' : 'Bounded minimization', 382 | 'snippet' : [ 383 | 'from scipy.special import j1 # Test function', 384 | "res = optimize.minimize_scalar(j1, bounds=(4, 7), method='bounded')", 385 | 'print(res.x)', 386 | ], 387 | }, 388 | ], 389 | }, 390 | { 391 | 'name' : 'General-purpose optimization', 392 | 'sub-menu' : [ 393 | { 394 | 'name' : 'Nelder-Mead Simplex algorithm', 395 | 'snippet' : [ 396 | 'def rosen(x):', 397 | ' """The Rosenbrock function"""', 398 | ' return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)', 399 | 'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])', 400 | "res = optimize.minimize(rosen, x0, method='nelder-mead',", 401 | " options={'xtol': 1e-8, 'disp': True})", 402 | 'print(res.x)',], 403 | }, 404 | { 405 | 'name' : 'Broyden-Fletcher-Goldfarb-Shanno (BFGS), analytical derivative', 406 | 'snippet' : [ 407 | 'def rosen(x):', 408 | ' """The Rosenbrock function"""', 409 | ' return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)', 410 | 'def rosen_der(x):', 411 | ' """Derivative of the Rosenbrock function"""', 412 | ' xm = x[1:-1]', 413 | ' xm_m1 = x[:-2]', 414 | ' xm_p1 = x[2:]', 415 | ' der = np.zeros_like(x)', 416 | ' der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)', 417 | ' der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])', 418 | ' der[-1] = 200*(x[-1]-x[-2]**2)', 419 | ' return der', 420 | 'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])', 421 | "res = optimize.minimize(rosen, x0, method='BFGS', jac=rosen_der, options={'disp': True})", 422 | 'print(res.x)',], 423 | }, 424 | { 425 | 'name' : 'Broyden-Fletcher-Goldfarb-Shanno (BFGS), finite-difference derivative', 426 | 'snippet' : [ 427 | 'def rosen(x):', 428 | ' """The Rosenbrock function"""', 429 | ' return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)', 430 | 'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])', 431 | "res = optimize.minimize(rosen, x0, method='BFGS', options={'disp': True})", 432 | 'print(res.x)',], 433 | }, 434 | { 435 | 'name' : 'Newton-Conjugate-Gradient, full Hessian', 436 | 'snippet' : [ 437 | 'def rosen(x):', 438 | ' """The Rosenbrock function"""', 439 | ' return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)', 440 | 'def rosen_der(x):', 441 | ' """Derivative of the Rosenbrock function"""', 442 | ' xm = x[1:-1]', 443 | ' xm_m1 = x[:-2]', 444 | ' xm_p1 = x[2:]', 445 | ' der = np.zeros_like(x)', 446 | ' der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)', 447 | ' der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])', 448 | ' der[-1] = 200*(x[-1]-x[-2]**2)', 449 | ' return der', 450 | 'def rosen_hess(x):', 451 | ' x = np.asarray(x)', 452 | ' H = np.diag(-400*x[:-1],1) - np.diag(400*x[:-1],-1)', 453 | ' diagonal = np.zeros_like(x)', 454 | ' diagonal[0] = 1200*x[0]-400*x[1]+2', 455 | ' diagonal[-1] = 200', 456 | ' diagonal[1:-1] = 202 + 1200*x[1:-1]**2 - 400*x[2:]', 457 | ' H = H + np.diag(diagonal)', 458 | ' return H', 459 | 'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])', 460 | "res = optimize.minimize(rosen, x0, method='Newton-CG', jac=rosen_der, hess=rosen_hess,", 461 | " options={'xtol': 1e-8, 'disp': True})", 462 | 'print(res.x)'], 463 | }, 464 | { 465 | 'name' : 'Newton-Conjugate-Gradient, Hessian product', 466 | 'snippet' : [ 467 | 'def rosen(x):', 468 | ' """The Rosenbrock function"""', 469 | ' return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)', 470 | 'def rosen_der(x):', 471 | ' """Derivative of the Rosenbrock function"""', 472 | ' xm = x[1:-1]', 473 | ' xm_m1 = x[:-2]', 474 | ' xm_p1 = x[2:]', 475 | ' der = np.zeros_like(x)', 476 | ' der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)', 477 | ' der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])', 478 | ' der[-1] = 200*(x[-1]-x[-2]**2)', 479 | ' return der', 480 | 'def rosen_hess_p(x,p):', 481 | ' x = np.asarray(x)', 482 | ' Hp = np.zeros_like(x)', 483 | ' Hp[0] = (1200*x[0]**2 - 400*x[1] + 2)*p[0] - 400*x[0]*p[1]', 484 | ' Hp[1:-1] = (-400*x[:-2]*p[:-2]+(202+1200*x[1:-1]**2-400*x[2:])*p[1:-1] ', 485 | ' -400*x[1:-1]*p[2:])', 486 | ' Hp[-1] = -400*x[-2]*p[-2] + 200*p[-1]', 487 | ' return Hp', 488 | 'x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])', 489 | "res = optimize.minimize(rosen, x0, method='Newton-CG', jac=rosen_der, hessp=rosen_hess_p,", 490 | " options={'xtol': 1e-8, 'disp': True})", 491 | 'print(res.x)'], 492 | }, 493 | ], 494 | }, 495 | { 496 | 'name' : 'Constrained multivariate minimization', 497 | 'sub-menu' : [ 498 | { 499 | 'name' : 'Unconstrained Sequential Least SQuares Programming (SLSQP)', 500 | 'snippet' : [ 501 | 'def func(x, sign=1.0):', 502 | ' """ Objective function """', 503 | ' return sign*(2*x[0]*x[1] + 2*x[0] - x[0]**2 - 2*x[1]**2)', 504 | 'def func_deriv(x, sign=1.0):', 505 | ' """ Derivative of objective function """', 506 | ' dfdx0 = sign*(-2*x[0] + 2*x[1] + 2)', 507 | ' dfdx1 = sign*(2*x[0] - 4*x[1])', 508 | ' return np.array([ dfdx0, dfdx1 ])', 509 | "res = optimize.minimize(func, [-1.0,1.0], args=(-1.0,), jac=func_deriv,", 510 | " method='SLSQP', options={'disp': True})", 511 | 'print(res.x)', 512 | ], 513 | }, 514 | { 515 | 'name' : 'Constrained Sequential Least SQuares Programming (SLSQP)', 516 | 'snippet' : [ 517 | 'def func(x, sign=1.0):', 518 | ' """ Objective function """', 519 | ' return sign*(2*x[0]*x[1] + 2*x[0] - x[0]**2 - 2*x[1]**2)', 520 | 'def func_deriv(x, sign=1.0):', 521 | ' """ Derivative of objective function """', 522 | ' dfdx0 = sign*(-2*x[0] + 2*x[1] + 2)', 523 | ' dfdx1 = sign*(2*x[0] - 4*x[1])', 524 | ' return np.array([ dfdx0, dfdx1 ])', 525 | '# Constraints correspond to x**3-y=0 and y-1>=0, respectively', 526 | "cons = ({'type': 'eq',", 527 | " 'fun' : lambda x: np.array([x[0]**3 - x[1]]),", 528 | " 'jac' : lambda x: np.array([3.0*(x[0]**2.0), -1.0])},", 529 | " {'type': 'ineq',", 530 | " 'fun' : lambda x: np.array([x[1] - 1]),", 531 | " 'jac' : lambda x: np.array([0.0, 1.0])})", 532 | "res = optimize.minimize(func, [-1.0,1.0], args=(-1.0,), jac=func_deriv,", 533 | " constraints=cons, method='SLSQP', options={'disp': True})", 534 | 'print(res.x)', 535 | ], 536 | }, 537 | ], 538 | }, 539 | { 540 | 'name' : 'Fitting (see also numpy.polynomial)', 541 | 'sub-menu' : [ 542 | { 543 | 'name' : 'Basic function fitting', 544 | 'snippet' : [ 545 | 'def fitting_function(x, a, b, c):', 546 | ' return a * np.exp(-b * x) + c', 547 | 'xdata = np.linspace(0, 4, 50)', 548 | 'ydata = fitting_function(xdata, 2.5, 1.3, 0.5) + 0.2 * np.random.normal(size=len(xdata))', 549 | 'optimal_parameters, estimated_covariance = optimize.curve_fit(fitting_function, xdata, ydata)', 550 | 'estimated_std_dev = np.sqrt(np.diag(estimated_covariance))', 551 | ], 552 | }, 553 | ], 554 | }, 555 | ], 556 | }, 557 | 558 | // { 559 | // 'name' : 'Signal processing', 560 | // 'sub-menu' : [ 561 | // { 562 | // 'name' : 'Setup', 563 | // 'snippet' : ['from scipy import signal',], 564 | // }, 565 | // '---', 566 | // ], 567 | // }, 568 | 569 | // { 570 | // 'name' : 'Sparse matrices and associated routines', 571 | // 'sub-menu' : [ 572 | // { 573 | // 'name' : 'Setup', 574 | // 'snippet' : ['from scipy import sparse',], 575 | // }, 576 | // '---', 577 | // ], 578 | // }, 579 | 580 | // { 581 | // 'name' : 'Spatial data structures and algorithms', 582 | // 'sub-menu' : [ 583 | // { 584 | // 'name' : 'Setup', 585 | // 'snippet' : ['from scipy import spatial',], 586 | // }, 587 | // '---', 588 | // ], 589 | // }, 590 | 591 | scipy_special, 592 | 593 | { 594 | 'name' : 'Statistical distributions and functions', 595 | 'sub-menu' : [ 596 | { 597 | 'name' : 'Setup', 598 | 'snippet' : ['from scipy import stats',], 599 | }, 600 | '---', 601 | { 602 | 'name' : 'Docs', 603 | 'external-link' : 'http://docs.scipy.org/doc/scipy-0.15.1/reference/stats.html' 604 | }, 605 | ], 606 | }, 607 | 608 | // { 609 | // 'name' : 'C/C++ integration', 610 | // 'sub-menu' : [ 611 | // { 612 | // 'name' : 'Setup', 613 | // 'snippet' : ['from scipy import weave',], 614 | // }, 615 | // '---', 616 | // ], 617 | // }, 618 | ], 619 | }; 620 | }); 621 | --------------------------------------------------------------------------------