Saravanan666/pypi-org huggingface dataset:
Package: nbodypy
nbodypy: N-Body Python ClassAuthors:Jacques Féjoz:fejoz@ceremade.dauphine.frMaxime Chupin:chupin@ceremade.dauphine.frPurposeWe are in development, and this is the beginning of the project! It is a beta version of the module.The package provides tools for studying the N-body problem. It
provides a sub package concerning the Restricted Circular Three Body
Problem, with the computation of periodic orbit around Libration
points and associated invariant manifolds.InstallationWarning:Python 3.6 (>) package!pippip install nbodypyPYTHONPATHPYTHONPATHsets the search path for importing python modules. So, a
reasonable way to usenbodypyis to install it using thePYTHONPATHmechanism.Suppose that we have a directory in which we want to put all the local
python package or modules:/home/LOGIN/the/path.You can export this directory to the environment variablePYTHONPATH(in your.bashrcfor example) :export PYTHONPATH=/home/LOGIN/the/path:$PYTHONPATHAdd thenbodypydirectoryAfter doing that, you just have to add thenbodypydirectory of the
git repository (containing the python files) in the python directory:/home/LOGIN/the/path/nbodypyDocumentationYou can find a (partial) documentation at :https://www.ceremade.dauphine.fr/~chupin/nbodypydoc/LicenseThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, seehttp://www.gnu.org/licenses.
Package: nb-offline-convert
nb_offline_convert - An offline exporter fornbconvertThe normalHTMLexporter ofnbconvertcreates theHTMLfiles that will fetch resources (javascript and css files) from CDN, and theWebPDFexporter also depends onHTMLexporter, so it's not possible to generateHTMLofPDFfiles with widgets usingnbconvertin an environement without internet connection.This exporter allowsnbconvertto export notebooks intoHTMLandPDFfiles that use all resources from the local machine by doing three steps:TheRequireJSfile content is injected directly into the generatedHTMLfiles.Theipywidgetsjavascript file (embed-amd.js), icons and fonts are bundled withnb_offline_convert.embed-amd.jsis patched to fetch icons and fonts from local paths instead of CDNThe javascript files of widgets are configured to be fetched from the local notebook extension paths.Installationnb_offline_convertcan be installed from PyPIpip install nb-offline-convertUsageUsage in CLI# convert to htmljupyternbconvert--tohtml-offlinenotebook-you-want-to-convert.ipynb# convert to pdfjupyternbconvert--towebpdf-offlinenotebook-you-want-to-convert.ipynbThe defaultMathjaxoption isTeX-AMS_CHTML-full,Safe, to change this option, pass--OfflineHTMLExporter.mathjax_optionto the command line:# Use 'TeX-MML-AM_CHTML,Safe' optionjupyternbconvert--tohtml-offline--OfflineHTMLExporter.mathjax_option=TeX-MML-AM_CHTML,Safenotebook-you-want-to-convert.ipynbUsage in a scriptfromnb_offline_convertimportOfflineHTMLExporter,OfflineWebPDFExporter# convert to htmlhtml_converter=OfflineHTMLExporter()content,_=html_converter.from_filename("notebook-you-want-to-convert.ipynb")withopen("converted_file.html","w")asf:f.write(content)# convert to pdfpdf_converter=OfflineWebPDFExporter()content,_=pdf_converter.from_filename("notebook-you-want-to-convert.ipynb")withopen("converted_file.pdf","wb")asf:f.write(content)Addmathjax_optionparameter to the constructor ofOfflineHTMLExporterorOfflineWebPDFExporterto modify theMathjaxoption:html_converter=OfflineHTMLExporter(mathjax_option="TeX-AMS_CHTML-full,Safe")Developmentinstallnb_offline_convertfor development using:git clone https://github.com/trungleduc/nb_offline_convert.git
cd nb_offline_convert
python -m pip install -e .
Package: nBomber
nBomberSMS BOMBING TOOL WITH HAVING 50,000 MESSAGE SENDING CAPACITY AT A TIME.nBomberA free and open-source SMS/Call bombing application[+] DescriptionSMS BOMBING TOOL WITH HAVING 50,000 MESSAGE SENDING CAPACITY AT A TIME.Now can see Name, Simcard, Region, Gender, and E-Mail of Target Number .•The application requires active internet connection to contact the APIs•You would not be charged for any SMS/calls dispatched as a consequence of this script•For best performance, use single thread with considerable delay time.•Always ensure that you are using the latest version of nBomber and have Python 3.•This application must not be used to cause harm/discomfort/trouble to others.•By using this, you agree that you cannot hold the contributors responsible for any misuse.[+] InstallationRun these commands to Install nBomber.pipinstallnBomber[+] USAGETo use the nBomber type the following commands:nBomberFAQQ:Poor Internet Connection Detected:A:Here are a few stuff you can try:Check your connection.Make sureopensslis installed.Try topingany remote site/address to be sure.Try to reinstall if nothing works.Q:How many COUNTRIES do you support?A:Most Countries are supported for SMS and only India for calls. The SMS delivery rate might be different for different countries.Q:How many COUNTRIES Do you support ?A:Most Countries are supported for SMS and only India for calls. The SMS delivery rate might be different for different countries.Q:How to get protection ?A:Use OTP blockers and activate DND.
Package: nbopen
Open notebooks from the command linenbopen looks for the nearest running notebook server - if it finds one, it
opens a web browser to that notebook. If not, it starts a new notebook server
in that directory.Installation:python3 -m pip install nbopenUsage:nbopen AwesomeNotebook.ipynbTo integrate with your file manager, so you can double click on notebooks
to open them, run:Linux/BSD:python3-mnbopen.install_xdgWindows:python3-mnbopen.install_winMac: Clone the repository and run./osx-install.sh
Package: nbox
🧐 What is Nbox?nboxprovides first class API support for all NimbleBox.ai infrastructure (NBX-Build, Jobs, Deploy) and services (NBX-Workspaces) components. Write jobs usingnbox.OperatorsInstallation# on macos find the correct wheel file based on python version: https://github.com/pietrodn/grpcio-mac-arm-build/releases/tag/1.51.1pipinstall<wheel_url>
pipinstallnbox# on linuxpipinstallnbox🤷Why NimbleBoxWrite and execute code in PythonDocument your code that supports mathematical equationsCreate/Upload/Share notebooksImport notebooks from your local machineImport/Publish notebooks from/to GitHubImport external datasets (e.g. from Kaggle)Integrate PyTorch, TensorFlow, Keras, OpenCVShare your projectsCollaborate with your team🚀 Startup ProgramIf you're a new startup with(<$1M raised,<3 years since founded) then you're in luck to be the part of our startup program!Get$420kworth of deals on your favorite toolsCheck it out !🎚 Features🏗️ Freedom To Build🦾 Automate with Ease🚀 Intuitive Dashboard🏁 Get StartedInstall the package from pypi:When loading nbox for the first time, it will prompt you the username and password and create a secrets file at~/.nbx/secrets.json.This file then contains all the information that you don’t have to fetch manually again.APIsOur APIs are deep, user functions are kept to minimum and most relavant. This documentation contains the full spec of everything, but here’s all the APIs you need to know:nbox
├── Model          # Framework agnostic Model
│   ├── __call__
│   ├── deploy
│   ├── train_on_instance (WIP)
│   └── train_on_jobs (WIP)
├── Operators      # How jobs are combinations of operators
│   ├── __call__
│   └── deploy
├── Jobs           # For controlling all your jobs
│   ├── logs       # stream logs right on your terminal
│   └── trigger    # manually trigger a job
└── Instance
   ├── __call__    # Run any command on the instance
   └── mv (WIP)    # Move files to and from NBX-BuildDeploy and run any modelLet's take this script as an examplefromnboximportoperator,Operatorfromnbox.lib.shellimportShellCommand# define your function and wrap it as an operator@operator()deffoo(x:Dict):return"bar"# or use OO to deploy an API@operator()classBaz():def__init__(self,power:int=2):# load any model that you wantself.model=load_tf_pt_model()self.power=powerdefforward(self,x:float=1.0):return{"pred":x**self.power}Through your CLI:# to deploy a jobnbxjobsuploadfile:foo'my_first_job'# to deploy an APInbxserveuploadfile:Baz'my_first_api'🛟 How to get help?Join ourdiscordand someone from our community or engineering team will respond!🔖Read ourBlog.🧩 LicenseThe code in thist repo is licensed asApache License 2.0. Please check for individual repositories for licenses.
