Saravanan666/pypi-org huggingface dataset:
Package: jupyteranalytics
Jupyter AnalyticsA simple Jupyter Notebook extension to injectGoogle Analyticstracking code into notebooks and JupyterHub web pages. This extension is based onyuvipanda/nbgoogleanylticsbut is extended for larger JupyterHub deployments.InstallationInstall the extension as follows:$ pip install jupyteranalyticsThis should both install and enable thejupyteranalyticsextension. Verify with:$ jupyter nbextension list
$ jupyter serverextension listThere are a couple of reasons why this might not have been installed and enabled automagically. If not, you can manually install and enable as follows:$ jupyter nbextension install --py --sys-prefix jupyteranalytics
$ jupyter nbextension enable --py --sys-prefix jupyteranalytics
$ jupyter serverextension enable --py --sys-prefix jupyteranalyticsNote that both the automatic and manual methods installjupyteranalyticsto your virtualenv using the--sys-prefixflag by default. Alternatively you can omit this flag or specify--userto install the configuration to your user configuration or you can use--systemto install the extension systemwide.Warning: For Google Analytics tracking to appear on every page (including the directory listing), the configuration must be innbconfig/common.json, the pip installer will copy a new configuration to the virtualenv location; ensure that you make a backup of any existingnbconfig.common.jsonfile. Note that this will not affect user or system installs, which require manual enabling of the extension.ConfigurationThe configuration property required by this extension is a Google Analytics Tracking ID, which can be obtained after you set up a Google Analytics property. This ID looks something likeUA-#########-#.To quickly get started you can pass this id as a command line parameter:$ jupyter notebook --GoogleAnalytics.tracking_id="UA-#########-#"To permenantly enable tracking on all notebook pages, check the path to your configuration usingjupyter nbextension list. Then, in<config_path>/common.jsonadd the following:{"GoogleAnalytics":{"tracking_id":"UA-#########-#"}}Alternatively you can set the Trackig ID by storing it in theGOOGLE_ANALYTICS_TRACKING_IDenvironment variable, this is particularly useful if you're deploying JupyterHub with Docker or Kubernetes.Note that the notebook logger will indicate if tracking is enabled if it can find the Tracking ID from the configuration, the environment, or the command line (resolved in that order). It will also indicate if the analytics are disabled because no tracking id could be found. Ensure that you have system logging enabled to check that your deployment is correct.
Package: jupyterannotate
jupyterannotateInteractive Text Annotation for Jupyter Notebook/LabInstallationYou can install usingpip:pipinstalljupyterannotateIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:jupyternbextensionenable--py[--sys-prefix|--user|--system]jupyterannotateUsageSeeExampleWithin an Jupyter Notebook cell:# Define some labels
LABELS = ["Organization", "Product", "Person", "Country", "Date", "Quantity"]

# Define some documents
DOCUMENTS = [
    "Oracle introduced a...",
    "Microsoft will delay the ...",
]

# Instantiate widget
# Optionally specify a list of spans to prepopulate
annotation_widget = jupyterannotate.AnnotateWidget(
    docs=NEWS_HEADLINES,
    labels=LABELS,
    spans=[
      [
        {'start': 0, 'end': 6, 'text': 'Oracle', 'label': 'Organization'},
      ],
      []
    ]
)

# Render
annotation_widgetChoose labelSelect text within displayed documentClick on existing span to removeNavigate documents using top-right# Access spans - a List containing a List of Spans per document
# e.g. [[{'start': 0, 'end': 6, 'text': 'Oracle', 'label': 'Organization'}], []]
annotation_widget.spans


