Add files using upload-large-folder tool

.bashrc

@@ -0,0 +1,107 @@
+# ~/.bashrc: executed by bash(1) for non-login shells.
+# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
+# for examples
+
+# If not running interactively, don't do anything
+[ -z "$PS1" ] && return
+
+# don't put duplicate lines in the history. See bash(1) for more options
+# ... or force ignoredups and ignorespace
+HISTCONTROL=ignoredups:ignorespace
+
+# append to the history file, don't overwrite it
+shopt -s histappend
+
+# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
+HISTSIZE=1000
+HISTFILESIZE=2000
+
+# check the window size after each command and, if necessary,
+# update the values of LINES and COLUMNS.
+shopt -s checkwinsize
+
+# make less more friendly for non-text input files, see lesspipe(1)
+[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"
+
+# set variable identifying the chroot you work in (used in the prompt below)
+if [ -z "$debian_chroot" ] && [ -r /etc/debian_chroot ]; then
+    debian_chroot=$(cat /etc/debian_chroot)
+fi
+
+# set a fancy prompt (non-color, unless we know we "want" color)
+case "$TERM" in
+    xterm-color) color_prompt=yes;;
+esac
+
+# uncomment for a colored prompt, if the terminal has the capability; turned
+# off by default to not distract the user: the focus in a terminal window
+# should be on the output of commands, not on the prompt
+#force_color_prompt=yes
+
+if [ -n "$force_color_prompt" ]; then
+    if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
+	# We have color support; assume it's compliant with Ecma-48
+	# (ISO/IEC-6429). (Lack of such support is extremely rare, and such
+	# a case would tend to support setf rather than setaf.)
+	color_prompt=yes
+    else
+	color_prompt=
+    fi
+fi
+
+if [ "$color_prompt" = yes ]; then
+    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
+else
+    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
+fi
+unset color_prompt force_color_prompt
+
+# If this is an xterm set the title to user@host:dir
+case "$TERM" in
+xterm*|rxvt*)
+    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
+    ;;
+*)
+    ;;
+esac
+
+# enable color support of ls and also add handy aliases
+if [ -x /usr/bin/dircolors ]; then
+    test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
+    alias ls='ls --color=auto'
+    #alias dir='dir --color=auto'
+    #alias vdir='vdir --color=auto'
+
+    alias grep='grep --color=auto'
+    alias fgrep='fgrep --color=auto'
+    alias egrep='egrep --color=auto'
+fi
+
+# some more ls aliases
+alias ll='ls -alF'
+alias la='ls -A'
+alias l='ls -CF'
+
+# Alias definitions.
+# You may want to put all your additions into a separate file like
+# ~/.bash_aliases, instead of adding them here directly.
+# See /usr/share/doc/bash-doc/examples in the bash-doc package.
+
+if [ -f ~/.bash_aliases ]; then
+    . ~/.bash_aliases
+fi
+
+# enable programmable completion features (you don't need to enable
+# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
+# sources /etc/bash.bashrc).
+#if [ -f /etc/bash_completion ] && ! shopt -oq posix; then
+#    . /etc/bash_completion
+#fi
+cat /etc/runpod.txt
+echo -e "\nFor detailed documentation and guides, please visit:\n\033[1;34mhttps://docs.runpod.io/\033[0m and \033[1;34mhttps://blog.runpod.io/\033[0m\n\n"
+PATH='/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin'
+VAST_CONTAINERLABEL="$(cat ~/.vast_containerlabel)"
+PS1="\[\e]0;\u@$VAST_CONTAINERLABEL: \w\a\]\[\e[01;34m\]\u\[\e[m\e[01m\]@\[\e[01;36m\]$VAST_CONTAINERLABEL\[\e[m\e[01m\]:\[\e[01;37m\]\w\$\[\e[m\] " ; if [ ! -e "$HOME/.no_auto_tmux" ] && [[ -z "$TMUX" ]] && [ "$SSH_CONNECTION" != "" ] && [ "$TMUX_STARTED" = "" ]; then tmux attach-session -t ssh_tmux || tmux new-session -s ssh_tmux; exit; elif ! [[ -z "$TMUX" ]]; then echo 'Welcome to your vast.ai container! This session is running in `tmux`.'; echo 'To disconnect without closing your processes, press ctrl+b, release, then d.'; echo 'To disable auto-tmux, run `touch ~/.no_auto_tmux` and reconnect. See also https://tmuxcheatsheet.com/'; fi; 
+DIRECT_PORT_START=0
+DIRECT_PORT_END=0
+VAST_CONTAINERLABEL=C.12728823

