Saravanan666/pypi-org huggingface dataset:
Package: dash-auth0-oauth
Dash Auth0 OAuthThis is a simple library using Auth0 OAuth2.0 to authenticate and view a Dash app
written based ondash-authanddash-google-oauth.
Upon authentication, a cookie is created and kept for 2 weeks.SetupSetup an Auth0 tenant and application.Add <your_app_base_url>/login/callback as allowed callback url and <your_app_base_url> as allowed logout url in the Auth0 Application settings.
For example:allowed callback url: https://www.myapp.com/login/callback
allowed logout url:   https://www.myapp.comInstall the package:$ pip install dash-auth0-oauthDefine following environment variables:FLASK_SECRET_KEY

AUTH0_AUTH_URL
AUTH0_AUTH_SCOPE
AUTH0_AUTH_TOKEN_URI
AUTH0_AUTH_USER_INFO_URL
AUTH0_AUTH_CLIENT_ID
AUTH0_AUTH_CLIENT_SECRET
AUTH0_LOGOUT_URL
AUTH0_API_AUDIENCE
AUTH_FLASK_ROUTESfor exampleFLASK_SECRET_KEY="<some secret key>"

AUTH0_AUTH_URL="https://<your tenant url>/authorize"
AUTH0_AUTH_SCOPE="openid profile email"
AUTH0_AUTH_TOKEN_URI="https://<your tenant url>/oauth/token"
AUTH0_AUTH_USER_INFO_URL="https://<your tenant url>/userinfo"
AUTH0_AUTH_CLIENT_ID="<your app client id>"
AUTH0_AUTH_CLIENT_SECRET="<your app client secret>"
AUTH0_LOGOUT_URL="https://<your tenant url>/v2/logout"
AUTH0_API_AUDIENCE="<your_api_audience_identifier>"
AUTH_FLASK_ROUTES="true"Add it to the application:app = Dash(__name__)

