Saravanan666/pypi-org huggingface dataset:
Package: dash-google-auth
Dash Google AuthDash Google Auth is a simple library using Google OAuth to authenticate and
view aDashapp.This Library usesFlask Danceand a modified version of Plotly's owndash authfor authentication.Basic UseAuthentication can be added to your Dash application using theGoogleOAuthclass, i.e.fromdashimportDashfromflaskimportFlaskfromdash_google_authimportGoogleOAuthserver=Flask(__name__)server.config.update({'GOOGLE_OAUTH_CLIENT_ID':...,'GOOGLE_OAUTH_CLIENT_SECRET':...,})app=Dash(__name__,server=server,url_base_pathname='/',auth='auth')authorized_emails=[...]additional_scopes=[...]auth=GoogleOAuth(app,authorized_emails,additional_scopes)# your Dash app here :)...ExampleSteps to try this out yourself:Install thedash-google-authlibrary usingpip:$pipinstalldash-google-authFollow theFlask Dance Guideto create an app on the google admin consoleMake a copy ofapp.pyand set the variables (or set the corresponding environment variables):server.config["GOOGLE_OAUTH_CLIENT_ID"]=...server.config["GOOGLE_OAUTH_CLIENT_SECRET"]=...with values from the Google OAuth 2 client you should have set up in step 1.
If you've set these up properly, you can find them atAPIs & Services > Credentialsunder the sectionOAuth 2.0 client IDs.Replaceauthorized_emailsinapp.pywith whatever
Google emails you want to grant access to your app. In production, I'd
recommend getting these from a database instead.Runpython app.pyand openlocalhostin a
browser window to try it out! If the app loads automatically without
prompting a Google login, that means you're already authenticated -- try
using an incognito window in this case if you want to see the login
experience for a new user.
Package: dash-google-auth-email
# Dash Google Auth EmailDash Google Auth Email is a simple library using Google OAuth to authenticate andview a [Dash](https://dash.plot.ly/) app.  This project is almost entirely sourced from the parernt project [dash-google-auth](https://github.com/lchapo/dash-google-auth)This Library uses [Flask Dance](https://github.com/singingwolfboy/flask-dance)and a modified version of Plotly's own [dash auth](https://github.com/plotly/dash-auth)for authentication.## Basic UseAuthentication can be added to your Dash application using the `GoogleOAuth`class, i.e.```pythonfrom dash import Dashfrom flask import Flaskfrom dash_google_auth_email import GoogleOAuthserver = Flask(__name__)server.config.update({'GOOGLE_OAUTH_CLIENT_ID': ...,'GOOGLE_OAUTH_CLIENT_SECRET': ...,})app = Dash(__name__, server=server, url_base_pathname='/', auth='auth')authorized_emails = [...]additional_scopes = [...]auth = GoogleOAuth(app, authorized_emails, additional_scopes)# your Dash app here :)...```## ExampleSteps to try this out yourself:1. Install the `dash-google-auth-email` library using `pip`:```bash$ pip install dash-google-auth-email```2. Follow the [Flask Dance Guide](http://flask-dance.readthedocs.io/en/latest/quickstarts/google.html)to create an app on the google admin console3. Make a copy of [app.py](https://github.com/ricklentz/dash-google-auth-email/blob/master/app.py)and set the variables (or set the corresponding environment variables):```pythonserver.config["GOOGLE_OAUTH_CLIENT_ID"] = ...server.config["GOOGLE_OAUTH_CLIENT_SECRET"] = ...```with values from the Google OAuth 2 client you should have set up in step 1.If you've set these up properly, you can find them at[APIs & Services > Credentials](https://console.developers.google.com/apis/credentials)under the section **OAuth 2.0 client IDs**.4. Replace `authorized_emails` in `app.py` with whateverGoogle emails you want to grant access to your app. In production, I'drecommend getting these from a database instead.5. Run `python app.py` and open [localhost](http://localhost:8050/) in abrowser window to try it out! If the app loads automatically withoutprompting a Google login, that means you're already authenticated -- tryusing an incognito window in this case if you want to see the loginexperience for a new user.
Package: dash-google-charts
dash-google-chartsGoogle Charts components for Plotly Dash built on top ofreact-google-charts.Warning:dash-google-chartsis still pretty experimental, the interface and
features could change, and some components may not be fully functional yet. Use
with caution.Getting startedInstall withpip:pip install dash-google-chartsSeethe examplesfor basic usage. Some examples make use of thegviz_apihelper library, availablehere. This is useful for
serialising your data in a JSON format ready for passing to Google Charts. Thegviz_apilibrary can be installed withpip:pip install gviz_api
Package: dash-google-oauth
Dash Google OAuthThis is a simple library using Google OAuth to authenticate and view a Dash app
written based ondash-auth.
Upon authentication, a cookie is created and kept for 2 weeks.SetupNavigate toGoogle API Console, and setup an OAuth credentials
withhttp://localhost:5000/login/callbackas authorized redirect URL.Install the package:$ pip install dash-google-oauthDefine following environment variables:FLASK_SECRET_KEY

