API Reference

This page displays the docstrings for the public methods of the
dash module including the app object.

Curious about the implementation details?
Browse the Dash source code.

The dash module

import dash

dash.ALL

dash.ALL

Used in the IDs of pattern-matching callback definitions, ALL
matches every component with the corresponding key in its ID, and
invokes the callback once with all items together in a list.

dash.ALLSMALLER

dash.ALLSMALLER

Used in the IDs of Input and State items in pattern-matching
callback definitions. You must use MATCH on the same key of an
Output, then ALLSMALLER matches every component with a value
smaller than that of the MATCH.

dash.ClientsideFunction

dash.ClientsideFunction(
    namespace=None,
    function_name=None
)

(No docstring available)

dash.Dash

dash.Dash(
    name=None,
    server=True,
    assets_folder='assets',
    assets_url_path='assets',
    assets_ignore='',
    assets_external_path=None,
    eager_loading=False,
    include_assets_files=True,
    url_base_pathname=None,
    requests_pathname_prefix=None,
    routes_pathname_prefix=None,
    serve_locally=True,
    compress=None,
    meta_tags=None,
    index_string='\n\n    \n        {%metas%}\n        {%title%}\n        {%favicon%}\n        {%css%}\n    \n    \n        {%app_entry%}\n        
\n {%config%}\n {%scripts%}\n {%renderer%}\n
\n \n', external_scripts=None, external_stylesheets=None, suppress_callback_exceptions=None, prevent_initial_callbacks=False, show_undo_redo=False, extra_hot_reload_paths=None, plugins=None, title='Dash', update_title='Updating...', long_callback_manager=None, **obsolete )

Dash is a framework for building analytical web applications.
No JavaScript required.

If a parameter can be set by an environment variable, that is listed as:
env: DASH_****
Values provided here take precedence over environment variables.

name

The name Flask should use for your app. Even if you provide
your own server, name will be used to help find assets.
Typically __name__ (the magic global var, not a string) is the
best value to use. Default '__main__', env: DASH_APP_NAME

type: string

server

Sets the Flask server for your app. There are three options:
True (default): Dash will create a new server
False: The server will be added later via app.init_app(server)
where server is a flask.Flask instance.
flask.Flask: use this pre-existing Flask server.

type: boolean or flask.Flask

assets_folder

a path, relative to the current working directory,
for extra files to be used in the browser. Default 'assets'.
All .js and .css files will be loaded immediately unless excluded by
assets_ignore, and other files such as images will be served if
requested.

type: string

assets_url_path

The local urls for assets will be:
requests_pathname_prefix + assets_url_path + '/' + asset_path
where asset_path is the path to a file inside assets_folder.
Default 'assets'.

type: string

assets_ignore

A regex, as a string to pass to re.compile, for
assets to omit from immediate loading. Ignored files will still be
served if specifically requested. You cannot use this to prevent access
to sensitive files.

type: string

assets_external_path

an absolute URL from which to load assets.
Use with serve_locally=False. assets_external_path is joined
with assets_url_path to determine the absolute url to the
asset folder. Dash can still find js and css to automatically load
if you also keep local copies in your assets folder that Dash can index,
but external serving can improve performance and reduce load on
the Dash server.
env: DASH_ASSETS_EXTERNAL_PATH

type: string

include_assets_files

Default True, set to False to prevent
immediate loading of any assets. Assets will still be served if
specifically requested. You cannot use this to prevent access
to sensitive files. env: DASH_INCLUDE_ASSETS_FILES

type: boolean

url_base_pathname

A local URL prefix to use app-wide.
Default '/'. Both requests_pathname_prefix and
routes_pathname_prefix default to url_base_pathname.
env: DASH_URL_BASE_PATHNAME

type: string

requests_pathname_prefix

A local URL prefix for file requests.
Defaults to url_base_pathname, and must end with
routes_pathname_prefix. env: DASH_REQUESTS_PATHNAME_PREFIX

type: string

routes_pathname_prefix

A local URL prefix for JSON requests.
Defaults to url_base_pathname, and must start and end
with '/'. env: DASH_ROUTES_PATHNAME_PREFIX

type: string

serve_locally

If True (default), assets and dependencies
(Dash and Component js and css) will be served from local URLs.
If False we will use CDN links where available.

type: boolean

compress

Use gzip to compress files and data served by Flask.
Default False

type: boolean

meta_tags

html <meta> tags to be added to the index page.
Each dict should have the attributes and values for one tag, eg:
{'name': 'description', 'content': 'My App'}

type: list of dicts

index_string

Override the standard Dash index page.
Must contain the correct insertion markers to interpolate various
content into it depending on the app config and components used.
See https://dash.plotly.com/external-resources for details.

type: string

external_scripts

Additional JS files to load with the page.
Each entry can be a string (the URL) or a dict with src (the URL)
and optionally other &lt;script&gt; tag attributes such as integrity
and crossorigin.

type: list of strings or dicts

external_stylesheets

Additional CSS files to load with the page.
Each entry can be a string (the URL) or a dict with href (the URL)
and optionally other &lt;link&gt; tag attributes such as rel,
integrity and crossorigin.

type: list of strings or dicts

suppress_callback_exceptions

Default False: check callbacks to
ensure referenced IDs exist and props are valid. Set to True
if your layout is dynamic, to bypass these checks.
env: DASH_SUPPRESS_CALLBACK_EXCEPTIONS

type: boolean

prevent_initial_callbacks

Default False: Sets the default value
of prevent_initial_call for all callbacks added to the app.
Normally all callbacks are fired when the associated outputs are first
added to the page. You can disable this for individual callbacks by
setting prevent_initial_call in their definitions, or set it
True here in which case you must explicitly set it False for
those callbacks you wish to have an initial call. This setting has no
effect on triggering callbacks when their inputs change later on.

show_undo_redo

Default False, set to True to enable undo
and redo buttons for stepping through the history of the app state.

type: boolean

extra_hot_reload_paths

A list of paths to watch for changes, in
addition to assets and known Python and JS code, if hot reloading is
enabled.

type: list of strings

plugins

Extend Dash functionality by passing a list of objects
with a plug method, taking a single argument: this app, which will
be called after the Flask server is attached.

type: list of objects

title

Default Dash. Configures the document.title
(the text that appears in a browser tab).

update_title

Default Updating.... Configures the document.title
(the text that appears in a browser tab) text when a callback is being run.
Set to None or ‘’ if you don’t want the document.title to change or if you
want to control the document.title through a separate component or
clientside callback.

long_callback_manager

Long callback manager instance to support the
@app.long_callback decorator. Currently an instance of one of
DiskcacheLongCallbackManager or CeleryLongCallbackManager

dash.Input

dash.Input(
    component_id,
    component_property
)

Input of callback: trigger an update when it is updated.

dash.MATCH

dash.MATCH

Used in the IDs of pattern-matching callback definitions, MATCH
matches every component with the corresponding key in its ID, and
invokes the callback once for each item it finds.

dash.Output

dash.Output(
    component_id,
    component_property
)

Output of a callback.

dash.State

dash.State(
    component_id,
    component_property
)

Use the value of a State in a callback but don’t trigger updates.

dash.callback

dash.callback(
    *_args,
    **_kwargs
)

Normally used as a decorator, @dash.callback provides a server-side
callback relating the values of one or more Output items to one or
more Input items which will trigger the callback when they change,
and optionally State items which provide additional information but
do not trigger the callback directly.

@dash.callback is an alternative to @app.callback (where app = dash.Dash())
introduced in Dash 2.0.
It allows you to register callbacks without defining or importing the app
object. The call signature is identical and it can be used instead of app.callback
in all cases.

The last, optional argument prevent_initial_call causes the callback
not to fire when its outputs are first added to the page. Defaults to
False and unlike app.callback is not configurable at the app level.

dash.callback_context

dash.callback_context

(No docstring available)

dash.clientside_callback

dash.clientside_callback(
    clientside_function,
    *args,
    **kwargs
)

(No docstring available)

dash.dash_table

dash.dash_table

An interactive table component designed for viewing, editing,
and exploring large datasets.

dash.dcc

dash.dcc

A core set of supercharged components for interactive user interfaces.

dash.html

dash.html

Vanilla HTML components for Dash

dash.no_update

dash.no_update

Return this from a callback to stop an output from updating.
See also dash.exceptions.PreventUpdate which you can raise
to stop all outputs from updating.


The app Object

import dash
app = dash.Dash(__name__)

app.callback

app.callback(
    *_args,
    **_kwargs
)

Normally used as a decorator, @app.callback provides a server-side
callback relating the values of one or more Output items to one or
more Input items which will trigger the callback when they change,
and optionally State items which provide additional information but
do not trigger the callback directly.

The last, optional argument prevent_initial_call causes the callback
not to fire when its outputs are first added to the page. Defaults to
False unless prevent_initial_callbacks=True at the app level.

app.clientside_callback

app.clientside_callback(
    clientside_function,
    *args,
    **kwargs
)

Create a callback that updates the output by calling a clientside
(JavaScript) function instead of a Python function.

Unlike @app.callback, clientside_callback is not a decorator:
it takes either a
dash.dependencies.ClientsideFunction(namespace, function_name)
argument that describes which JavaScript function to call
(Dash will look for the JavaScript function at
window.dash_clientside[namespace][function_name]), or it may take
a string argument that contains the clientside function source.

For example, when using a dash.dependencies.ClientsideFunction:
app.clientside_callback( ClientsideFunction('my_clientside_library', 'my_function'), Output('my-div' 'children'), [Input('my-input', 'value'), Input('another-input', 'value')] )

With this signature, Dash’s front-end will call
window.dash_clientside.my_clientside_library.my_function with the
current values of the value properties of the components my-input
and another-input whenever those values change.

Include a JavaScript file by including it your assets/ folder. The
file can be named anything but you’ll need to assign the function’s
namespace to the window.dash_clientside namespace. For example,
this file might look:
window.dash_clientside = window.dash_clientside || {}; window.dash_clientside.my_clientside_library = { my_function: function(input_value_1, input_value_2) { return ( parseFloat(input_value_1, 10) + parseFloat(input_value_2, 10) ); } }

Alternatively, you can pass the JavaScript source directly to
clientside_callback. In this case, the same example would look like:
app.clientside_callback( ''' function(input_value_1, input_value_2) { return ( parseFloat(input_value_1, 10) + parseFloat(input_value_2, 10) ); } ''', Output('my-div' 'children'), [Input('my-input', 'value'), Input('another-input', 'value')] )

The last, optional argument prevent_initial_call causes the callback
not to fire when its outputs are first added to the page. Defaults to
False unless prevent_initial_callbacks=True at the app level.

app.config

app.config

Most of the app-wide settings are collected into app.config.
In general it’s preferable to set these using Dash() constructor
arguments, but many of these settings can also be altered later,
for example:

app.config.suppress_callback_exceptions=True

app.csp_hashes

app.csp_hashes(
    hash_algorithm='sha256'
)

Calculates CSP hashes (sha + base64) of all inline scripts, such that
one of the biggest benefits of CSP (disallowing general inline scripts)
can be utilized together with Dash clientside callbacks (inline scripts).

Calculate these hashes after all inline callbacks are defined,
and add them to your CSP headers before starting the server, for example
with the flask-talisman package from PyPI:

flask_talisman.Talisman(app.server, content_security_policy={
“default-src”: “‘self’“,
“script-src”: [“‘self’“] + app.csp_hashes()
})

hash_algorithm

One of the recognized CSP hash algorithms (‘sha256’, ‘sha384’, ‘sha512’).

returns: List of CSP hash strings of all inline scripts.

app.enable_dev_tools

app.enable_dev_tools(
    debug=None,
    dev_tools_ui=None,
    dev_tools_props_check=None,
    dev_tools_serve_dev_bundles=None,
    dev_tools_hot_reload=None,
    dev_tools_hot_reload_interval=None,
    dev_tools_hot_reload_watch_interval=None,
    dev_tools_hot_reload_max_retry=None,
    dev_tools_silence_routes_logging=None,
    dev_tools_prune_errors=None
)

Activate the dev tools, called by run_server. If your application
is served by wsgi and you want to activate the dev tools, you can call
this method out of __main__.

All parameters can be set by environment variables as listed.
Values provided here take precedence over environment variables.

Available dev_tools environment variables:

  • DASH_DEBUG
  • DASH_UI
  • DASH_PROPS_CHECK
  • DASH_SERVE_DEV_BUNDLES
  • DASH_HOT_RELOAD
  • DASH_HOT_RELOAD_INTERVAL
  • DASH_HOT_RELOAD_WATCH_INTERVAL
  • DASH_HOT_RELOAD_MAX_RETRY
  • DASH_SILENCE_ROUTES_LOGGING
  • DASH_PRUNE_ERRORS

debug

Enable/disable all the dev tools unless overridden by the
arguments or environment variables. Default is True when
enable_dev_tools is called directly, and False when called
via run_server. env: DASH_DEBUG

type: bool

dev_tools_ui

Show the dev tools UI. env: DASH_UI

type: bool

dev_tools_props_check

Validate the types and values of Dash
component props. env: DASH_PROPS_CHECK

type: bool

dev_tools_serve_dev_bundles

Serve the dev bundles. Production
bundles do not necessarily include all the dev tools code.
env: DASH_SERVE_DEV_BUNDLES

type: bool

dev_tools_hot_reload

Activate hot reloading when app, assets,
and component files change. env: DASH_HOT_RELOAD

type: bool

dev_tools_hot_reload_interval

Interval in seconds for the
client to request the reload hash. Default 3.
env: DASH_HOT_RELOAD_INTERVAL

type: float

dev_tools_hot_reload_watch_interval

Interval in seconds for the
server to check asset and component folders for changes.
Default 0.5. env: DASH_HOT_RELOAD_WATCH_INTERVAL

type: float

dev_tools_hot_reload_max_retry

Maximum number of failed reload
hash requests before failing and displaying a pop up. Default 8.
env: DASH_HOT_RELOAD_MAX_RETRY

type: int

dev_tools_silence_routes_logging

Silence the werkzeug logger,
will remove all routes logging. Enabled with debugging by default
because hot reload hash checks generate a lot of requests.
env: DASH_SILENCE_ROUTES_LOGGING

type: bool

dev_tools_prune_errors

Reduce tracebacks to just user code,
stripping out Flask and Dash pieces. Only available with debugging.
True by default, set to False to see the complete traceback.
env: DASH_PRUNE_ERRORS

type: bool

returns: debug

app.get_asset_url

app.get_asset_url(
    path
)

(No docstring available)

app.get_relative_path

app.get_relative_path(
    path
)

Return a path with requests_pathname_prefix prefixed before it.
Use this function when specifying local URL paths that will work
in environments regardless of what requests_pathname_prefix is.
In some deployment environments, like Dash Enterprise,
requests_pathname_prefix is set to the application name,
e.g. my-dash-app.
When working locally, requests_pathname_prefix might be unset and
so a relative URL like /page-2 can just be /page-2.
However, when the app is deployed to a URL like /my-dash-app, then
app.get_relative_path('/page-2') will return /my-dash-app/page-2.
This can be used as an alternative to get_asset_url as well with
app.get_relative_path('/assets/logo.png')

Use this function with app.strip_relative_path in callbacks that
deal with dcc.Location pathname routing.
That is, your usage may look like:
app.layout = html.Div([ dcc.Location(id='url'), html.Div(id='content') ]) @app.callback(Output('content', 'children'), [Input('url', 'pathname')]) def display_content(path): page_name = app.strip_relative_path(path) if not page_name: # None or '' return html.Div([ dcc.Link(href=app.get_relative_path('/page-1')), dcc.Link(href=app.get_relative_path('/page-2')), ]) elif page_name == 'page-1': return chapters.page_1 if page_name == "page-2": return chapters.page_2

app.index_string

app.index_string

Set this to override the HTML skeleton into which Dash inserts
the app.

app.init_app

app.init_app(
    app=None
)

Initialize the parts of Dash that require a flask app.

app.interpolate_index

app.interpolate_index(
    metas='',
    title='',
    css='',
    config='',
    scripts='',
    app_entry='',
    favicon='',
    renderer=''
)

Called to create the initial HTML string that is loaded on page.
Override this method to provide you own custom HTML.

Example:

class MyDash(dash.Dash):
    def interpolate_index(self, **kwargs):
        return '''<!DOCTYPE html>
        &lt;html&gt;
            &lt;head&gt;
                &lt;title&gt;My App&lt;title&gt;
            &lt;head&gt;
            &lt;body&gt;
                &lt;div&gt;My custom header&lt;div&gt;
                {app_entry}
                {config}
                {scripts}
                {renderer}
                &lt;div&gt;My custom footer&lt;div&gt;
            &lt;body&gt;
        &lt;html&gt;'''.format(app_entry=kwargs.get('app_entry'),
                          config=kwargs.get('config'),
                          scripts=kwargs.get('scripts'),
                          renderer=kwargs.get('renderer'))

metas

Collected & formatted meta tags.

title

The title of the app.

css

Collected & formatted css dependencies as <link> tags.

config

Configs needed by dash-renderer.

scripts

Collected & formatted scripts tags.

renderer

A script tag that instantiates the DashRenderer.

app_entry

Where the app will render.

favicon

A favicon <link> tag if found in assets folder.

returns: The interpolated HTML string for the index.

app.layout

app.layout

Set this to the initial layout the app should have on page load.
Can be a Dash component or a function that returns a Dash component.

app.long_callback

app.long_callback(
    *_args,
    **_kwargs
)

Normally used as a decorator, @app.long_callback is an alternative to
@app.callback designed for callbacks that take a long time to run,
without locking up the Dash app or timing out.

@long_callback is designed to support multiple callback managers.
Two long callback managers are currently implemented:

  • A diskcache manager (DiskcacheLongCallbackManager) that runs callback
    logic in a separate process and stores the results to disk using the
    diskcache library. This is the easiest backend to use for local
    development.
  • A Celery manager (CeleryLongCallbackManager) that runs callback logic
    in a celery worker and returns results to the Dash app through a Celery
    broker like RabbitMQ or Redis.

The following arguments may include any valid arguments to @app.callback.
In addition, @app.long_callback supports the following optional
keyword arguments:

manager

    A long callback manager instance. Currently an instance of one of
    `DiskcacheLongCallbackManager` or `CeleryLongCallbackManager`.
    Defaults to the `long_callback_manager` instance provided to the
    `dash.Dash constructor`.

running

    A list of 3-element tuples. The first element of each tuple should be
    an `Output` dependency object referencing a property of a component in
    the app layout. The second element is the value that the property
    should be set to while the callback is running, and the third element
    is the value the property should be set to when the callback completes.

cancel

    A list of `Input` dependency objects that reference a property of a
    component in the app's layout.  When the value of this property changes
    while a callback is running, the callback is canceled.
    Note that the value of the property is not significant, any change in
    value will result in the cancellation of the running job (if any).

progress

    An `Output` dependency grouping that references properties of
    components in the app's layout. When provided, the decorated function
    will be called with an extra argument as the first argument to the
    function.  This argument, is a function handle that the decorated
    function should call in order to provide updates to the app on its
    current progress. This function accepts a single argument, which
    correspond to the grouping of properties specified in the provided
    `Output` dependency grouping

progress_default

    A grouping of values that should be assigned to the components
    specified by the `progress` argument when the callback is not in
    progress. If `progress_default` is not provided, all the dependency
    properties specified in `progress` will be set to `None` when the
    callback is not running.

cache_args_to_ignore

    Arguments to ignore when caching is enabled. If callback is configured
    with keyword arguments (Input/State provided in a dict),
    this should be a list of argument names as strings. Otherwise,
    this should be a list of argument indices as integers.

app.run_server

app.run_server(
    host='127.0.0.1',
    port='43636',
    proxy=None,
    debug=False,
    dev_tools_ui=None,
    dev_tools_props_check=None,
    dev_tools_serve_dev_bundles=None,
    dev_tools_hot_reload=None,
    dev_tools_hot_reload_interval=None,
    dev_tools_hot_reload_watch_interval=None,
    dev_tools_hot_reload_max_retry=None,
    dev_tools_silence_routes_logging=None,
    dev_tools_prune_errors=None,
    **flask_run_options
)

Start the flask server in local mode, you should not run this on a
production server, use gunicorn/waitress instead.

If a parameter can be set by an environment variable, that is listed
too. Values provided here take precedence over environment variables.

host

Host IP used to serve the application
env: HOST

type: string

port

Port used to serve the application
env: PORT

type: int

proxy

If this application will be served to a different URL
via a proxy configured outside of Python, you can list it here
as a string of the form "{input}::{output}", for example:
"http://0.0.0.0:8050::https://my.domain.com"
so that the startup message will display an accurate URL.
env: DASH_PROXY

type: string

debug

Set Flask debug mode and enable dev tools.
env: DASH_DEBUG

type: bool

debug

Enable/disable all the dev tools unless overridden by the
arguments or environment variables. Default is True when
enable_dev_tools is called directly, and False when called
via run_server. env: DASH_DEBUG

type: bool

dev_tools_ui

Show the dev tools UI. env: DASH_UI

type: bool

dev_tools_props_check

Validate the types and values of Dash
component props. env: DASH_PROPS_CHECK

type: bool

dev_tools_serve_dev_bundles

Serve the dev bundles. Production
bundles do not necessarily include all the dev tools code.
env: DASH_SERVE_DEV_BUNDLES

type: bool

dev_tools_hot_reload

Activate hot reloading when app, assets,
and component files change. env: DASH_HOT_RELOAD

type: bool

dev_tools_hot_reload_interval

Interval in seconds for the
client to request the reload hash. Default 3.
env: DASH_HOT_RELOAD_INTERVAL

type: float

dev_tools_hot_reload_watch_interval

Interval in seconds for the
server to check asset and component folders for changes.
Default 0.5. env: DASH_HOT_RELOAD_WATCH_INTERVAL

type: float

dev_tools_hot_reload_max_retry

Maximum number of failed reload
hash requests before failing and displaying a pop up. Default 8.
env: DASH_HOT_RELOAD_MAX_RETRY

type: int

dev_tools_silence_routes_logging

Silence the werkzeug logger,
will remove all routes logging. Enabled with debugging by default
because hot reload hash checks generate a lot of requests.
env: DASH_SILENCE_ROUTES_LOGGING

type: bool

dev_tools_prune_errors

Reduce tracebacks to just user code,
stripping out Flask and Dash pieces. Only available with debugging.
True by default, set to False to see the complete traceback.
env: DASH_PRUNE_ERRORS

type: bool

flask_run_options

Given to Flask.run

returns:

app.server

app.server(
    environ: dict,
    start_response: Callable
) -> Any

The Flask server associated with this app.
Often used in conjunction with gunicorn when running the app
in production with multiple workers:

app.py

app = dash.Dash(__name__)

# expose the flask variable in the file
server = app.server

Procfile

gunicorn app:server

app.strip_relative_path

app.strip_relative_path(
    path
)

Return a path with requests_pathname_prefix and leading and trailing
slashes stripped from it. Also, if None is passed in, None is returned.
Use this function with get_relative_path in callbacks that deal
with dcc.Location pathname routing.
That is, your usage may look like:
app.layout = html.Div([ dcc.Location(id='url'), html.Div(id='content') ]) @app.callback(Output('content', 'children'), [Input('url', 'pathname')]) def display_content(path): page_name = app.strip_relative_path(path) if not page_name: # None or '' return html.Div([ dcc.Link(href=app.get_relative_path('/page-1')), dcc.Link(href=app.get_relative_path('/page-2')), ]) elif page_name == 'page-1': return chapters.page_1 if page_name == "page-2": return chapters.page_2
Note that chapters.page_1 will be served if the user visits /page-1
or /page-1/ since strip_relative_path removes the trailing slash.

Also note that strip_relative_path is compatible with
get_relative_path in environments where requests_pathname_prefix set.
In some deployment environments, like Dash Enterprise,
requests_pathname_prefix is set to the application name, e.g. my-dash-app.
When working locally, requests_pathname_prefix might be unset and
so a relative URL like /page-2 can just be /page-2.
However, when the app is deployed to a URL like /my-dash-app, then
app.get_relative_path('/page-2') will return /my-dash-app/page-2

The pathname property of dcc.Location will return ‘/my-dash-app/page-2
to the callback.
In this case, app.strip_relative_path('/my-dash-app/page-2')
will return 'page-2'

For nested URLs, slashes are still included:
app.strip_relative_path('/page-1/sub-page-1/') will return
page-1/sub-page-1
``

app.title

app.title

Configures the document.title (the text that appears in a browser tab).

Default is “Dash”.

This is now configurable in the dash.Dash(title='...') constructor
instead of as a property of app. We have kept this property
in the app object for backwards compatibility.


The dash.dependencies module

The classes in dash.dependencies are all used in callback
definitions. Starting in Dash v2.0 these are all available directly
from the main dash module.

dash.dependencies.ALL

dash.dependencies.ALLSMALLER

dash.dependencies.ClientsideFunction

dash.dependencies.Input

dash.dependencies.MATCH

dash.dependencies.Output

dash.dependencies.State


The dash.exceptions module

Dash will raise exceptions under certain scenarios.
Dash will always use a special exception class that can be caught to
handle this particular scenario.
These exception classes are in this module.

dash.exceptions.CallbackException

dash.exceptions.DashException

dash.exceptions.DependencyException

dash.exceptions.DuplicateCallback

dash.exceptions.DuplicateIdError

dash.exceptions.IDsCantContainPeriods

dash.exceptions.IncorrectTypeException

dash.exceptions.InvalidCallbackReturnValue

dash.exceptions.InvalidComponentIdError

dash.exceptions.InvalidConfig

dash.exceptions.InvalidIndexException

dash.exceptions.InvalidResourceError

dash.exceptions.MissingCallbackContextException

dash.exceptions.NoLayoutException

dash.exceptions.NonExistentEventException

dash.exceptions.ObsoleteKwargException

dash.exceptions.PreventUpdate

dash.exceptions.ProxyError

dash.exceptions.ResourceException

dash.exceptions.UnsupportedRelativePath

dash.exceptions.WildcardInLongCallback