.cache/pip/http-v2/4/2/f/8/a/42f8a0202dbbd3a131c6443d28a5b01775c53d41dec7e7928a8b5a4c.body

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: multidict
+Version: 6.1.0
+Summary: multidict implementation
+Home-page: https://github.com/aio-libs/multidict
+Author: Andrew Svetlov
+Author-email: [email protected]
+License: Apache 2
+Project-URL: Chat: Matrix, https://matrix.to/#/#aio-libs:matrix.org
+Project-URL: Chat: Matrix Space, https://matrix.to/#/#aio-libs-space:matrix.org
+Project-URL: CI: GitHub, https://github.com/aio-libs/multidict/actions
+Project-URL: Code of Conduct, https://github.com/aio-libs/.github/blob/master/CODE_OF_CONDUCT.md
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/multidict
+Project-URL: Docs: Changelog, https://multidict.aio-libs.org/en/latest/changes/
+Project-URL: Docs: RTD, https://multidict.aio-libs.org
+Project-URL: GitHub: issues, https://github.com/aio-libs/multidict/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/multidict
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: typing-extensions >=4.1.0 ; python_version < "3.11"
+
+=========
+multidict
+=========
+
+.. image:: https://github.com/aio-libs/multidict/actions/workflows/ci-cd.yml/badge.svg
+   :target: https://github.com/aio-libs/multidict/actions
+   :alt: GitHub status for master branch
+
+.. image:: https://codecov.io/gh/aio-libs/multidict/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/aio-libs/multidict
+   :alt: Coverage metrics
+
+.. image:: https://img.shields.io/pypi/v/multidict.svg
+   :target: https://pypi.org/project/multidict
+   :alt: PyPI
+
+.. image:: https://readthedocs.org/projects/multidict/badge/?version=latest
+   :target: https://multidict.aio-libs.org
+   :alt: Read The Docs build status badge
+
+.. image:: https://img.shields.io/pypi/pyversions/multidict.svg
+   :target: https://pypi.org/project/multidict
+   :alt: Python versions
+
+.. image:: https://img.shields.io/matrix/aio-libs:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat
+   :target: https://matrix.to/#/%23aio-libs:matrix.org
+   :alt: Matrix Room — #aio-libs:matrix.org
+
+.. image:: https://img.shields.io/matrix/aio-libs-space:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs-space%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat
+   :target: https://matrix.to/#/%23aio-libs-space:matrix.org
+   :alt: Matrix Space — #aio-libs-space:matrix.org
+
+Multidict is dict-like collection of *key-value pairs* where key
+might occur more than once in the container.
+
+Introduction
+------------
+
+*HTTP Headers* and *URL query string* require specific data structure:
+*multidict*. It behaves mostly like a regular ``dict`` but it may have
+several *values* for the same *key* and *preserves insertion ordering*.
+
+The *key* is ``str`` (or ``istr`` for case-insensitive dictionaries).
+
+``multidict`` has four multidict classes:
+``MultiDict``, ``MultiDictProxy``, ``CIMultiDict``
+and ``CIMultiDictProxy``.
+
+Immutable proxies (``MultiDictProxy`` and
+``CIMultiDictProxy``) provide a dynamic view for the
+proxied multidict, the view reflects underlying collection changes. They
+implement the ``collections.abc.Mapping`` interface.
+
+Regular mutable (``MultiDict`` and ``CIMultiDict``) classes
+implement ``collections.abc.MutableMapping`` and allows them to change
+their own content.
+
+
+*Case insensitive* (``CIMultiDict`` and
+``CIMultiDictProxy``) assume the *keys* are case
+insensitive, e.g.::
+
+   >>> dct = CIMultiDict(key='val')
+   >>> 'Key' in dct
+   True
+   >>> dct['Key']
+   'val'
+
+*Keys* should be ``str`` or ``istr`` instances.
+
+The library has optional C Extensions for speed.
+
+
+License
+-------
+
+Apache 2
+
+Library Installation
+--------------------
+
+.. code-block:: bash
+
+   $ pip install multidict
+
+The library is Python 3 only!
+
+PyPI contains binary wheels for Linux, Windows and MacOS.  If you want to install
+``multidict`` on another operating system (or *Alpine Linux* inside a Docker) the
+tarball will be used to compile the library from source.  It requires a C compiler and
+Python headers to be installed.
+
+To skip the compilation, please use the `MULTIDICT_NO_EXTENSIONS` environment variable,
+e.g.:
+
+.. code-block:: bash
+
+   $ MULTIDICT_NO_EXTENSIONS=1 pip install multidict
+
+Please note, the pure Python (uncompiled) version is about 20-50 times slower depending on
+the usage scenario!!!
+
+
+
+Changelog
+---------
+See `RTD page <http://multidict.aio-libs.org/en/latest/changes>`_.

