Saravanan666/pypi-org huggingface dataset:
Package: jupyter-server-mathjax
MathJax resources endpoints for Jupyter ServerBasic UsageInstall from PyPI:>pipinstalljupyter_server_mathjaxThis will automatically enable the extension in Jupyter Server.To test the installation, you can run Jupyter Server and visit the/static/jupyter_server_mathjax/MathJax.jsendpoint:>jupyterserverMaintenance NotesTo install an editable install locally for development, first clone the repository locally,
then run:`pipinstall-e.[test]`Note that the editable install will not install the data file that
automatically configures the extension for use. To manually enable it, run:jupyterserverextensionenable--pyjupyter_server_mathjaxTo build for distribution, use thebuildpackage:pipinstallbuild
python-mbuildThen release using twine:twinecheckdist/*
twinecheckdist/*
Package: jupyter-server-proxy
Jupyter Server ProxyJupyter Server Proxy lets you run arbitrary external processes (such as
RStudio, Shiny Server, Syncthing, PostgreSQL, Code Server, etc)
alongside your notebook server and provide authenticated web access to
them using a path like/rstudionext to others like/lab. Alongside
the python package that provides the main functionality, the JupyterLab
extension (@jupyterhub/jupyter-server-proxy) provides buttons in the
JupyterLab launcher window to get to RStudio for example.Note:This project used to be callednbserverproxy. As
nbserverproxy is an older version of jupyter-server-proxy, uninstall
nbserverproxy before installing jupyter-server-proxy to avoid conflicts.The primary use cases are:Use with JupyterHub / Binder to allow launching users into web
interfaces that have nothing to do with Jupyter - such as RStudio,
Shiny, or OpenRefine.Allow access from frontend javascript (in classic notebook or
JupyterLab extensions) to access web APIs of other processes running
locally in a safe manner. This is used by theJupyterLab
extensionfordask.The documentationcontains information on installation & usage.Security warningJupyter Server Proxy is often used to start a user defined process listening to
some network port (e.g.http://localhost:4567) for a user starting a Jupyter Server
that only that user has permission to access. The user can then access the
started process proxied through the Jupyter Server.For safe use of Jupyter Server Proxy, you should ensure that the process started
by Jupyter Server proxy can't be accessed directly by another user and bypass
the Jupyter Server's authorization!A common strategy to enforce access proxied via Jupyter Server is to start
Jupyter Server within a container and only allow network access to the Jupyter
Server via the container.For more insights, seeRyan Lovett's comment about
it.InstallPython packagepippipinstalljupyter-server-proxycondacondainstall-cconda-forgejupyter-server-proxyJupyter Client ExtensionsA JupyterLab and Notebook extension is bundled with the Python package to
provide:servers in theNewdropwdown of the Notebook Tree viewlaunch buttons in JupyterLab's Launcher panel for registered server processes.Client compatibilityFor historical compatibility ranges, see the table below:jupyter-server-proxynotebookjupyterlab4.1.x>=6,<8>=3,<54.0.x>=6,<7>=3,<43.x>=6,<7>=2,<4DisableServer extensionjupyterserverextensiondisable--sys-prefixjupyter_server_proxy
jupyterserverextensiondisable--sys-prefixjupyter_server_proxyNotebook Classic extensionjupyternbextensiondisable--sys-prefix--pyjupyter_server_proxyJupyterLab extensionjupyterlabextensiondisable@jupyterhub/jupyter-server-proxyLocal developmentTo setup a local development environment, see thecontributing guide.
Package: jupyter-server-synchronizer
Jupyter Server SynchronizerA Jupyter Server Session Manager that rehydrates and persists kernels and sessions beyond the lifetime of a server.This is particularly useful for Jupyter Servers running remote kernels and contents.Basic usageInstall and enable the extension:pip install jupyter_server_synchronizer

jupyter server extension enable jupyter_server_synchronizerWhen you start a Jupyter Server, it synchronize all managers before the Web application is started.jupyter server --ServerApp.session_manager_class=jupyter_server_synchronizer.SynchronizerSessionManagerTo synchronize periodically, enable the auto-synchronizing feature using theautosyncconfig option. For example,jupyter server --ServerApp.session_manager_class=jupyter_server_synchronizer.SynchronizerSessionManager --SynchronizerSessionManager.autosync=TrueOtherwise, you can trigger the synchronization making aPOSTrequest to the/api/syncendpoint.ExampleBelow is a example of running the synchronizer with Jupyter Server talking to a Jupyter Kernel Gateway as its "remote" kernel service provider.First, start the Kernel Gateway. You'll need to enable thelist_kernelsmethod. In the example, we are assuming the Kernel Gateway isnotmulti-tenant; i.e. there is a single KG for a single Jupyter Server. We'll set the port to9999to free up8888for our Jupyter Server.jupyter kernelgateway \
    --port 9999 \
    --JupyterWebsocketPersonality.list_kernels=TrueSecond, start the Jupyter Server and point it at the Kernel Gateway. Note that we set adatabase_filepathtrait in both theSessionManagerandSynchronizerExtension(these paths don't need to be the same). The Synchronize relies on saving/storing of information about Jupyter kernels and sessions in a persistent database. This information is necessary to rehydrate and synchronize.We'll enable the "autosync" feature to periodically synchronize the server.jupyter lab \
    --gateway-url=http://127.0.0.1:9999 \
    --ServerApp.session_manager_class=jupyter_server_synchronizer.SynchronizerSessionManager
    --SynchronizerSessionManager.database_filepath=jupyter-database.db \
    --SynchronizerSessionManager.autosync=True \
    --SynchronizerSessionManager.log_level=DEBUGNow, let's kill that server:kill -9 $(echo $(pgrep -lf jupyter-lab) | awk '{print $1;}')And restart it to see if the kernels rehydrate and begin synchronizing again.jupyter lab \
    --gateway-url=http://127.0.0.1:9999 \
    --ServerApp.session_manager_class=jupyter_server_synchronizer.SynchronizerSessionManager
    --SessionManager.database_filepath=jupyter-database.db \
    --SynchronizerSessionManager.autosync=True \
    --SynchronizerSessionManager.log_level=DEBUG
Package: jupyter-server-terminals
Jupyter Server TerminalsJupyter Server Terminals is a Jupyter Server Extension providing support for terminals.Installation and Basic usageTo install the latest release locally, make sure you havepip installedand run:pip install jupyter_server_terminalsJupyter Server Terminals currently supports Python>=3.6 on Linux, OSX and Windows.TestingSeeCONTRIBUTING.ContributingIf you are interested in contributing to the project, seeCONTRIBUTING.About the Jupyter Development TeamThe Jupyter Development Team is the set of all contributors to the Jupyter project.
This includes all of the Jupyter subprojects.The core team that coordinates development on GitHub can be found here:https://github.com/jupyter/.Our Copyright PolicyJupyter uses a shared copyright model. Each contributor maintains copyright
over their contributions to Jupyter. But, it is important to note that these
contributions are typically only changes to the repositories. Thus, the Jupyter
source code, in its entirety is not the copyright of any single person or
institution. Instead, it is the collective copyright of the entire Jupyter
Development Team. If individual contributors want to maintain a record of what
changes/contributions they have specific copyright on, they should indicate
their copyright in the commit message of the change, when they commit the
change to one of the Jupyter repositories.With this in mind, the following banner should be used in any source code file
to indicate the copyright and license terms:# Copyright (c) Jupyter Development Team.
# Distributed under the terms of the Modified BSD License.
Package: jupyter_server_terminals_proxy
Jupyter Server Terminals ProxyIn one terminal/environment:pip install fps_uvicornpip install fps_terminalspip install fps-noauth#launchaterminalserverathttp://127.0.0.1:8000fps-uvicorn --port=8000 --no-open-browserIn another terminal/environment:pip install jupyter_server_terminals_proxypip install jupyterlab#launchJupyterLabathttp://127.0.0.1:8888andproxyterminalsathttp://127.0.0.1:8000jupyter lab --port=8888 --ServerApp.terminals_enabled=False --TerminalsProxyExtensionApp.proxy_url='http://127.0.0.1:8000'Terminals should now be served fromhttp://127.0.0.1:8000.
Package: jupyter-server-widget
# Jupyter Server WidgetJupyter Notebook %%magics and Widget to start and stop servers from a CellUsageLoad extension inside a Jupyter notebook:` %load_ext jupyterserverwidget `Add server commands with cell magic:` %server myserver1--argsmyargs `` %%servers myserver1--argsmyargs myserver2--argsmyargs `Click buttons to start them, click again to stop.Examples![Screenshot](screenshot.png “Examples”)InstallationInstall and activate dependencies:[ipywidgets](https://github.com/jupyter-widgets/ipywidgets)Then:$ pip install jupyter_server_widget
Package: jupyter-server-ydoc
Jupyter Server YDocJupyter Server YDoc is a Jupyter Server Extension providing support for Y documents.Installation and Basic usageTo install the latest release locally, make sure you havepip installedand run:pip install jupyter_server_ydocJupyter Server YDoc currently supports Python>=3.6 on Linux, OSX and Windows.TestingSeeCONTRIBUTING.ContributingIf you are interested in contributing to the project, seeCONTRIBUTING.
Package: jupyter-sigplot
A Custom Jupyter Widget Library for the SigPlot plotting libraryInstallationTo install usepip:$ pip install jupyter-sigplot
$ jupyter nbextension enable --py --sys-prefix jupyter_sigplotFor a development installation (requiresnpm):$ git clone https://github.com/LGSInnovations/jupyter-sigplot.git
$ cd jupyter-sigplot
$ python setup.py install
$ jupyter nbextension install --py --symlink --sys-prefix jupyter_sigplot
$ jupyter nbextension enable --py --sys-prefix jupyter_sigplot
Package: jupyter-simlin
simlin Jupyter widgetEdit system dynamics models from Jupyter notebooksThis extension is composed of a Python package namedsimlinfor the server extension and a NPM package namedsimlinfor the frontend extension.RequirementsJupyterLab >= 3.0Installpipinstalljupyter-simlinTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the simlin directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Rebuild extension Typescript source after making changesjlpmrunbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmrunwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm run buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseUninstallpipuninstalljupyter-simlin
Package: jupyter-singleton
jupyter-singletonIntroductionjupyter-singleton is a wrapper for the jupyter notebook that allows using output cells from outside of thejupyter notebookenvironment. Thus it enables you to useipywidgetsandGrammar of Graphicspackages whilst programming in your favorite IDE.UsageExample 1You can use the jupyter-singletondisplayfunction similar to the IPythondisplayfunction. However, here the result will be shown in a new browser window.from ipywidgets import Label
from jupyter_singleton.direct import display

display(Label('I will be displayed in a browser window'))
display(Label('I will be displayed in another browser window'))Example 2You can also use jupyter-singletonsopen_singletonfunction to activate a jupyter output-cell in a new browser window. Than you can use the traditional IPythondisplayfunction to show your widgets, as well as ipywidgetsinteractfunction.from IPython.display import display
from ipywidgets import interact, Label
from jupyter_singleton.direct import open_singleton


def f(x):
    return x


open_singleton()
interact(f, x=10)
display(Label('I will be displayed in the same browser window as the interact-slider'))Dependenciesipykernel(version >= 5.1.1)IPython(version >= 7.5.0)jinja2(version >= 2.10.1)jupyter_client(version >= 5.2.4)jupyter_nbextensions_configurator(version >= 0.4.1)notebook(version >= 5.7.8)tornado(version >= 6.0.2)Installation$ pip install jupyter-singletonLicenseThis software is licensed under the MIT license. See theLICENSEfile
for details.
Package: jupyter-slurm-provisioner
Installationpip installslurm-provisionerOverviewThe slurm provisioner is a subclass of`jupyter_client.KernelProvisionerBase<https://github.com/jupyter/jupyter_client/blob/v7.4.2/jupyter_client/provisioning/provisioner_base.py#L24>`__.
Its area of use is any slurm-based HPC system. However, it was written
to be used within the Juelich Supercomputing Centre, which uses a script
calledjutilto create a user-specific environment based on a
project. You may have to updatescripts/slurmel_allocateto use it
on any other HPC system. It allows users to start their jupyter kernel
on any partition, while their notebook server is running on an
interactive login node. This offers a separation between code execution
and user interface. The slurm provisioner will not use its ipykernel
argv configuration but is meant to be a wrapper for any existing kernel.
It is recommended to use this kernel with the option`--KernelRestarter.restart_limit=0<https://github.com/jupyter/jupyter_client/blob/v7.4.2/jupyter_client/restarter.py#L43>`__
to avoid unsought compute time and costs.ConfigurationConfigure a kernel.json file in your$HOME. It is not recommended to
define the kernel globally, since the configuration is user-specific.Optionsproject [required]: Used for correct budgeting of compute time.partition [required]: specify the slurm partitionnodes [required]: specify the number of nodesruntime [required]: specify the runtime in minuteskernel_argv [required]: copy & paste this from the kernel you want to
rungpus [optional]: specify the number of GPUs, if the partition
supports GPUsreservation [optional]: specify the slurm reservation, if you have
onejobid [optional]: specify a pre-existing slurm allocation and start
your kernel there. Without this, a new allocation for each kernel
will be created.node [optional]: specify a node in your pre-existing allocationExamplekernel.json.local/share/jupyter/kernels/slurmel/kernel.json{
    "display_name": "Slurm Kernel",
    "language": "python",
    "metadata": {
        "debugger": true,
        "kernel_provisioner": {
            "config": {
                "gpus": "0",
                "nodes": "2",
                "partition": "batch",
                "project": "...",
                "reservation": "None",
                "runtime": 30,
                "jobid": "None",
                "node": "None",
                "kernel_argv": [
                    "~/.local/share/jupyter/kernels/my_kernel/kernel.sh",
                    "-f",
                    "{connection_file}"
                ]
            },
            "provisioner_name": "slurm-provisioner"
        }
    }
}
Package: jupyter-slurm-provisioner-extension
jupyter_slurm_provisioner_extensionConfigure the Slurm kernel in JupyterLabThis extension is composed of a Python package namedjupyter_slurm_provisioner_extensionfor the server extension and a NPM package namedjupyter-slurm-provisioner-extensionfor the frontend extension.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstalljupyter_slurm_provisioner_extensionUninstallTo remove the extension, execute:pipuninstalljupyter_slurm_provisioner_extensionTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the jupyter_slurm_provisioner_extension directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenablejupyter_slurm_provisioner_extension# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstall# Server extension must be manually disabled in develop modejupyterserverextensiondisablejupyter_slurm_provisioner_extension
pipuninstalljupyter_slurm_provisioner_extensionIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedjupyter-slurm-provisioner-extensionwithin that folder.Packaging the extensionSeeRELEASE
Package: jupyter-slurm-provisioner-extension-nh
jupyter_slurm_provisioner_extension_nhConfigure the Slurm kernel in JupyterLabThis extension is composed of a Python package namedjupyter_slurm_provisioner_extension_nhfor the server extension and a NPM package namedjupyter-slurm-provisioner-extension-nhfor the frontend extension.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstalljupyter_slurm_provisioner_extension_nhUninstallTo remove the extension, execute:pipuninstalljupyter_slurm_provisioner_extension_nhTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the jupyter_slurm_provisioner_extension_nh directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenablejupyter_slurm_provisioner_extension_nh# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstall# Server extension must be manually disabled in develop modejupyterserverextensiondisablejupyter_slurm_provisioner_extension_nh
pipuninstalljupyter_slurm_provisioner_extension_nhIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedjupyter-slurm-provisioner-extension-nhwithin that folder.Packaging the extensionSeeRELEASE
Package: jupyter-source-magic
# Jupyter Source MagicA Jupyter Notebook %%magic to quickly edit and run source code.Both saves and evaluates source code when cell is runAccepts and evaluates other cell magic annotations, without saving themDeals with existing files and monitors external changesDisclaimerThis is an experimental project. Use at your own risk.UsageLoad extension inside a Jupyter notebook:` %load_ext jupytersourcemagic `Add code with Cell magic:` %%source path/to/source.py # code to run `Run to save and evaluate.ExamplesSave and run a script:` %%source path/to/source.pyprint('hello')`Load an existing source to edit.` %loadsource path/to/source.py ## when run, cell contents will be replaced with path/to/source.py `Handle other cell magic annotations:` %%source path/to/source.sh %%bash echo 'hello' `HelpDisplay usage and configuration options:` %%source? `InstallationInstall and activate dependencies:[ipywidgets](https://github.com/jupyter-widgets/ipywidgets)[jupyter-interval-widget](https://github.com/srizzo/jupyter-interval-widget)Then:$ pip install jupyter-source-magic