Saravanan666/pypi-org huggingface dataset:
Package: jupydebug
jupydebugThis package provides easy access to all objects throughout an Exception traceback stack. It mimics the behavior of the post_mortem function in Python's built-in debugger (pdb), but let's the user interact with traceback object directly within a jupyter notebook as opposed to the pdb interpreter. Following an exception, run post_mortem() to inspect frames from the traceback stack. For example:a_failing_test()---------------------------------------------------------------------------IndexErrorTraceback(mostrecentcalllast)<ipython-input-14-ac3ec94daf8d>in<module>()---->1a_failing_test()/home/dan/Documents/jupydebug/tests/conftest.pyinnested_test()28defnested_test():29nf_local_var="nested_test's_local_var"--->30returnparent_test(failing_test)3132/home/dan/Documents/jupydebug/tests/conftest.pyinparent_test(func,*args,**kwargs)23defparent_test(func,*args,**kwargs):24pf_local_var="parent test's local var"--->25returnfunc(*args,**kwargs)2627/home/dan/Documents/jupydebug/tests/conftest.pyinfailing_test()10a_local_var="failing_test's local var"11x=range(3)--->12y=x[3]# this will raise an exception13returny14IndexError:rangeobjectindexoutofrangeget access to the traceback stack with jupydebug's post_mortem function:frames=jpdb.post_mortem()inspect the stack:framesfilelinecallinglocals0/home/dan/Documents/jupydebug/tests/conftest.py12failing_test(a_local_var, x)1/home/dan/Documents/jupydebug/tests/conftest.py25parent_test(func, args, kwargs, pf_local_var)2/home/dan/Documents/jupydebug/tests/conftest.py30nested_test(nf_local_var)3<ipython-input-12-ac3ec94daf8d>1<module>(__name__, __doc__, __package__, __loader__, __spec__, __builtin__, __builtins__, _ih, _oh, _dh, _sh, In, Out, get_ipython, exit, quit, _, __, ___, sys, _i, _ii, _iii, _i1, context, jpdb, conftest, _i2, contexts, _i3, _3, _i4, _i5, _i6, _6, _i7, debugger, _7, _i8, _8, _i9, _i10, _i11, a_failing_test, _i12, _i13, _13, _i14, df, _i15, _15, _i16)4/home/dan/miniconda3/envs/jupydebug/lib/python3.7/site-packages/IPython/core/interactiveshell.py2898run_code(self, code_obj, result, old_excepthook, outflag)and access the local or global variables in each frame with e.g.frames[0].locals{'a_local_var': "failing_test's local var", 'x': range(0, 3)}frames[0].globals{'__name__': 'conftest',
 '__doc__': None,
 '__package__': '',
 '__loader__': <_frozen_importlib_external.SourceFileLoader at 0x7fac7027d990>,
 '__spec__': ModuleSpec(name='conftest', loader=<_frozen_importlib_external.SourceFileLoader object at 0x7fac7027d990>, origin='/home/dan/Documents/jupydebug/tests/conftest.py'),
 '__file__': '/home/dan/Documents/jupydebug/tests/conftest.py',
 '__cached__': '/home/dan/Documents/jupydebug/tests/__pycache__/conftest.cpython-37.pyc',
 '__builtins__': {'__name__': 'builtins',
  '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
  '__package__': '',...
Package: jupydocs
The easiest way to document your python library with jupyter and markdown.GitHubdocsPyPiPleaes note jupydocs is currently under active development. 
It can be used for testing, but should not be used for deployment. 
It will change!InstallationpipinstalljupydocsQuickstartfromjupydocs.numpydocstringimportNumpyDocStringdefcustom_sum(x,y):"""A new take on the class `sum` function.Does 1 + 1 always need to equal 2? Not anymore! Thanks to the `custom_sum`function 1 + 1 will never equal 2 again.Parameters----------x : floatA number.y : floatA number.Returns-------num : FloatA new take on the traditional sum function. x * 2 + y * 3. Not at alluseful. But fun!Example------->>> from examplepackage.example import custom_sum>>> custom_sum(2, 3)13"""returnx*2+y*3docstring=NumpyDocString(custom_sum)docstring.render_md()custom_sumA new take on the classsumfunction.Does 1 + 1 always need to equal 2? Not anymore! Thanks to thecustom_sumfunction 1 + 1 will never equal 2 again.ParametersNAMETYPEDESCRIPTIONxfloatA number.yfloatA number.ReturnsNAMETYPEDESCRIPTIONnumFloatA new take on the traditional sum function. x * 2 + y * 3. Not at all useful. But fun!Example>>>fromexamplepackage.exampleimportcustom_sum>>>custom_sum(2,3)13print(docstring.render_md(return_str=True))## custom_sum

A new take on the class `sum` function. 

Does 1 + 1 always need to equal 2? Not anymore! Thanks to the `custom_sum` function 1 + 1 will never equal 2 again.

### Parameters

| NAME   | TYPE   | DESCRIPTION   |
|:-------|:-------|:--------------|
| x      | float  | A number.     |
| y      | float  | A number.     |

### Returns

| NAME   | TYPE   | DESCRIPTION                                                                            |
|:-------|:-------|:---------------------------------------------------------------------------------------|
| num    | Float  | A new take on the traditional sum function. x * 2 + y * 3. Not at all useful. But fun! |

### Example

```python
>>> from examplepackage.example import custom_sum
>>> custom_sum(2, 3)
13
```
Package: jupyfmt
jupyfmtThe uncompromising Jupyter notebook formatter.jupyfmtallows you to format notebooks in-place from the commandline as well as assert properly formatted Jupyter notebook cells in your CI.
Inspired bysnakefmt. Usesblackunder the hood.InstallationInstall the latest release from PyPI:$pipinstalljupyfmtUsagejupyfmtcan be used to format notebooks in-place or report diffs and summary statistics.Overview of commandline parameters:$ jupyfmt --help
Usage: jupyfmt [OPTIONS] [PATH_LIST]...

  The uncompromising Jupyter notebook formatter.

  PATH_LIST specifies notebooks and directories to search for notebooks in. By
  default, all notebooks will be formatted in-place. Use `--check`, `--diff`
  (or `--compact-diff`) to print summary reports instead.

Options:
  -l, --line-length INT           How many characters per line to allow.
  -S, --skip-string-normalization
                                  Don't normalize string quotes or prefixes.
  --check                         Don't write files back, just return status
                                  and print summary.
  -d, --diff                      Don't write files back, just output a diff
                                  for each file to stdout.
  --compact-diff                  Same as --diff but only show lines that
                                  would change plus a few lines of context.
  --assert-consistent-execution   Assert that all cells have been executed in
                                  correct order.
  --exclude PATTERN               Regular expression to match paths which
                                  should be exluded when searching
                                  directories.  [default: (/.git/|/.ipynb_chec
                                  kpoints/|/build/|/dist/)]
  --accepted-languages PATTERN    Only format Jupyter notebooks in these
                                  languages.  [default: python]
  --version                       Show the version and exit.
  --help                          Show this message and exit.Report formatting suggestions for a given notebook (this is particularly useful for CI workflows):$jupyfmt--check--compact-diffNotebook.ipynb
---Notebook.ipynb-Cell1(original)+++Notebook.ipynb-Cell1(formatted)@@-1,2+1,2@@
-deffoo(*args):
+deffoo(*args):returnsum(args)---Notebook.ipynb-Cell2(original)+++Notebook.ipynb-Cell2(formatted)@@-1+1@@
-foo(1,2,3)+foo(1,2,3)2cell(s)wouldbechanged😬1cell(s)wouldbeleftunchanged🎉1file(s)wouldbechanged😬Mega-Linter Integrationjupyfmtcan be run as part ofMega-Linterby adding the following to.mega-linter.yml:PLUGINS:-https://raw.githubusercontent.com/kpj/jupyfmt/master/mega-linter-plugin-jupyfmt/jupyfmt.megalinter-descriptor.ymlENABLE_LINTERS:-JUPYTER_JUPYFMT
Package: jupyformat
jupyformatjupyformatis a custom parser for Jupyter Book designed to execute Python code within your Markdown files, generating dynamic content during the parsing process.Table of ContentsInstallationUsageFeaturesExamplesContributingLicenseInstallationTo installjupyformat, usepip:pipinstalljupyformatDependenciesList any external dependencies required byjupyformat.UsageIntegratejupyformatinto your Jupyter Book configuration to enhance content parsing. Update your_config.ymlor equivalent configuration file:# _config.yml# ...markdown:parser:jupyformat.readsextension:.mdsphinx:config:nb_custom_formats:.bpy:-jupyformat.reads-format:.mdNow, your Jupyter Book will usejupyformatto read.bpyfiles or whatever extension as long is python code.FeaturesDynamic Content:Execute Python code within Markdown files to generate dynamic content.Custom Metadata:Utilize custom metadata in your.mdfiles to control rendering options.Flexible Output Formats:Support for rendering content in various output formats.ExamplesExecuting Python Code# your_file.bpyname=JuanPrietooutput=f"# This is a dynamic Markdown content generated by:{name}"Using Custom MetadataContributingWe welcome contributions to enhance and improvejupyformat. Feel free to submit bug reports, feature requests, or pull requests. Refer to theCONTRIBUTINGguide for details.Code StyleSpecify the coding style and any linters or formatting tools used in the project.TestingYou can test with pytestLicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: jupygit
jupygitIntegrating Jupyter Notebooks to a git workflow.Installation.(I highly recommend installing this into a conda environment) To install the extension and enable it just run the following commands:pip install jupygit
jupyter serverextension enable --py jupygit --sys-prefix
jupyter nbextension install --py jupygit --sys-prefix
jupyter nbextension enable --py jupygit --sys-prefixWhy?I've been working with Jupyter Notebooks for a while, and I always felt something dying inside me everytime I pushed a massive file to GitHub, only to have it overwritten by my nexthugecommit causing me to have unreadable diffs. I decided to create this extension that, as I previously stated, is a hack.How?  (and usage)Let's say you are working on a file calledAwesome.ipynb. What this extension will do once you press shiny newgitbutton on your Notebook is:Shows a nice modal with an encouraging message.Renames your current file toAwesome-jupygit___.ipynbusing Jupyter's API so that your kernel stays alive and you do not lose any work, we'll call this the"dirty"file.Adds the pattern*-jupygit___.ipynbto your .gitignore file, so that your"dirty"file does not show up as a new file in your git repository.Creates a copy ofAwesome-jupygit___.ipynbbut with the original nameAwesome.ipynb, this copy is clean, no outputs and noexecution_counts, we'll call this the"clean"file.Now is your turn to commitAwesome.ipynb, the"clean"file to source control!Are you done pushing things to Git? Now close the dialog and this will happen:Delete the fileAwesome.ipynb(do not worry! your kernel and work is safe in the"dirty"file).RenameAwesome-jupygit___.ipynbtoAwesome.ipynbso that you can resume your work where you left it before being a good human and using source control.
Package: jupylint
Jupyter Pylinter - ArchivedThis project is archived, and no longer under active development.Please consider usinghttps://github.com/nbQA-dev/nbQAinsteadA simple tool to extract python code from a Jupyter notebook, and then run
pylint on it for static analysis.If you find this tool useful, please give it a star on GitHub!UsageThe package can be installed via PyPI, then run from the command line, as
follows:pipinstalljupylint
jupylint<inputfilename>Full documentation is available:On readthedocsDownloadThe tool can be downloaded in the following places:As a standalone python fileAs a package on PyPIContributions and errataIf you find a bug in the code, feel free to submit a pull request or an issue
through GitHub, and I will endeavour to fix it!
Package: jupylite-duckdb
ExperimentalThis is highly experimental and will change frequently.jupyterlite_duckdb_wasmPython wrapper to run DuckDB_WASM within JupyterLite with a Pyodide KernelSeenotebooksfor example of running this withinjupyterliteCell Magic %%dqlFollowing the example ofmagic_duckdb, there's an initial proof of concept for a duckdb for JupyterLite.
SeeMagic ExampleYou can also test directly on pyodidepyodide consoleimport micropip;
await micropip.install('pandas');
await micropip.install('jupylite-duckdb');
import jupylite_duckdb as jd;
conn = await jd.connect();
r1 = await jd.query("pragma version", conn);
r2 = await jd.query("create or replace table xyz as select * from 'https://raw.githubusercontent.com/Teradata/kylo/master/samples/sample-data/parquet/userdata2.parquet'", conn);
r3 = await jd.query("select gender, count(*) as c from xyz group by gender", conn);
print(r1);
print(r2);
print(r3);Some development notesThere's some (well known) CORS considerations when trying to load data from other sites. Examples here are all using public sites, there's some limits that to address with your own jupyterlite deploymentIf you're adding local .py files, useimportlib.invalidate_caches(). Even then, it was flaky to import.Careful with caching... %pip install will pull from browser cache. I had to clear frequently within dev toolsTo clear local storage, which is annoyingly persistent,https://superuser.com/questions/519628/clear-html5-local-storage-on-a-specific-page
Package: jupyprint
jupyprintA simple python package to print markdown and LaTeX equations from code cells in
Jupyter notebooks.jupyprintlet's you print your variables as markdown/LaTeX.You can print LaTeX strings involving 'live' variables (e.g. the variables you
are using in your jupyter code cells).You can print numpy arrays as LaTeX matrices and you can print nice-looking pandas
dataframes.To install use:pip install jupyprintSeehttps://github.com/pxr687/jupyprint/blob/main/jupyprint_demo.ipynbfor a
demo. Here are some screenshots from the demo (there are no markdown cells in
the demo notebook, all the markdown/LaTeX is printed from the code cells):
Package: jupyros
ROS Support for jupyter notebooksWhile the Jupyter ecosystem has been widely adopted by
the Data Science and Machine Learning community, the
robotics community has not jumped on the band wagon yet!
Most tools around ROS, the Robot Operating System, are
built using Python and QT.However, using QT separates the user away from the code.
We've built a set of ROS tools for jupyter
notebook, trying to promote a rich, interactive experience
for Robotics developers utilizing the power of the jupyter
notebook.With jupyter-ros, it's possible to easily create widgets for
custom message types to send messages.If you find this package useful, don't hesitate to
contribute!
You can also always reach out tow.vollprecht@gmail.comor
on twitter:https://twitter.com/wuoulf, or join us onGitterInstallation and DependenciesYou need a ROS environment with rospy. We recommend usingRobostack(follow their installation instructions) which allows you to install ROS in a conda environment.
Also required arenumpyandbqplotfor the live-plotting,ipywidgetsfor the interactive widgets, andipycanvasfor the Turtlesim animations.conda install jupyter bqplot pyyaml ipywidgets ipycanvaspyyamlis necessary for rospy.To install use conda or mamba:conda install jupyter-ros -c robostackDevelopment installationYou can create a dev environment with:condacreate-njupyros-cconda-forgepythonnodejs=14jupyterlab=3jupyterbqplotpyyamlipywidgetsipycanvasFor a development installation (requires npm),git clone https://github.com/RoboStack/jupyter-ros.git
cd jupyter-ros
pip install -e .
jupyter nbextension install --py --symlink --sys-prefix jupyros
jupyter nbextension enable --py --sys-prefix jupyrosTo update thedefaults.jsjavascript you need to runpython jupyros/ros3d.py.TroubleshootingYou might see a warning like "The rospy package is not found in your $PYTHONPATH.
Subscribe and publish are not going to work. Do you need to activate your ROS environment?"This is harmless during installation, but if you see this warning in a notebook, you should check that your ROS environment is activated. You can also set the path from inside the notebook usingimport sys
sys.path.append('/opt/ros/melodic/lib/python2.7/dist-packages/')