GOOGLE_AUTH_URL
GOOGLE_AUTH_SCOPE
GOOGLE_AUTH_TOKEN_URI
GOOGLE_AUTH_REDIRECT_URI
GOOGLE_AUTH_USER_INFO_URL
GOOGLE_AUTH_CLIENT_ID
GOOGLE_AUTH_CLIENT_SECRETfor example usingpython-dotenv:FLASK_SECRET_KEY="..."

GOOGLE_AUTH_URL=https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&prompt=consent
GOOGLE_AUTH_SCOPE="openid email profile"
GOOGLE_AUTH_TOKEN_URI=https://oauth2.googleapis.com/token
GOOGLE_AUTH_REDIRECT_URI=http://localhost:5000/login/callback
GOOGLE_AUTH_USER_INFO_URL=https://www.googleapis.com/userinfo/v2/me
GOOGLE_AUTH_CLIENT_ID="..."
GOOGLE_AUTH_CLIENT_SECRET="..."Add it to the application:app = Dash(__name__)

from dash_google_oauth.google_auth import GoogleAuth
auth = GoogleAuth(app)To logout, you may make aGETrequest to/logout
Package: dash-google-picker
Dash Google PickerThedash_google_pickeris a Python module that allows the integration of Google's Picker API with a Dash application. The module provides a Dash componentGooglePickerto easily implement the Google Picker functionality into your application, enabling your users to select files from their Google Drive account, among other data sources.FeaturesLeverages Google Picker API for seamless integration with Google Drive.Allows selection of multiple files from Google Drive.Customizable views and features according to Google Picker API.DocumentationInstallationUse pip to install the package:pipinstalldash-google-pickerPrerequisitesFollow the officialGoogle Picker Guideto create the required credentials.UsageThe usage example below shows how to use theGooglePickercomponent in your Dash application.fromtypingimportListfromdashimportDash,dcc,html,Input,Output,State,dccfromdash_google_pickerimportGooglePickerfromdash_google_picker.DocumentsimportGoogleDocuments,GoogleDocumentimportosapp=Dash(__name__)app.layout=html.Div([html.Button('Open Google Picker',id='open-picker-button',n_clicks=0),GooglePicker(id='google-picker',client_id='GOOGLE_CLIENT_ID',developer_key='GOOGLE_DEVELOPER_KEY'),dcc.Markdown(id='display-documents',style={'whiteSpace':'pre-wrap'}),html.Div(id='display-action')])if__name__=='__main__':app.run_server(debug=True)The picker view can be customised, for more information see theGooglePickercomponent documentation or theGoogle Picker API Documentation.CallbacksTheGooglePickercomponent generates two outputsdocumentsandaction. Thedocumentsoutput contains a list of documents selected by the user, andactioncontains the current action status.@app.callback(Output('google-picker','open'),[Input('open-picker-button','n_clicks')],[State('google-picker','open')])defopen_google_picker(n_clicks,is_open):ifn_clicks>0:returnnotis_openreturnFalse@app.callback(Output('display-documents','children'),[Input('google-picker','documents')],prevent_initial_call=True)defdisplay_output(documents):docs:List[GoogleDocument]=GoogleDocuments(documents)x="\n".join([f"{prop}:{getattr(obj,prop)}"forobjindocsforpropindir(obj)ifnotprop.startswith("__")])returnx@app.callback(Output('display-action','children'),[Input('google-picker','action')],prevent_initial_call=True)defdisplay_action(action):ifaction=="loaded":return"Opened the Google Picker Popup"elifaction=="picked":return"Picked a document"elifaction=="cancelled":return"Cancelled the Google Picker Popup"returnf'Action:{action}'LicenseMIT
Package: dash-hash
dash_hash (python) v1.5.1Python module for Dash's X11 hashing.InstallPython 3.10+ and the associated development package (e.g.,python3-dev) is required as well as a gcc.$ pip3 install -r requirements.txt .TestAfter installation, test hash.$ python3 test.pyUninstall$ pip3 uninstall dash_hashCreditsModule written by @chaeplinhttps://github.com/chaeplin/xcoin-hashModule maintained by @eduffieldhttps://github.com/darkcoinproject/xcoin-hashModule maintained by @flarehttps://github.com/nightlydarkcoin/xcoin-hashModule maintained by @vertoehttps://github.com/vertoe/darkcoin_hash
Package: dash-holoniq-apexcharts
dash-holoniq-apexchartsMinimalDashwrapper forreact-apexchartslibrary.Code Snippetfrom dash_holoniq_apexcharts import DashApexcharts
import dash
from dash import  html

