Saravanan666/pypi-org huggingface dataset:
Package: jupytercad-freecad
jupytercad_freecadA JupyterLab extension.RequirementsJupyterLab >= 4.0.0InstallTo install the extension, execute:pipinstalljupytercad_freecadUninstallTo remove the extension, execute:pipuninstalljupytercad_freecadContributingDevelopment 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 jupytercad_freecad 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 modejupyterserverextensionenablejupytercad_freecad# 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 uninstallpipuninstalljupytercad_freecadIn 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@jupytercad/jupytercad_freecadwithin that folder.Packaging the extensionSeeRELEASE
Package: jupyter-cadquery-widgets
jupyter_cadquery_widgets 2.0.2Treeview and Image Button widgets forjupyter-cadqueryRequirementsJupyterLab >= 3.0Installpipinstalljupyter_cadquery_widgetsContributingDevelopment 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_cadquery_widgets 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=FalseUninstallpipuninstalljupyter_cadquery_widgets
Package: jupytercad-salome
jupytercad_salomeJupyterCAD-Salomeis an extension for JupyterCAD which enables users to generate meshes from their creations in JupyterCAD, leveraging the powerful meshing capabilities of Salome, a leading open-source platform for numerical simulation.JupyterCAD-Salomeis currently in active development.Creating a mesh with JupyterCAD in combination withJupyterCAD-SalomeAs you can see in the video above,JupyterCAD-Salomewill add a new button to the JupyterCAD toolbar allowing to generate a mesh from the currently selected object in the JupyterCAD viewer.Try it liveA deployment is published for you to give it a try:https://trungleduc-jupytercad.hf.space/labThis demo is entirely collaborative, which means anybody getting to this link will
see what you do and be able to collaborate with you.You can make your own deployment on HuggingFace pressing the "⋮" button on the top-right corner of the page, then "Duplicate this Space"Local InstallInstall Salome fromhttps://www.salome-platform.org/?page_id=2430To install the extension, execute:pipinstalljupyterlab
pipinstall--prejupytercadjupytercad-salomeThen you can either start JupyterLab or JupyterCAD:jupyterlab# ORjupytercadImplementationJupyterCAD-Salomeconsists of two components:Ajupyter-serverendpoint which is ready to compute the mesh upon client demand. This endpoint is defined usingan OpenAPI spec. Users are not bound to the provided jupyter-server endpoint,JupyterCAD-Salomecan connect to any server implementing the OpenAPI spec.[!NOTE]
To useJupyterCAD-Salomewith a different Salome server, set theSALOME_SERVER_BASE_URLenvironment variable to your server address before startingJupyterLab.A client plugin for JupyterCAD adding UI elements to interact with the mesh-generation endpoint. Whenever the user clicks on the toolbar button, they are prompted with a dialog to configure the API call:[!NOTE]
This user interface is generated automatically fromthis schema file.Once the API call is made, the server will compute the mesh using thesmesh libraryand send back the response with the computed mesh to the client.The user can later on re-generated the mesh with different inputs:Packaging the extensionSeeRELEASE
Package: jupyter-capture-output
jupyter-caputure-outputA cell magic that captures jupyter cell outputInstallRequires Python >=3.8pipinstalljupyter_capture_outputExamplehttps://user-images.githubusercontent.com/44469195/199723257-ee428f53-d576-47be-93b9-d6ab98c46d8e.movimportjupyter_capture_output%%capture_text--path"foo.txt"print("Hello World")importmatplotlib.pyplotasplt%%capture_img--path"foo.png bar.png"plt.plot([1,2],[10,20])plt.show()plt.plot([3,4],[-10,-20])plt.show()%%capture_img--path"foo.jpg bar.jpg"--compression50plt.plot([1,2],[10,20],color="r")plt.show()plt.plot([3,4],[-10,-20],color="r")plt.show()Implemented%%capture_text->  to .txt file with text output%%capture_code->  to .py file with cell content%%capture_img-> to .png or .jpg with image output%%capture_video-> to .mp4 file with the video outputUse casesmatplotlib, scipy, PIL , cv2, manim etc. have their own APIs to save images. With this package, one just have to learn one line of code and can use it to save all kind of image outputs made by different packages.When tweaking plots, one can use this cell magic to track the process, so to say a visual version control system.In context of Science, one can generate log files of experiments with this package. As the cell magic is always on the top of the cell, it's easy to see in which cells log files are generated and in which not.This can be used to create sheet cheats, e.g. thismath-functions-cheat-sheetwebsite was generated from a jupyter notebook using a derivative of this capture package.This package will also auto-generate the folder-tree of subdirectories for you.Changelog0.0.11add support for embedded videos.0.0.10use importlib.metadata0.0.9support python 3.110.0.8Addcapture_codemagic. Because this is not cell output but cell content, it might be worth to think about renaming this project fromcapture-outputto onlycaptureor evencapture-content.remove experimental_capture_video_first_lastandexperimental_video_thumbnailagain. This package is not the right place for that.0.0.7Add relative path support and automatically create paths if they don't exist yet.Add some experimental magic, but this will likely be removed in future versions:experimental_capture_video_first_lastcaptures video and extracts first and last frame from it. Useful for post-processing of videos in other video editors. Needs ffmpeg installedexperimental_video_thumbnailextracts video from the Jupyter cell output, and replaces it with an image thumbnail of the video -> useful for Version control. Needs matplotlib and ffmpeg installed0.0.6better regex in capture video
change example images to dogs0.0.5Remove debugging code
Add JupyterLiteDemo0.0.4Add Text and Video capture cell magic
update example0.0.3Setup automatic release action.0.0.2Update example0.0.1Initial release
Package: jupyter-cassini-server
jupyter_cassini_serverJupyterlab extension for interacting with Cassini projectsThis project creates a GUI forCassinithat runs inside jupyterlab. This allows the gui to be more performant and gives more flexiblity in terms of what it can do.See theCassinirepo for some information on the Python-side of things.In this repo there is a Python package namedjupyter_cassini_serverfor the server extension and a NPM package namedjupyter_cassinifor the frontend extension.The server serves up information about the contents of a users project. The frontend extension then renders nice widgets to interface with this.ContributingCheck out the contribution guidehere
Package: jupyter-cleaner
jupyter-cleanerjupyter-cleaner makes tracking Jupyter lab files in git easy.This is done by:Removing the output of cellsFormatting the source of cells (using black)Reordering imports in the source of cells (using reorder-python-imports)Setting the execution count of cellspretty printing the JSON arrayIt is recommended to run jupyter-cleaner before adding the Jupyter lab files to the stage in git. This allows for easier tracking of differences between commits.CLIrunningjupyter-cleaner -hdisplays:usage: jupyter-cleaner [-h] [--exclude_files_or_dirs EXCLUDE_FILES_OR_DIRS [EXCLUDE_FILES_OR_DIRS ...]] [--execution_count EXECUTION_COUNT]
                       [--indent_level INDENT_LEVEL] [--remove_outputs] [--format] [--reorder_imports] [--ignore_pyproject]
                       files_or_dirs [files_or_dirs ...]

