Saravanan666/pypi-org huggingface dataset:
Package: jupyter-jobstorm
Jupyter-JobStormJupyterLab is a wonderful development environment for notebooks.
By using JupyterLab, you can run a Python program easily.
In a notebook, you can run a code and get the output directly below the code cell.
In case of quick code execution and fast response, it becomes a wonderful development experience.
Waiting about one minute for the response would be fine for almost everyone.
If it takes several minutes for executing a code, how do you spend your time?
You may use time to code for the next execution, chat or have a coffee.
But, do you want to run your codes any time and get results later?Jupyter-JobStorm is a solution for executing your codes asynchronously.
Jupyter-JobStorm generates a job for a code to run and requests Jenkins to run the job.
You can check the job status and get the result through Jupyter-JobStorm.
Please see examples for details.I believe that Jenkins will catch and execute jobs which are sent from you like the mighty storm on the planet Jupiter.FeatureSupporting Jenkins as job runnerRunning a function (*)(**) of Python/SageMath script as a jobRetrieving the status and the result of the job(*) Currently only variables of function arguments are passed to the function and variables outside of the function are not supported.(**) Since version 0.4.0, function using classes defined in Jupyter code cell is supported.Requirementdill >= 0.3.5.1python-jenkins >= 1.8.0tabulate >= 0.9.0JenkinsJupyterShared directory accessible to Jupyter server and Jenkins nodes.InstallationInstallations required for Jupyter server and Jenkins nodes.$pipinstalljupyter-jobstormUsageExample 1: Python Job TestExample 2: Sage Job TestExample 3: Job Management TestLicenseJupyter-JobStorm is under MIT license.
Package: jupyter-jsmol
jupyter-jsmolThis is JSmol viewer widget which can be used in Jupyter Notebooks and JupyterLabInstallationYou can install usingpip:pipinstalljupyter_jsmolOr if you use jupyterlab:pipinstalljupyter_jsmol
jupyterlabextensioninstall@jupyter-widgets/jupyterlab-managerIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:jupyternbextensionenable--py[--sys-prefix|--user|--system]jupyter_jsmolDevelopment InstallationCreate a dev environment:condacreate-njupyter-jsmol-dev-cconda-forgepythonpipnodejsyarnjupyterjupyterlabipywidgetsjupyter-packaging==0.7.9asepymatgen
condaactivatejupyter-jsmol-devInstall the python. This will also build the TS package.# First install the python package. This will also build the JS packages.pipinstall-e".[test, examples]"# Run the python tests. This should not give you a few successful example testspy.testWhen developing your extensions, you need to manually enable your extensions with the
notebook / lab frontend. For lab, this is done by the command:cd js
jupyter labextension develop --overwrite .
yarn run buildFor classic notebook, you can run:jupyter nbextension install --sys-prefix --symlink --overwrite --py jupyter_jsmol
jupyter nbextension enable --sys-prefix --py jupyter_jsmolNote that the--symlinkflag doesn't work on Windows, so you will here have to run
theinstallcommand every time that you rebuild your extension. For certain installations
you might also need another flag instead of--sys-prefix, but we won't cover the meaning
of those flags here.How to see your changesJavaScript:If you use JupyterLab to develop then you 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 widget.# Watch the source directory in one terminal, automatically rebuilding when neededyarnrunwatch# Run JupyterLab in another terminaljupyterlabAfter a change wait for the build to finish and then refresh your browser and the changes should take effect.Python:If you make a change to the python code then you will need to restart the notebook kernel to have it take effect.
Package: jupyter-jsonnet
Jupyter-JsonnetThis package provides a Jupyter Kernel to support the Jsonnet language.  It is
based on the official Jsonnet Python bindings.After installing it, you need to register it to Jupyter with the command:python3-mjupyter_jsonnet.post_installThis kernel extends jsonnet syntax slightly to permitCells containing only statements (These produce no result, but are checked
for errrors).Definitions (statements) from previous cells to carry over, even if the cell
containing the definition produced a result.Using//jupyter: stringas the first line of a cell causes the output to be
the raw string instead of the json-escaped version, similarly to--stringat the CLI.  For use with e.g.std.manifestTomlEx()The parsing to separate statements from expressions is very simple, and can
easily be fooled by semicolons that do not terminate statements, like in
comments or strings.Building from SourceEnsure PyPAbuildis installed:pip3installbuild
python3-mbuildI don't currently have a satisfactory way of doing develop/editable installs.
Package: jupyter-js-tools
Jupyter JS ToolsA small collection of useful (?) tools written in js to use in a jupyter notebook.TicTacToePlay tic-tac-toe! The two players can be either both humans, one human and a function or two functions; it will show a tic-tac-toe game grid under the notebook cell.How does it workImporttic_tac_toefromjupyter_js_toolsand call the functiontic_tac_toe.play_game. This function will accep 3 parameters: the first two must be twohandlers, the third one defines the side of the grid (default = 3).Anhandlercan be one of two things:Noneif you want to let an human play, or a function that accepts the grid as an array of['X', 'O', 0]and the player symbol and returns the index of the next move to be played, or -1 if there is no move to be made.Code examplefromjupyter_js_toolsimporttic_tac_toeimportrandomdefrandom_player(match,symbol):free_cells=[idxforidxinrange(len(match))ifmatch[idx]==0]iflen(free_cells)==0:return-1returnrandom.choice(free_cells)tic_tac_toe.play_game('human',random_player)
Package: jupyter-kernel-chapel
# Jupyter Kernel Chapel## Using Chapel in JupyterIt is possible to use [Jupyter](http://www.jupyter.org) as front-end for Chapel.### InstallationThese installation instructions are for Ubuntu Linux 16.04 (Xenial).#### Python and JupyterIf you want to run the Jupyter notebook locally on your computer, you need a recent versionof Python 2 or 3 and Jupyter installed. The use of Python 3 is recommended.To install Python3 run```bashapt-get install python3-pip```We recommend using Python3, but you can also use Python2.To install Jupyter using pip, run```bashpip3 install jupyter```#### ChapelPlease install Chapel in shared mode```bashexport CHPL_LIB_PIC=shared```#### Jupyter Kernel Chapel```bashpip3 install jupyter-kernel-chapel```
Package: jupyter-kernel-client
jupyter_kernel_clientCode execution client based on jupyter server websocketHow to use1. Start Jupyter Server(or Lab)Enter the following command to startjupyterserverBy default, you'll get output like below, and you can get your server host islocalhost, port is8888, token
isfa42b5d1f787df44f5ca70a88c4fa6f2d42fdb4a1838c59b...
[C 2022-12-12 17:37:40.953 ServerApp]
        http://localhost:8888/?token=fa42b5d1f787df44f5ca70a88c4fa6f2d42fdb4a1838c59b
     or http://127.0.0.1:8888/?token=fa42b5d1f787df44f5ca70a88c4fa6f2d42fdb4a1838c59b2. Start a kernelUsing Jupyter Server REST API to start a kernelsee:POST /api/kernelsTODO: Start kernel by client3. Connect to kernel and execute codeYou can get thekernel_idin the request to start the kernelfromjupyter_kernel_client.clientimportKernelWebsocketClientclient=KernelWebsocketClient(kernel_id=kernel_id,# you can get it in 2. Start a kernelport='8888',# you can get port in 1. Start Jupyter Server(or Lab)host='localhost',# you can get host in 1. Start Jupyter Server(or Lab)token=token,# you can get token in 1. Start Jupyter Server(or Lab))code="""print('hello world')"""importasyncioresult=asyncio.run(client.execute(code))print(result)You will get{'outputs':[{'output_type':'stream','name':'stdout','text':'hello world\n'}],'execution_count':1}