app = dash.Dash(__name__)


app.layout = html.Div([
    DashApexcharts(
        options = {
            'chart': {'id': 'apex-chart-example'},
            'xaxis': { 'categories': [1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999]}
        },

        series = [{
            'name': 'series-1',
            'data': [30, 40, 35, 50, 49, 60, 70, 91, 125]
        }],

        type = "bar",
        width=500,
        height=320
    )
])

if __name__ == '__main__':
    app.run_server(debug=False, host="0.0.0.0", port=5000)InstallationYou can installdash-holoniq-apexchartswithpip:pip install dash-holoniq-apexchartsDocumentationHead over to theREADMEfor more details.ContributingThe source code fordash-holoniq-apexchartsis availableon GitHub. If you find a bug or something is unclear, we encourage
you to raise an issue. We also welcome contributions, to contribute, fork the
repository and open apull request.
Package: dash-holoniq-components
dash-holoniq-componentsA set of house-keeping components forDashthat make the
implementation of forms and larger, multi-page applications a little easier.The following components are available:AlertThe Alert component is hidden if it has no children. When children are injected the Alert
component sets its style to become visibleButtonLinkAllows you to create a clickable link within a multi-page app in
the same way asdcc.Link. The standarddcc.Buttonattributesn_clicksandn_clicks_timestamphave been
added to ButtonLink. These attributes can be used for notification that theButtonLinkhas
been clicked.ButtonLinkcan be enabled/disabled allowing conditional control of the link via a Dash callbackFormTheFormcomponents normal submit action can be inhibited. The form data, as it would be
reported by the a submit action, is available in a Dash callback via the componentsform_dataattribute.InputWithIconAdds a font awesome glyph and tooltip to the end of a standard input boxLayoutRouterThe children of LayoutRouter are each wrapped in a Div that is
is hidden/shown based on the current value of the LayoutRouter 'switch' attribute.The advantage ofLayoutRouterover thestandardapproach to
dynamic layout is thatALLthe applications layout is rendered, but hidden, when the
Dash application starts.LayoutRouterovercomes the problem with thestandardapproach
were callbacks linked to dynamic content are difficult to realise.PageTitleSets the page title:PasswordWithShowPassword input with a show/hide icon that can be clicked to reveal the passwordLocationA modified version ofdash-core-componentsLocation component. Allows multiple instances
to co-exist. In thedash-core-componentsversion the last instance is the only one
to get history event notifications.ButtonA modified version ofdash-core-componentsButton component. The component
has a booleanfocusattribute that is set true when the button gains
focus and false when it looses it. The focus attribute can be used in a dash
callback to hide an associated dropdown whenever the user clicks
the application background or makes a selection from the dropdown.Example dropdown callback@callback(Output(ids.container(MATCH), 'className'),
            Input(ids.button(MATCH), 'n_clicks'),
            Input(ids.button(MATCH), 'focus'),
            State(ids.container(MATCH), 'className'))
    def show_dropdown(button_clicks, button_focus, className):
        logging.info('show_dropdown: button_clicks=%s, className = %s', button_clicks, className)

        if not button_clicks:
            return className

        if 'show' in className and button_focus == False:
            return className.replace(' show', '')
        else:
            return className + ' show'InstallationPyPIYou can installdash-holoniq-componentswithpip:pip install dash-holoniq-componentsDocumentationHead over to theREADMEfor more details.ContributingThe source code fordash-bootstrap-componentsis availableon GitHub. If you find a bug or something is unclear, we encourage
you to raise an issue. We also welcome contributions, to contribute, fork the
repository and open apull request.
Package: dash-holoniq-wordcloud
This project isPlotly/Dashwrapper for for the highly configurablewordcloud.Usagepip install dash-holoniq-wordcloudfrom dash_holoniq_wordcloud import DashWordcloud

