Saravanan666/pypi-org huggingface dataset:
Package: jupyter-native-kernel
Minimal Native kernel for JupyterThe goal of this kernel is to provide a unified frontend for working with native languages from jupyter.It was started from thejupyter C kernel.Usage:%load  to load a file to the cell//%load https://passlab.github.io/CSCE569/resources/axpy.c
//%compiler: gcc
//%cflags: -fopenmp
//%ldflags: -lm
//%args: 1024SetupWorks only on Linux and OS X.
Windows is not supported yet.
If you want to use this project on Windows, please use Docker.Make sure you have the following requirements installed:gccjupyterpython 3pipInstall (system)This installs the kernel at the system level. (Not tested yet.)git clone <this repo>sudo pip3 install -e jupyter-native-kernelsudo install_native_kernelTo install on system folder, dosudo install_native_kernel --sys-prefixInstall (virtualenv)This installs the kernel within the current virtualenv.git clone <this repo>virtualenv -p python3 venvsource venv/bin/activatepip3 install -e jupyter-native-kernelinstall_native_kernel --userLicenseThis project is released under theMIT License.
Package: jupyter-nb-double-quote-to-single-quote
jupyter-nb-double-quote-to-single-quoteConvert double quotes ("") to single quotes ('') in Jupyter notebook code cellsInstallationpipinstalljupyter-nb-double-quote-to-single-quoteAs a command line tooljupyter-nb-double-quote-to-single-quotemy_notebook.ipynbUse--helpto see documentations of command line arguments.As a pre-commit hookPut the following into your.pre-commit-config.yamlfile. Remember to replace<VERSION>with your version of this tool (such asv0.1.0):-repo:https://github.com/cyyc1/jupyter-nb-double-quote-to-single-quoterev:<VERSION>hooks:-id:jupyter-nb-double-quote-to-single-quoteSeepre-commitfor more instructions.LicensesThe license of this tool is MIT License.  See the fileLICENSEA significant portion of the code used in this tool comes fromhttps://github.com/pre-commit/pre-commit-hooks, in particular, the filestring_fixer.py.  As such, we added pre-commit-hooks' license as the original license (see the fileORIGINAL_LICENSE).
Package: jupyter-nbrequirements
jupyter-nbrequirementsDependency management and optimization in Jupyter Notebooks.AboutThis extension provides control over the notebook dependencies.The main goals of the project are the following:manage notebook requirements without leaving the notebookprovide a unique and optimized* environment for each notebook*The requirements are optimized using theThothresolution engineInstallationpipinstalljupyter-nbrequirementsAnd enable the required extensions (might not be needed with the latest version, but to be sure..)jupyternbextensioninstall--user--pyjupyter_nbrequirementsUsageNBRequirements UISincev0.4.0, we've introduced a new UI! Check it out, interact with it and see what it can offer you!Our development efforts will from now on focus primarily on improving the UI.The old-school approachThe Jupyter magic is in sync with the UI, so don't worry old schoolers, you can still run the commands manually and the existing notebooks will work!Create the environment for the notebook to run inSay we want to do an EDA, we will probably needpandas, a visualization library likeplotlyand some additional libraries to make our lives easier, likesklearnandpandas-profiling.In a Jupyter notebook cell:%dep add pandas --version ">=0.24.0"
%dep add plotly
%dep add sklearn
%dep add pandas-profilingAnd perhaps our code would need some refactoring and linter checks later on, so let's add adevdependency.%dep add --dev blackYou can now check the requirements that your notebook has by issuing%requirements(or%dep, which is just an alias for it) command:%requirements[packages]
pandas = ">=0.24.0"
plotly = "*"
sklearn = "*"
pandas-profiling = "*"

[dev-packages]
black = "*"