Package: nbpages
nbpagesnbpages is a command line tool for managing a collection of Jupyter notebooks published onGithub Pages. This project was inspired by the tools included with thePython Data Science HandbookbyJake Vanderplas.Installationpip install nbpagesTo upgrade a previously installed version to the latest versionpip install nbpages --upgradeSetting up the notebook repositoryThe first step in publishing a collection of notebooks on Github Pages is tocreate a repository on Github.com.
Github Pages are enabled under the settings tab for the repository. Scroll down to the Github Pages heading and selectmaster branchfor the source. This is also a good time to select a theme for the published collection.nbpagesrequires a local copy of the repository that can be created by cloning the remote repository.
Then from the command line, navigate to the top level directory of the local repository and issue the commandnbpages --setupDirectories namednotebooksandtemplateswill be created if they do not already exist.  A configuration fileconfigwill be created inside the directory using data read from the.git. Jinja templatesREADME.md.jinjaandnotebook_header.jinjawilled created if they don't already exist. These templates can be edited as required
using data fields defined inconfig.Notebook organizationNotebooks are maintained within thenotebooksdirectory. Thare are organized into a chapter/section heirarchy
using a filename prefix. Filenames have annn.mm-prefix wherennrefers to the chapter number or, if a letter, to
an Appendix. The digitsmmrefers to the section number. Section00is reserved to hold the chapter title and
any introductory material. The notebooks must also have the usual.ipynbsuffix.Normal usageFollowing setup, the normal use ofnbpagesis to execute the command linenbpagesfrom the top level directory of the notebook repository. Normally this command would be between completing edits or
additions to the notebooks and prior to a github commit. The command willadd or amend headers and navigation bars in all notebooks,write a table of contents filewrite a keyword indexwrite README.md using the template fileUtilitiesTo help achieve a consistent style over a collection of notebooks, use the commandnbpages --lintto locate some forms of notebook 'lint'.  A current list of additional features can be foundnbpages --helpTable of ContentsKeyword IndexChapter 1.0 Style GuideChapter 2.0 Examples
Package: nbparameterise
This is a tool to run notebooks with input values. When you write the notebook,
these are defined in the first code cell - or a cell with a ‘parameters’ cell
tag - with regular assignments like this:stock='YHOO'days_back=600Nbparameterise handles finding and extracting these parameters, and replacing
them with input values. You can then run the notebook with the new values.
This can be used for:Batch processing: run the same code on a list of different inputs. Seeexamples/batch.py.Simple user interfaces: build an input form based on the parameters, and run
the notebook when the user submits the form. Seeexamples/webapp.pyfor
an implementation of this with an HTML form.Nbparameterise can identify and replace numbers, strings, booleans (True/False),
lists and dicts - the types which can be represented in JSON (apart from None).
It’s designed to change parameter values but keep their types, although this
isn’t enforced.Extra information about the parameters, such as names to display in a user
interface, can be stored in notebook metadata.Nbparameterise is written in Python 3, but it can handle notebooks that use
Python 2.Usage:importnbclientimportnbformatfromnbparameteriseimport(extract_parameters,replace_definitions,parameter_values)withopen("Stock display.ipynb")asf:nb=nbformat.read(f,as_version=4)# Get a list of Parameter objectsorig_parameters=extract_parameters(nb)# Update one or more parametersparams=parameter_values(orig_parameters,stock='GOOG')# Make a notebook object with these definitionsnew_nb=replace_definitions(nb,params)# Execute the notebook with the new parametersnbclient.execute(new_nb)If you are interested in using your parameterized Jupyter notebooks through a command line interface, have a look atnbclick.Changes0.62023-02-28The parameters cell no longer needs to be the first code cell: if you add a cell tag
‘parameters’ to another cell, parameters will be extracted from and replaced in that
cell. Capitalisation doesn’t matter. (PR #27).Only the parameter values are replaced: other code in the parameter cell  will now be
preserved unchanged (PR #19).
Thecomment=parameter now has no effect, and it may be removed in a future
version.Theexecute=parameter forreplace_definitions()is now deprecated.
Please usenbclientto execute
your notebook after substituting parameters.nbparameterise now requires Python 3.8 or above.
Package: nb-pdf-template
classic.tplxA more accurate representation of jupyter notebooks when converting to pdfs.
This template was designed to make converted jupyter notebooks look (almost) identical to the actual notebook. If something doesn't exist in the original notebook then it doesn't belong in the conversion.Note for nbconvert 5.5.0As of nbconvert 5.5.0, the majority of these improvements have been merged into nbconvert's default template. Version 3.x of this package will continue to support nbconvert 5.5.0 and lower, whereas in the future version 4.x will only support nbconvert 5.5.0 and newer. Versions 3.x, and 4.x will overlap support for nbconvert version 5.5.0.Improvements\maketitle is removed (If you want a title then add a markdown cell to the top of your notebook).Sections are no longer numbered automatically (notebooks don't number sections so the pdf shouldn't).Markdown paragraphs are no longer auto-indented in the pdf.Syntax highlighting improvements. (Bonus if using XeLaTeX)BOXES!are drawn around code cells.(This change was merged into nbconvert 5.5.0)In/Out counts will move to the left as the execution count increases instead of pushing code to the right (only numbers are displayed by default to save page width).(This change was merged into nbconvert 5.5.0)$\LaTeX$ and $\Tex$ in markdown cells will no longer cause conversion to fail.(This change was merged into nbconvert 5.4.0)"\LaTeX" and "\TeX" are no longer converted into a logo on conversion to pdf unless they are in math mode. (This and the above point replicate the functionality of these commands in notebook markdown).In/Out prompt colours updated to match Jupyter.(This change was merged into nbconvert 5.5.0)Output text wrapping improvements.(This change was merged into nbconvert 5.5.0)Code cell text wrapping.(This change was merged into nbconvert 5.5.0)Quick Comparison:for a closer look see the example directory.Installationpip install nb_pdf_template
python -m nb_pdf_template.installUpdatingpip install -U nb_pdf_template
python -m nb_pdf_template.installManual Install:Drop all of the "*.tplx" files into the folder containing the other LaTeX nbconvert templates. If using anaconda, it should be something like:*/Anaconda3/Lib/site-packages/nbconvert/templates/latexUseFrom the command line:jupyternbconvert--topdffilename.ipynb--templateclassicAdding:c.LatexExporter.template_file='classic'to thejupyter_nbconvert_config.pyfile will let you drop the "--template classic", and to thejupyter_notebook_config.pyfile will let you use "download as pdf" from within the Jupyter notebook.Replaceclassicwith your template of choice.TemplatesThis package offers the following templates:TemplateUseclassic.tplx(Recommended)For most accurate recreation of the default Jupyter Notebook style.classicm.tplxm for modified. Similar to classic.tplx, but in/out prompts are above cells instead of in the margin. Bonus left margins are smaller so code cells are wider.Tips (Good for any template)Moved to the wiki
Package: nbpipeline
Snakemake-like pipelines for Jupyter Notebooks, producing interactive
pipeline reports like this:Install & general remarksThese are still early days of this software so please bear in mind that
it is not ready for production yet. Note: for simplicity I assume that
you are using a recent Ubuntu with git installed.pipinstallnbpipelineGraphiz is required for static SVG plots:sudoapt-getinstallgraphvizlibgraphviz-devgraphviz-devDevelopment installTo install the latest development version you may use:gitclonehttps://github.com/krassowski/nbpipelinecdnbpipelinepipinstall-rrequirements.txtln-s$(pwd)/nbpipeline/nbpipeline.py~/bin/nbpipelineQuickstartCreatepipeline.pyfile with list of rules for your pipeline. For
example:fromnbpipeline.rulesimportNotebookRuleNotebookRule('Extract protein data',# a nice name for the stepinput={'protein_data_path':'data/raw/data_from_wetlab.xlsx'},output={'output_path':'data/clean/protein_levels.csv'},notebook='analyses/Data_extraction.ipynb',group='Proteomics'# this is optional)NotebookRule('Quality control and PCA on proteins',input={'protein_levels_path':'data/clean/protein_levels.csv'},output={'qc_report_path':'reports/proteins_failing_qc.csv'},notebook='analyses/Exploration_and_quality_control.ipynb',group='Proteomics')the keys of the input and output variables should correspond to
variables in one of the first cells in the corresponding notebook, which
should be tagged as “parameters”. It can be done easily in JupyterLab:If you forget to add them, a warning will be displayed.Alternativaly, you can create a dedicated cell for input paths
definitions and tag it “inputs” and a separate one for output paths
definitions, tagging it “outputs”, which allows to omit input and output
keywords when creating aNotebookRule. However, only simple variable
definitions will be deduced (parsing uses regular expressions to avoid
potential dangers ofeval).For more details, please see the examplepipelineandnotebooksin theexamplesdirectory.Run the pipeline:nbpipelineOn any consecutive run the notebooks which did not change will not be
run again. To disable this cache, use--disable_cacheswitch.To generate an interactive diagram of the rules graph, together with
reproducibility report add-iswitch:nbpipeline-iThe software defaults togoogle-chromefor graph visualization
display, which can be changed with a CLI option.If you named your definition files differently (e.g.my_rules.pyinstead ofpipeline.py), use:nbpipeline--definitions_filemy_rules.pyTo display all command line options use:nbpipeline-hTroubleshootingIf you seeModuleNotFoundError: No module named 'name_of_your_local_module',
you may need to enforce the path, running nbpipeline with:PYTHONPATH=/path/to/the/parent/of/local/module:$PYTHONPATHnbpipelineOftentimes the path is the same as the current directory, so the
following command may work:PYTHONPATH=$(pwd):$PYTHONPATHnbpipeline
Package: nbplugins-watch
nonebot-plugins-watchhot plug and remove nonebot pluginsInstallationpip install nbplugins-watchTo validate installationpython -c "import nbplugins_watch; print(nbplugins_watch.__version__)"
0.0.6UsageMake a directory somewhere and place an empty __init__.py and a plugin file in it.Monitor the directory in your nonebot runner file, e.g. inmy_nonebot.py:importnonebotfromnbplugins_watchimportnbplugins_watchnonebot.load_builtin_plugins()# optionalnonebot.load_builtin_plugins("mature-plugin-dir")plugin_dir_path=r"path_to_plugin_dir"# absolute or relative pathnbplugins_watch(plugin_dir_path)# turn debug on to see what's going on# nbplugins_watch(plugin_dir_path, debug=True)nonebot.run()Create a file, say fancy_plugin.py if not already there, in the directory above. Edit and test and/or remove the file fancy_plugin.py to your heart's content.Note:if a plugin file contains syntax errors (as opposed to logic errors), you'll have to restart nonebot, in other words, nbplugins_watch will cease to work after an uncaught error.nbplugins_watch can recover from syntax errors, in other words, even when a plugin file contains syntax errors (as opposed to logic errors), it just still works.AcknowledgmentsThanks to everyone whose code was used
Package: nbplus
➤ nbsafetyAboutnbsafetyadds a layer of protection to computational notebooks by solving thestale dependency problemwhen executing cells out-of-order. Here's an
example in action:When the first cell is rerun, the second cell now contains a reference to an
updatedfand is suggested for re-execution with a turquoise highlight. The
third cell contains a reference to a staley--yis stale due to its
dependency on an old value off. As such, the third cell is marked as unsafe
for re-execution with a red highlight.  Once the second cell is rerun, it is
now suggested to re-execute the third cell in order to refresh its stale
output.nbsafetyaccomplishes its magic using a combination of a runtime tracer (to
build the implicit dependency graph) and a static checker (to provide warnings
before running a cell), both of which are deeply aware of Python's data model.
In particular,nbsafetyrequiresminimal to no changesin user
behavior, opting to get out of the way unless absolutely necessary and letting
you use notebooks the way you prefer.InstallpipinstallnbsafetyInterfaceThe kernel ships with an extension that highlights cells with live references
to stale symbols using red UI elements. It furthermore uses turquoise highlights
for cells with live references to updated symbols, as well as for cells that
resolve staleness.RunningTo run annbsafetykernel in Jupyter, select "Python 3 (nbsafety)" from the
list of notebook types in Jupyter's "New" dropdown dialogue. For JupyterLab,
similarly select "Python 3 (nbsafety)" from the list of available kernels in
the Launcher tab.Jupyter Notebook Entrypoint:Jupyter Lab Entrypoint:UninstallpipuninstallnbsafetyLicenseCode in this project licensed under theBSD-3-Clause License.➤ ContributorsStephen MackeRay GongShreya Shankar
Package: nbplusplus
➤ nbsafetyAboutnbsafetyadds a layer of protection to computational notebooks by solving thestale dependency problemwhen executing cells out-of-order. Here's an
example in action:When the first cell is rerun, the second cell now contains a reference to an
updatedfand is suggested for re-execution with a turquoise highlight. The
third cell contains a reference to a staley--yis stale due to its
dependency on an old value off. As such, the third cell is marked as unsafe
for re-execution with a red highlight.  Once the second cell is rerun, it is
now suggested to re-execute the third cell in order to refresh its stale
output.nbsafetyaccomplishes its magic using a combination of a runtime tracer (to
build the implicit dependency graph) and a static checker (to provide warnings
before running a cell), both of which are deeply aware of Python's data model.
In particular,nbsafetyrequiresminimal to no changesin user
behavior, opting to get out of the way unless absolutely necessary and letting
you use notebooks the way you prefer.InstallpipinstallnbsafetyInterfaceThe kernel ships with an extension that highlights cells with live references
to stale symbols using red UI elements. It furthermore uses turquoise highlights
for cells with live references to updated symbols, as well as for cells that
resolve staleness.RunningTo run annbsafetykernel in Jupyter, select "Python 3 (nbsafety)" from the
list of notebook types in Jupyter's "New" dropdown dialogue. For JupyterLab,
similarly select "Python 3 (nbsafety)" from the list of available kernels in
the Launcher tab.Jupyter Notebook Entrypoint:Jupyter Lab Entrypoint:UninstallpipuninstallnbsafetyLicenseCode in this project licensed under theBSD-3-Clause License.➤ ContributorsStephen MackeRay GongShreya Shankar