Package: jupyter-kernel-gateway
Jupyter Kernel GatewayOverviewJupyter Kernel Gateway is a web server that provides headless access to
Jupyter kernels. Your application communicates with the kernels remotely,
through REST calls and Websockets rather than ZeroMQ messages.
There are no provisions for editing notebooks through the Kernel Gateway.
The following operation modes, called personalities, are supported
out of the box:Send code snippets for execution using theJupyter kernel protocolover Websockets. Start and stop kernels through REST calls.
This HTTP API is compatible with the respective API sections
of the Jupyter Notebook server.Serve HTTP requests from annotated notebook cells. The code snippets
are cells of a static notebook configured in the Kernel Gateway.
Annotations define which HTTP verbs and resources it supports.
Incoming requests are served by executing one of the cells in a kernel.Jupyter Kernel Gateway uses the same code as Jupyter Notebook
to launch kernels in its local process/filesystem space.
It can be containerized and scaled out using common technologies liketmpnb,Cloud Foundry, andKubernetes.Example Uses of Kernel GatewayAttach a local Jupyter Notebook server to a compute cluster in the cloud running near big data (e.g., interactive gateway to Spark)Enable a new breed of non-notebook web clients to provision and use kernels (e.g., web dashboards usingjupyter-js-services)Create microservices from notebooks using the Kernel Gatewaynotebook-httpmodeFeaturesSee theFeatures pagein the
documentation for a list of the Jupyter Kernel Gateway features.InstallationDetailed installation instructions are located in theGetting Started pageof the project docs. Here's a quick start usingpip:# install from pypipipinstalljupyter_kernel_gateway# show all config optionsjupyterkernelgateway--help-all# run it with default optionsjupyterkernelgatewayContributingTheDevelopment pageincludes information about setting up a development environment and typical developer tasks.
Package: jupyter_kernel_gateway_quarc_custom
Jupyter Kernel Gateway is a web server that supports different mechanisms for
spawning and communicating with Jupyter kernels, such as:A Jupyter Notebook server-compatible HTTP API used for requesting kernels
and talking theJupyter kernel protocolwith the kernels over WebsocketsA HTTP API defined by annotated notebook cells that maps HTTP verbs and
resources to code to execute on a kernelThe server launches kernels in its local process/filesystem space. It can be
containerized and scaled out using common technologies liketmpnb,Cloud Foundry, andKubernetes.
Package: jupyter_kernel_gateway_quarc_custom_fix
Jupyter Kernel Gateway is a web server that supports different mechanisms for
spawning and communicating with Jupyter kernels, such as:A Jupyter Notebook server-compatible HTTP API used for requesting kernels
and talking theJupyter kernel protocolwith the kernels over WebsocketsA HTTP API defined by annotated notebook cells that maps HTTP verbs and
resources to code to execute on a kernelThe server launches kernels in its local process/filesystem space. It can be
containerized and scaled out using common technologies liketmpnb,Cloud Foundry, andKubernetes.
Package: jupyterkernelgen
jupyterkernelgenGenerates a jupyter kernel from a given conda environment
while ensuring that ipykernel is installed in that environment
so that the kernel can be used.It prompts the user for the necessary inputs as it goes along
and will not touch existing jupyter kernels.InstallationPypi Installation:https://pypi.org/project/jupyterkernelgenpipinstalljupyterkernelgenHow to use:Command Line:You can use thejupyterkernelgencommand.If environment or name is specified in the command line arguments,
the user will not be prompted for the specified argument while running--name,--environement, both, or neither can be specifiedExamplesjupyterkernelgen--help
jupyterkernelgen
jupyterkernelgen-e~/path/to/environment-1-nkernel-name1
jupyterkernelgen-e../path/to/environment-2-nkernel-name2-y
jupyterkernelgen-e~/path/to/environment-3-nkernel-name3ArgumentsNameShortcutTypeExampleDescription--help-hN/AN/AShow help message.--version-vN/AN/AThe current version of jupyterkernelgen--environment-estring/path/to/environmentThe path to a conda environment. May be an absolute or relative path--name-nstringkernel-nameThe name of the kernel to create--yes-yN/AN/AInstall necessary packages without promptIn Python:Importjupyterkernelgenand run theinstall()functionExamplesimportjupyterkernelgenjupyterkernelgen.install()# Install a kernel interactivelyjupyterkernelgen.install(environment="/path/to/environment-1",name="kernel-name1")# Install a kernel with a specified path and namejupyterkernelgen.install(environment="/path/to/environment-2",name="kernel-name2",yes=True)# Install a kernel without promptsArgumentsNameTypeExampleDescriptionenvironmentstring"path/to/environment"The path to a conda environment. May be an absolute or relative pathnamestring"kernel-name"The name of the kernel to createyesboolTrueInstall necessary packages without promptInstalling from source codeClone the repository:gitclonehttps://github.com/phac-nml/jupyterkernelgen.gitInstall the project:cdjupyterkernelgen
pipinstall.Execute the program:jupyterkernelgen[-h][-eENVIRONMENT][-nNAME][-y]Developer NotesLegalCopyright Government of Canada 2023Written by: National Microbiology Laboratory, Public Health Agency of CanadaLicensed under the Apache License, Version 2.0 (the "License");
you may not use this work except in compliance with the License.
You may obtain a copy of the License at:http://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and limitations under the License.ContactPhilip Mabon:philip.mabon@phac-aspc.gc.ca
Package: jupyter-kernel-provisioner-proxy
jupyter-kernel-provisioner-proxyA Jupyter kernelprovisionerthat actually talks to a remote kernel through the kernel REST API of a Jupyter server.UsageMain server sideInstall jupyter-kernel-provisioner-proxy:pip install jupyter-kernel-provisioner-proxyThen install a kernelspec with thejupyter-kernel-provisioner-proxy installcommand.$jupyter-kernel-provisioner-proxyinstall--helpUsage: jupyter-kernel-provisioner-proxy install [OPTIONS]╭─ Options ────────────────────────────────────────────╮│ --display     TEXT  The kernel's display name        ││ --language    TEXT  The kernel's language name       ││ --kernel      TEXT  The kernel's name                ││ --url         TEXT  The kernel server URL            ││ --help              Show this message and exit.      │╰──────────────────────────────────────────────────────╯By default,jupyter-kernel-provisioner-proxy installwill install a Python kernelspec, with the Jupyter server serving remote kernels athttp://localhost:8000.Kernel server sideYou can usejupyter-serverorjupyverseto serve remote kernels.Using jupyter-serverpip install jupyter-serverjupyter server --ServerApp.token='' --ServerApp.password='' --ServerApp.disable_check_xsrf=True --no-browser --port=8000Using jupyversepip install fps-kernels fps-noauth fps-frontend ipykerneljupyverse
Package: jupyter-kernel-proxy
Jupyter Kernel ProxyThis Jupyter kernel serves as a proxy to any already running kernel. It is meant
to allow Jupyter Notebook to use kernels it cannot start itself, such as kernel
embedded in another applications.Jupyter Kernel Proxy was initially created as a way to use Jupyter Notebook
usingIPyIDA, but should work with any other
embedded or remote kernel.InstallJupyter Kernel Proxy is onPyPiand can be installed
usingpip install jupyter-kernel-proxyThe kernelspec must also be installed using:python -m jupyter_kernel_proxy installUsageIn Jupyter Notebook, start a new notebook and choose "Existing session" as
kernel type.When launched, the kernel proxy will try to connect to the last started kernel.
This is similar to whatjupyter console --existingwould do.The kernel implements a magic%proxycommand to allow connecting to other
running kernels. Only two subcommands are implemented:listandconnect.Here is an example usage:In  [ ]: %proxy list
           kernel-382cad4b-2286-4ea0-bcb7-fcc30039ac78.json (proxy)
         * kernel-55159.json (no name)
           kernel-55151d00-21e4-4ea9-8dfd-b0842e27cba1.json (no name)
           kernel-50889.json (no name)