# See updates in real-time
annotation_widget.spans = [
    [
        {'start': 0, 'end': 6, 'text': 'Oracle', 'label': 'Organization'},
        {'start': 69, 'end': 72, 'text': '10g', 'label': 'Quantity'}
    ],
    []
]Development InstallationCreate a dev environment:condacreate-njupyterannotate-dev-cconda-forgenodejsyarnpythonjupyterlab
condaactivatejupyterannotate-devInstall the python. This will also build the TS package.pipinstall-e".[test, examples]"When developing your extensions, you need to manually enable your extensions with the
notebook / lab frontend. For lab, this is done by the command:jupyter labextension develop --overwrite .
yarn run buildFor classic notebook, you need to run:jupyter nbextension install --sys-prefix --symlink --overwrite --py jupyterannotate
jupyter nbextension enable --sys-prefix --py jupyterannotateNote that the--symlinkflag doesn't work on Windows, so you will here have to run
theinstallcommand every time that you rebuild your extension. For certain installations
you might also need another flag instead of--sys-prefix, but we won't cover the meaning
of those flags here.How to see your changesTypescript:If you use JupyterLab to develop then you can watch the source directory and run JupyterLab at the same time in different
terminals to watch for changes in the extension's source and automatically rebuild the widget.# Watch the source directory in one terminal, automatically rebuilding when neededyarnrunwatch# Run JupyterLab in another terminaljupyterlabAfter a change wait for the build to finish and then refresh your browser and the changes should take effect.Python:If you make a change to the python code then you will need to restart the notebook kernel to have it take effect.
Package: jupyter-annotator
jupyter json annotatorThis package provides an annotation UI for arbitrary dataset in json format.Installpip install jupyter-annotatorUsage1. Normal usagefromjupyter_annotatorimportAnnotatorproblems=[{"id":2,"problem":"Where would I not want a fox? (a problem from coommonsenseQA)","options":{"a":"hen house","b":"england","c":"mountains","d":"english hunt","e":"california"},"answer":"a","filtered":"xxxxxxxxxx"}]anno=Annotator(problems)anno.start()2. Custom fields + skip + filterCustom fields: add custom field in the format (field_name, type, max_length)Skip fields: the fields which will not appear in the form but still in the preview so that they won't be edited.Filter fields: the fields that won't appear either in the form or in the previewproblems=[{"id":2,"problem":"Where would I not want a fox? (a problem from coommonsenseQA)","options":{"a":"hen house","b":"england","c":"mountains","d":"english hunt","e":"california"},"answer":"a","filtered":"xxxxxxxxxx"}]custom_fields=[("rationale",str,100)]skip_fields=['id']filter_fields=["xxx"]annotator=Annotator(problems,custom_fields=custom_fields,skip_fields=skip_fields,filter_fields=filter_fields)annotator.start()ReferencesJupyter Widgets - Using Interactjupyter-innotater
Package: jupyter_app
Run Jupyter lab as a desktop app.Installation$ pip install jupyter_appAdditionally, you need Firefox installed,
or downloadNW.jsto your downloads folder.Usage$ jupyter_appSelect a specific app runtime (seedocs):$ jupyter_app --webruntime=nw-appHow it worksThejupyter_labcommand starts a normal Jupyterlab server, but instead
of launching a brower tab to connect to it, it launches a browser window
that is made to look like a desktop app (including icon, process name, etc.).
When the window is closed, the server shuts down. This uses thewebruntimemodule.
Package: jupyter-app-launcher
jupyter_app_launcherA JupyterLab extension to create custom launcher entriesjupyter_app_launcherhelps users customize the JupyterLab launcher with a simple YAML file. Users can add custom entries to the launcher to:Open a predefined notebook or markdown file.Render a notebook in dashboard modeOpen a notebook with VoilaStart a local web server and open the predefined URL.Open a remote URL (as widget tab in Jupyter or in new browser window).https://user-images.githubusercontent.com/4451292/191499842-3b3aae7b-dd61-416b-9958-6490c1e220c7.mp4Try it online!You can try it online by clicking on this badge:Or you can run it directly in your browser withJupyterLite:DocumentationYou can read the documentation following this link:https://jupyter-app-launcher.readthedocs.io/InstallationYou can install usingpip:pipinstalljupyter-app-launcherOr usingconda:condainstall-cconda-forgejupyter_app_launcherjupyter_app_launcherworks withJupyterLab>=3.1ExampleOpen a predefined notebookOpen a predefined markdown fileRender a notebook in dashboard modeOpen a notebook with VoilaStart a local web server and open the URL.Open a remote URLContributingSeeContributingPackaging the extensionSeeRELEASE
Package: jupyter-athena-sql
We run SQL queries on AWS Athena from jupyter notebooksathena.ipynbrun the notebookI like using jupyterlab but other notebooks should work, too$jupyterlabthis should open the notebook in your browser. just click onathena.ipynb.see alsosimilar libs I found:https://github.com/catherinedevlin/ipython-sqlhttps://github.com/pivotal/sql_magicLicenseCopyright (c) 2017 finklabs and others. fink and plugins are released
under the MIT License (see LICENSE).
Package: jupyter-auth
🛡️ Jupyter Authpipinstall-e.[test]jupyterlabextensiondevelop.--overwrite
jupyterlabextensionlist
jupyterserverextensionlist# open http://localhost:8686/api/jupyter/lab?token=60c1661cc408f978c309d04157af55c9588ff9557c9380e4fb50785750703da6yarnjupyterlab
Package: jupyter-autotime
jupyter-autotimeDisplay elapsed time on Jupyter.Getting startInstallOn shell.pipinstalljupyter-autotimeOn Jupyter.!pipinstalljupyter-autotimeEnable autotime%load_extautotimeOther usage# Reload.%reload_extautotime# Disable.%unload_extautotimeCustomizationFirst, import the module to hackautotime.importautotimeCustomize timespan format.defmy_format_timepan(timespan:float)->str):"""My custom timespan format."""# e.g. '12 sec'return'{}sec'.format(int(timespan))autotime.format_timespan=my_format_timepanCustomize time format.# e.g. '2020/12/10 16:15:11'autotime.TIME_FORMAT='%Y/%m/%d%H:%M:%S'Customize output format.# e.g. '[RUNNING] 3.09 s (2020-12-10T15:58:35)'autotime.RUNNING_FORMAT='[RUNNING]{timespan}({start})'# e.g. '[FINISH] 4.02 s (2020-12-10T15:59:54~2020-12-10T15:59:58)'autotime.FINISHED_FORMAT='[FINISH]{timespan}({start}~{end})'Customize units.# e.g. 5 分 7 秒autotime.set_units(sec='秒',min='分',hr='時間',d='日')Customize output with method.defmy_format_output(timespan:float,start_time:time.struct_time,end_time:float=None,is_finished:bool=False):"""My Custom output format."""ifis_finished:# e.g. 'Finished. 2.0160000000032596'return'Finished.{}'.format(timespan)else:# e.g. 'Running... 1.0159999999887077'return'Running...{}'.format(timespan)autotime.format_output=my_format_outputYou can access below objects on customformat_output.autotime.UNITS (dict)autotime.format_time (method)autotime.TIME_FORMAT (str)autotime.RUNNING_FORMAT (str)autotime.FINISHED_FORMAT (str)DevelopmentRequirements: poetry, pyenvpoetryinstall