jupyter_cleaner

positional arguments:
  files_or_dirs         Jupyter lab files to format or directories to search for lab files

options:
  -h, --help            show this help message and exit
  --exclude_files_or_dirs EXCLUDE_FILES_OR_DIRS [EXCLUDE_FILES_OR_DIRS ...]
                        Jupyter lab files or directories to exclude from formatting and search
  --execution_count EXECUTION_COUNT
                        Number to set for the execution count of every cell. Defaults to 0.
  --indent_level INDENT_LEVEL
                        Integer greater than zero will pretty-print the JSON array with that indent level. An indent level of 0 or negative
                        will only insert newlines.. Defaults to 4.
  --remove_outputs      Remove output of cell. Defaults to false.
  --format              Format code of every cell (uses black). Defaults to false.
  --reorder_imports     Reorder imports of every cell (uses reorder-python-imports). Defaults to false.
  --ignore_pyproject    Argparse will over-ride pyproject. Defaults to false.pyproject.tomlInputs to jupyter-cleaner can be supplied via pyproject.toml:[tool.jupyter_cleaner]
execution_count=0
remove_outputs=true
format=true
reorder_imports=true
indent_level=4
Package: jupyter_cms
This package adds the following features to Jupyter Notebook:Search dialog on file tree, editor, and notebook screens to search over filenames and .ipynb content in the notebook directoryIPython kernel extension to make notebooks importable, and notebook cells injectable via # <api> and # <help> annotationsFull-page drag-and-drop upload targetPop-over table of contents navigation for notebooksSeethe project READMEfor more information.
Package: jupyter-code-extractor
Jupyter Code Cells to TXTA simple command-line tool for extracting code cells from Jupyter notebooks. Optionally, it allows extraction of all cell types including markdown.Table of ContentsInstallationDevelopment InstallationLocal InstallationUsageRequirementsContributingLicenseChangelogInstallationDevelopment InstallationFor those contributing and making changes to the codebase, it's often more efficient to install the package in 'editable' mode. This way, changes you make to the source immediately reflect in the installed package.To install in editable mode:python setup.py developThis will set up a link to your source code, so you won't have to repackage and reinstall every time you make a change.Local InstallationClean thedistdirectory to prevent old distributions:rm -r dist/*Package the project:python setup.py sdist bdist_wheelInstall the packaged distribution (Note: the version might depend on what is set insetup.py):pip install --upgrade dist/jupyter-code-extractor-0.1.tar.gzUsageAfter installation, you can run thejupyter-code-extractordirectly from the CLI.To extract all cell types, use the--all-cellsoption:jupyter-code-extractor --all-cells your_notebook.ipynbWithout the--all-cellsoption, only code cells will be extracted.RequirementsPython 3.xOther dependencies can be found in therequirements.txtfile.ContributingFor contributions, please create a fork, make your changes, and submit a pull request. Details on the development setup and guidelines can be found in theCONTRIBUTING.mdfile.Once pull requests are approved and merged, maintainers will handle versioning and releases. New releases on GitHub will automatically trigger package updates on PyPI via GitHub Actions.LicenseThis project is licensed under the MIT License. See theLICENSEfile for more details.ChangelogFor a detailed history of changes, seeCHANGELOG.md.0.1- Initial release with basic features.0.2- ... (and so on for a few recent versions)For any issues or contributions, please open an issue or pull request.
Package: jupyter-codeserver-proxy
jupyter-codeserver-proxyIntegratecode-serverin your Jupyter environment for an fast, feature-rich and easy to use remote desktop in the browser.ATTENTION:code-serverhas no official support for passing the password/token via url-parameters. Sad thing, a pull request was not merged[more].
Hence, we need to disable authentication at the moment completly with--auth=none[more].
This allows any user who can access localhost:port of the machine running thecode-serverto use it - even if he is not authorized to do so.
An alternative solution to close this security hole might be to use unix sockets instead of ports. As soon as this is fully supported byjupyter-server-proxywe will switch[more].RequirementsPython 3.6+Jupyter Notebook 6.0+JupyterLab >= 3.xjupyter-server-proxy >= 3.1.0This package executes thecode-servercommand.It tries to find thecode-serverexecutable checking the following:environment variable $CODESERVER_BIN<dir-of-__init__.py>/bin/code-serverwhich code-server(searching standard $PATH)special locations:/opt/codeserver/bin/code-serverInstallCreate and Activate Environmentvirtualenv -p python3 venv
source venv/bin/activateInstall jupyter-codeserver-proxypip install git+https://github.com/FZJ-JSC/jupyter-codeserver-proxy.gitEnable jupyter-codeserver-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 code-server icon from the Jupyter Lab Launcher or the code-server item from the New dropdown in Jupyter Classic.Connect to your database as instructed in the Quickstart section.ConfigurationThis package callscode-serverwith a bunch of settings.You have to modifysetup_codeserver()injupyter_codeserver_proxy/__init__.pyfor change.Creditscode-serverjupyter-server-proxyLicenseBSD 3-Clause
Package: jupyter-cogram
Cogram: Intuitive coding with natural languageCogram brings intuitive coding with natural language to Jupyter Notebook.📖 DocumentationDocumentation🚀️Sign upSign up to get your API token and get started!⭐️How toNew to Cogram? Check out our videos!📚CommunityHave questions our comments? Join our Slack!FeaturesAI-powered coding for Jupyter NotebooksSupports Python: ideal for data science tasksCycle through different suggestions⏳ Install cogramRequirementsAPI token: If you don't have one yet,sign upOperating system: macOS · Linux · WindowsPython version: Python 3.6+ (only 64 bit)Package managers:pipInstallationThe easiest way to install Cogram for Jupyter Notebook is using pip.pipinstall-Ujupyter-cogram
jupyternbextensionenablejupyter-cogram/mainNext, you should install your API token available on yourMy Accountpage. Install it withpython-mjupyter_cogram--tokenYOUR_TOKENThat's it! You can now start a new Jupyter Notebook server withjupyternotebookand you're ready to go!Updating CogramThe easiest way to upgrade to a new version of Cogram is using pip:pipinstall-Ujupyter-cogramYou'll then have to kill any active Jupyter Notebook servers and start a new one withjupyternotebookUninstalling CogramTo remove Cogram from your system, simply use pip:pipuninstalljupyter-cogramFinally, remove Cogram from the list of extensions Jupyter will load when you
start a Notebook:jupyternbextensiondisablejupyter-cogram/main📚 Use Cogram🛫 First startIf you've installed Cogram by following the instructions on yourMy Accountpage your API token
will automatically be saved. You can open a Jupyter Notebook and get started.You may be asked for your API token when you open a new Notebook for the first time. If this happens, paste the API token from yourMy Accountpage into the prompt box that opens when you start a new Jupyter Notebook.The Cogram extension is on by default. You can toggle the extension off and on by clicking the Cogram button
() in the toolbar of your Jupyter Notebook. The green circle indicates that Cogram is on.🔮 Working with CogramYou can use Cogram in two ways:Generating code from plain language by writing a comment and completing with the Tab keyComleting code you've written with the Tab keyThe status light will turn orange indicating that Cogram is busy.For example, writing the comment# fibonacci sequenceand hitting the Tab key will generate a function that produces the Fibonacci sequence.Alternatively, writing the codedeffibonacciand hitting the Tab key will complete the function to produce the Fibonacci sequence.Once your code has been generated you can explore different options with the ← and → keys.
If you're happy with a suggestion you can accept it with the Tab key.💡 Tips for working with CogramCogram works especially well if you give it some context. Cogram knows the code in your notebook above the current position of your cursor.
The more code you've already written, the better Cogram will work.📚 SupportFor help with Cogram please join our support channel incommunity.
Package: jupyter-collaboration
Jupyter Real-Time CollaborationJupyterLab Real-Time Collaboration is a Jupyter Server Extension and JupyterLab extensions providing support forY documentsand adding collaboration UI elements in JupyterLab.Installation and Basic usageTo install the latest release locally, make sure you havepip installedand run:pipinstalljupyter-collaborationOr usingconda/mamba:condainstall-cconda-forgejupyter-collaborationTestingSeeCONTRIBUTING.ContributingIf you are interested in contributing to the project, seeCONTRIBUTING.
Package: jupyter-conf-search
In order to use thispip install jupyter_conf_searchWhich is then executed asjupyter_conf_search "your_search_term"on the command line to search for “your_search_term”.If you pass justjupyter_conf_searchit will return the total list of configuration files that it found
relative to the directory that you are running the command from (not
just the directories, which you can find usingjupyter--pathsbeneathconfig:).© Mike Pacer 2017-W09-3-1543
Package: jupyter-console
Jupyter ConsoleA terminal-based console frontend for Jupyter kernels.
This code is based on the single-process IPython terminal.Install with pip:pip install jupyter-consoleInstall with conda:conda install -c conda-forge jupyter_consoleStart:jupyter consoleHelp:jupyter console -hJupyter Console allows for console-based interaction with non-python
Jupyter kernels such as IJulia, IRKernel.To start the console with a particular kernel, ask for it by name::jupyter console --kernel=julia-0.4A list of available kernels can be seen with::jupyter kernelspec listRelease build:$pipinstallpep517
$python-mpep517.build.ResourcesProject Jupyter websiteDocumentation for Jupyter Console[PDF]Documentation for Project Jupyter[PDF]IssuesTechnical support - Jupyter Google GroupAbout the Jupyter Development TeamThe Jupyter Development Team is the set of all contributors to the Jupyter project.
This includes all of the Jupyter subprojects.The core team that coordinates development on GitHub can be found here:https://github.com/jupyter/.Our Copyright PolicyJupyter uses a shared copyright model. Each contributor maintains copyright
over their contributions to Jupyter. But, it is important to note that these
contributions are typically only changes to the repositories. Thus, the Jupyter
source code, in its entirety is not the copyright of any single person or
institution.  Instead, it is the collective copyright of the entire Jupyter
Development Team.  If individual contributors want to maintain a record of what
changes/contributions they have specific copyright on, they should indicate
their copyright in the commit message of the change, when they commit the
change to one of the Jupyter repositories.With this in mind, the following banner should be used in any source code file
to indicate the copyright and license terms:# Copyright (c) Jupyter Development Team.
# Distributed under the terms of the Modified BSD License.
Package: jupyter-containds
jupyter-containdsCompanion Jupyter extension forContainDSWhen editing a Jupyter notebook, one click creates a new Voila dashboard based on the current file.From the JupyterLab launcher screen, access your own dashboard configuration pages or click straight through to view
dashboards shared with you.RequirementsJupyterLab >= 2.0ipywidgets >= 7InstallationYou can install usingpipand JupyterLab 3+:pipinstalljupyter-containdsIf you use JupyterLab 2:pipinstalljupyter-containds
jupyterlabextensioninstall@jupyter-widgets/jupyterlab-manager@ideonate/jupyter-containdsIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:jupyternbextensionenable--py[--sys-prefix|--user|--system]jupyter_containdsUninstallpipuninstalljupyter-containdsIf you use JupyterLab 2:jupyterlabextensionuninstall@ideonate/jupyter-containds
pipuninstalljupyter-containdsDevelopment Installation# First install the python package. This will also build the JS packages.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 . --overwriteFor classic notebook, you can run:jupyter nbextension install --sys-prefix --symlink --overwrite --py jupyter_containds
jupyter nbextension enable --sys-prefix --py jupyter_containdsNote 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:To continuously monitor the project for changes and automatically trigger a rebuild, start JupyterLab:jupyterlabAnd in a separate session, begin watching the source directory for changes:jlpmrunwatchAfter 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.