Saravanan666/pypi-org huggingface dataset:
Package: jupyter-spaces
Jupyter SpacesJupyter Spaces is an IPython extension for creating parallel namespaces
available within the user namespace. It is designed to be used via IPython
magics in Jupyter notebooks.Installationpipinstalljupyter_spacesjupyter_spacessupports Python versions3.6,3.7,3.8,3.9and3.10.UsageLoadjupyter_spacesextension%load_extjupyter_spacesReloadjupyter_spacesextension%reload_extjupyter_spacesReloading the extension will remove all spaces.Run a cell within a space%%space<space-name>alpha=0.50alphaWhen you execute a cell within a space, all references are firstly searched in
the space namespace and secondly in the user namespace. All assignments are
made in the space namespace.Trying to delete a user namespace reference will raise an error. Trying to
affect a user namespace reference using the keywordglobalwill produce an
execution equivalent to not using such keyword.Mutable objects in the user namespace can be altered (e.g. appending an item
to a list).Remove a space%remove_space<space-name>Access all spaces at onceYou can access all the spaces' namespaces at once without using any magic.
This might be useful to jointly post-process or compare the spaces' contents.fromjupyter_spacesimportget_spacesspaces=get_spaces()space=spaces[<space-name>]reference=space.namespace[<reference-name>]Spaceobjects have two properties:namethe name of the spacenamespacea dictionary with the namespace of the spaceModifying the spaces viaget_spaceswill actually modify the underlying
spaces.AcknowledgementsMany thanks toYeray Diaz DiazandKarol Duleba!
Package: jupyter-sphinx
Jupyter Sphinx Extensionsjupyter-sphinxenables running code embedded in Sphinx documentation and
embedding output of that code into the resulting document. It has support
for rich output such as images and even Jupyter interactive widgets.InstallationWith pip:pipinstalljupyter_sphinxwith conda:condainstalljupyter_sphinx-cconda-forgeUsageYou can check out the documentation onhttps://jupyter-sphinx.readthedocs.iofor up to date
usage information and examples.LicenseWe use a shared copyright model that enables all contributors to maintain the
copyright on their contributions.All code is licensed under the terms of the revised BSD license.
Package: jupyter-sphinx-theme
# jupyter-sphinx-themeA Jupyter [Sphinx](http://www.sphinx-doc.org/en/stable/) theme for narrativedocumentation.## InstallationInstall the package using PIP:```bashpip install jupyter_sphinx_theme```Edit the "conf.py" configuration file to point to the jupyter theme:```python# At the top.from jupyter_sphinx_theme import *init_theme()# ...# Comment out the `html_theme =` line```
Package: jupyterspot
jupyterspotInstead of screen-sharing a Jupyter notebook, share a link to a real-time collaborative whiteboard with live cursors, scroll syncing, freehand drawings, text, and sticky notes.Create afree accountto get an API key, then click the "Open in JupyterSpot" button to see your notebook's whiteboard. Check out thedocumentationfor more detailed instructions.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstalljupyterspotUninstallTo remove the extension, execute:pipuninstalljupyterspotContributingDevelopment 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 jupyterspot 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 uninstallpipuninstalljupyterspotIn 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 namedjupyterspotwithin that folder.Testing the extensionFrontend testsThis extension is usingJestfor JavaScript code testing.To execute them, execute:jlpm
jlpmtestIntegration testsThis extension usesPlaywrightfor the integration tests (aka user level tests).
More precisely, the JupyterLab helperGalatais used to handle testing the extension in JupyterLab.More information are provided within theui-testsREADME.Packaging the extensionSeeRELEASE
Package: jupyterstan
jupyterstanjupyterstanis a package to help development of Stan models (usingpystan)
in jupyter notebooks.The package is heavily based on Arvinds-dsstanmagicpackage, but provides an
interface that simply returns apystan.Modelobject.In addition, it bundles Arvinds-dsstan_code_helperpackage to improve
syntax highlighting for stan cells.FeaturesStan language syntax highlighting in all cells beginning with%%stanCompile a stan model and save it as a pystan variable by running a%%stancellNo longer worry aboutmodel_code, reading in stan files, etc.InstallationTo install the library:pipinstalljupyterstanUsageTo use themagicin your notebook, you need to lead the extension:%load_extjupyterstanTo define a stan model inside a jupyter notebook, start a cell with the%%stanmagic. You can also provide a variable name, which is the variable name that
thepystan.Modelobject will be assigned to. For example:%%stanparis_female_birthsdata{intmale;intfemale;}parameters{real<lower=0,upper=1>p;}model{female~binomial(male+female,p);}When you run this cell,jupyterstanwill create a pystan Model object, which will compile your model and allow
you to sample from it. To use your compiled model:fit=paris_female_births.sampling(data={'male':251527,'female':241945},iter=1000,chains=4)
Package: jupyter-starters
jupyterlab-startersParameterized file and directory starters for JupyterLab.releasesdepscidemodocsWhat's a starter?A starter is a...single filedirectorypython functioncookiecutternotebook... that creates a...single filedirectory of files (or more directories)... that shows upwhere you want itin JupyterLabat the click of a buttonInstallingYou'll needjupyterlab >=3,<4,python >=3.7, andnodejs >=12pipinstall--prejupyter_startersCheck your installation:jupyterserverextensionlist
jupyterlabextensionlistIf you don't seejupyterlab_startersrun:jupyterserverextensionenable--sys-prefixjupyterlab_startersConfiguringLike the Jupyter Notebook server, JupyterHub and other Jupyter interactive computing
tools,jupyter-starterscan be configured viaPython or JSON filesinwell-known locations. You can find out where to put them on your system with:jupyter--pathsThey will be merged from bottom to top, and the directory where you launch yournotebookserver wins, making it easy to check in to version control.The very simplest starter,copy, will copy a file or folder to the location it is
launched from in the JupyterLabLauncher.{"StarterManager":{"extra_starters":{"whitepaper-single":{"type":"copy","label":"Whitepaper Notebook","description":"A reusable notebook for proposing research","src":"examples/whitepaper-single.ipynb"}}}}more docs TBD: for now, see examples in thedemo configuration.AlternativesDon't like what you see here? Try these other approaches:jupyterlab_templates
Package: jupyter-style
Jupyter notebook Style HelperWhat is, the purpose of this project?This is style generator, you can simply generate inline css to insert into your Jupyter notebook to change look of tables in your preview.How to install:pipinstalljupyter-styleWhat python version is required?Code is compatible with python >= 3.5How to use it?fromIPython.displayimportHTML,displayimportseabornassnsfromjupyterStyleimportStyleHelperstyle_generator=StyleHelper.StyleHelper()style_generator.emit_style()iris=sns.load_dataset('iris')display(iris.head(5))style_generator.emit_style(col_header_color="#F02020",row_header_color="#AAAA40")Show me how default Jupyter style looks like to compare.How can I customise generated style?col_header_color- Column header colorrow_header_color- Row header colorselector- css selector to apply style only to selected elementsToDo:Add parameters for: lines, margins, shadows, etc.Add a support for predefined themes
Package: jupyter-summarytools
DataFrame Summary Tools in Jupyter NotebookThis is python version ofsummarytools, which is used to generate standardized and comprehensive summary of dataframe in Jupyter Notebooks.The idea is originated from thesummarytoolsR package (https://github.com/dcomtois/summarytools).OnlydfSummaryfunction is made available for nowAdded two html widgets to avoid displaying lengthy contentcollapsible summarytabbed summaryInstallationpip install jupyter-summarytoolsDependenciespython 3.6+pandas >= 1.4.0Quick Startthe quick-start notebook is available inhereout-of-boxdfSummaryfunction will generate a HTML based data frame summary.importpandasaspdfromsummarytoolsimportdfSummarytitanic=pd.read_csv('./data/titanic.csv')dfSummary(titanic)collapsible summaryimportpandasaspdfromsummarytoolsimportdfSummarytitanic=pd.read_csv('./data/titanic.csv')dfSummary(titanic,is_collapsible=True)tabbed summaryimportpandasaspdfromsummarytoolsimportdfSummary,tabsettitanic=pd.read_csv('./data/titanic.csv')vaccine=pd.read_csv('./data/country_vaccinations.csv')vaccine['date']=pd.to_datetime(vaccine['date'])tabset({'titanic':dfSummary(titanic).render(),'vaccine':dfSummary(vaccine).render()})Export notebook as HTMLwhen export jupyter notebook to HTML, make sureExport Embedded HTMLextension is installed and enabled.Using the following bash command to retain the data frame summary in exported HTML.jupyternbconvert--tohtml_embedpath/of/your/notebook.ipynb
Package: jupyter-swi-prolog
SWI-Prolog Kernel for JupyterThis is a simple wrapper kernel for SWI Prolog.Quick StartTable of ContentsSetupUsing pipUsing DockerUsageSetupUsing pipRunpipto install the corresponding package frompypiafterJupyter is already installed.pipinstalljupyter-swi-prologRegister the kernel.jupyterkernelspecinstall<pathtothesite-packagesdirectory>/swi_prolog_kernelNow start Jupyter the usual way and the kernel should be available.Using DockerExecute the following command to pull a and run a prepared image.dockerrun-p8888:8888troebs/jupyter:swi-prologThis image can also be used with JupyterHub and theDockerSpawner / SwarmSpawnerand probably with thekubespawner.
You can also build your own image using theDockerfilein the repository.UsageAn example can be foundin the repository.Please note:consultis usually used to read facts and rules from a Prolog source file. To avoid the need for
separate files, the magic command%%CONSULTis supported, which replaces this file with the contents of a cell in the
Jupyter notebook.
Package: jupyter-tabnine
This extension for Jupyter Notebook enables the use of
coding auto-completion based on Deep Learning.Other client plugins of TabNine require starting a child process for TabNine binary
and using Pipe for communication. This can’t be done with Jupyter Notebook, since child process
can’t be created with JQuery and Jupyter Notebook doesn’t provide any way for adding third-part js libs to plugins.In this repository, it is achived by developing a client plugin and a server plugin for Jupyter Notebook.
The client plugin generate request info and send http request to the server plugin.
The server plugin pass the request info to it’s client process (TabNine) and return the request to client plugin.InstallationThe extension consists of a pypi package that includes a javascript
notebook extension, along with a python jupyter server extension.
Since Jupyter 4.2, pypi is the recommended way to distribute nbextensions.
The extension can be installedfrom the master version on the github repo (this will be always the most recent version)via pip for the version hosted on pypiFrom the github repo or from Pypi,install the packagepip3 installhttps://github.com/wenmin-wu/jupyter-tabnine/archive/master.zip[--user][--upgrade]orpip3 installjupyter-tabnine[--user][--upgrade]or clone the repo and installgit clonehttps://github.com/wenmin-wu/jupyter-tabnine.gitpython3 setup.py installinstall the notebook extensionjupyter nbextension install --py jupyter_tabnine [--user|--sys-prefix|--system]and enable notebook extension and server extensionjupyter nbextension enable --py jupyter_tabnine [--user|--sys-prefix|--system]
jupyter serverextension enable --py jupyter_tabnine [--user|--sys-prefix|--system]For Jupyter versions before 4.2, the situation after step 1 is more
tricky, since the--pyoption isn’t available, so you will have to
find the location of the source files manually as follows (instructions
adapted from [@jcb91](https://github.com/jcb91)’sjupyter_highlight_selected_word).
Executepython -c "import os.path as p; from jupyter_tabnine import __file__ as f, _jupyter_nbextension_paths as n; print(p.normpath(p.join(p.dirname(f), n()[0]['src'])))"Then, issuejupyter nbextension install <output source directory>
jupyter nbextension enable jupyter_tabnine/jupyter_tabninewhere<output source directory>is the output of the first python
command.TipsA shortcut is added to let you switch between Jupyter raw completion and TabNine auto-competion. Just entershift+spacewhen you want raw completion of Jupyter :)Remote auto-completion server is also supported. You may want this to speed up the completion request handing. Or maybe your company want to deploy a compeltion server cluster that services everyone. Referhttps://github.com/wenmin-wu/jupyter-tabnineto learn how to deploy remote server.
Package: jupyter-telemetry
TelemetryTelemetry for Jupyter Applications and extensions.Telemetry (təˈlemətrē): the process of recording and transmitting the readings of an instrument. [Oxford Dictionaries]Jupyter Telemetry enables Jupyter Applications (e.g. Jupyter Server, Jupyter Notebook, JupyterLab, JupyterHub, etc.) to recordevents—i.e. actions by application users—and transmit them to remote (or local) destinations asstructureddata. It works with Python's standardlogginglibrary to handle the transmission of events allowing users to send events to local files, over the web, etc.InstallJupyter's Telemetry library can be installed from PyPI.pip install jupyter_telemetryBasic UsageTelemetry provides a configurable traitlets object,EventLog, for structured event-logging in Python. It leverages Python's standardlogginglibrary for filtering, handling, and recording events. All events are validated (usingjsonschema) against registeredJSON schemas.Let's look at a basic example of anEventLog.importloggingfromjupyter_telemetryimportEventLogeventlog=EventLog(# Use logging handlers to route where events# should be record.handlers=[logging.FileHandler('events.log')],# List schemas of events that should be recorded.allowed_schemas=['uri.to.event.schema'])EventLog has two configurable traits:handlers: a list of Python'slogginghandlers.allowed_schemas: a list of event schemas to record.Event schemas must be registered with theEventLogfor events to be recorded. An event schema looks something like:{"$id":"url.to.event.schema","title":"My Event","description":"All events must have a name property.","type":"object","properties":{"name":{"title":"Name","description":"Name of event","type":"string"}},"required":["name"],"version":1}2 fields are required:$id: a valid URI to identify the schema (and possibly fetch it from a remote address).version: the version of the schema.The other fields follow standard JSON schema structure.Schemas can be registered from a Pythondictobject, a file, or a URL. This example loads the above example schema from file.# Register the schema.eventlog.register_schema_file('schema.json')Events are recorded using therecord_eventmethod. This method validates the event data and routes the JSON string to the Pythonlogginghandlers listed in theEventLog.# Record an example event.event={'name':'example event'}eventlog.record_event(schema_id='url.to.event.schema',version=1,event=event)
Package: jupyter-telemetry-sphinxext
Jupyter Telemetry Sphinx ExtensionSphinx extension for auto-generating Jupyter Telemetry schema documentation.To activate this extension, addjupyter_telemetry_sphinxextto yourconf.pyfile
and set the following configuration values:# config.py file.# Add jupyter_telemetry_sphinxext to the extensions list.extensions=['jupyter_telemetry_sphinxext',...]# Jupyter telemetry configuration values.jupyter_telemetry_schema_source="path/to/schemas/source/directory"# Path is relative to conf.pyjupyter_telemetry_schema_output="path/to/output/directory"# Path is relative to conf.pyjupyter_telemetry_index_title="Example Event Schemas"# Title of the index page that lists all found schemas.
Package: jupyterterminals
General instructions for building for pip distributionAfter changingsetup.pyor any part of the JupyterTerminals codebase, increase the version number in setup.py appropriately, around line 37.Then run the commands shown below to upgrade what's stored in pippython3setup.pyprep_to_buildnpm_run_buildsdistbdist_wheelUploading to the pypi test servers:python3-mtwineupload--repository-urlhttps://test.pypi.org/legacy/dist/*--verbose(For User name you can usewillkessler.)Installing to a host in the cloud, from the test servers:python3-mpipinstall--index-urlhttps://test.pypi.org/simple/jupyterterminalsTesting new installation on cloud host:jupyternotebook—port=3001—ip=127.0.0.1—allow-rootUploading to the pypi production servers:python3-mtwineuploaddist/*(For User name you can usewillkessler.)General instructions for building for conda distributionNB: this relies on jupyterterminals being in the main (production) pypi repository.
First time steps:mkdir conda
cd conda
rm -rf jupyterterminals
conda skeleton pypi jupyterterminals
conda install conda-verifyModifyjupyterterminals/meta.yamlto includebuild   noarch:  python.
Modifyjupyterterminals/meta.jsonto include github handle:willkessler(Re)building on macosx:(After you make updates, make sure to bump the version number injupyterterminals/meta.yml.conda build jupyterterminals
export TERMINALS_VERSION=0.1.1
anaconda upload /Users/will/anaconda/conda-bld/noarch/jupyterterminals-$TERMINALS_VERSION-py_0.tar.bz2Then you want to convert to other architectures and upload these as well:conda convert --platform all ~/anaconda/conda-bld/osx-64/jupyterterminals-$TERMINALS_VERSION-py36_0.tar.bz2 -o linux64_out
anaconda upload linux64_out/linux-64/jupyterterminals-$TERMINALS_VERSION-py36_0.tar.bz2... etc for all the architectures you want to support. This last step doesn't seem to be necessary any more (01/23/2020).To install you should be able to do :conda install -c willkessler jupyterterminalsBuilding for Windows and building for pip on WindowsTo debug issues on Windows, you need to have cygwin64 and node installed on the system. Then you need to usejupyterterminals/package.json_windowsinstead ofjupyterterminals/package.json. This version ofpackage.jsonhas a different build step using utilities provided by Cygwin:...
  "scripts": {
    "build": "/cygwin64/bin/rm.exe -rf terminals-dist build ../build_for_pip/code-prep && node node_modules/gulp/bin/gulp.js prebuild && cd node_modules/.bin && r_js.cmd -o ../../build.js && cd ../.. && node ./node_modules/gulp/bin/gulp.js moveStyles && cd node_modules/.bin && r_js.cmd -o ../../../build_for_pip/buildPip.js && cd ../.. && node ./node_modules/gulp/bin/gulp.js pipMoveStyles"
  },
...You can follow the steps above to build for pip. For creating the pip artifact, from this directory do:python3 setup.py prep_to_build npm_run_build sdist bdist_wheelbut then you can install from this build, without uploading to pypi servers, by simply :unpacking the tarball found in the dist directoryswitching to the unpack directoryfinally:pip install .
Package: jupyter-theme-christmas
Ξ JupyterLab Theme for ChristmasDesign byIsabela Presedo-Floyd, coded with the help of Jovyans atQuansightUsecondacreate-y-njupyter-theme-christmaspython=3.8&&\condaactivatejupyter-theme-christmas&&\pipinstall--prejupyterlab==3.0.0rc10jupyter_theme_christmas--upgrade--force-reinstall# How to launch jupyter lab with a defined theme?mkdir-p~/.jupyter/lab/user-settings/\@jupyterlab/apputils-extension&&\CONF="{ \"theme\": \"JupyterLab Christmas\" }"&&\cat>~/.jupyter/lab/user-settings/\@jupyterlab/apputils-extension/themes.jupyterlab-settings<<EOF${CONF}EOFjupyterlabTODOUpdate the Launcher page with something like e.g.https://github.com/fcollonval/jlab-enhanced-launcherStrip down the variables.css to only the needed css?Bring more fancy ui like inhttps://github.com/timkpaine/jupyterlab_miami_nights: Search tool + neon billboard + Collapser + neon light + Scrollbar + FM-84's "Atlas" (compatible with webKit browsers) + A surprise in the presentation mode (Top menu --> View --> Presention mode)Develop# Build the extension and link for dev in shell 1.jupyterlabextensiondevelop--overwrite# List extensions.jupyterlabextensionlist
piplist|grepjupyter-theme-christmas# Run and watch jupyterlab in shell 1.jlpmwatch# Run and watch jupyterlab in shell 2.# Look at the remote entry javascript, a webpack5 feature.mkdir~/notebooks&&\jupyterlab\--dev-mode\--watch\--notebook-dir=~/notebooks\--ServerApp.token=\--extensions-in-dev-modeBuild# Generate sourcemaps.jupyterlabextensionbuild--developmentTrue.
jupyterlabbuild--minimize=False# Do not generate sourcemaps.jupyterlabextensionbuild.
jupyterlabbuildPublishpipinstalljupyter_packagingtwine&&\pythonsetup.pysdistbdist_wheel&&\twineuploaddist/*jlpmbuild:lib&&\npmpublish--accesspublic
Package: jupyter-threejs-sage
Custom build of Three.js for SageMathThis package provides a single minified Javascript filethree.min.js, which combines
standard Three.js with a number of scripts fromexamples/jsm/.The file is made available both as package data of a Python packagejupyter_threejs_sage(for local access by SageMath) and as a Jupyter notebook extension (to be installed in the Jupyter notebook's Python environment).DevelopmentThe steps to create this build from a stable tagged version of Three.js arePerform a shallow clone of the desired version withgit clone --depth=1 --branch r<n> --single-branch https://github.com/mrdoob/three.js.gitAdd the following lines tosrc/Three.jsjust after all other exportsexport { OrbitControls } from '../examples/jsm/controls/OrbitControls.js';
export { Line2 } from '../examples/jsm/lines/Line2.js';
export { LineGeometry } from '../examples/jsm/lines/LineGeometry.js';
export { LineMaterial } from '../examples/jsm/lines/LineMaterial.js';
export { LineSegments2 } from '../examples/jsm/lines/LineSegments2.js';
export { LineSegmentsGeometry } from '../examples/jsm/lines/LineSegmentsGeometry.js';Move into the library directory withcd three.jsConfigure the library withnpm installBuild the library withnpm run buildThe minified filethree.min.jswill be located in thebuilddirectory.Copy the minified file to thebuilddirectory here.Create a new directory for the new version injupyter_threejs_sage/static/and copy the minified file there.
(Do not remove old versions that needed by any released versions of Sage.)The final step before releasing is to update theversionfile.As noted inthis issue, Three.js releases can be modified for up to a week after the initial release. This build process should wait for this period of time to ensure future consistency of building.