Saravanan666/pypi-org huggingface dataset:
Package: jupyter-plotly-dash
jupyter-plotly-dashAllow use ofplotly dashapplications within Jupyter notebooks, with the management of both session and internal state.See the source for this project here:https://github.com/GibbsConsulting/jupyter-plotly-dashTry me here in your browser:More detailed information
can be found in the online documentation athttps://readthedocs.org/projects/jupyter-plotly-dashInstallationInstall the package. Use of avirtualenvenvironment is strongly recommended.pip install jupyter_plotly_dashNow the package is installed, it can be used within a Jupyter notebook.Simple useAfter installation, launch a python Jupyter notebook server usingjupyter notebookorjupyter labas desired. Create aDashapplication, using
theJupyterDashclass instead ofdash.Dashfor the application, and copy the following into a code cell and evaluate it.fromjupyter_plotly_dashimportJupyterDashimportdashimportdash_core_componentsasdccimportdash_html_componentsashtmlfromdash.dependenciesimportInput,Outputapp=JupyterDash('SimpleExample')app.layout=html.Div([dcc.RadioItems(id='dropdown-color',options=[{'label':c,'value':c.lower()}forcin['Red','Green','Blue']],value='red'),html.Div(id='output-color'),dcc.RadioItems(id='dropdown-size',options=[{'label':i,'value':j}fori,jin[('L','large'),('M','medium'),('S','small')]],value='medium'),html.Div(id='output-size')])@app.callback(dash.dependencies.Output('output-color','children'),[dash.dependencies.Input('dropdown-color','value')])defcallback_color(dropdown_value):return"The selected color is%s."%dropdown_value@app.callback(dash.dependencies.Output('output-size','children'),[dash.dependencies.Input('dropdown-color','value'),dash.dependencies.Input('dropdown-size','value')])defcallback_size(dropdown_color,dropdown_size):return"The chosen T-shirt is a%s%sone."%(dropdown_size,dropdown_color)appThe last line causes the dash application to be rendered. All callbacks are invoked asynchronously, so the display of an
application does not prevent other notebook cells from being evaluated. Multiple instances of the same dash application
can be rendered at the same time within a single notebook.Binder useTo launch a binder
image, visitto
run Jupyter notebooks using the latest version on the master branch of the main repository.
Package: jupyter-pluto-proxy
Run Pluto.jl on a JupyterHubLaunch the awesomePluto.jl Notebookfrom the
Jupyter LabLauncheror the Jupyter ClassicNewdropdown. This
package was built using thejupyter-server-proxycookiecutter
template.This is primarily for use withJupyterHubin container
based environments.Based onoriginal repo from Illumidesk.Try it outTake it for a spin with Binder:This should launch you straight into Pluto.InstallationYou can installjupyter-pluto-proxyfromPyPI.pipinstalljupyter-pluto-proxyYou also need to have Julia andPluto.jlinstalled.DevelopmentFork and clone this repo and install the package:gitclonehttps://github.com/<account>/jupyter-pluto-proxyCreate and activate a virtual environment:virtualenv-ppython3venvsourcevenv/bin/activateInstall package:cdjupyter-pluto-proxy
pipinstall-e.Creditsjupyter-server-proxyPluto.jlLicenseBSD 3-Clause
Package: jupyter-plz
# Copilot, for your Jupyter Notebook%plzis a Jupyter magic command that generates programs from human-readable descriptions in Jupyter notebooks.https://user-images.githubusercontent.com/11509740/210084133-61f2cb2d-9968-4b01-8a67-85fcb92eb312.mov## InstallationYou can installplzin your Python virtual environment by running the following command in your terminal:`bash pip install plz `## Usageplzuses [GPT-3](https://beta.openai.com/). To use it, you’ll need to:Activate billing on your OpenAI [account](https://beta.openai.com/account/billing/overview).Grab an API key from [your dashboard](https://beta.openai.com/).Provide the API key to thejupyter_plzpackage upon request inside your notebook.Once you have configured your environment, you can run theplzmagic command in your notebook. Example:`bash %plz "create a function that generates a random walk in the form of an array." `Or markdown guides:`bash %plz--markdown"Provide astep-by-stepguide on how to identify anomalies in a list of numbers." `## CreditThis tool is inspired by [plz-cli](https://github.com/m1guelpf/plz-cli) (designed for the command line).## LicenseThis project is open-sourced under the MIT license. See [the License file](LICENSE) for more information.History0.1.0 (2022-12-30)First release on PyPI.
Package: jupyterpool
🪐 🎱 JupyterpoolA pool of Jupyter pre-warmed and pre-mounted kernels.Jupyterpool is a pool of Jupyter Kernels that are pre-warmed with code and pre-mounted with content. It solves the cold-start Kernel issue.Jupyterpool serves user interfaces or processes eager to consume code execution from Kernels.A set of available Kernels is maintained on a Kubernetes cluster. Those Kernels can be configured to pre-run defined code before being available and have mounted local or remote drives. A defined number of available Kernels (min and max) is guaranteed by Jupyterpool.pipinstall-e.[test,k8s]jupyterlabextensiondevelop.--overwrite
jupyterlabextensionlist
jupyterserverextensionlist
yarnjupyterlab
Package: jupyterpost
Jupyterpost: post from Jupyterhub to a Mattermost serverInstallingpip install jupyterpostEnabling jupyterpostCreate a bot user on your Mattermost server and get its token.Add the following at the end of your Jupyterhub config file.fromjupyterpostimportconfigure_jupyterhubconfigure_jupyterhub(c,mattermost_token="your mattermost token",mattermost_url="https://your.mattermost.server/api/v4/",mattermost_team="your mattermost team name",jupyterpost_url="https://services.your.jupyterhub/services/jupyterpost",)This will:add a new servicejupyterpostto your Jupyterhubgive all usersand their serversaccess to this serviceprovide the service URL to the user's server as an environment variableJUPYTERPOST_URLThe function is somewhat fragile, but should work for standard Jupyterhub installations.Using jupyterpostfromjupyterpostimportpostfrommatplotlibimportpyplotpyplot.plot([0,1])post(message="Check out my plot",channel="my-channel",# Or "@username"attachment=pyplot.gcf(),# Or png bytes)Posting from outside of your JupyterhubGet the variablesJUPYTERPOST_URLandJPY_API_TOKENfrom your Jupyterhub server.Provide them tojupyterpost.postas additional arguments and connect from anywhere!ContributingContributions are welcome! Please open an issue or a pull request.Specifically I would like to support more chat services, and more ways to post messages.Tests would also be great huehuehue.
Package: jupyter-process-manager
Table of ContentsOverview.Installation via pip:Usage examplesHow to create create and start processes forjupyter_process_managerJupyterProcessManager arguments:Usage in Jupyter NotebookHow to check output for the processesHow to add more processesHow to stop a processHow to do a debug run without a new process creationOther methods available within running processes for JPMClearstdoutoutput from the processGetstdoutoutput for the processUsage in a consoleLinksProject local LinksContactsLicenseOverview.This is a library which helps working with many processes in a jupyter notebook in a very simple way.Installation via pip:pipinstalljupyter_process_managerUsage examplesHow to create create and start processes forjupyter_process_managerfromjupyter_process_managerimportJupyterProcessManagerprocess_manager=JupyterProcessManager(".")# "." - path where to store outputs of the processes# And functions for processingprocess_manager.add_function_to_processing(func1,*func1_args,**func1_kwargs)process_manager.add_function_to_processing(func2,*func2_args,**func2_kwargs)WARNING: Please do NOT try to use functions defined inside jupyter notebook, they won’t work.JupyterProcessManager arguments:str_dir_for_output: Directory where to store processes outputsis_to_delete_previous_outputs=True: Flag If you want to delete outputs for all previous processes in the directoryUsage in Jupyter NotebookAfter processes were added, you can check what is happening with them.process_managerShowing the JupyterProcessManager widget won’t block execution so you can run the code in other cellsHow to check output for the processesSelect the process for which you want to see the output.Select which output you want to see.The output will get updated every 2 seconds.How to add more processesYou can add as many processes as you wantby running the code below in any other jupyter notebook cellprocess_manager.add_function_to_processing(func_new,*func_new_args,**func_new_kwargs)How to stop a processTo stop the process, select it and press the orange button to stop itWhen the button to stop the selected process is pushed.KeyboardInterrupt Exception is called for the processIf within 5 seconds process is not finished then the process will be killed.How to do a debug run without a new process creation# arguments are the same as in **add_function_to_processing(...)**process_manager.debug_run_of_1_function(func_to_process,*args,**kwargs)Other methods available within running processes for JPMClearstdoutoutput from the processfromjupyter_process_managerimportclear_outputclear_output()Getstdoutoutput for the processfromjupyter_process_managerimportread_stdoutstdout_content=read_stdout()Usage in a consoleprocess_manager.wait_till_all_processes_are_over()You will see the output like shown belowLinksPYPIreadthedocsGitHubProject local LinksCHANGELOG.ContactsEmail:stas.prokopiev@gmail.comvk.comFacebookLicenseThis project is licensed under the MIT License.
Package: jupyter-pyfilesystem
Jupyter Notebook PyFilesystem Contents ManagerAJupyter NotebooksContentsManagerthat usesPyFilesystemfor storing files.
Includes a compatibleCheckpointsclass.Installationpip install jupyter-pyfilesystemExamplejupyter_notebook_config.py:c.NotebookApp.contents_manager_class='jupyter_pyfilesystem.FsContentsManager'# In-memory temporary filesystemc.FsContentsManager.fs_url='mem://'Seehttps://docs.pyfilesystem.org/en/latest/openers.htmlfor information on how to definefs_url, andhttps://docs.pyfilesystem.org/en/latest/builtin.htmlfor a list of built-in filesystems.
There are also several externally-contributed filesystems that can be used.
Some are listed onhttps://www.pyfilesystem.org/page/index-of-filesystems/Note some filesystems may not behave as you expect.
For example, the curent implementations of thezip://andtar://filesystems do not allow you to update an existing file.
You can only create/overwrite an existing file, or open a file read-only.For example:c.FsContentsManager.fs_url='zip:///tmp/test.zip'importosifos.path.exists(fs_url[6:]):c.FsContentsManager.create=Falsec.FsContentsManager.writeable=FalseIf you are using a remote filesystem you may want to enable thekeepalive.
For example, this will make a remote request to get the details of/every 60 seconds:c.FsContentsManager.keepalive=60AcknowledgementsThis repository is based onhttps://github.com/quantopian/pgcontents/tree/5fad3f6840d82e6acde97f8e3abe835765fa824b
Package: jupyter-pytest-2
jupyter-pytest-2This small pytest plugin allows it to discover and run tests written inside ipython notebook cells. It works by examining notebook global scope, putting it into a module object and passing it to pytest for futher processing. No temporary files or bytecode hacks. This allows you to share objects, dataframes, and references between your notebook, pytest fixtures and tests.There may be memory leaks, but i did not bother testing it.You can not run pytest itself and give it a notebook, likepytestexample.ipynbThis will not work.But why??!!1I wrote this plugin to write data quality tests in databricks platform.Installationpipinstalljupyter-pytest-2Example notebookhttps://github.com/sashgorokhov/jupyter-pytest-2/blob/master/example.ipynbUsageInstall the plugin, copypaste this into the notebook cell and run:importpytestdeftest_foo():assertTruepytest.main()You can separate this by different cells, write fixtures, parametrized or not, use different fixture scopes - you can use everything you love pytest for.importpytestsome_out_of_test_object='Hello, world!'# Cell@pytest.fixture(params=[1,2,3])deffoo(request):returnrequest.param# Celldeftest_foo(foo):assertsome_out_of_test_object=='Hello, world!'assertisinstance(foo,int)# Cellpytest.main(args=['-sv'])Usage notesPlugin will discover only tests, fixtures and data in cells which were run in the current kernel scope. If you restart kernel, or load a notebook, you need to re-run cells with test related stuff.If you write some tests, execute a cell, and then remove or rename that test, this test will remain in global scope and will be found & executed by plugin. This can lead to an unexpected things, even harming ones. When renaming or removing test or fixture, also restart the kernel.Enjoy!
Package: jupyter-ra-extension
jupyter_ra_extensionRelational Algebra Symbols in JupyterRequirementsJupyterLab >= 4.0.0InstallTo install the extension, execute:pipinstalljupyter_ra_extensionUninstallTo remove the extension, execute:pipuninstalljupyter_ra_extensionContributingDevelopment 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_ra_extension directory# Install package in development modepipinstall-e"."# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# 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 uninstallpipuninstalljupyter_ra_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-ra-extensionwithin that folder.Packaging the extensionSeeRELEASE
Package: jupyter-react
🪐 ⚛️ Jupyter ReactclientId
: 
"8bbaf1ef-b6b4-4b36-93a4-50c3e78e9372"
id
: 
"114ecc62-9162-4ee8-b349-8012ca743ba3"
kernelInfo
: 
undefined
path
: 
"kernel-b5e89a69-0867-4ffd-abf2-e5f4f32ce51d"
sessionId
: 
"2873df11-3e7d-45e1-8946-49f0e2ece55a"Jupyter React is a set ofReact.jscomponents that allow a frontend developer to build data products compatible with theJupyterecosystem. The user interface delivers executable notebooks and cells.The below image shows a gallery of the available React.js components ready to be used in you custom application. These open source components are used to build the onlineDatalayer service, a collaborative platform for data analysis.The Jupyter(Lab) notebook is a tool that allows data scientist to analyse dataset. However, it is not easy to create a custom user interface integrated in an existing application.Jupyter React, an open-source library, fills that gap and provides components that a developer can easily integrate in any React.js application.In terms of technical stack, the Jupyter(Lab) user interface is built on top of Lumino, which is an imperative way to build user interface andcan notbe consumed by industry standard declarative frameworks like React.js. As a user interface developer, if you want to create a custom data product on top of Jupyter, you have to stick to Lumino and carry-on the full notebook interface not tailored to your specific needs. This is not what you want. You just want to expose what you need, you want to develop with your favorite toolkit (like React.js) and you also want to integrate on a per-component basis the Jupyter functionality in your application.Although a developer can embed a React.js component into JupyterLab, the reverse is not possible: you can not embed JupyterLab into a React.js application. To solve that issue, Jupyter-React ships components to easily create a React.js data product compatible with the Jupyter ecosystem. Those components can be used in any React.js application, and also in static websites like Docusaurus, Next.js or Remix. They wrap underneath the JupyterLab code and allow developing React.js applications with code execution capability. State management is based on Redux, and Mobx is to be added.IPyWidgets are supported (the Comm feature needs to be fixed). JupyterLite and PyScript support is on the roadmap. Autocompletion is also available.You can find more context reading thisabstractof the talk given atFOSDEM 2022(video recording).As a React.js developer, you just write a few lines of code get a live notebook or live cell in your application.The typedoc documentation isavailable online.Jupyter React can be used in any React.js application. Install the latest@datalayer/jupyter-reactnpm package and get inspired by theexamplesin this repository.ReleasesJupyter React is released inNpm.jsandPyPI.
Package: jupyter-references
Repo structureEither use as library repo with with<package_name>anddocs(and maybenotebook) dirs. Or as data analysis repo withscripts,notebooks,data,steps,results,figuresdirs.Conda environmentCreate empty environment:conda create -n <name>Activate environmentconda activate <name>Add channels first to make the appear in the exported environment:
Add any channels first to make the appear in the exported environment (you can always add more later):conda config --env --append channels conda-forge
conda config --env --append channels bioconda
conda config --env --append channels etetoolkit
conda config --env --append channels gwforg
conda config --env --append channels kaspermunchInstall a subset of packages:conda install jupyterlab pandas seaborn ...
conda install gwf jupyterlab pandas seaborn ipympl statsmodels bioconda pyfaidx tskit ete3 scikit-allel samtools bamtools vcftoolsExport it to the binder folder:conda env export --from-history > binder/environment.ymlList revisions to envirionment:conda list --revisionsRestore a past revision:conda install --revision 2Once you land on stable environment this can make it more stable:conda env export --from-history > binder/environment.yml
conda deactivate <name>
conda env remove -n <name>
conda env create -n <name> -f binder/environment.ymlCreate PyPi and Conda packagesconda install conda-build twine anaconda-clientbash pypi.shbash conda.sh [-c channel -c channel ...]Using submodules with GitRead onhere
Package: jupyter-releaser
Jupyter ReleaserJupyter Releasercontains a set of helper scripts and GitHub Actions to aid in automated releases of Python and npm packages.InstallationTo install the latest release locally, make sure you havepip installedand run:pipinstallgit+https://github.com/jupyter-server/jupyter_releaserLibrary Usagejupyter-releaser--helpjupyter-releaserbuild-python--helpjupyter-releasercheck-npm--helpChecklist for AdoptionSee theadoption guides.ActionsGitHub actions scripts are available to draft a changelog, draft a release, publish a release, and check a release.See theaction details documentationfor more information.The actions can be run on aforkofjupyter_releaserand target multiple
repositories, or run as workflows on thesource repositories, using
shared credentials.
Package: jupyter-remote
Jupyter-Remoteis a command-line tool that automatically runs Jupyter on a remote server.
It is derived fromJupyter-O2.Jupyter-Remote aims to streamline remote Jupyter usage for a range of remote configurations,
from simple servers to SLURM clusters that require request forwarding to a compute node.InstallationSet up Jupyter on the remote server.Next, install Jupyter-Remote.pip install jupyter-remoteThen, generate the config file.jupyter-remote --generate-configFollow the printed path tojupyter-remote.cfgand edit to suit your needs.For more info on setting up Jupyter and troubleshooting Jupyter-Remote, see thejupyter-remote tips.Usagejupyter-remote [profile] [subcommand]Both arguments are optional.If Jupyter is installed on your machine, Jupyter-Remote can be run as a Jupyter subcommand:jupyter remote o2 labBe sure to try outJupyterLab!For more info on the Jupyter-Remote command-line options, usejupyter-remote--help.ProfilesMake a copy ofjupyter-remote.cfgand name itjupyter-remote-[profilename].cfg.
Seeexample_cfgs/jupyter-remote-o2.cfg.Note: Both the profile and subcommand option are optional.
If only one is provided, Jupyter-Remote will first look for a profile with that name,
and if none is found, it will use the default profile with the given subcommand.Requirements and compatibilitypython 2.7 or 3.6pexpect.pxsshPOSIX: Jupyter-Remote has been tested on MacOS and Linux, while on Windows it will
require Cygwin and Cygwin’s version of Python.pinentry (suggested)