In  [1]: a = 5
In  [ ]: %proxy connect 55151d00-21e4-4ea9-8dfd-b0842e27cba1
         Connecting to kernel-55151d00-21e4-4ea9-8dfd-b0842e27cba1.json
In  [1]: a = 4
In  [2]: a
Out [2]: 4
In  [ ]: %proxy connect kernel-55159.json
         Connecting to kernel-55159.json
In  [2]: a
Out [2]: 5
Package: jupyter-kernel-test
jupyter_kernel_testis a tool for testingJupyterkernels. It tests kernels
for successful code execution and conformance with theJupyter Messaging Protocol(currently 5.0).InstallInstall it with pip (python3.4 or greater required):pip3 install jupyter_kernel_testUsageTo use it, you need to write a (python)unittestfile containing code
samples in the relevant language which test various parts of the messaging protocol.
A short example is given below, and you can also refer to thetest_ipykernel.pyandtest_irkernel.pyfiles for complete examples.Some parts of the messaging protocol are relevant only to the browser-based
notebook (rich display) or console interfaces (code completeness,
history searching). Only parts of the spec for which you provide code samples
are tested.Run this file directly using python, or usenosetestsorpy.testto find
and run it.Exampleimportunittestimportjupyter_kernel_testclassMyKernelTests(jupyter_kernel_test.KernelTests):# Required --------------------------------------# The name identifying an installed kernel to run the tests againstkernel_name="mykernel"# language_info.name in a kernel_info_reply should match thislanguage_name="mylanguage"# Optional --------------------------------------# Code in the kernel's language to write "hello, world" to stdoutcode_hello_world="print 'hello, world'"# Pager: code that should display something (anything) in the pagercode_page_something="help(something)"# Samples of code which generate a result value (ie, some text# displayed as Out[n])code_execute_result=[{'code':'6*7','result':'42'}]# Samples of code which should generate a rich display output, and# the expected MIME typecode_display_data=[{'code':'show_image()','mime':'image/png'}]# You can also write extra tests. We recommend putting your kernel name# in the method name, to avoid clashing with any tests that# jupyter_kernel_test adds in the future.deftest_mykernel_stderr(self):self.flush_channels()reply,output_msgs=self.execute_helper(code='print_err "oops"')self.assertEqual(output_msgs[0]['header']['msg_type'],'stream')self.assertEqual(output_msgs[0]['content']['name'],'stderr')self.assertEqual(output_msgs[0]['content']['text'],'oops\n')if__name__=='__main__':unittest.main()CoverageThe following aspects of the messaging protocol are not explicitly tested:Widget comms:comm_open,comm_msg,comm_closestdin:input_request,input_replydisplay_data metadataShutdown/restart:shutdown_request,shutdown_replyHistory: not all option combinations coveredInspection: multiple levelsExecution payloads (deprecated but still used): payloadsload,edit,ask_exitUser expressionsExecution: combinations ofsilent,store_historyandstop_on_error
Package: jupyter-kroki-magic
Jupyter Kroki MagicA Jupyter Notebook %%magic for drawing diagrams using kroki.ioUsageLoad extension inside a Jupyter notebook:%load_ext krokimagicAdd code with Cell magic:%%kroki [diagram-type]