[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[requires]
python_version = "3.6"Up to this point, we've been working only with the metadata. In order to create the environment and actually install the dependencies, you run the%dep ensurecommand (insipired by the golang'sdep, for those familiar with Golang).%dep ensureSince this project is still under development and it uses theThothresolution engine to optimize the notebook dependencies (which is also still under development as well), in case something goes wrong,ensureaccepts theengineparameter, which can be set topipenv%dep ensure --engine pipenvCheck out theexamplesfor more info.Future plans:See theProject Board.Author: Marek Cermakmacermak@redhat.com, @AICoE - Project Thoth
Package: jupyterngsplugin
Jupyter notebook plugin Bioinformatics NGS data analysisRequirementsPython 2.7 or 3.xPublic Domain noticeNational Center for Biotechnology Information.This software is a "United States Government Work" under the terms of the United States
Copyright Act. It was written as part of the authors' official duties as United States
Government employees and thus cannot be copyrighted. This software is freely available
to the public for use. The National Library of Medicine and the U.S. Government have not
placed any restriction on its use or reproduction.Although all reasonable efforts have been taken to ensure the accuracy and reliability
of the software and data, the NLM and the U.S. Government do not and cannot warrant the
performance or results that may be obtained by using this software or data. The NLM and
the U.S. Government disclaim all warranties, express or implied, including warranties
of performance, merchantability or fitness for any particular purpose.Please cite NCBI in any work or product based on this material.
Package: jupyter-notebookparams
Jupyter Notebook ParamsTakes query parameters from a url to update a parameter cell of a jupyter notebook.Installationpip install jupyter-notebookparamsThis should automatically enable the extension. If it is not listed injupyter nbextension listinstall and enable it:jupyter nbextension install --py jupyter_notebookparams --sys-prefix
jupyter nbextension enable --py jupyter_notebookparams --sys-prefixUsageCreate a notebook cell that starts with the exact string# Parameters:Add parameters to the URL of a notebook, e.g.http://example.org/notebook.ipynb?a=1&b=False.
The content of the first cell starting with# Parameters:will be replaced with the passed parameters, e.g.# Parameters:
a = 1
b = FalseAdd the parameterautorun=trueto automatically run the notebook.
Package: jupyter-notebook-parser
jupyter-notebook-parserA Python library to parse cell contents from Jupyter notebooksInstallationpipinstalljupyter-notebook-parserUsageParserfromjupyter_notebook_parserimportJupyterNotebookParserparsed=JupyterNotebookParser('my_notebook.ipynb')parsed.get_all_cells()# returns List[Dict], each Dict is a notebook cellparsed.get_markdown_cells()# returns List[Dict], each Dict is a markdown celparsed.get_markdown_cell_indices()# returns List[int], each is a markdown cell's indexparsed.get_markdown_cell_sources()# returns List[str], each is a markdown cell's textparsed.get_code_cells()# returns List[Dict], each Dict is a code cellparsed.get_code_cell_indices()# returns List[int], each int is a code cell's indexparsed.get_code_cell_sources()# returns List[SourceCodeContainer]source=parsed.get_code_cell_sources()[0]source.raw_source# strsource.source_without_magic# str (all ipython magics excluded)source.magics# Dict[int, str] (all magics, from line number to magic text)Rewriterfromjupyter_notebook_parserimportJupyterNotebookParserfromjupyter_notebook_parserimportJupyterNotebookRewriterparsed=JupyterNotebookParser('my_notebook.ipynb')rewriter=JupyterNotebookRewriter(parsed_notebook=parsed)rewriter.replace_source_in_code_cell(index=5,new_source='print(2)')Source code containerfromjupyter_notebook_parserimportSourceCodeContainercontainer=SourceCodeContainer('a = 2\n%timeit b = 2 ** 10\nprint(b)')container.raw_source# same as the inputcontainer.source_without_magic# 'a = 2\n b = 2 ** 10\nprint(b)'container.magics# {1: '%timeit'}
Package: jupyter-omero-authenticator
Jupyter OMERO AuthenticatorUseOMEROto authenticate withJupyterHub.ExampleYou are strongly recommended to enable auth_state persistence so that OMERO session-ids can be checked and refreshed.jupyterhub_config.py:c.JupyterHub.authenticator_class='jupyter_omero_authenticator.OmeroAuthenticator'c.OmeroAuthenticator.omero_host='omero.example.org'# Pass OMERO_HOST OMERO_USER OMERO_SESSION environment variablesc.OmeroAuthenticator.export_omero_env=Truec.Authenticator.auth_refresh_age=300c.Authenticator.enable_auth_state=Truec.Authenticator.refresh_pre_spawn=TrueexportJUPYTERHUB_CRYPT_KEY=$(opensslrand-hex32)jupyterhub
Package: jupyter-omnicm
jupyter-omnicm is a flexible content manager system for Jupyter notebooks.Free software: Apache Software License 2.0It currently supports the HDFS Content Manager.Installationpip install jupyter-omnicmDocumentationhttps://jupyter-omnicm.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog
Package: jupyter-openbis-authenticator
Jupyter-OpenBIS-AuthenticatorDescriptionThis authenticator module for JupyterHub connects to a given openBIS instance, using the pyBIS module. It exports the environment variablesOPENBIS_URLOPENBIS_TOKENto the user environment. Later, in a notebook, a user is then able to use pyBIS without any url, username or credentials:from pybis import Openbis
o = Openbis()CompatibilityThis Authenticator works only with Jupyterhub > 0.8.0. This module was tested with version 0.8.1The authenticator uses thespawner.environmentfeature to modify the users environment variables during session creation. This feature was introduced in Jupyterhub by version 0.8.0.Installationpip install jupyter_openbis_authenticatorJupyterhub ConfigurationEdit yourjupyterhub_config.pyfile and add the following to registerjupyter_openbis_authenticatoras a JupyterHub authenticator class:c.JupyterHub.authenticator_class = 'jupyter_openbis_authenticator.auth.OpenbisAuthenticator'
c.JupyterHub.spawner = 'jupyter_openbis_authenticator.auth.KerberosSudoSpawner'