.cache/pip/http-v2/7/3/5/4/e/7354e15b7a2b590d713d4782bd16917fac9db3c087fa80d4d8dc0db5.body

@@ -0,0 +1,212 @@
+Metadata-Version: 2.1
+Name: pytest
+Version: 8.3.3
+Summary: pytest: simple powerful testing with Python
+Author: Holger Krekel, Bruno Oliveira, Ronny Pfannschmidt, Floris Bruynooghe, Brianna Laugher, Florian Bruhin, Others (See AUTHORS)
+License: MIT
+Project-URL: Changelog, https://docs.pytest.org/en/stable/changelog.html
+Project-URL: Homepage, https://docs.pytest.org/en/latest/
+Project-URL: Source, https://github.com/pytest-dev/pytest
+Project-URL: Tracker, https://github.com/pytest-dev/pytest/issues
+Project-URL: Twitter, https://twitter.com/pytestdotorg
+Keywords: test,unittest
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: iniconfig
+Requires-Dist: packaging
+Requires-Dist: pluggy <2,>=1.5
+Requires-Dist: exceptiongroup >=1.0.0rc8 ; python_version < "3.11"
+Requires-Dist: tomli >=1 ; python_version < "3.11"
+Requires-Dist: colorama ; sys_platform == "win32"
+Provides-Extra: dev
+Requires-Dist: argcomplete ; extra == 'dev'
+Requires-Dist: attrs >=19.2 ; extra == 'dev'
+Requires-Dist: hypothesis >=3.56 ; extra == 'dev'
+Requires-Dist: mock ; extra == 'dev'
+Requires-Dist: pygments >=2.7.2 ; extra == 'dev'
+Requires-Dist: requests ; extra == 'dev'
+Requires-Dist: setuptools ; extra == 'dev'
+Requires-Dist: xmlschema ; extra == 'dev'
+
+.. image:: https://github.com/pytest-dev/pytest/raw/main/doc/en/img/pytest_logo_curves.svg
+   :target: https://docs.pytest.org/en/stable/
+   :align: center
+   :height: 200
+   :alt: pytest
+
+
+------
+
+.. image:: https://img.shields.io/pypi/v/pytest.svg
+    :target: https://pypi.org/project/pytest/
+
+.. image:: https://img.shields.io/conda/vn/conda-forge/pytest.svg
+    :target: https://anaconda.org/conda-forge/pytest
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest.svg
+    :target: https://pypi.org/project/pytest/
+
+.. image:: https://codecov.io/gh/pytest-dev/pytest/branch/main/graph/badge.svg
+    :target: https://codecov.io/gh/pytest-dev/pytest
+    :alt: Code coverage Status
+
+.. image:: https://github.com/pytest-dev/pytest/actions/workflows/test.yml/badge.svg
+    :target: https://github.com/pytest-dev/pytest/actions?query=workflow%3Atest
+
+.. image:: https://results.pre-commit.ci/badge/github/pytest-dev/pytest/main.svg
+   :target: https://results.pre-commit.ci/latest/github/pytest-dev/pytest/main
+   :alt: pre-commit.ci status
+
+.. image:: https://www.codetriage.com/pytest-dev/pytest/badges/users.svg
+    :target: https://www.codetriage.com/pytest-dev/pytest
+
+.. image:: https://readthedocs.org/projects/pytest/badge/?version=latest
+    :target: https://pytest.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/badge/Discord-pytest--dev-blue
+    :target: https://discord.com/invite/pytest-dev
+    :alt: Discord
+
+.. image:: https://img.shields.io/badge/Libera%20chat-%23pytest-orange
+    :target: https://web.libera.chat/#pytest
+    :alt: Libera chat
+
+
+The ``pytest`` framework makes it easy to write small tests, yet
+scales to support complex functional testing for applications and libraries.
+
+An example of a simple test:
+
+.. code-block:: python
+
+    # content of test_sample.py
+    def inc(x):
+        return x + 1
+
+
+    def test_answer():
+        assert inc(3) == 5
+
+
+To execute it::
+
+    $ pytest
+    ============================= test session starts =============================
+    collected 1 items
+
+    test_sample.py F
+
+    ================================== FAILURES ===================================
+    _________________________________ test_answer _________________________________
+
+        def test_answer():
+    >       assert inc(3) == 5
+    E       assert 4 == 5
+    E        +  where 4 = inc(3)
+
+    test_sample.py:5: AssertionError
+    ========================== 1 failed in 0.04 seconds ===========================
+
+
+Due to ``pytest``'s detailed assertion introspection, only plain ``assert`` statements are used. See `getting-started <https://docs.pytest.org/en/stable/getting-started.html#our-first-test-run>`_ for more examples.
+
+
+Features
+--------
+
+- Detailed info on failing `assert statements <https://docs.pytest.org/en/stable/how-to/assert.html>`_ (no need to remember ``self.assert*`` names)
+
+- `Auto-discovery
+  <https://docs.pytest.org/en/stable/explanation/goodpractices.html#python-test-discovery>`_
+  of test modules and functions
+
+- `Modular fixtures <https://docs.pytest.org/en/stable/explanation/fixtures.html>`_ for
+  managing small or parametrized long-lived test resources
+
+- Can run `unittest <https://docs.pytest.org/en/stable/how-to/unittest.html>`_ (or trial)
+  test suites out of the box
+
+- Python 3.8+ or PyPy3
+
+- Rich plugin architecture, with over 1300+ `external plugins <https://docs.pytest.org/en/latest/reference/plugin_list.html>`_ and thriving community
+
+
+Documentation
+-------------
+
+For full documentation, including installation, tutorials and PDF documents, please see https://docs.pytest.org/en/stable/.
+
+
+Bugs/Requests
+-------------
+
+Please use the `GitHub issue tracker <https://github.com/pytest-dev/pytest/issues>`_ to submit bugs or request features.
+
+
+Changelog
+---------
+
+Consult the `Changelog <https://docs.pytest.org/en/stable/changelog.html>`__ page for fixes and enhancements of each version.
+
+
+Support pytest
+--------------
+
+`Open Collective`_ is an online funding platform for open and transparent communities.
+It provides tools to raise money and share your finances in full transparency.
+
+It is the platform of choice for individuals and companies that want to make one-time or
+monthly donations directly to the project.
+
+See more details in the `pytest collective`_.
+
+.. _Open Collective: https://opencollective.com
+.. _pytest collective: https://opencollective.com/pytest
+
+
+pytest for enterprise
+---------------------
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of pytest and thousands of other packages are working with Tidelift to deliver commercial support and
+maintenance for the open source dependencies you use to build your applications.
+Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use.
+
+`Learn more. <https://tidelift.com/subscription/pkg/pypi-pytest?utm_source=pypi-pytest&utm_medium=referral&utm_campaign=enterprise&utm_term=repo>`_
+
+Security
+^^^^^^^^
+
+pytest has never been associated with a security vulnerability, but in any case, to report a
+security vulnerability please use the `Tidelift security contact <https://tidelift.com/security>`_.
+Tidelift will coordinate the fix and disclosure.
+
+
+License
+-------
+
+Copyright Holger Krekel and others, 2004.
+
+Distributed under the terms of the `MIT`_ license, pytest is free and open source software.
+
+.. _`MIT`: https://github.com/pytest-dev/pytest/blob/main/LICENSE