# The next line should now work!
import jupyrosIf you got the following error when you run a cellfailed to display Jupyter Widget of type VBox,
you can solve it by running the following commandjupyter nbextension enable --py --sys-prefix widgetsnbextensionLicenseWe use a shared copyright model that enables all contributors to maintain the copyright on their contributions.This software is licensed under the BSD-3-Clause license. See the LICENSE file for details.
Package: jupysec
jupysecJupyterLab Security UtilitiesSecurity utilities for Jupyter environments. This set of rules and JupyerLab extension evaluates the security posture of the environment by comparing configuration values with best practices. Read morehere.FunctionRun the extension to generate an HTML report of the security configuration of your Jupyter instance and other Jupyter instances on your host.Configurations will be compared againstthese rules.These rules currently evaluate:Whether there are any executables in your ipython startup directoriesWhat lines of your configuration are nonstandard with known malicious usesWhether your servers require tokens for authenticationWhether your server and client are communicating over HTTPSWhether you are serving Jupyter to a broader domain than just localhostIf silent commands have been run against your kernelsSome of these categories may have false-positives depending on your environment and use-case. However, users should monitor their environments and be aware of their security posture and any changes.Matches againstthe rulesare referred to as "Findings" and displayed in the Report Card.RequirementsJupyterLab >= 3.0Getting StartedTo install just the rules, install with:pipinstalljupysecThen in your python environment:fromjupysec.rulesimportRulesRules().get_findings()Or to also install the JupyterLab extension:pipinstall'jupysec[jupyterlab]'After starting jupyterlab, your launcher window should now have a "Security" section with a widget for generating your findings. This will launch and index page with a list of all findings, color-coded by category. Click into findings for more details.
Package: jupysec-extension
jupysecJupyterLab Security UtilitiesSecurity utilities for Jupyter environments. This set of rules and JupyerLab extension evaluates the security posture of the environment by comparing configuration values with best practices.FunctionRun the extension to generate an HTML report of the security configuration of your Jupyter instance and other Jupyter instances on your host.Configurations will be compared againstthese rules.These rules currently evaluate:Whether there are any executables in your ipython startup directoriesWhat lines of your configuration are nonstandard with known malicious usesWhether your servers require tokens for authenticationWhether your server and client are communicating over HTTPSWhether you are serving Jupyter to a broader domain than just localhostIf silent commands have been run against your kernelsSome of these categories may have false-positives depending on your environment and use-case. However, users should monitor their environments and be aware of their security posture and any changes.Matches againstthe rulesare referred to as "Findings" and displayed in the Report Card.RequirementsJupyterLab >= 3.0Getting StartedTo install the rules in cli mode, execute:pipinstalljupysecThen in your python environment:fromjupysec.rulesimportRulesRules().get_findings()Or install the JupyterLab extension withpipinstalljupysec[jupyterlab]After starting jupyterlab, your launcher window should now have a "Security" section with a widget for generating your findings. This will launch and index page with a list of all findings, color-coded by category. Click into findings for more details.
Package: jupyslack
jupyslackSlack integration for notebooks. Keep track of your code right in your pocket.Installation :$pipinstalljupyslackConnection to Slack :First, you need to create an authorization token on your Slack account.In[1]:%load_extjupyslackIn[2]:%jupyslacksetup<slack_token><channel_name>"Connected to Slack !"To track a cell, simply put this magic line at its beggining :In[3]:%jupyslacktrackYou can give a name to the cell with : -nameIn[4]:%jupyslacktrack-name<name>New feature : automatic trackingThis will notify you for all cells whose runtime is above 2 minutesIn[5]:%jupyslackautotrackYou can set the minimum runtime with : -mintime (default=120)In[6]:%jupyslackautotrack-mintime<time_in_sec>And stop the automatic tracking with :In[7]:%jupyslackuntrack
Package: jupyslides
A tool that allows you to display embedded slides in jupyter notebook. This is a simple widget to help you display your PPT / slides inside the jupyter notebook environment for better presentation experience.How to installYou can install the package by typing this command in your terminal:pip install jupyslidesHow to use the packageStep 1- Export the PPT in image formatThe essential mechanism of this package is that you are displaying images instead of displaying the PPT itself. Therefore, the most critical step is to export your PPT in image format.Luckily, if you are working with Microsoft PowerPoint, you can export your PPT internally by clicking the following tabs in your PPT menu:File >Export...> File Format > PNG > Save Every Slide > Export. By doing so, PowerPoint will automatically generate a folder whose name is the same as your PPT file name. Inside this folder, each slide is exported as a.pngimage file.Notice that, the name of each image file ends with a number - this is critical as it tells the tool the sequence of the slides, for example,Slide1.png,Slide2.png,Slide3.pngetc. The slides will then be sorted in ascending order.Under any circumstance that PowerPoint does not generate these numbers, please manually add the number at the end of the file. Any file without a number in the end will be IGNORED. If you are not working with Microsoft PowerPoint, please make sure that you have fulfilled the above requirements.Step 2- InitializationStarting from this step, you are assumed to have already exported your PPT in a folder with a bunch of images. Please make sure that you are aware of the path of this folder. If you are not sure where the folder is, you cancdinto the PPT folder, and type the commandpwdto check where it is located in your system.Below is the quickest way to initiate your slidesfrom jupyslides import jupyslidesYou can adhere to the default dimension of your slides, which iswidth = 720pxandheight_to_width_ratio = 810/1080slides_path = 'path/to/your/PPT/folder'js = jupyslides(slides_path)You do have some level of control over the default size of the width of your slide, as well as the ratio between the height and width of your slides, you can make such customization by doing the followingjs = jupyslides(slides_path, default_width=1000, height_to_width_ratio=12/30)Step 3- SlideshowAs of now, you have initialized the slides already, the last step is to display the slides embedded in your jupyter notebook.
The simplest method to showcase your embedded slides isjs.slideshow()In this case, you are adhering to the default zoom-in, zoom-out and zoom-step factors. However, if you do want to have some control over the zooming feature, you can modify the parametersmin_zoom,max_zoomandstep_zoom.js.slideshow(min_zoom=0.2, max_zoom=3, step_zoom=0.1)That’s it for the tutorial, if you have any questions, please contact me atnding17@outlook.com
Package: jupyspace
jupyspaceTable of ContentsInstallationLicenseInstallationInstallmicromambafor your platform, then:pip install jupyspaceDevelopment installationInstallmicromambafor your platform, then:micromamba create -n jupyspacemicromamba activate jupyspacemicromamba install -c conda-forge pythonpip install -e jupyspace_apipip install -e plugins/localspacepip install -e plugins/spacexpip install -e .[test]asphalt run config.yamlUsagejupyspace --open-browserLicensejupyspaceis distributed under the terms of theMITlicense.