if 'JUPYTERHUB_CRYPT_KEY' not in os.environ:
    warnings.warn(
        "Need JUPYTERHUB_CRYPT_KEY env for persistent auth_state.\n"
        "    export JUPYTERHUB_CRYPT_KEY=$(openssl rand -hex 32)"
    )
    c.CryptKeeper.keys = [ os.urandom(32) ]

# enable persisting auth_state, i.e. enable JupyterHub to change the environment variables of the user.
c.Authenticator.enable_auth_state = True

# openBIS settings
c.OpenbisAuthenticator.server_url = 'https://my_openbis_instance.ch'
c.OpenbisAuthenticator.verify_certificates = TrueRRPPersistentBinderSpawnerThis spawner reads directories from a specified project folder and presents them to the logged-in user. The user then can
launch virtual machines (using kubernetes) with the given running environment thatrepo2dockerdetects in the chosen
project folder.Changes injupyterhub_config.pyto enable this spawner:c.JupyterHub.spawner_class='jupyter_openbis_authenticator.spawner.RRPPersistentBinderSpawner'c.JupyterHub.spawner_class='rrp_pbh_spawner'c.RRPPersistentBinderSpawner.projects_dir='/path/to/my/projects'
Package: jupyter-openscad-kernel
OpenSCAD Kernel for JupyterI was missing a Jupyter Kernel forOpenSCAD. So I took up the challenge and here is the result.Any regular text in a cell is added to the overall OpenSCAD code buffer. This allows you to build up an OpenSCAD model in multiple steps using Jupyter cells and document the design along the way.PreconditionsJupyter or Jupyterlab should have been installedPlease make sure that OpenSCAD has been installed on your system (e.g. with apt install openscad) and that it can be called on the command line:openscad -vdiplays the version. E.g. 2019.12.20Installationpip install jupyter-openscad-kernel
python -m iopenscad.installInstallation from sourcegit clone https://github.com/pschatzmann/jupyter-openscad-kernel.git
cd jupyter-openscad-kernel
pip install .
python -m iopenscad.installOptional StepsIf you want to be able to display stl files you need to install a mime renderer for Jupyter. E.gjupyter labextension install jupyterlab-viewer-3dIf you want to have syntax highlighting for OpenSCAD:jupyter labextension install jupyterlab-openscad-syntax-highlightingOn linux, if you want to run openscad in a headless environment (e.g. Docker) you need to install xvfbapt install -y xvfbNow you can launch your kernel my callingjupyter laborjupyter workspaceVersions1.0     Initial Version1.0.1   Additional syntax checking; Publish to pypi1.0.13  Error corrections for parser and installer, support for %use1.0.14  Cleanup and corrections for spelling mistakes, Upgrade node and setuptools release in DockerfileFurther InformationA quickOverview
Package: jupyter-paperboy
paperboyA web frontend for scheduling Jupyter Notebooks as reportsOverviewPaperboy is a production-grade application for scheduling reports. It has a flexible architecture and extensible APIs, and can integrate into a wide variety of deployments. It is composed of various industrial-strength technologies from the open source world.Jupyter Notebooksfor the reports themselvesJupyter notebooks are an ideal report template, and withNBConvertsupport a wide variety of output types, including PDFs, HTML, Emails, etcPapermillto parameterize notebooksSQLAlchemyfor Storage (default)Apache Airflowfor Scheduling (default)DaskforAirflow WorkersLuigias a scheduling alternative forAirflow(relies oncron)PhosphorJSfor the frontendSupport for PythonVirtualenvsviarequirements.txtor customDockerimages viaDockerfiles on a per-notebook levelTraitlets parameterization of storage and scheduler classes for easy integration with custom storage backends and custom schedulersSingle click notebook deployment withVoilaandDokkuProcess FlowUpload notebookConfigure jobstart timeintervalpapermill parameters to autoconfigure reportsif autoconfiguring reports from papermill:run or publishoutputnotebookpdfhtmlemailscriptstrip or keep codeTo edit or create additional reports on a job, configure reportsrun or publishoutputnotebookpdfhtmlemailscriptstrip or keep codeInstallation from sourcePaperboy requires Python andNode.js, which can be installed fromconda-forgeifcondais available.Clone the repository and run following commands to install and launch the
application:npm installnpm run buildpip install -e .python -m paperboyVisithttp://0.0.0.0:8080in a browser to view the application.The default authentication backend requires the registration of a username that
can be used on subsequent launches.
Package: jupyter-parser
jupyter-parser is a jupyter notebook parser that attempts to gather
information about the varying ways in which a notebook may be used.
jupyter-parser has been tested on python 2.7.12 and python 3.5.2. The
current plugins written to parse notebook files are found in thepluginsdirectory and are described below…Plugins - CellsCorrectPlugin: determines whether or not cells are in the
correct execution order - NotebookLibrariesPlugin: determines the
modules imported from the notebooks (can be local) -
NotebookSparkPlugin: uses a regular expression to search for any pyspark
variablesPlugins are included in the constructor of the main
parser(JupyterParser). This architecture is likely to be temporary as
the goal of being language/file agnostic is in the future.This library should be used with`gist-dl <https://github.com/cameres/gist-dl>`__in order to quickly
download example notebooks from`gist.github.com <http://gist.github.com>`__.InstallationThe project was recently added to PYPI. Feel free to submit an issue if
there are any issues with downloading via the command below…pipinstallgithub-dlInstallation (Development)Install the project by downloading the project as a zip file or cloning
the repository. After downloading the source, run the following command
to install in the root directory of the project…pipinstall-e.Usagejupyter-parser’s functionality is currently fairly limited, but the
following functionality is supportedcommand line argument/optionfunctionality--helplist arguments/options for tool--rootspecify the root directory to parse for files
Package: jupyter-pgadmin-proxy
Jupyter pgAdmin proxyjupyter-pgadmin-proxy provides Jupyter extension to runpgAdmin 4. See also official pages forpgAdmin.InstallationYou can install jupyter-pgadmin-proxy inside your environment with Jupyter / Jupyterlab:python3 -m pip install jupyter-pgadmin-proxyBuildpython3 -m pip install hatch

