Saravanan666/pypi-org huggingface dataset:
Package: jupyterwebcatconnect
jupyterwebcatconnectA JupyterLab extension to submit notebook to webcat.This extension is composed of a Python package namedjupyterwebcatconnectfor the server extension and a NPM package namedjupyterwebcatconnectfor the frontend extension.RequirementsJupyterLab >= 4.0.0InstallTo install the extension, execute:pipinstalljupyterwebcatconnectUninstallTo remove the extension, execute:pipuninstalljupyterwebcatconnectTroubleshootIf 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 jupyterwebcatconnect 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 modejupyterserverextensionenablejupyterwebcatconnect# 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 modejupyterserverextensiondisablejupyterwebcatconnect
pipuninstalljupyterwebcatconnectIn 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 namedjupyterwebcatconnectwithin that folder.Packaging the extensionSeeRELEASE
Package: jupyter-widget-echo-testing
jupyter-widget-echo-testingA Custom Jupyter Widget LibraryInstallationYou can install usingpip:pipinstalljupyter_widget_echo_testingIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:jupyternbextensionenable--py[--sys-prefix|--user|--system]jupyter_widget_echo_testingDevelopment InstallationCreate a dev environment:condacreate-njupyter_widget_echo_testing-dev-cconda-forgenodejsyarnpythonjupyterlab
condaactivatejupyter_widget_echo_testing-devInstall the python. This will also build the TS package.pipinstall-e".[test, examples]"When developing your extensions, you need to manually enable your extensions with the
notebook / lab frontend. For lab, this is done by the command:jupyter labextension develop --overwrite .
yarn run buildFor classic notebook, you need to run:jupyter nbextension install --sys-prefix --symlink --overwrite --py jupyter_widget_echo_testing
jupyter nbextension enable --sys-prefix --py jupyter_widget_echo_testingNote 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 changesTypescript: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-workflow
Jupyter WorkflowThe Jupyter Workflow framework enables Jupyter Notebooks to describe complex workflows and to execute them in a distributed fashion on hybrid HPC-Cloud infrastructures. Jupyter Workflow relies on theStreamFlowWMS as its underlying runtime support.Install Jupyter WorkflowThe Jupyter Workflow IPython kernel is available onPyPI, so you can install it using pip.pipinstalljupyter-workflowThen, you can install it on a Jupyter Notebook server by running the following command.python-mjupyter_workflow.ipython.installPlease note that Jupyter Workflow requirespython >= 3.8. Then you can associate your Jupyter Notebooks with the newly installed kernel. Some examples can be found under theexamplesfolder in theGitHub repository.Jupyter Workflow TeamIacopo Colonnelliiacopo.colonnelli@unito.it(creator and maintainer)Sergio Rabellinosergio.rabellino@unito.it(maintainer)Barbara Cantalupobarbara.cantalupo@unito.it(maintainer)Marco Aldinuccialdinuc@di.unito.it(maintainer)
Package: jupyter-wren-syntax
jupyter_wren_syntaxA JupyterLab extension.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstalljupyter_wren_syntaxUninstallTo remove the extension, execute:pipuninstalljupyter_wren_syntaxContributingDevelopment 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_wren_syntax 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=FalseDevelopment uninstallpipuninstalljupyter_wren_syntaxIn 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-wren-syntaxwithin that folder.Packaging the extensionSeeRELEASE
Package: jupyter-www-proxy
Jupyter www serverA very simple HTTP jupyter proxy server to servewwwfolder of the jupyter notebook directory. Install with pip:pip install jupyter-www-proxyThe server can be launched from the JupyterLab launcher window by clicking thewwwicon. In the classic notebook interface, lauch it from the file tab menu itemnew->www. Ifwwwwill be created under the jupyter working directory if it does not already exists.
Package: jupyter-wysiwyg
Rich Text HTML/Markdown Editor for JupyterLabThis is an nbextension that enables WYSIWYG editing functionality for HTML/Markdown cells in Jupyter.RequirementsJupyterLab >= 3.0ipywidgets >= 7.0.0InstallingThis extension can be installed through PIP.pipinstalljupyter-wysiwygOR# Clone the jupyter-wysiwyg repositorygitclonehttps://github.com/g2nb/jupyter-wysiwyg.gitcdjupyter-wysiwyg# Install the jupyter-wysiwyg JupyterLab prototypepipinstall-e.
jupyterlabextensiondevelop.--overwriteDevelopmentYou 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. To develop, run each of the following commands in a
separate terminal.jlpmrunwatch
jupyterlabThejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You
may useyarnornpmin lieu ofjlpm.With 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=False
Package: jupyter-xblock
Jupyter XBlockThis is anXBlockto integrate JupyterHub notebooks to yourOpen edXlearning management system (LMS).Features:IntegrateJupyterLabnotebooks to the Open edX courseware.Fully editable notebooks and student workspaces.Simple integration of notebooks from public git repositories.Here is a screenshot of the Jupyter XBlock in action:UsageTo use this xblock withTutor, useTutor-jupyterplugin as this will automatically be installed with it.
In your course "Advanced Settings", add "jupyter" to the "Advanced Module List":ConfigurationJupyterHub base URLThe JupyterHub cluster can be configured separately for every XBlock, but this can be quite tedious for course instructors. Instead, a default JupyterHub cluster URL can be defined globally by adding theLTI_DEFAULT_JUPYTER_HUB_URLsetting to both the LMS and CMS settings.For instance:LTI_DEFAULT_JUPYTER_HUB_URL = "https://hub.myopenedx.com"If this setting is undefined, the base URL will default tohttps://hub.LMS_HOST.LTI passport IDSimilarly, the LTI passport ID can be defined globally for all Jupyter XBlock instances. When a passport ID is not explicitely defined in an XBlock, it will default to theLTI_DEFAULT_JUPYTER_PASSPORT_IDsetting. If this setting is also undefined, then it will default toLTI_DEFAULT_PASSPORT_ID. The fallback value is "jupyterhub".To define a global LTI passport ID to be used by all Jupyter XBlock instances, add to your LMS/CMS settings:LTI_DEFAULT_JUPYTER_PASSPORT_ID = "myjupyterhub"Then, the corresponding passport must be created in the course advanced settings, as described in theOpen edX documentation:Configuring JupyterHubYou will have to launch your own JupyterHub cluster separately from Open edX. Your cluster should support:LTI authentication vialtiauthenticator.LTI authentication must accept the key and secret defined in the course LTI passport (see above).Pulling git repositories vianbgitpuller.Iframe embedding in your LMS/CMS, via the"Content-Security-Policy"header.Known limitationsGrading is not supported at the moment.It is not possible to pull notebooks from a raw URL -- only from a public git repository.TroubleshootingThis XBlock was kickstarted by Matthew Brett (@matthew-brett) and funded by a grant from theChan Zuckerberg Initiative. This project is maintained by Muhammad Hassan Siddiqi fromEdly. Community support is available from the officialOpen edX forum.LicenseThis work is licensed under the terms of theGNU Affero General Public License (AGPL).
Package: jupyter-xprahtml5-proxy
jupyter-xprahtml5-proxyIntegrate Xpra in your Jupyter environment for an fast, feature-rich and easy to use remote desktop in the browser.RequirementsPython 3.6+Jupyter Notebook 6.0+JupyterLab >= 3.xjupyter-server-proxy >= 3.1.0This package executes thexpracommand. This command assumes thexpracommand is available in the environment's $PATH.SecurityXprasupports password and encryption.Both are NOT required, if you can trusteveryone, who can log in to the host where your JupyterLab is running.
(incl.jupyter-server-proxy,jupyter-xprahtml5-proxyandXpra-HTML5)BUT (!!!)if you are on a multiuser system, where you CANNOT trust everyone,you must(!) ensure that your Xpra session is secured by at least a password.Currently this requiresthatjupyter-server-proxyincludes thispull requestandyou use jupyter-xprahtml5-proxy with a version number >= 0.3.0 (not on pypi)XpraXprais an open-source multi-platform persistentremote displaysolution for forwarding applications and desktop screens. It allows you to run X11 programs, usually on a remote host, and direct their display to your local machine.Best of it. It is fast, fast, fast and comes with a build-in html5 client to allow remote.Jupyter-Server-ProxyJupyter-Server-Proxylets you run arbitrary external processes (such as Xpra-HTML5) alongside your notebook, and provide authenticated web access to them.InstallCreate and Activate Environmentvirtualenv -p python3 venv
source venv/bin/activateInstall jupyter-xprahtml5-proxypip install git+https://github.com/FZJ-JSC/jupyter-xprahtml5-proxy.gitEnable jupyter-xprahtml5-proxy ExtensionsFor Jupyter Classic, activate the jupyter-server-proxy extension:jupyter serverextension enable --sys-prefix jupyter_server_proxyFor Jupyter Lab, install the @jupyterlab/server-proxy extension:jupyter labextension install @jupyterlab/server-proxy
jupyter lab buildStart Jupyter Classic or Jupyter LabClick on the Xpra icon from the Jupyter Lab Launcher or the Xpra item from the New dropdown in Jupyter Classic.Connect to your database as instructed in the Quickstart section.ConfigurationThis package callsxprawith a bunch of settings. Please read theXpra manualif you want to know the details.You have to modifysetup_xprahtml5()injupyter_xprahtml5_proxy/__init__.pyfor change.CreditsXprajupyter-server-proxyLicenseBSD 3-Clause
Package: jupyter-ydoc
jupyter_ydocjupyter_ydocprovidesYpy-based data structures for various
documents used in the Jupyter ecosystem. Built-in documents include:YBlob: a generic immutable binary document.YUnicode: a generic UTF8-encoded text document (YFileis an alias toYUnicode).YNotebook: a Jupyter notebook document.These documents are registered via an entry point under the"jupyter_ydoc"group as"blob","unicode"(or"file"), and"notebook", respectively. You can access them as follows:fromjupyter_ydocimportydocsprint(ydocs)# {#     'blob': <class 'jupyter_ydoc.yblob.YBlob'>,#     'file': <class 'jupyter_ydoc.yfile.YFile'>,#     'notebook': <class 'jupyter_ydoc.ynotebook.YNotebook'>,#     'unicode': <class 'jupyter_ydoc.yunicode.YUnicode'># }Which is just a shortcut to:importpkg_resourcesydocs={ep.name:ep.load()forepinpkg_resources.iter_entry_points(group="jupyter_ydoc")}Or directly import them:fromjupyter_ydocimportYBlob,YUnicode,YNotebookThe"jupyter_ydoc"entry point group can be populated with your own documents, e.g. by adding the
following to your package'spyproject.toml:[project.entry-points.jupyter_ydoc]
my_document = "my_package.my_file:MyDocumentClass"
Package: jupyter_zenroom_kernel
Jupyter zenroom kernelAZenroom:key: Jupyterkernelthat usesmetakernelDependenciesPython 3ZenroomInstallBefore installing you probably want to create avirtual environmentas per python best practices.
Once you activate your virtualenv you can install the kernel with the following commands:$ pip install jupyter_zenroom_kernel
$ python3 -m zenroom install --userIf the zenroom binary (shared or static) is installed system wide and/or is in your $PATH, then you just run jupyter as you would normally do$ jupyter notebookIf the binary is not in your path you have to set an environment variableZENROOM_BINwith the absolute path of the binaryStep by step installation for :snake: noobsWhat is zenroom?Zenroom is a brand new, small and portable virtual machine for cryptographic operations and is part of theDECODE projectabout data-ownership andtechnological sovereignty.
You can read more about it onhttps://zenroom.dyne.org/todozenroom_exec_buffoldable json renderingcell syntax highlightingmark lines on syntax errorsunit testingbetter documentationcode completion
Package: jupytest
You like the super-short try-until-succeed development cycle that comes from
implementing code in a Jupyter notebook? You would also like to perform your
development with a bit of discipline, writing repeatable unit and integration
tests as you go? This Python package is for you.You can start your notebook by instantiating a test suite, and as you
test-driven-develop your code (or something), you add tests to that suite.
These tests are run as you go. The test suite accumulates your test results
and can produce a report at the end. The package also includes an executable
script that will take your notebook of tests as input, run it all from the
command line, and write a nice result report to the shell – or some raw test
result data structure, if that’s how you fly.Find out more onjupytest’s Github
repository.
Package: jupytex
JupyTeXProvides Jupyter-backed execution of LaTeXcodeenvironments, and embeds the results. Similar in concept toPythonTex, but focuses on codeexecution, and avoids any language specific features.How to useInstall JupyTeX withpip install git+https://github.com/agoose77/jupytex.git#egg=jupytexRunjupytex installin LaTeX project directory (or provide an install directory with-d DIR) to create the necessary.latexmkrcandjupytex.styfilesAdd\usepackage{jupytex}to the document headerDeclare code environments with\begin{code}{language}[opts]
    Some source code\end{code}See the configuration section for valid options inopts.Runjupytex make(which is a pass-through tolatexmk --shell-escape) to invokelatexmk.Example Python Script\begin{code}{python}[kernel=python3]
    print("$x+y=z$")\end{code}UninstallationRunjupytex uninstallin LaTeX project directory (or provide an install directory with-d DIR) to remove the installed.latexmkrcandjupytex.styfilesCleaningRunjupytex clean(which is a pass-through tolatexmk -corlatexmk -C) to remove both LaTeX and JupyTex-related run files.JupyTeX flow controljupytex.stydeclares dependency upon\jobname.timestampjupytex.stymacro writes code blocks to numbered.codefiles and attempts to include resultsCode 'blocks' are written to a\jobname.blockscsv filejupytex hashis invoked to calculate the md5 hash for all of the blocks, which is written to\jobname.hash. In future this should only be performed per-kernel-session.If\jobname.hashhas been modified,jupytex executeis invoked for the corresponding job, the code blocks executed, and results written to.resultfiles, and errors to.tracebackfiles. Code blocks which do not write to stdout write an empty results file.\jobname.timestampis updated with new timestamp.latexmkperforms a new pass for the dependencies upon\jobname.timestampConfigurationEach code block must be given a language.One can specify the Jupyter kernel name with akernelkey parameter, which will be used instead of the language if present. One can also access an existing kernel, by passing the name of a connection file.Asessionkey parameter may be passed to create a new kernel associated with the kernel-session pair.  If thekernelparameter is set to a connection file, thenthis will create a new client to the same kernel.