# diagram syntaxExamples%%kroki plantuml

skinparam monochrome true
skinparam ranksep 20
skinparam dpi 150
skinparam arrowThickness 0.7
skinparam packageTitleAlignment left
skinparam usecaseBorderThickness 0.4
skinparam defaultFontSize 12
skinparam rectangleBorderThickness 1

rectangle "Main" {
  (main.view)
  (singleton)
}
rectangle "Base" {
  (base.component)
  (component)
  (model)
}
rectangle "<b>main.ts</b>" as main_ts

(component) ..> (base.component)
main_ts ==> (main.view)
(main.view) --> (component)
(main.view) ...> (singleton)
(singleton) ---> (model)Installation$ pip install jupyter-kroki-magic
Package: jupyter-KULeuven-slides
Jupyter KULeuven slides TemplateA nbconvert template to convert jupyterlab notebooks into reveal.js slides using the KULeuven presentation style.Installation instructionsThis nbconvert template can be installed using pip:pip install jupyter-KULeuven-SlidesThis will make the reveal.js template "KULeuven" available in the python environment.Basic usageFirst mark (using theproperty inspectormenu at the left hand side) the start of each slide in any existing Jupyter notebook, by selectingslideunder the topicSlide type.Subsequently, using the jupyterlab top-menu, please select :File->Save and Export Notebook as->KULeuvenCommand lineConverting Jupyter notebooks into templated KULeuven slides can also be done from the command line as follows:jupyter nbconvert --to KULeuven Notebook.ipynbor converting all notebooks in a folder:jupyter nbconvert --to KULeuven *.ipynbAdding and modifying the title slideYou can add a title slide, by adding thenotebook metadataa section labeledKULeuvenslides. In this section the following tags can be optionally added:"KULeuvenSlides": {
        "title": "test title",
        "subtitle": "test subtitle",
        "authors": "Jan Genoe",
        "location": "Ergens",
        "date": "Vandaag"
    },Please do not forget to commit these changes to the jupyter notebook changes after adding this metadata. (The smallvon top of the box).
The screenshot below shows a possible implementation:Please do not forget to commit changes after adding metadata. (The smallvon top of the box).Selecting a global templateThe following global templates are available:SedesNormal1425  (The key referring to the foundation date of our university)In this folder you can find 3jupyter notebooksthat are converted according to each of those 3 templates.TheNormaltemplate is added by adding to thenotebook metadata"KULeuvenSlides": {
        "kuleuven_presentation_style": "Normal"
    },Please do not forget to commit changes after adding metadata. (The smallvon top of the box).Adding a structure slide in the presentation, using a different templateA structure slide, typically for the outline of the presentation, can be added at any point in the presentation by adding to the cell metadata underKULeuvenSlides:"KULeuvenSlides": {
        "slide_code": "structure"
    },(typically there will be already theslide_typepresent in this section)Please do not forget to commit changes after adding metadata. (The smallvon top of the box).Develop notesFor building and developing thistemplatehas been used.For the reveal.js template that is used as  a source, pleasesee hereSeeherefor nbconvert's documentation on creating custom templates.