poetrypublish

pipinstall--no-cache-dir--upgradejupyter-autotime
Package: jupyter-base16-theme
jupyter_base16_themejupyter-base16-theme inspired bychriskempson/base16.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstalljupyter_base16_themeThanksI used the jupyterlab-theme-templatejupyter-nightby Martin Renou and the css-stylesheetbase16by Chris Kempson.
Package: jupyter-bifrost
Jupyter BifrostA Jupyter Widget for Interactive Data Visualization. Bifrost provides useful chart recommendations and easy integration with Pandas DataFrames. It also provides a variety of analysis tools:Chart history log for keeping track of your data analysis.Targeted graph suggestions to drive further data exploration.Interactive filters for quantitative and categorical fields.Aggregations and binning for axis encodings.An expressive Python APIThe extension allows data scientists to build familiarity with a dataset without sacrificing the reproducibility of code. Changes made in the Bifrost GUI are automatically translated into Pandas Queries, allowing developers to jump back into scripting whenever it is most convenient.Getting StartedInstallationYou can install usingpip:pipinstalljupyter_bifrostIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:jupyternbextensionenable--py[--sys-prefix|--user|--system]jupyter_bifrostUsing the ExtensionJupyter Bifrost is intended to be used in Jupyter Notebooks in JupyterLab. Start by importing the package:fromjupyter_bifrostimportChartThen instantiate the chart object with a dataset:chart=Chart("<my-dataset>.csv")#ordf=pd.DataFrame()chart=Chart(df)Finally, plot the dataset to open up the Bifrost GUI:res=chart.plot()# the `res` DataFrame will always stay up to date with the filters and aggregations applied in the GUIFor additional help with the extension, take a look at the wiki, or the help menu located in the menu bar of the Bifrost GUI.Development InstallationCreate a dev environment:condacreate-njupyter_bifrost-dev-cconda-forgenodejsyarnpythonjupyterlab
condaactivatejupyter_bifrost-devInstall the python. This will also build the TS package.pipinstall-e".[test, examples]"When developing your extensions, you need to manually enable your extensions with the
notebook / lab frontend. For lab, this is done by the command:jupyter labextension develop --overwrite .
yarn run buildFor classic notebook, you need to run:jupyter nbextension install --sys-prefix --symlink --overwrite --py jupyter_bifrost
jupyter nbextension enable --sys-prefix --py jupyter_bifrostNote that the--symlinkflag doesn't work on Windows, so you will here have to run
theinstallcommand every time that you rebuild your extension. For certain installations
you might also need another flag instead of--sys-prefix, but we won't cover the meaning
of those flags here.How to see your changesTypescript:If you use JupyterLab to develop then you can watch the source directory and run JupyterLab at the same time in different
terminals to watch for changes in the extension's source and automatically rebuild the widget.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabAfter a change wait for the build to finish and then refresh your browser and the changes should take effect.Python:If you make a change to the python code then you will need to restart the notebook kernel to have it take effect.
Package: jupyterblack
jupyterblackFormat code cells in Jupyter Notebook and JupyterLab usingBlack.It's as simple as calling jblackjblacknotebook.ipynbInstall jupyterblack from the command line with pippipinstalljupyterblackUsage# Format one Jupyter file:jblacknotebook.ipynb# Format multiple Jupyter files:jblacknotebook_1.ipynbnotebook_2.ipynb[...]# Format a directory:jblackpython/# Format one Jupyter file with a line length of 70:jblack-l70notebook.ipynb# Show help:jblack-hOptionspositionalarguments:targets

