Saravanan666/pypi-org huggingface dataset:
Package: jupyterlab-email
jupyterlab_emailA jupyterlab extension to email notebooks from the browser.OptionsInline notebook as email, with codeInline notebook as email, without codeSend notebook as HTML attachment, with codeSend notebook as HTML attachment, without codeSend notebook as PDF attachment, with codeSend notebook as PDF attachment, without codeAttach output data as CSV, TSV, PDF, PNG, or Excel SpreadsheetInstallpipinstalljupyterlab_email
jupyterlabextensioninstalljupyterlab_email
jupyterserverextensionenable--pyjupyterlab_emailAdding templatesinstall the server extension, and add the following tojupyter_notebook_config.pyc.JupyterLabEmail.smtp_servers=[{'name':'gmail','domain':'gmail.com','username':'<YOUR USERNAME>','smtp':'smtp.gmail.com','port':465}]Create email from notebook:Use the function injupyterlab_email._emaildefmake_email(path,model,from_,type='email',template='',code=False,subject='',also_attach='none',also_attach_pdf_template='',also_attach_html_template=''):'''path        : path to notebookmodel       : notebook itself (in case deployment strips outputs ornotebook not available except through ContentsManager)from_       : address to send the email fromtype        : type to convert notebook totemplate    : template to use when converting notebookcode        : include input cells in notebooksubject     : subject of emailalso_attach : also attach pdf/html/both'''Attach dataframe as csv or spreadsheetInjupyterlab_email.attachmentsdefattach(data,filename,type):Modifyjupyterlab_email.attachments.EXCEL_ENGINEto use a different excel writer (defaults toxlsxwriter)Inline LaTeXInjupyterlab_email.attachmentsdeflatex(expression):importmatplotlib.pyplotaspltfig,ax=plt.subplots(figsize=(10,1))ax.xaxis.set_visible(False)ax.yaxis.set_visible(False)ax.axis('off')plt.text(0,0.6,r'$%s$'%expression,fontsize=25)plt.show()
Package: jupyterlab-empinken-extension
jupyterlab-empinken-extensionColoured JupyterLab / RetroLab notebook cells based on cell tagsJUPYTERLAB 4 version:pip install https://github.com/innovationOUtside/jupyterlab_empinken_extension/raw/jlv4/dist/jupyterlab_empinken_extension-0.4.0-py3-none-any.whlBELOW RELATES TO JUPYTERLAB V3Jupyterlite demo:https://innovationoutside.github.io/jupyterlab_empinken_extension/This extension optionally enables four notebook toolbar buttons that can toggle persistent tag state on notebook markdown and code cells.To install the prebuilt extension from a wheel:pip3 install --upgrade jupyterlab-empinken-extensionTo install the wheel from this repo:pip3 install --upgrade https://raw.githubusercontent.com/innovationOUtside/jupyterlab_empinken_extension/main/dist/jupyterlab_empinken_extension-0.1.1-py3-none-any.whlYou may need to restart the JupyterLab server? [NOT TESTED]I have no idea how to construct the repo so that you couldpip install git+REPOand it wouldn't go through the build process. TBH, I'm surprised I made it this far...The extension detects appropriate tags and adds corresponding classes to the notebook cell HTML DOM, which allows the backgrounds of the styles to be styled:Extension settings can be accessed from the Settings menu (Advanced Settings) and used to define the parsed tag patterns and the corresponding background colours.The extension also allows the display of each of the toolbar buttons to be individually controlled, as well as whether cells with parsed tags have HTML DOM classes added or not.Building and Pushing Newly Built Wheels to PyPi# Buildpipinstallbuildjupyter-packaging# Install the packagepipinstall.# Node MUST BE INSTALLEDpython-mbuild# packages built into ./dist# Push to PyPipipinstalltwine
twineuploadMY_PACKAGE.whlRelated Blog PostsNotes on the JupyterLab Notebook HTML DOM Model, Part 1: Rendered Markdown CellsNotes on the JupyterLab Notebook HTML DOM Model, Part 2: Code CellsNotes on the JupyterLab Notebook HTML DOM Model, Part 3: Setting Classes Based on Cell Tags From a JupyterLab ExtensionNotes on the JupyterLab Notebook HTML DOM Model, Part 4: Styling Custom ClassesNotes on the JupyterLab Notebook HTML DOM Model, Part 5: Setting DOM Classes and Cell Tags From Notebook Toolbar ButtonsNotes on the JupyterLab Notebook HTML DOM Model, Part 6: Pulling an Extension TogetherNotes on the JupyterLab Notebook HTML DOM Model, Part 7: Extension User SettingsNotes on the JupyterLab Notebook HTML DOM Model, Part 8: Setting CSS Variable Values from an ExtensionNotes on the JupyterLab Notebook HTML DOM Model, Part 8.5: A Reproducible Development ProcessNotes on the JupyterLab Notebook HTML DOM Model, Part 9: Building and Distributing a Pre-Built ExtensionDemoing JupyterLab Extensions from an Extension Repo Using Github Pages and JupyterLite
Package: jupyterlab-execute-time
jupyterlab-execute-timeDisplay cell timings in Jupyter LabThis is inspired by the notebook versionhere.RequirementsJupyterLab >= 3.0InstallTo install this package withpiprunpipinstalljupyterlab_execute_timeTo install this package withcondaruncondainstall-cconda-forgejupyterlab_execute_timeNote: By default, if this extension is enabled, it will automatically change your settings to record timing in the notebook metadata when it is loaded. If this fails, you can do this manually via Settings->Advanced Settings Editor->Notebook:{"recordTiming": true}. This is a notebook metadata setting and not a plugin setting. The plugin just displays this data.ContributingDevelopment 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 jupyterlab_execute_time 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=FalsePublishingBefore starting, you'll need to have run:pip install twine jupyter_packagingUpdate the version inpackage.jsonand update the release date inCHANGELOG.mdCommit the change in step 1, tag it, then push itgit commit -am <msg>
git tag vX.Z.Y
git push && git push --tagsCreate the artifactsrm -rf dist build jupyterlab_execute_time/labextension
jlpm run build
python setup.py sdist bdist_wheelTest this against the test pypi. You can then install from here to test as well:twine upload --repository-url https://test.pypi.org/legacy/ dist/*
# In a new venv
pip install --index-url https://test.pypi.org/simple/ jupyterlab_execute_timeUpload this to pypi:twine upload dist/*Uninstallpipuninstalljupyterlab_execute_timeHistoryThis plugin was contributed back to the community by theD. E. Shaw group.LicenseThis project is released under aBSD-3-Clause license.We love contributions! Before you can contribute, please sign and submit thisContributor License Agreement (CLA).
This CLA is in place to protect all users of this project."Jupyter" is a trademark of the NumFOCUS foundation, of which Project Jupyter is a part.
Package: jupyterlab-executor
jupyterlab-executorJupyterLab extension of executing the scriptsThe extension helps the user execute the script in the terminal and provides
multiple common executors, e.g. bash and python. Users can customise the
executors in the settings as well.RequirementsJupyterLab >= 4.0InstallThe package can be installed via PyPIpipinstalljupyterlab_executorCustomisationThe executors can be customised from the JupyterLab settings.Alternatively, the customisation JSON file can be appended into theusers setting directory.
The file path should be$HOME/.jupyter/lab/user-settings/@gavincyi/jupyterlab-executor/executor.jupyterlab-settingsand the format is like the following{
    "executors": [
        {
            "name": "bash",
            "command": "bash {path} {args}"
        },
        {
            "name": "python",
            "command": "python {path} {args}"
        },
        ...
    ]
}Theexecutorsvariable is a list of descriptions, of whichnameis the string shown in the dialogcommandis the executor command template to run, where{path}is the file path returned by the content manager in the JupyterLab,
andargsis the arguments passed in by the users.The environment variables are always appended at the beginning of the
command.For example, the following execution parametersrun the following command on the terminalPYTHONPATH=. bash test.py --time 1ContributingRoadmapThe following features are not yet completed but on the roadmap.Support script argument templateSupport default script argumentsThe above features will come out very soon.Development 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 jupyterlab_executor directory# Install jupyterlabpipinstalljupyterlab# 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=FalseUninstallpipuninstalljupyterlab_executorReleaseThe release should follow the below stepsmake cleanmake venvUpdate the version number inpackage.jsonmake release
Package: jupyterlab-extension-theme-onedark
jupyterlab_extension_theme_onedarkA JupyterLab extension theme as vscode onedarkRequirementsJupyterLab >= 4.0.0InstallTo install the extension, execute:pipinstalljupyterlab_extension_theme_onedarkUninstallTo remove the extension, execute:pipuninstalljupyterlab_extension_theme_onedarkContributingDevelopment 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 jupyterlab_extension_theme_onedark 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 uninstallpipuninstalljupyterlab_extension_theme_onedarkIn 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 namedjupyterlab-extension-theme-onedarkwithin 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: jupyterlab-ext-rightbar-doc
jupyterlab-ext-rightbar-docA JupyterLab extension.RequirementsJupyterLab >= 3.0Installpipinstalljupyterlab-ext-rightbar-docContributingDevelopment 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 jupyterlab-ext-rightbar-doc 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=FalseUninstallpipuninstalljupyterlab-ext-rightbar-doc
Package: jupyterlab-fasta
jupyterlab-fastaA JupyterLab extension for renderingFastadata. This extension uses theMSA Fasta viewer.RequirementsJupyterLab >= 3.0Installpipinstalljupyterlab-fastaUsageTo render fasta output in IPython:fromIPython.displayimportdisplaydefFasta(data=''):bundle={}bundle['application/vnd.fasta.fasta']=databundle['text/plain']=datadisplay(bundle,raw=True)Fasta(""">SEQUENCE_1MTEITAAMVKELRESTGAGMMDCKNALSETNGDFDKAVQLLREKGLGKAAKKADRLAAEGLVSVKVSDDFTIAAMRPSYLSYEDLDMTFVENEYKALVAELEKENEERRRLKDPNKPEHKIPQFASRKQLSDAILKEAEEKIKEELKAQGKPEKIWDNIIPGKMNSFIADNSQLDSKLTLMGQFYVMDDKKTVEQVIAEKEKEFGGKIKIVEFICFEVGEGLEKKTEDFAAEVAAQL>SEQUENCE_2SATVSEINSETDFVAKNDQFIALTKDTTAHIQSNSLQSVEELHSSTINGVKFEEYLKSQIATIGENLVVRRFATLKAGANGVVNGYIHTNGRVGVVIAAACDSAEVASKSRDLLRQICMH""")To render a.fastafile, simply open it.ContributingDevelopment 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 jupyterlab-fasta 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=FalseUninstallpipuninstalljupyterlab-fasta
Package: jupyterlab-favorites
jupyterlab-favoritesAdd the ability to save favorite folders to JupyterLab for quicker browsing.RequirementsJupyterLab >= 4.0.0 or Notebook >= 7.0.0For JupyterLab 3, you can install jupyterlab-favorites 3.1.x using pip for example:pipinstall"jupyterlab-favorites~=3.1.1"InstallTo install the extension, execute:pipinstalljupyterlab_favoritesUninstallTo remove the extension, execute:pipuninstalljupyterlab_favoritesContributingDevelopment 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 jupyterlab_favorites 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 uninstallpipuninstalljupyterlab_favoritesIn 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 named@jlab-enhanced/favoriteswithin that folder.Packaging the extensionSeeRELEASE
Package: jupyterlab-filebrowser-terminal
jupyterlab_filebrowser_terminalA simple extension to open a JupyterLab terminal in the current filebrowser locationRequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstalljupyterlab_filebrowser_terminalUninstallTo remove the extension, execute:pipuninstalljupyterlab_filebrowser_terminalContributingDevelopment 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 jupyterlab_filebrowser_terminal 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 uninstallpipuninstalljupyterlab_filebrowser_terminalIn 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 namedjupyterlab-filebrowser-terminalwithin that folder.jupyterlab-filebrowser-terminal