.cache/pip/http-v2/b/6/8/7/d/b687d90e2a44328db9c9ecd9af0a9c577a4e68f9d239bbb73aebc319.body

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: wheel
+Version: 0.42.0
+Summary: A built-package format for Python
+Keywords: wheel,packaging
+Author-email: Daniel Holth <[email protected]>
+Maintainer-email: Alex Grönholm <[email protected]>
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Archiving :: Packaging
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pytest >= 6.0.0 ; extra == "test"
+Requires-Dist: setuptools >= 65 ; extra == "test"
+Project-URL: Changelog, https://wheel.readthedocs.io/en/stable/news.html
+Project-URL: Documentation, https://wheel.readthedocs.io/
+Project-URL: Issue Tracker, https://github.com/pypa/wheel/issues
+Project-URL: Source, https://github.com/pypa/wheel
+Provides-Extra: test
+
+wheel
+=====
+
+This library is the reference implementation of the Python wheel packaging
+standard, as defined in `PEP 427`_.
+
+It has two different roles:
+
+#. A setuptools_ extension for building wheels that provides the
+   ``bdist_wheel`` setuptools command
+#. A command line tool for working with wheel files
+
+It should be noted that wheel is **not** intended to be used as a library, and
+as such there is no stable, public API.
+
+.. _PEP 427: https://www.python.org/dev/peps/pep-0427/
+.. _setuptools: https://pypi.org/project/setuptools/
+
+Documentation
+-------------
+
+The documentation_ can be found on Read The Docs.
+
+.. _documentation: https://wheel.readthedocs.io/
+
+Code of Conduct
+---------------
+
+Everyone interacting in the wheel project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
+