Package: jupytexmagic
Why jupytex?This is a python package for rendering LaTeX in Jupyter notebook with native
rendering capabilities. Jupyter uses MathJax to render LaTeX inside of
Markdown cells, which is fine for most use cases; however, this does not
provide the full set of tools that LaTeX has to offer (e.g. tikzpictures,
complex figures). What we want is the ability to write content using Jupyter
for dynamic content while not sacrificing the beauty of native LaTeX.How Does it Work?This is a custom ipythonmagic pluginwhich allows users to create a new code cell, placing%%texat the top and
then put all of their LaTeX source code afterwards. Running the cell compiles
the code into.svgformat which is displayed following the cell.Jupytex usespdflatexto compile your cell's code into PDF format, thenpdfcropto crop the content, andpdf2svgto convert the PDF to.svgformat. Then this is displayed using the IPython module. The compilation is
fast, and has the upside of your LaTeX not needing to be rendered with
Javascript when viewed on the web.The.svgformat is great because it doesn't lose any definition upon
zooming in on the compiled LaTeX and you can highlight text with your cursor,
which you cannot do with normal image formats like PNG/JPEG.Usagerunpip install jupytexmagiccreate a new cell withimport jupytexmagicand%load_ext jupytexmagichave fun! for tex cells, place%%texat the top of your cellNote: see test/jupytexmagic.ipynb for an example runCurrently the document class is standalone with variable height\documentclass[varwidth, margin=1in]{standalone}and has page numbers turned off\pagenumbering{gobble}but other than that, you can fully customize the output. This is needed so that the rendering of the svg is continous similar to how Jupyter renders markdown.If your tex compilation fails, you can use the%%texdebugmagic command
to display the output ofpdflatexwhen compiling for debugging purposes.Current LimitationsBecause jupytex presents the compiled LaTeX in.svgformat, it assumes
a standard page layout. Currentlytexify()crops to content; although there
are slight things that are off about the margins. The goal is to fix this in
the next release!For some reason, the compilation does not work properly with JupyterNotebook;
however, it works just fine with JupyterLab. Currently uploading the source.ipynbfiles ruins the view on GitHub, but displaying and building inside
a Jupyter Book works properly (see images attached in [example run screenshots](#Example Run Screenshots)Tests directoryCurrently this directory contains a screenshot andlab.ipynb, which are
Jupyter example runs. Some ideas for testing could be to use selenium for
screenshotting and comparing images with known working versions.Example Run Screenshots