from dash_auth0_oauth.auth0_auth import Auth0Auth
auth = Auth0Auth(app)You have access to/logoutroute in order to logout user by making aGETrequest.User's name stored in cookie:flask.request.cookies.get('AUTH-USER')
Package: dash-auth-external
dash-auth-externalIntegrate your dashboards with 3rd party APIs and external OAuth providers.OverviewDo you want to build a Plotly Dash app which pulls user data from external APIs such as Google, Spotify, Slack etc?Dash-auth-externalprovides a simple interface to authenticate users through OAuth2 code flow. Allowing developers to serve user tailored content.InstallationDash-auth-externalis distributed viaPyPipip install dash-auth-externalUsage#using spotify as an exampleAUTH_URL="https://accounts.spotify.com/authorize"TOKEN_URL="https://accounts.spotify.com/api/token"CLIENT_ID="YOUR_CLIENT_ID"# creating the instance of our auth classauth=DashAuthExternal(AUTH_URL,TOKEN_URL,CLIENT_ID)We then pass the flask server from this object to dash on init.app=Dash(__name__,server=auth.server)That's it! You can now define your layout and callbacks as usual.To obtain your access token, call the get_token method of your Auth object.NOTEThis canONLYbe done in the context of a dash callback....app.layout=html.Div([html.Div(id="example-output"),dcc.Input(id="example-input")])@app.callback(Output("example-output","children"),Input("example-input","value"))defexample_callback(value):token=auth.get_token()##The token can only be retrieved in the context of a dash callbacktoken_data=auth.get_token_data()# get_token_data can be used to access other data returned by the OAuth Providerprint(token)print(token_data)returntokenResults in something like:>>>fakeToken123
>>>{"access_token":"fakeToken123","user_id":"lucifer","some_other_key":666,"expires_at":"judgmentDay"}Refresh TokensIf your OAuth provider supports refresh tokens, these are automatically checked and handled in theget_tokenmethod.Check if your OAuth provider requires any additional scopes to support refresh tokensTroubleshootingIf you hit 400 responses (bad request) from either endpoint, there are a number of things that might need configuration.Make sure you have checked the followingRegister your redirect URIwith OAuth provider!The library uses a default redirect URI ofhttp://127.0.0.1:8050/redirect.ContributingContributions, issues, and ideas are all more than welcome.
Package: dash-autocomplete-input
dash-autocomplete-inputdash-autocomplete-input is a Dash component library.Dash wrapper for react-autocomplete-input fromhttps://github.com/yury-dymov/react-autocomplete-inputGet started with:Install Dash and its dependencies:https://dash.plotly.com/installationRunpython usage.pyVisithttp://localhost:8050in your web browserContributingSeeCONTRIBUTING.mdInstall dependenciesIf you have selected install_dependencies during the prompt, you can skip this part.Install npm packages$ npm installCreate a virtual env and activate.$ virtualenv venv
$ . venv/bin/activateNote: venv\Scripts\activate for windowsInstall python packages required to build components.$ pip install -r requirements.txtInstall the python packages for testing (optional)$ pip install -r tests/requirements.txtWrite your component code insrc/lib/components/AutocompleteInput.react.js.The demo app is insrc/demoand you will import your example component code into your demo app.Test your code in a Python environment:Build your code$ npm run buildRun and modify theusage.pysample dash app:$ python usage.pyWrite tests for your component.A sample test is available intests/test_usage.py, it will loadusage.pyand you can then automate interactions with selenium.Run the tests with$ pytest tests.The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g.https://github.com/plotly/dash-core-components)Add custom styles to your component by putting your custom CSS files into your distribution folder (dash_autocomplete_input).Make sure that they are referenced inMANIFEST.inso that they get properly included when you're ready to publish your component.Make sure the stylesheets are added to the_css_distdict indash_autocomplete_input/__init__.pyso dash will serve them automatically when the component suite is requested.Review your codeCreate a production build and publish:Build your code:$ npm run buildCreate a Python distribution$ python setup.py sdist bdist_wheelThis will create source and wheel distribution in the generated thedist/folder.
SeePyPAfor more information.Test your tarball by copying it into a new environment and installing it locally:$ pip install dash_autocomplete_input-0.0.1.tar.gzIf it works, then you can publish the component to NPM and PyPI:Publish on PyPI$ twine upload dist/*Cleanup the dist folder (optional)$ rm -rf distPublish on NPM (Optional if chosen False inpublish_on_npm)$ npm publishPublishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can setserve_locallytoFalseand you may see faster load times.Share your component with the community!https://community.plotly.com/c/dashPublish this repository to GitHubTag your GitHub repository with the plotly-dash tag so that it appears here:https://github.com/topics/plotly-dashCreate a post in the Dash community forum:https://community.plotly.com/c/dash
Package: dashbar
dashbarA progress-bar designed to be useful and easy to use.UsageFirstly, you need to importdashbar.It will be useful to import thetimemodule as wellimportdashbar,timeIteratingTo start dashbar, follow the example code below:foriindashbar.dash(10,dash_type="pipe",desc="example"):time.sleep(1/10)#completion after one secondifi==5:dashbar.status("half-way complete")If the progress is large, theautodashfunction can be used, which adjusts the step count to fit the terminal.foriindashbar.autodash(10):time.sleep(1/10)ifi==8:dashbar.log("eighty percent complete")Customizing dashbarDashbars can be customized by the following code:dashbar.customize(element="filler",value=" ")List of dashbars:classicarrowboxcircle_chargerbox_chargerstripeddollarbox_shadepipecustomList of dashbar elements:startheadtrailfillerfinishBuilding a DashbarDashbars can be built via theBuildclass.bar=dashbar.Build(10,"box_shade")foriinrange(100):ifi%10==0:bar.update(1,display=True)time.sleep(1/20)#completion after five seconds
Package: dash-bio
Dash BioDash Bio is a suite of bioinformatics components built to work withDash.Announcement:https://medium.com/@plotlygraphs/announcing-dash-bio-ed8835d5da0cDemo:https://dash-gallery.plotly.host/Portal/?search=BioinformaticsDocumentation:https://dash.plotly.com/dash-bioComponentsThe Dash Bio components each fall into one of three categories:Custom chart typesSequence analysis tools3D rendering toolsCustom chart typesDash CircosDash ClustergramDash Manhattan PlotDash Needle PlotDash Volcano PlotSequence analysis toolsDash Alignment ChartDash Onco PrintDash Forna ContainerDash Sequence ViewerVisualization toolsDash Mol2DDash Mol3DDash SpeckDash NglUsing Dash BioIt's easy to add a fully interactive chromosomal, molecular or genomic visualization to your Dash app by simply
including the Dash Bio component into your app layout as follows:importurllib.requestasurlreqfromdashimportDash,htmlimportdash_bioasdashbioapp=Dash(__name__)data=urlreq.urlopen('https://raw.githubusercontent.com/plotly/dash-bio-docs-files/master/alignment_viewer_p53.fasta').read().decode('utf-8')app.layout=html.Div([dashbio.AlignmentChart(id='my-default-alignment-viewer',data=data)])if__name__=='__main__':app.run_server(debug=True)See theDash Bio documentationfor more components and examples.Run Dash Bio in a JupyterLab environmentCreate a virtual environment:The following steps require a virtual environment tool to be installed on your computer:pip install virtualenva. On macOS and Linux:python3 -m venv envb. On Windows, enter:py -m venv envActivate your new environment:a. On macOS and Linux, enter:source env/bin/activateb. On Windows, enter:.\env\Scripts\activateInstall required libraries (make sure you have pip installed withpip help):pip install dash dash-bio pandas numpy JupyterlabTo run Dash inside Jupyter lab:a. Install jupyter-dash:pip install jupyter-dashb. Enterjupyter lab build(Note: This step requires Node.js and NPM installed on yourcomputer. To check if Node and NPM are installed, enternode -vandnpm -vin your terminal. For install instructions seenodejs.org.To display Plotly figures in JupyterLab:pip install jupyterlab "ipywidgets>=7.5”
jupyter labextension install jupyterlab-plotly@4.14.3Start JupyterLab by typing:jupyter labImportant: JupyterLab must be run within the virtual environment that was previously activated.For more on running a Dash app in Jupyter Lab visitGetting Started with Jupyter Dash.DashLearn more about Dash athttps://plotly.com/products/dash/.Consulting and OEMFor inquiries about Dash app development, advanced OEM integration,
and more, pleasereach
out.Contributing and Local DevelopmentIf you would like to contribute to this repository, or run demo apps and tests, please refer to
thecontributing
guidelines.
Package: dash-bio-utils
NoticeAs of Dash Bio 1.0, the development of dash-bio-utils has been moved to the mainDash Biorepo.This package exists for backward compatibility.Dash Bio UtilsDash Bio utils is a set of helper scripts that work together with thedash-biopackage.DashLearn more about Dash athttps://plot.ly/products/dash/.Consulting and OEMFor inquiries about Dash app development, advanced OEM integration,
and more, pleasereach out.ContributingIf you would like to contribute to this repository, please refer to
thecontributing
guidelines.Running testsCreate and activate a new virtualenv:python3-mvenvvenvsourcevenv/bin/activate
pipinstallpytestor a conda env:condacreate-ndash-bio-utilspython=3.7sourceactivatedash-bio-utils
condaconfig--addchannelsconda-forge
condainstallpytestClone this repo, install thedash-bio-utilspackage, and run its tests:gitclonehttps://github.com/plotly/dash-bio-utils.gitcddash-bio-utils/
pythonsetup.pyinstall
python-mpytesttests/If you are setting breakpoints withipdb, you
want to disable capturing on the command line:python-mpytest-stests/
Package: dashblock
Python SDKTable of ContentsInstallationGetting StartedMethodspipinstalldashblockGetting startedfromdashblockimportDashblockimportasyncioasyncdefmain():# You can get an API Key on beta.dashblock.comdk=awaitDashblock.connect(api_key=YOU_API_KEY)awaitdk.goto("https://www.google.com",timeout=5000)content=awaitdk.html()print(content)awaitdk.close()if__name__=="__main__":asyncio.get_event_loop().run_until_complete(main())Methodsgotohtml(Coming soon)clickinputcollect
Package: dashboard
An admin dashboard for use with ASGI web frameworks.Work in progress.example.pyfromstarlette.applicationsimportStarlettefromstarlette.routingimportMount,Routefromstarlette.responsesimportRedirectResponsefromstarlette.templatingimportJinja2Templatesfromstarlette.staticfilesimportStaticFilesimportdatabasesimportdashboardimportormimportdatetimedatabase=databases.Database('sqlite:///test.db')models=orm.ModelRegistry(database=database)statics=StaticFiles(packages=['dashboard'])classNotes(orm.Model):registry=modelstablename='notes'fields={'id':orm.Integer(title="ID",primary_key=True,read_only=True),'created':orm.DateTime(title="Created",default=datetime.datetime.now,read_only=True),'text':orm.String(title="Text",max_length=100),'completed':orm.Boolean(title="Completed",default=False)}admin=dashboard.Dashboard(tables=[dashboard.DashboardTable(ident="notes",title="Notes",datasource=Notes.objects.order_by('-id')),])routes=[Mount("/admin",app=admin,name='dashboard'),Mount("/statics",app=statics,name='static'),Route("/",endpoint=RedirectResponse(url='/admin')),]app=Starlette(debug=True,routes=routes,on_startup=[database.connect],on_shutdown=[database.disconnect])Rough installation...$virtualenvvenv
$venv/bin/pipinstalldashboard
$venv/bin/python
>>>fromexampleimportmodels
>>>models.create_all()$venv/bin/uvicornexample:appWith many thanks to Eren Güven (Twitter,GitHub) for thedashboardPyPI package name.
Package: dashboard-engine
dashboard-enginedashboard-engine is a part ofDash Enterprise,
Plotly's end-to-end Dash application platform. This public copy of the package
is a stub published on pypi.org designed to shield Dash Enterprise users fromdependency confusion,
a remote code execution attack publicly disclosed in 2021 by Alex Birsan.If you are a Dash Enterprise user, you will only see this public package if your
app is not properly configured to find the local package repository built into
Dash Enterprise. Visit the docs for your Dash Enterprise installation for details.If you never see this public package, it's still doing its job of protecting you
from the dependency confusion attack!
Package: dashboardmods
Dashboard Mods is a set ofDashboardModules fordjango-admin-tools.Changes0.2Updated to support Django Admin Tools 0.4.0InstallationUsing PIP:pip install dashboardmodsor download the appherepython setup.py installAdddashboardmodsto your settingsINSTALLED_APPS:INSTALLED_APPS = (
    ...
    'dashboardmods',
    ...
)MemcacheDashboardModuleDisplays a bar graph of memory usage, hit/miss ratio and uptime for each memcache server configured in Django’s settings.To enable, simply add:from dashboardmods import get_memcache_dash_modulesat the top of the page and in the__init__method add:self.children.extend(get_memcache_dash_modules())If no memcache servers are configured, nothing happens.VarnishDashboardModuleDisplays a bar graph of memory usage and hit/miss ratios for each Varnish server configured inVARNISH_MANAGEMENT_ADDRS. It usespython-varnishfor communication. See its docs for more information on setup and installation ofpython-varnish.To enable, simply add:from dashboardmods import get_varnish_dash_modulesat the top of the page and in the__init__method add:self.children.extend(get_varnish_dash_modules())If no Varnish servers are configured, nothing happens.RSSDashboardModuleThis is a model that allows the dynamic input of RSS feeds to appear as aDashboardModule.To enable, adddashboardmodsto yourINSTALLED_APPSand./manage.py syncdb.Then add:from dashboardmods import get_rss_dash_modulesat the top of the page and in the__init__method add:self.children.extend(get_rss_dash_modules())If noRSSDashboardModulerecords are entered, nothing happens. As soon as one is entered, theDashboardModuleis immediately available.
Package: dashboard-pyechart
基于python，用pyechart绘制简单的dashboard。一个简单的例子```pythonimport dashboard_pyechart as dpfrom pyecharts import Bards = dp.Dashboard(title='myfst',logo_img=r'C:\Users\Administrator\Desktop\logo.png',background_img=r'C:\Users\Administrator\Desktop\background.png')attr = ["衬衫", "羊毛衫", "雪纺衫", "裤子", "高跟鞋", "袜子"]v1 = [5, 20, 36, 10, 75, 90]v2 = [10, 25, 8, 60, 20, 80]bar = Bar("柱状图数据堆叠示例")bar.add("商家A", attr, v1, is_stack=True)bar.add("商家B", attr, v2, is_stack=True)bar1 = Bar("柱状图数据堆叠示例")bar1.add("商家A", attr, v1, is_stack=True)bar1.add("商家B", attr, v2, is_stack=True)bar2 = Bar("柱状图数据堆叠示例")bar2.add("商家A", attr, v1, is_stack=True)bar2.add("商家B", attr, v2, is_stack=True)bar3 = Bar("柱状图数据堆叠示例")bar3.add("商家A", attr, v1, is_stack=True)bar3.add("商家B", attr, v2, is_stack=True)bar4 = Bar("柱状图数据堆叠示例")bar4.add("商家A", attr, v1, is_stack=True)bar4.add("商家B", attr, v2, is_stack=True)ds.add_chart(bar,'wodediyige chart')ds.add_chart(bar1,'wodediyige chart')ds.add_chart(bar2,'wodediyige chart')ds.add_chart(bar3,'wodediyige chart')ds.add_chart(bar4,'wodediyige chart')ds.save()```
Package: dashboards-app-baymaxx-1
=====
Blero DashboardsQuick startAdd "dashbboards_app" and desired plugins to your INSTALLED_APPS setting like this::INSTALLED_APPS = [
...'dashboards_app','dashboards_app.dash_docs_app',
'dashboards_app.plugins.blero_container_client',
'dashboards_app.plugins.form_addon_client',
'dashboards_app.plugins.blero_grid_client',
'dashboards_app.plugins.db_addon_client',
'dashboards_app.plugins.log_terminal_client',
'dashboards_app.plugins.task_tracker_client',
'dashboards_app.celery_progress',
]
Package: dashboards-app-blero
=====
Blero DashboardsQuick startAdd "dashbboards_app" and desired plugins to your INSTALLED_APPS setting like this::INSTALLED_APPS = [
...'dashboards_app','dashboards_app.dash_docs_app',
'dashboards_app.plugins.blero_container_client',
'dashboards_app.plugins.form_addon_client',
'dashboards_app.plugins.blero_grid_client',
'dashboards_app.plugins.db_addon_client',
'dashboards_app.plugins.log_terminal_client',
'dashboards_app.plugins.task_tracker_client',
'dashboards_app.celery_progress',
]
Package: dash-bootstrap-components
Dash Bootstrap ComponentsBootstrap components for Plotly DashExplore the documentation~Report a bug~Request a featuredash-bootstrap-componentsis a library ofBootstrapcomponents for use withPlotly Dash, that makes it easier to
build consistently styled Dash apps with complex, responsive layouts.InstallationPyPIYou can installdash-bootstrap-componentswithpip:pipinstalldash-bootstrap-componentsAnacondaYou can also installdash-bootstrap-componentswithcondathrough the
conda-forge channel:condainstall-cconda-forgedash-bootstrap-componentsQuick startTo usedash-bootstrap-componentsyou must do two things:Link a Bootstrap v5 compatible stylesheetIncorporatedash-bootstrap-componentsinto your layoutLinking a stylesheetdash-bootstrap-componentsdoesn't come with CSS included. This is to give you
the freedom to use any Bootstrap v5 stylesheet of your choice. This means
however that in order for the components to be styled properly, you must link
to a stylesheet yourself.For convenience, links toBootstrapCDNfor each theme are
available through thethemesmodule, which can be used as follows:importdashimportdash_bootstrap_componentsasdbcapp=dash.Dash(external_stylesheets=[dbc.themes.BOOTSTRAP])For more information on how to link local or external CSS, check out theDash documentation.Build the layoutWith CSS linked, you can start building your app's layout with our Bootstrap
components. See ourdocumentationfor a full list of
available components.ContributingWe welcome contributions todash-bootstrap-components. If you find a bug or
something is unclear pleasesubmit a bug report, if you have ideas
for new features please feel free to make afeature request.
If you would like to submit a pull request, please read ourcontributing guide.Copyright and licenseCode and documentation is copyrightFaculty Science Ltd.2018-2022, and released under theApache 2.0 license
Package: dashbored
dashboredA simple dashboard framework created out of boredom. It provides a simple, tabular interface using a Python module that implements the defined specification.UsageCreating a dashbored moduleThe dashbored specification expects the following attributes.fetch(required) - A function that takes no arguments and returns a list of mappings of field names to values.FORMAT(optional, suggested) - This is a Pythonformat mini-languagestring using columns from the data source as keywords.FREQUENCY(optional, suggested) - The frequency to fetch updated data using thefetchfunctionFor convenience, it's also suggested to create an entry_point within thedashboredgroup although it's not required as noted below.Command line interfaceIf a dashbored module provides the suggested defaults, then running one should be as easy as:python3-mdashbored<spec>where specification is either a fully qualified module name or an entrypoint name within thedashboredgroup.Library interfaceTo be used as a library, simply provide the above mentioned arguments in the same positional order to thecreatefuncton in thedashboredmodule.importdashboreddefmyfetch():...dashbored.create("{field_a}{field_b}",myfetch,1)
Package: dash-callback-conglomerate
This is a Plotly Dash add-on for enabling more freedom with callback handling, enabling sharing inputs, outputs, and
only returning some of the outputs registered for a callback. There are two ways to use this add-on. One method is
seamless integration where the dash callback function is hijacked and replaced with a call to this modules callback
function, and the other method is directly calling the function with the decorators. Look at github for examples.
Package: dash-callbackmanager
dash-callbackmanagerAs your dash application grows the management of callbacks becomes a bit of an overhead. The
callback manager allows you to bundle collections of dash callbacks together allowing you to easily keep yourapp.pyclean.Installation:pipinstalldash-callbackmanagerUsage:The callback manager allows you to easily slip out the callbacks into separate files.# callbacks.pyfromdash_callbackmanagerimportCallbackManagermanager=CallbackManager()@manger.callback()defmy_callback(Output("element","children"),Input("other-element","value")):...# app.pyfromdashimportDashfrom.callbacksimportmanagerapp=Dash(__name__)manager.register(app)
Package: dash-chakraui-components
Dash Chakra UI ComponentsDash Chakra UI Components (DXC) is a Dash component library that wraps theChakra UIReact library. It follows the same principles from the React library, with a flair of the excellentdash-bootstrap-componentsfor the components logic required in Dash.Some interesting features:Style Props: Most of DXC components acceptstyleProps. Style Props are a very simple way to style components via Python dictionaries, including  convenient shorthands for common CSS parameters.See the original documentation about it..Grid System: The Chakra UI Grid system is quite flexible and support templates, going beyond the 12-cols approach from Bootstrap.Take a look here for an example.(WIP) Themes and Customization: More to come!Getting startedThe DXC documentation is available as a Heroku app:https://dash-chakraui-components.herokuapp.comThedocsapp codebase is located inanother repository. It serves as an example of amulti-page appusingdash-chakraui-components.Instalationdash-chakraui-componentsis available in pip:pipinstalldash-chakraui-componentsContributingSeeCONTRIBUTING.md