.launchpadlib/api.launchpad.net/cache/api.launchpad.net,devel,-application,json,fc4e1e3a03117146fb1e9d492ab76690

@@ -0,0 +1,19 @@
+status: 200
+date: Mon, 05 Feb 2024 23:25:35 GMT
+server: Apache/2.4.41 (Ubuntu)
+content-location: index.json
+vary: negotiate,accept,Accept-Encoding
+tcn: choice
+last-modified: Wed, 31 Jan 2024 08:46:52 GMT
+etag: "8fa-61039eb973700-gzip"
+accept-ranges: bytes
+content-type: application/json; qs=0.9
+x-cache: MISS from juju-98d295-prod-launchpad-30
+x-cache-lookup: MISS from juju-98d295-prod-launchpad-30:3128
+via: 1.1 juju-98d295-prod-launchpad-30 (squid/4.10)
+content-length: 2298
+-content-encoding: gzip
+-varied-accept: application/json
+-varied-accept-encoding: gzip, deflate
+
+{"resource_type_link": "https://api.launchpad.net/devel/#service-root", "temporary_blobs_collection_link": "https://api.launchpad.net/devel/temporary-blobs", "countries_collection_link": "https://api.launchpad.net/devel/+countries", "languages_collection_link": "https://api.launchpad.net/devel/+languages", "questions_collection_link": "https://api.launchpad.net/devel/questions", "specifications_collection_link": "https://api.launchpad.net/devel/", "bug_trackers_collection_link": "https://api.launchpad.net/devel/bugs/bugtrackers", "cves_collection_link": "https://api.launchpad.net/devel/bugs/cve", "bugs_collection_link": "https://api.launchpad.net/devel/bugs", "builders_collection_link": "https://api.launchpad.net/devel/builders", "processors_collection_link": "https://api.launchpad.net/devel/+processors", "charm_bases_collection_link": "https://api.launchpad.net/devel/+charm-bases", "charm_recipes_collection_link": "https://api.launchpad.net/devel/+charm-recipes", "branches_collection_link": "https://api.launchpad.net/devel/branches", "git_repositories_collection_link": "https://api.launchpad.net/devel/+git", "snap_bases_collection_link": "https://api.launchpad.net/devel/+snap-bases", "snaps_collection_link": "https://api.launchpad.net/devel/+snaps", "snappy_serieses_collection_link": "https://api.launchpad.net/devel/+snappy-series", "archives_collection_link": "https://api.launchpad.net/devel/archives", "livefses_collection_link": "https://api.launchpad.net/devel/livefses", "packagesets_collection_link": "https://api.launchpad.net/devel/package-sets", "translation_groups_collection_link": "https://api.launchpad.net/devel/+groups", "translation_import_queue_entries_collection_link": "https://api.launchpad.net/devel/+imports", "distributions_collection_link": "https://api.launchpad.net/devel/distros", "people_collection_link": "https://api.launchpad.net/devel/people", "polls_collection_link": "https://api.launchpad.net/devel/+polls", "projects_collection_link": "https://api.launchpad.net/devel/projects", "project_groups_collection_link": "https://api.launchpad.net/devel/projectgroups", "services_link": "https://api.launchpad.net/devel/services", "pillars_link": "https://api.launchpad.net/devel/pillars", "me_link": "https://api.launchpad.net/devel/people/+me"}

.local/share/Trash/info/train_001.bin.trashinfo

@@ -0,0 +1,3 @@
+[Trash Info]
+Path=/root/data/fineweb/train_001.bin
+DeletionDate=2024-09-26T05:50:34

.local/share/Trash/info/train_003.bin.trashinfo

@@ -0,0 +1,3 @@
+[Trash Info]
+Path=/root/data/fineweb/train_003.bin
+DeletionDate=2024-09-26T05:50:34