optionalarguments:-h,--helpshowthishelpmessageandexit--check--pyi-lLINE_LENGTH,--line-lengthLINE_LENGTH-s,--skip-string-normalization-wWORKERS,--workersWORKERSnumberofworkerprocesses--show-invalid-code-t{py27,py33,py34,py35,py36,py37,py38}[{py27,py33,py34,py35,py36,py37,py38}...],--target-version{py27,py33,py34,py35,py36,py37,py38}[{py27,py33,py34,py35,py36,py37,py38}...]ContributeIssues TrackerSource CodeSupportIf you are having issues or would like to propose a new feature, please use theissues tracker.LicenseThe project is licensed under the MIT license.
Package: jupyter_bokeh
jupyter_bokehA Jupyter extension for renderingBokehcontent within Jupyter.  See also the separateipywidgets_bokehlibrary for support for using Jupyter widgets/ipywidgets objects within Bokeh applications.InstallFor versions 3.0 and newer of JupyterLab, you have the option to install
jupyter_bokeh with eitherpiporconda:pipinstalljupyter_bokehorcondainstall-cconda-forgejupyter_bokehFor versions of Jupyter Lab older than 3.0, you must install the labextension
separately:condainstall-cconda-forgejupyter_bokeh
jupyterlabextensioninstall@jupyter-widgets/jupyterlab-manager
jupyterlabextensioninstall@bokeh/jupyter_bokehTo install a specific version:jupyterlabextensioninstall@bokeh/jupyter_bokeh@x.y.xCompatibilityThe coreBokehlibrary is generally version independent ofJupyterLaband thisjupyter_bokehextension
for versions ofbokeh>=2.0.0.Our goal is thatjupyter_bokehminor releases (using theSemVerpattern) are
made to follow JupyterLab minor release bumps, while micro releases are for newjupyter_bokehfeatures
or bug fix releases. We've been previously inconsistent with having the extension release minor version bumps
track that of JupyterLab, so users seeking to find extension releases that are compatible with their JupyterLab
installation may refer to the below table.Compatible JupyterLab andjupyter_bokehversionsJupyterLabjupyter_bokeh0.34.x0.6.20.35.x0.6.31.0.x1.0.02.0.x2.0.03.0.x3.0.04.0.x4.0.0ContributingDevelopment 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_bokeh 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_bokeh
Package: jupyter-book
Jupyter BookJupyter Book is an open-source tool for building publication-quality books and documents from computational material.Jupyter Book allows users towrite their content inmarkdown filesorJupyternotebooks,include computational elements (e.g., code cells) in either type,include rich syntax such as citations, cross-references, and numbered equations, andusing a simple command, run the embedded code cells,cachethe outputs and convert this content into:a web-based interactive book anda publication-quality PDF.Governance of this projectJupyter Book is still developing relatively rapidly, so please be patient if things change
or features iterate and change quickly. Once Jupyter Book hits 1.0, it will slow down
considerably!Contribute or improve the bookNotice some inefficient CSS? A typo in the text? Want to add a cool feature so that others
can enjoy the improvements to Jupyter Books? Check out theJupyter Book Contributor's
Guide. We'd love your help!AcknowledgementsJupyter Book is maintained and primarily developed by
theExecutable Book Project.
Package: jupyterbook-latex
jupyterbook-latex [IN DEVELOPMENT]Sphinx extension to support LaTeX infrastructure for Jupyter Book.This repository is adevelopmentproject to improve LaTeX support
inJupyter Book.Get startedTo get started withjupyterbook-latex, first install it throughpip:pip install jupyterbook-latexthen, addjupyterbook_latexto your extensions,
in a Sphinxconf.py:extensions=["jupyterbook_latex"]# autoload the sphinx.ext.imgconverter extension, optional (default is True)# jblatex_load_imgconverter = True# turn root level toctree captions into top-level `part` headings, optional (default is to auto-infer)#  jblatex_captions_to_parts = TrueOR in the jupyterbookconfig.yml:sphinx:extra_extensions:-jupyterbook_latex# config:#   jblatex_load_imgconverter: true#   jblatex_captions_to_parts: trueExtension DetailsThis extension does not provide an actual Sphinx LaTeX theme,
instead it instantiates a number of transforms (for LaTeX builders only) that manipulate the AST into the required format:Overrides some configuration:latex_engine->xelatexlatex_theme->jupyterBookappends necessary LaTeX commands to the preambleWhen a latex builder is specified:Set's upsphinx.ext.imgconverter(ifjblatex_load_imgconverter)Replace sub-headers in the root documentCreate headings from the root-level toctree captions (ifjblatex_captions_to_parts)Move bibliographies to the bottom of the documentIssuesA list of issues that need to be addressed:https://github.com/executablebooks/meta/issues/169Developer NotesArepository that contains many different project configurationsfor testing and development is available, along with implementation
idea and notes
Package: jupyter-brat-proxy
jupyter-brat-proxyJupyter proxyProxy extension that provides BRAT rapid annotation tool usingbratserver wrapperin your Jupyterlab environment.DevelopmentShow quick helpmakehelpDockerQuick run locally with docker:makerebuildInstall from repositoryIf you need to install directly from repository for development / testing purposes:python3-mpipinstallgit+https://github.com/huntdatacenter/jupyter-brat-proxy.git@main#egg=jupyter-brat-proxy
Package: jupyter-browser-clipboard
jupyter_browser_clipboardCopy text to OS clipboard when using Jupyter remotely. This uses the web browser's
own clipboard via Javascript.Originally a gist on github but got tired of copy pasting it into each notebooks.Installation$pipinstalljupyter_browser_clipboardOr, alternatively,$pipinstallgit+https://github.com/bsdz/jupyter_browser_clipboard.git#mainUsage>>>fromjupyter_browser_clipboardimportBrowserClipboard>>>df=pd.DataFrame(data=[1,2,3,5,6,101])>>>BrowserClipboard(df.to_csv(sep="\t"))Copyingtexttobrowser's clipboard.. success!
Package: jupyter-cache
jupyter-cacheA defined interface for working with a cache of jupyter notebooks.Why use jupyter-cache?If you have a number of notebooks whose execution outputs you want to ensure are kept up to date, without having to re-execute them every time (particularly for long running code, or text-based formats that do not store the outputs).The notebooks must have deterministic execution outputs:You use the same environment to run them (e.g. the same installed packages)They run no non-deterministic code (e.g. random numbers)They do not depend on external resources (e.g. files or network connections) that change over timeFor example, it is utilised byjupyter-book, to allow for fast document re-builds.Installpipinstalljupyter-cacheFor development:gitclonehttps://github.com/executablebooks/jupyter-cachecdjupyter-cache
gitcheckoutdevelop
pipinstall-e.[cli,code_style,testing]See the documentation for usage.DevelopmentSome desired requirements (not yet all implemented):PersistentSeparates out "edits to content" from "edits to code cells". Cell
rearranges and code cell changes should require a re-execution. Content changes should not.Allow parallel access to notebooks (for execution)Store execution statistics/reportsStore external assets: Notebooks being executed often require external assets: importing scripts/data/etc. These are prepared by the users.Store execution artefacts: created during executionA transparent and robust cache invalidation: imagine the user updating an external dependency or a Python module, or checking out a different git branch.Contributingjupyter-cache follows theExecutable Book Contribution Guide. We'd love your help!Code StyleCode style is tested usingflake8,
with the configuration set in.flake8,
and code formatted withblack.Installing withjupyter-cache[code_style]makes thepre-commitpackage available, which will ensure this style is met before commits are submitted, by reformatting the code
and testing for lint errors.
It can be setup by:>>cdjupyter-cache
>>pre-commitinstallOptionally you can runblackandflake8separately:>>black.
>>flake8.Editors like VS Code also have automatic code reformat utilities, which can adhere to this standard.