security_data = [
    ["Equity", 74, "Zillions of equity based funds"],
    ["Bond", 45],
    ["Global", 30],
    ["Sector Equity", 17],
    ["EUR", 15],
    ["Large Cap", 13],
    ["Europe", 11],
]

app.layout = html.Div([
    html.Div([
        DashWordcloud(
            id='wordcloud',
            list=security_data,
            width=300, height=200,
            gridSize=16,
            color='#f0f0c0',
            backgroundColor='#001f00',
            shuffle=False,
            rotateRatio=0.5,
            shrinkToFit=True,
            shape='circle',
            hover=True
            )
        ])
    ])FeaturesDashWordcloudsupports the extensive wordcloudAPI.Hover-over word highlighting and word tooltips are supported.WordonClickevents are reported to Dash and can be used in Dash callbacksInstallationYou can installdash-holoniq-wordcloudwithpip:pip install dash-holoniq-wordcloudDocumentationHead over to theREADMEfor more details.ContributingThe source code fordash-holoniq-wordcloudis availableon GitHub. If you find a bug or something is unclear, we encourage
you to raise an issue. We also welcome contributions, to contribute, fork the
repository and open apull request.
Package: dash-htmlayout
Build your Dash layouts with HTML snippetsThis package allows you to craft your Dash application layouts
by writing HTML instead of a cascade of Python objects.InstallationYou can install the package with pip:pipinstalldash-htmlayoutDocumentationRead documentation to learn moreIntroductionIt's a bit counterproductive to force users to build dashboard
layouts using Python, when most component classes are translated
into HTML.Having to write code with deeply nested object instances to mimic HTML
should almost be considered malpractice in Python when there is a language
and a document type that addresses this exact need; HTML.This package provides a simple class to generate layouts
from a partial HTML snippet. For example, we could partially reproduce a classic
layout with the following document:<!-- Example with Bootstrap classes and some components --><section><h1class="mb-5">Dashboard component.</h1><divclass="row"><divclass="col-3"><divclass="form-group mb-3"><labelfor="">Genres filter</label><dcc-dropdownid="genre-list"placeholder="Filter genres"data-multi="True"/></div><divclass="form-group mb-3"><labelfor="">Max results</label><dcc-sliderid="genre-limit"data-value="1"data-min="0"data-max="10"/></div></div>...</div></section>In PythonfromdashimportDashfromdash.htmlayoutimportBuilderapplication=Dash("appname")builder=Builder(file="myfile.html")application.layout=builder.layout...
Package: dash-html-components
NoticeAs of Dash 2, the development of dash-html-components has been moved to themain Dash repoThis package exists for backward compatibilitydash-html-componentsVanilla HTML components forDashInstall dependenciesCreate a virtual env and activate.$ virtualenv venv
$ venv/bin/activateNote: venv\Scripts\activate for WindowsInstall Python packages required to build components.$ pip install -r dev-requirements.txtGenerate components and install npm packages$ npm installGenerating HTML ComponentsThe components insrc/components, as well as the export index insrc/index.jsare programmatically generated from element definitions inscripts/. To regenerate:$npmrungenerate-componentsThe list of attributes is regenerated by scraping theMDN HTML attribute reference.Note: This step will have already been done for you when you rannpm installDevelopmentTesting your components in DashWatch for changes$ npm run build:watchInstall module locally (after every change)# Generate metadata, and build the JavaScript bundle
 $ npm run install-local

 # Now you're done. For subsequent changes, if you've got `npm run build:watch`
 $ python setup.py installRun the Dash layout you want to test# Import dash_html_components to your layout, then run it:
 $ python my_dash_layout.pyInstalling Python package locallyBefore publishing to PyPi, you can test installing the module locally:# Install in `site-packages` on your machine$npmruninstall-localUninstalling Python package locally$npmrununinstall-localContributingSee thecontributing guidefor guidelines on contributing to this project.Create a production build and publish:Build your code:$ npm run buildCreate a Python tarball$ python setup.py sdistThis distribution tarball will get generated in thedist/folderTest your tarball by copying it into a new environment and installing it locally:$ pip install dash-html-components-<new-version>.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 servers the component library's CSS and JS from the remote unpkg CDN, so if you haven't published the component package to NPM you'll need to set theserve_locallyflags toTrue(unless you chooseFalseonpublish_on_npm). We will eventually makeserve_locally=Truethe default,follow our progress in this issue.