.local/share/Trash/info/train_006.bin.trashinfo

@@ -0,0 +1,3 @@
+[Trash Info]
+Path=/root/data/fineweb/train_006.bin
+DeletionDate=2024-09-26T05:50:34

.local/share/Trash/info/train_007.bin.trashinfo

@@ -0,0 +1,3 @@
+[Trash Info]
+Path=/root/data/fineweb/train_007.bin
+DeletionDate=2024-09-26T05:50:34

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

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

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

@@ -0,0 +1,24 @@
+define([
+    "require",
+    "./snippets_submenus_python/numpy",
+    "./snippets_submenus_python/scipy",
+    "./snippets_submenus_python/matplotlib",
+    "./snippets_submenus_python/sympy",
+    "./snippets_submenus_python/pandas",
+    "./snippets_submenus_python/astropy",
+    "./snippets_submenus_python/h5py",
+    "./snippets_submenus_python/numba",
+    "./snippets_submenus_python/python",
+], function (requirejs, numpy, scipy, matplotlib, sympy, pandas, astropy, h5py, numba, python) {
+    return {
+        numpy:numpy,
+        scipy:scipy,
+        matplotlib:matplotlib,
+        sympy:sympy,
+        pandas:pandas,
+        astropy:astropy,
+        h5py:h5py,
+        numba:numba,
+        python:python,
+    };
+});

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

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

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

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

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

@@ -0,0 +1,109 @@
+define({
+    'name' : 'List of assumptions',
+    'sub-menu' : [
+        {
+            'name' : 'Bounded',
+            'snippet' : ['Q.bounded(x)',],
+        },
+        {
+            'name' : 'Commutative',
+            'snippet' : ['Q.commutative(x)',],
+        },
+        {
+            'name' : 'Complex',
+            'snippet' : ['Q.complex(x)',],
+        },
+        {
+            'name' : 'Imaginary',
+            'snippet' : ['Q.imaginary(x)',],
+        },
+        {
+            'name' : 'Real',
+            'snippet' : ['Q.real(x)',],
+        },
+        {
+            'name' : 'Extended real',
+            'snippet' : ['Q.extended_real(x)',],
+        },
+        {
+            'name' : 'Integer',
+            'snippet' : ['Q.integer(x)',],
+        },
+        {
+            'name' : 'Odd',
+            'snippet' : ['Q.odd(x)',],
+        },
+        {
+            'name' : 'Even',
+            'snippet' : ['Q.even(x)',],
+        },
+        {
+            'name' : 'Prime',
+            'snippet' : ['Q.prime(x)',],
+        },
+        {
+            'name' : 'Composite',
+            'snippet' : ['Q.composite(x)',],
+        },
+        {
+            'name' : 'Zero',
+            'snippet' : ['Q.zero(x)',],
+        },
+        {
+            'name' : 'Nonzero',
+            'snippet' : ['Q.nonzero(x)',],
+        },
+        {
+            'name' : 'Rational',
+            'snippet' : ['Q.rational(x)',],
+        },
+        {
+            'name' : 'Algebraic',
+            'snippet' : ['Q.algebraic(x)',],
+        },
+        {
+            'name' : 'Transcendental',
+            'snippet' : ['Q.transcendental(x)',],
+        },
+        {
+            'name' : 'Irrational',
+            'snippet' : ['Q.irrational(x)',],
+        },
+        {
+            'name' : 'Finite',
+            'snippet' : ['Q.finite(x)',],
+        },
+        {
+            'name' : 'Infinite',
+            'snippet' : ['Q.infinite(x)',],
+        },
+        {
+            'name' : 'Infinitesimal',
+            'snippet' : ['Q.infinitesimal(x)',],
+        },
+        {
+            'name' : 'Negative',
+            'snippet' : ['Q.negative(x)',],
+        },
+        {
+            'name' : 'Nonnegative',
+            'snippet' : ['Q.nonnegative(x)',],
+        },
+        {
+            'name' : 'Positive',
+            'snippet' : ['Q.positive(x)',],
+        },
+        {
+            'name' : 'Nonpositive',
+            'snippet' : ['Q.nonpositive(x)',],
+        },
+        {
+            'name' : 'Hermitian',
+            'snippet' : ['Q.hermitian(x)',],
+        },
+        {
+            'name' : 'Antihermitian',
+            'snippet' : ['Q.antihermitian(x)',],
+        },
+    ],
+});