hatch build

ls -la dist/*DevelopmentTrymake helpto see available commands:make helppython3 -m pip install git+https://github.com/huntdatacenter/jupyter-pgadmin-proxy.git@mainTesting in dockerRun/rebuild local Jupyterlab service:make rebuildRunning the command should open a url in the browserhttp://127.0.0.1:8888/labTo stop the service run:make down
Package: jupyterpie
# jupyterpie### Installation` pip install jupyterpie `### Usage` jupyterpie <path to ipynb file> `The python file will have the same name with a .py extension.### Why use jupyterpie?While most libraries do not preserve cell outputs from Jupyter when converting to a py file, jupyterpie will store these outputs as comments. It is particularly useful if you regularly upload .ipynb files to Github because Github often fails to render .ipynb files.https://pypi.org/project/jupyterpie/
Package: jupyterpilot
JupyterPilotJupyter Pilot is a Python package that uses the OpenAI API to generate code from natural language prompts. It is designed to simplify the process of writing code and to make programming more accessible to non-programmers.InstallationTo install Jupyter Pilot, simply run:pip install jupyterpilotUpdate 1.0.0Please run:pip install --upgrade jupyterpilotRemoved issues where people were getting In[ ]: in code.Code insertion in new cellAll parameters of model can be set using CodetoCell()Improved accuracy with new default paramsNote: Most of these errors are model generated. For this exact reason, the code creates a test.py in the same working directory as that of the notebook. User can read and manually or programmatically remove these errors.UsageTo use JupyterPilot, import thepysetupclass from thejupyterpilotmodule:from jupyterpilot import pysetupThen, create an instance ofCodetoCellwith your OpenAI API key:openai_key = "YOUR_API_KEY"
cc = pysetup.CodetoCell(openai_key)Call theget_codemethod with a natural language prompt to generate code:prompt = "Create a function to get stock data from yahoo finance api"
cc.get_code(prompt)This will create a file calledtest1.pywith the generated code and import statements, and then load the code into a Jupyter Notebook cell for further use.OptionsYou can pass options to theCodetoCellconstructor to customize its behavior:cc = pysetup.CodetoCell(
    	openai_key=openai_key,
    	model="code-cushman-001", # Choose a different model (optional)
    	tokens=2048, # Increase the number of tokens (optional)
	tokens=1024 # (optional), 
	temperature=0.1 # (optional),
	top_p=1 # (optional),
	penalty=0, # (optional)
	presence_penalty=0 # (optional)
)You can choose a different model by setting themodelparameter to a different model ID. Other models can be found on theOpenAI API documentation.You can increase the number of tokens by setting thetokensparameter to a larger value. The maximum number of tokens supported by thecode-cushman-001model is 2048, while thecode-davinci-002model supports up to 8000 tokens.Authors@ishu121992LicenseJupyterPilot is licensed under the MIT License. See theLICENSEfile for details.
Package: jupyterplot
jupyterplotCreate real-time plots in Jupyter notebooks.What is it?It generalises Andreas Madsen's excellentpython-lrcurvelibrary for machine learning to produce visualisations for arbitrary functions in real-time.Installpip install jupyterplotHow to useSingle plotCreating a simple real-time plot in a Jupyter notebook is as easy as easy as the following snippet:from jupyterplot import ProgressPlot
import numpy as np

pp = ProgressPlot()
for i in range(1000):
    pp.update(np.sin(i / 100))
pp.finalize()Note:Thepp.finalize()statement is necessary to make the plots persistent between notebook sessions.Custom rangeBy default, the x and y ranges adapt to new data points. If the scale is known beforehand, it can be steadier to set it beforehand:pp = ProgressPlot(x_lim=[0, 1000], y_lim=[-1.5, 1.5])
for i in range(1000):
    pp.update(np.sin(i / 100))
pp.finalize()Multiple linesOne can also plot several lines in parallel by specifying the line names in the constructor and passing all values in a list.pp = ProgressPlot(line_names=["lin", "log", "cos", "sin"],
                  x_lim=[0, 1000],
                  y_lim=[-1, 4])

for i in range(1000):
    pp.update([[i / 250, np.log10(i + 1), np.cos(i / 100), np.sin(i / 100)]])
pp.finalize()Note:The data is fed topp.update()as a list of lists, where each sublist corresponds to the curves that are generated in each subplot.Multiple plotspp = ProgressPlot(plot_names=["cos", "sin"],
                  line_names=["data", "delayed-data"],
                  x_lim=[0, 1000],
                  y_lim=[-1, 1])

for i in range(1000):
    pp.update([[np.cos(i / 100), np.cos((i + 20) / 100)],
               [np.sin(i / 100), np.sin((i + 20) / 100)]])
pp.finalize()Custom x-valuesIf the x values should not be incremented by 1 at every update one can set thex_iterator=False. This requires passing two values to theupdate(x, y), wherexis anintorfloatandyfollows the same format as in the previous examples.pp = ProgressPlot(x_iterator=False, x_label="custom-x", x_lim=[0, 10000], y_lim=[0, 10])
for i in range(1000):
    pp.update(10 * i, i / 100)
pp.finalize()Decoupled y-limitsIf each subplot should have different y-limits then the y-limits can be passed as a list containing the the limits for each subplot.pp = ProgressPlot(plot_names=['plot 1', 'plot 2'], x_lim=[0, 1000], y_lim=[[0, 10],[0, 100]])
for i in range(1000):
    pp.update([[(i/100)], [(i/100)**2]])Input formatSingle plot, single lineIf the progress plot consists of a single plot with a single line one can pass the y-updates asintorfloat.Multiple plots, multiple linesIf multiple plots or lines are used, the y-updates can either be lists or dicts:y_update_list=[[y_plot_1_line_1,y_plot_1_line_2],[y_plot_2_line_1,y_plot_2_line_2]]y_update_dict={'plot_name_1':{'line_name_1':y_plot_1_line_1,'line_name_2':y_plot_1_line_2},'plot_name_2':{'line_name_1':y_plot_2_line_1,'line_name_2':y_plot_2_line_2}}LimitationsOnly oneProgressPlot()object can be used at a time.Each subplot must have the same number of lines.The same color cycle for each subplot is used.