Package: dashhtmlgrid
IntroductionData science typically involves data, analysis, tests and outputs. A simple way to review, verify or present results is via Visualizations.Plotly Dash is selected to help prepare and present visualizations in a single dashboard. The key is to help present results in a organized manner to avoidSummaryA library is under development to standardize this. Seedashhtmlgrid#TODOA decidated plotly visualization library is required to help develop faster custom plottingThe data provided to charts should be dedicated dfs with simple configuration filesUsagePrepare dataDefine html div matrix using app layout (based on expected outputs). Some examples are:Utilize standard elements to plug into each matrix divs charts, tablesThe library currently supports:1 dropdown menu box (with only 1 input field)multiple tablesmultiple plotsExample codesDropdown, multiple option selection. Example is given below:Code file: src\dashhtmlgrid\tests\test_dropdown_multiple_options.pyDropdown - Single selection. Example is given below:https://github.com/vamseeachanta/energy/blob/ea3d37d9c65175cb6718d3052948d1871b3e54e2/py/utilities/plotly_dash_dropdown_graph.pyDrag value - Circular Callbackhttps://community.plotly.com/t/dash-1-19-0-circular-callbacks-drag-value-in-dcc-slider-close-button-in-dev-tools-dcc-graph-bug-fixes/49500CSS templateshttps://towardsdatascience.com/how-to-embed-bootstrap-css-js-in-your-python-dash-app-8d95fc9e599eReferenceshttps://pypi.org/project/dash/https://www.statworx.com/en/content-hub/blog/how-to-build-a-dashboard-in-python-plotly-dash-step-by-step-tutorial/https://chart-studio.plotly.com/dashboard/PythonPlotBot:540/present#/20 line code dashboard tutorialhttps://pythoninoffice.com/python-dash-web-app-tutorial/https://youtu.be/fhJ_6EbawUAUnexpected errorshttps://pyquestions.com/getting-the-error-message-r-is-null-whenever-running-a-dash-application#:~:text=The%20r%20is%20null%20also%20error%20occurs%20for,are%20no%20traces%20that%20meet%20the%20user-specified%20criteria.
Package: dash-iconify
Dash IconifyDash Iconify based on Iconify is a Dash component library which brings over 100,000 vector icons.Table of contentsInstallationQuickstartUsing with dmcKeyword ArgumentsInstallationpipinstalldash-iconifyQuickstartfromdash_iconifyimportDashIconifyfromdashimportDashapp=Dash(__name__)app.layout=DashIconify(icon="ion:logo-github",width=30,height=30,rotate=1,flip="horizontal",)if__name__=="__main__":app.run_server(debug=True)Using with dmcDash Mantine Componentsenables using icons natively.importdash_mantine_componentsasdmcfromdash_iconifyimportDashIconifybutton=dmc.Button("Send Mail",leftIcon=[DashIconify(icon="fluent:folder-mail-16-filled")])Keyword ArgumentsVisit this site to browse all the available icons:https://icon-sets.iconify.design/Keyword arguments:

- id (string; optional):
    The ID used to identify this component in Dash callbacks.

- color (string; optional):
    Color.

- flip (a value equal to: "horizontal", "vertical"; optional):
    Flip the icon horizontally or vertically.

- height (number; optional):
    Icon height.

- icon (string; optional):
    Icon name is a string, which has 3 parts: @api-provider : icon-prefix : icon-name
    provider points to API source. Starts with "@", can be empty (empty value is used for public Iconify API).
    prefix is name of icon set.
    name is name of icon.

- inline (boolean; optional):
    Toggles inline or block mode.

- rotate (a value equal to: 0, 1, 2, 3; optional):
    Rotates icon, 0: 0 deg, 1: 90 deg, 2: 180 deg, 3: 270 deg.

- style (dict; optional):
    Inline style.

- width (number; optional):
    Icon width.
Package: dash-id-utils
Dash ID UtilsInstallpipinstalldash-id-utilsUsagefromdashimporthtml,ALL,callbackclassAnnotatedImageListSidebar(html.Div):classslots:id=DashIDGenerator(page="session",type="view",name="image-list")image=DashIDGenerator(page="session",type="view",name="image")def__init__(self,items,**kwargs):self.items=itemssuper().__init__(self.render(),id=self.slots.id.get_identifier(),**kwargs)defrender(self):return[html.Img(src=item.url,id=self.slots.image.get_identifier(item.id))foriteminitems]@callback([...]AnnotatedImageListSidebar.slots.image.get_input("n_clicks",ALL),)defx(all_n_clicks):...@callback([AnnotatedImageListSidebar.slots.id.get_output("children"),]...)defy(...):...
Package: dash-insights
dash-insightsdash-insights 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!