module Dash

Julia backend for Plotly Dash

Examples

using Dash
app = dash(external_stylesheets=["https://codepen.io/chriddyp/pen/bWLwgP.css"]) do
    html_div() do
        dcc_input(id="graphTitle", value="Let's Dance!", type = "text"),
        html_div(id="outputID"),
        dcc_graph(id="graph",
            figure = (
                data = [(x = [1,2,3], y = [3,2,8], type="bar")],
                layout = Dict(:title => "Graph")
            )
        )

    end
end
callback!(app, Output("outputID", "children"), Input("graphTitle","value"), State("graphTitle","type")) do value, type
    "You've entered: '$(value)' into a '$(type)' input control"
end
callback!(app, Output("graph", "figure"), Input("graphTitle", "value")) do value
    (
        data = [
            (x = [1,2,3], y = abs.(randn(3)), type="bar"),
            (x = [1,2,3], y = abs.(randn(3)), type="scatter", mode = "lines+markers", line = (width = 4,))
        ],
        layout = (title = value,)
    )
end
run_server(app, HTTP.Sockets.localhost, 8050)

struct DashApp <: Any

Dash.jl's internal representation of a Dash application.

This struct is not intended to be called directly; developers should create their Dash application using the dash function instead.

Base.==(a::Dependency, b::Dependency)

We use "==" to denote two deps that refer to the same prop on the same component. In the case of wildcard deps, this means the same prop on at least one of the same components.

function callback!(func::Union{Function, ClientsideFunction, String},
    app::DashApp,
    output::Union{Vector{Output}, Output},
    input::Union{Vector{Input}, Input},
    state::Union{Vector{State}, State} = []
    )

Create a callback that updates the output by calling function func.

Examples

app = dash() do
    html_div() do
        dcc_input(id="graphTitle", value="Let's Dance!", type = "text"),
        dcc_input(id="graphTitle2", value="Let's Dance!", type = "text"),
        html_div(id="outputID"),
        html_div(id="outputID2")

    end
end
callback!(app, [Output("outputID2", "children"), Output("outputID", "children")],
    Input("graphTitle", "value"),
    State("graphTitle", "type")
    ) do inputValue, stateType
    return (stateType * "..." * inputValue, inputValue)
end

function callback!(func::Union{Function, ClientsideFunction, String},
    app::DashApp,
    deps...
    )

Create a callback that updates the output by calling function func. "Flat" version of callback! function, deps must be $Output..., Input...[,State...]$

Examples

app = dash() do
    html_div() do
        dcc_input(id="graphTitle", value="Let's Dance!", type = "text"),
        dcc_input(id="graphTitle2", value="Let's Dance!", type = "text"),
        html_div(id="outputID"),
        html_div(id="outputID2")

    end
end
callback!(app,
    Output("outputID2", "children"),
    Output("outputID", "children"),
    Input("graphTitle", "value"),
    State("graphTitle", "type")
    ) do  inputValue, stateType
    return (stateType * "..." * inputValue, inputValue)
end

callback_context()::CallbackContext

Get context of current callback, available only inside callback processing function

dash(;
        external_stylesheets,
        external_scripts,
        url_base_pathname,
        requests_pathname_prefix,
        routes_pathname_prefix,
        assets_folder,
        assets_url_path,
        assets_ignore,
        serve_locally,
        suppress_callback_exceptions,
        eager_loading ,
        meta_tags,
        index_string,
        assets_external_path,
        include_assets_files,
        show_undo_redo,
        compress,
        update_title
    )

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.

Arguments

• assets_folder::String - 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.

• assets_url_path::String - 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'.

• assets_ignore::String - [EXPERIMENTAL] A regex, as a string to pass to $Regex$, 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 assets_ignore: string

• assets_external_path::String - [EXPERIMENTAL] an absolute URL from which to load assets. Use with $serve_locally=false$. 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

• include_assets_files::Bool - [EXPERIMENTAL] 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

• url_base_pathname::String: A local URL prefix to use app-wide. Default $nothing$. Both requests_pathname_prefix and routes_pathname_prefix default to url_base_pathname. env: DASH_URL_BASE_PATHNAME

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

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

• serve_locally: [EXPERIMENTAL] If true (default), assets and dependencies (Dash and Component js and css) will be served from local URLs. If false Dash will use CDN links where available. (Dash and Component js and css) will be served from local URLs. If $false$ we will use CDN links where available.

• meta_tags::Vector{Dict{String, String}}: html <meta> tags to be added to the index page. Each dict should have the attributes and values for one tag, eg: $Dict("name"=>"description", "content" => "My App")$

• index_string::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.

• external_scripts::Vector: Additional JS files to load with the page. Each entry can be a String (the URL) or a Dict{String, String} with $src$ (the URL) and optionally other $<script>$ tag attributes such as $integrity$ and $crossorigin$.

• external_stylesheets::Vector: Additional CSS files to load with the page. Each entry can be a String (the URL) or a Dict{String, String} with $href$ (the URL) and optionally other $<link>$ tag attributes such as $rel$, $integrity$ and $crossorigin$.

• suppress_callback_exceptions::Bool: 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

• prevent_initial_callbacks::Bool: 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::Bool: Default $false$, set to $true$ to enable undo and redo buttons for stepping through the history of the app state.

• compress::Bool: Default $true$, controls whether gzip is used to compress files and data served by HTTP.jl when supported by the client. Set to $false$ to disable compression completely.

• update_title::String: Default $Updating...$. Configures the document.title (the text that appears in a browser tab) text when a callback is being run. Set to '' 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.

dash_datatable(;kwargs...)

A DataTable component Dash DataTable is an interactive table component designed for viewing, editing, and exploring large datasets. DataTable is rendered with standard, semantic HTML <table/> markup, which makes it accessible, responsive, and easy to style. This component was written from scratch in React.js specifically for the Dash community. Its API was designed to be ergonomic and its behavior is completely customizable through its properties.

• id (String; optional): The ID of the table.
• active_cell (lists containing elements row, column, rowid, columnid - row (optional) - column (optional) - row_id (String; optional) - column_id (String; optional); optional): The row and column indices and IDs of the currently active cell.

row_id is only returned if the data rows have an id key.

• cell_selectable (Bool; optional): If True (default), then it is possible to click and navigate

table cells.

• column_selectable ('single', 'multi', false; optional): If single, then the user can select a single column or group

of merged columns via the radio button that will appear in the header rows. If multi, then the user can select multiple columns or groups of merged columns via the checkbox that will appear in the header rows. If false, then the user will not be able to select columns and no input will appear in the header rows. When a column is selected, its id will be contained in selected_columns and derived_viewport_selected_columns.

• columns (optional):Columns describes various aspects about each individual column.

name and id are the only required parameters.. columns has the following type: Array of lists containing elements id, name, type, presentation, selectable, clearable, deletable, editable, hideable, renamable, filteroptions, format, onchange, sortasnull, validation - id (String; required): The id of the column. The column id is used to match cells in data with particular columns. The id is not visible in the table. - name (String | Array of Strings; required): The name of the column, as it appears in the column header. If name is a list of strings, then the columns will render with multiple headers rows. - type ('any', 'numeric', 'text', 'datetime'; optional): The data-type provides support for per column typing and allows for data validation and coercion. 'numeric': represents both floats and ints. 'text': represents a string. 'datetime': a string representing a date or date-time, in the form: 'YYYY-MM-DD HH:MM:SS.ssssss' or some truncation thereof. Years must have 4 digits, unless you use validation.allow_YY: true. Also accepts 'T' or 't' between date and time, and allows timezone info at the end. To convert these strings to Python datetime objects, use dateutil.parser.isoparse. In R use parse_iso_8601 from the parsedate library. WARNING: these parsers do not work with 2-digit years, if you use validation.allow_YY: true and do not coerce to 4-digit years. And parsers that do work with 2-digit years may make a different guess about the century than we make on the front end. 'any': represents any type of data. Defaults to 'any' if undefined. - presentation ('input', 'dropdown', 'markdown'; optional): The presentation to use to display data. Markdown can be used on columns with type 'text'. See 'dropdown' for more info. Defaults to 'input' for ['datetime', 'numeric', 'text', 'any']. - selectable ('first', 'last' | Bool | Array of Bools; optional): If true, the user can select the column by clicking on the checkbox or radio button in the column. If there are multiple header rows, true will display the input on each row. If last, the input will only appear on the last header row. If first it will only appear on the first header row. These are respectively shortcut equivalents to [false, ..., false, true] and [true, false, ..., false]. If there are merged, multi-header columns then you can choose which column header row to display the input in by supplying an array of booleans. For example, [true, false] will display the selectable input on the first row, but now on the second row. If the selectable input appears on a merged columns, then clicking on that input will select all of the merged columns associated with it. The table-level prop column_selectable is used to determine the type of column selection to use. - clearable ('first', 'last' | Bool | Array of Bools; optional): If true, the user can clear the column by clicking on the clear action button on the column. If there are multiple header rows, true will display the action button on each row. If last, the clear action button will only appear on the last header row. If first it will only appear on the first header row. These are respectively shortcut equivalents to [false, ..., false, true] and [true, false, ..., false]. If there are merged, multi-header columns then you can choose which column header row to display the clear action button in by supplying an array of booleans. For example, [true, false] will display the clear action button on the first row, but not the second row. If the clear action button appears on a merged column, then clicking on that button will clear all of the merged columns associated with it. Unlike column.deletable, this action does not remove the column(s) from the table. It only removed the associated entries from data. - deletable ('first', 'last' | Bool | Array of Bools; optional): If true, the user can remove the column by clicking on the delete action button on the column. If there are multiple header rows, true will display the action button on each row. If last, the delete action button will only appear on the last header row. If first it will only appear on the first header row. These are respectively shortcut equivalents to [false, ..., false, true] and [true, false, ..., false]. If there are merged, multi-header columns then you can choose which column header row to display the delete action button in by supplying an array of booleans. For example, [true, false] will display the delete action button on the first row, but not the second row. If the delete action button appears on a merged column, then clicking on that button will remove all of the merged columns associated with it. - editable (Bool; optional): There are two editable flags in the table. This is the column-level editable flag and there is also the table-level editable flag. These flags determine whether the contents of the table are editable or not. If the column-level editable flag is set it overrides the table-level editable flag for that column. - hideable ('first', 'last' | Bool | Array of Bools; optional): If true, the user can hide the column by clicking on the hide action button on the column. If there are multiple header rows, true will display the action button on each row. If last, the hide action button will only appear on the last header row. If first it will only appear on the first header row. These are respectively shortcut equivalents to [false, ..., false, true] and [true, false, ..., false]. If there are merged, multi-header columns then you can choose which column header row to display the hide action button in by supplying an array of booleans. For example, [true, false] will display the hide action button on the first row, but not the second row. If the hide action button appears on a merged column, then clicking on that button will hide all of the merged columns associated with it. - renamable ('first', 'last' | Bool | Array of Bools; optional): If true, the user can rename the column by clicking on the rename action button on the column. If there are multiple header rows, true will display the action button on each row. If last, the rename action button will only appear on the last header row. If first it will only appear on the first header row. These are respectively shortcut equivalents to [false, ..., false, true] and [true, false, ..., false]. If there are merged, multi-header columns then you can choose which column header row to display the rename action button in by supplying an array of booleans. For example, [true, false] will display the rename action button on the first row, but not the second row. If the rename action button appears on a merged column, then clicking on that button will rename all of the merged columns associated with it. - filter_options (lists containing elements case, placeholdertext - case ('sensitive', 'insensitive'; optional): (default: 'sensitive') Determine whether the applicable filter relational operators will default to sensitive or insensitive comparison. - `placeholdertext(String; optional): (default: 'filter data...') The filter cell placeholder text.; optional): There are twofilteroptions` props in the table. This is the column-level filteroptions prop and there is also the table-level filter_options prop. If the column-level filter_options prop is set it overrides the table-level filter_options prop for that column. - format (optional):The formatting applied to the column's data. This prop is derived from the d3-format library specification. Apart from being structured slightly differently (under a single prop), the usage is the same. See also dashtable.FormatTemplate. It contains helper functions for typical number formats.. format has the following type: lists containing elements locale, nully, prefix, specifier - locale (optional):Represents localization specific formatting information. When left unspecified, will use the default value provided by d3-format.. locale has the following type: lists containing elements symbol, decimal, group, grouping, numerals, percent, separate4digits - symbol (Array of Strings; optional): (default: ['$', '']). A list of two strings representing the prefix and suffix symbols. Typically used for currency, and implemented using d3's currency format, but you can use this for other symbols such as measurement units - decimal (String; optional): (default: '.'). The string used for the decimal separator - group (String; optional): (default: ','). The string used for the groups separator - grouping (Array of s; optional): (default: [3]). A list of integers representing the grouping pattern. The default is 3 for thousands. - numerals (Array of Strings; optional): A list of ten strings used as replacements for numbers 0-9 - percent (String; optional): (default: '%'). The string used for the percentage symbol - separate_4digits (Bool; optional): (default: True). Separates integers with 4-digits or less - nully (Bool | Real | String | Dict | Array; optional): A value that will be used in place of the nully value during formatting. If the value type matches the column type, it will be formatted normally. - prefix (optional): A number representing the SI unit to use during formatting. See dash_table.Format.Prefix enumeration for the list of valid values - specifier (String; optional): (default: ''). Represents the d3 rules to apply when formatting the number. - on_change (optional):The on_change behavior of the column for user-initiated modifications.. onchange has the following type: lists containing elements action, failure - action ('coerce', 'none', 'validate'; optional): (default 'coerce'): 'none': do not validate data; 'coerce': check if the data corresponds to the destination type and attempts to coerce it into the destination type if not; 'validate': check if the data corresponds to the destination type (no coercion). - failure ('accept', 'default', 'reject'; optional): (default 'reject'): What to do with the value if the action fails. 'accept': use the invalid value; 'default': replace the provided value with validation.default; 'reject': do not modify the existing value. - `sortasnull(Array of String | Bools; optional): An array of string, number and boolean values that are treated asnull(i.e. ignored and always displayed last) when sorting. This value overrides the table-levelsortasnull. -validation(optional):Thevalidation` options for user input processing that can accept, reject or apply a default value.. validation has the following type: lists containing elements allownull, default, allowYY - `allownull(Bool; optional): Allow the use of nully values. (undefined, null, NaN) (default: False) -default(Bool | Real | String | Dict | Array; optional): The default value to apply with on_change.failure = 'default'. (default: None) -allow_YY(Bool; optional): This is fordatetimecolumns only. Allow 2-digit years (default: False). If True, we interpret years as ranging from now-70 to now+29 - in 2019 this is 1949 to 2048 but in 2020 it will be different. If used withaction: 'coerce'`, will convert user input to a 4-digit year.s

• css (Array of lists containing elements selector, rule - selector (String; required) - rule (String; required)s; optional): The css property is a way to embed CSS selectors and rules

onto the page. We recommend starting with the style_* properties before using this css property. Example: [ {"selector": ".dash-spreadsheet", "rule": 'font-family: "monospace"'} ]

• data (Array of Dict with Strings as keys and values of type String | Bools; optional): The contents of the table.

The keys of each item in data should match the column IDs. Each item can also have an 'id' key, whose value is its row ID. If there is a column with ID='id' this will display the row ID, otherwise it is just used to reference the row for selections, filtering, etc. Example: [ {'column-1': 4.5, 'column-2': 'montreal', 'column-3': 'canada'}, {'column-1': 8, 'column-2': 'boston', 'column-3': 'america'} ]

• data_previous (Array of Dicts; optional): The previous state of data. data_previous

has the same structure as data and it will be updated whenever data changes, either through a callback or by editing the table. This is a read-only property: setting this property will not have any impact on the table.

• data_timestamp (optional): The unix timestamp when the data was last edited.

Use this property with other timestamp properties (such as n_clicks_timestamp in dash_html_components) to determine which property has changed within a callback.

• derived_filter_query_structure (Dict; optional): This property represents the current structure of

filter_query as a tree structure. Each node of the query structure has: type (string; required): 'open-block', 'logical-operator', 'relational-operator', 'unary-operator', or 'expression'; subType (string; optional): 'open-block': '()', 'logical-operator': '&&', '||', 'relational-operator': '=', '>=', '>', '<=', '<', '!=', 'contains', 'unary-operator': '!', 'is bool', 'is even', 'is nil', 'is num', 'is object', 'is odd', 'is prime', 'is str', 'expression': 'value', 'field'; value (any): 'expression, value': passed value, 'expression, field': the field/prop name. block (nested query structure; optional). left (nested query structure; optional). right (nested query structure; optional). If the query is invalid or empty, the derived_filter_query_structure will be None.

• derived_viewport_data (Array of Dicts; optional): This property represents the current state of data

on the current page. This property will be updated on paging, sorting, and filtering.

• derived_viewport_indices (Array of s; optional): derived_viewport_indices indicates the order in which the original

rows appear after being filtered, sorted, and/or paged. derived_viewport_indices contains indices for the current page, while derived_virtual_indices contains indices across all pages.

• derived_viewport_row_ids (Array of Strings; optional): derived_viewport_row_ids lists row IDs in the order they appear

after being filtered, sorted, and/or paged. derived_viewport_row_ids contains IDs for the current page, while derived_virtual_row_ids contains IDs across all pages.

• derived_viewport_selected_columns (Array of Strings; optional): derived_viewport_selected_columns contains the ids of the

selected_columns that are not currently hidden.

• derived_viewport_selected_row_ids (Array of Strings; optional): derived_viewport_selected_row_ids represents the IDs of the

selected_rows on the currently visible page.

• derived_viewport_selected_rows (Array of s; optional): derived_viewport_selected_rows represents the indices of the

selected_rows from the perspective of the derived_viewport_indices.

• derived_virtual_data (Array of Dicts; optional): This property represents the visible state of data

across all pages after the front-end sorting and filtering as been applied.

• derived_virtual_indices (Array of s; optional): derived_virtual_indices indicates the order in which the original

rows appear after being filtered and sorted. derived_viewport_indices contains indices for the current page, while derived_virtual_indices contains indices across all pages.

• derived_virtual_row_ids (Array of Strings; optional): derived_virtual_row_ids indicates the row IDs in the order in which

they appear after being filtered and sorted. derived_viewport_row_ids contains IDs for the current page, while derived_virtual_row_ids contains IDs across all pages.

• derived_virtual_selected_row_ids (Array of Strings; optional): derived_virtual_selected_row_ids represents the IDs of the

selected_rows as they appear after filtering and sorting, across all pages.

• derived_virtual_selected_rows (Array of s; optional): derived_virtual_selected_rows represents the indices of the

selected_rows from the perspective of the derived_virtual_indices.

• dropdown (Dict with Strings as keys and values of type lists containing elements clearable, options - clearable (Bool; optional) - options (Array of lists containing elements label, value - label (String; required) - value (String | Bool; required)s; required); optional): dropdown specifies dropdown options for different columns.

Each entry refers to the column ID. The clearable property defines whether the value can be deleted. The options property refers to the options of the dropdown.

• dropdown_conditional (Array of lists containing elements clearable, if, options - clearable (Bool; optional) - if (lists containing elements columnid, filterquery - column_id (String; optional) - filter_query (String; optional); optional) - options (Array of lists containing elements label, value - label (String; required) - value (String | Bool; required)s; required)s; optional): dropdown_conditional specifies dropdown options in various columns and cells.

This property allows you to specify different dropdowns depending on certain conditions. For example, you may render different "city" dropdowns in a row depending on the current value in the "state" column.

• dropdown_data (Array of Dict with Strings as keys and values of type lists containing elements clearable, options - clearable (Bool; optional) - options (Array of lists containing elements label, value - label (String; required) - value (String | Bool; required)s; required)s; optional): dropdown_data specifies dropdown options on a row-by-row, column-by-column basis.

Each item in the array corresponds to the corresponding dropdowns for the data item at the same index. Each entry in the item refers to the Column ID.

• editable (Bool; optional): If True, then the data in all of the cells is editable.

When editable is True, particular columns can be made uneditable by setting editable to False inside the columns property. If False, then the data in all of the cells is uneditable. When editable is False, particular columns can be made editable by setting editable to True inside the columns property.

• end_cell (lists containing elements row, column, rowid, columnid - row (optional) - column (optional) - row_id (String; optional) - column_id (String; optional); optional): When selecting multiple cells

(via clicking on a cell and then shift-clicking on another cell), end_cell represents the row / column coordinates and IDs of the cell in one of the corners of the region. start_cell represents the coordinates of the other corner.

• export_columns ('all', 'visible'; optional): Denotes the columns that will be used in the export data file.

If all, all columns will be used (visible + hidden). If visible, only the visible columns will be used. Defaults to visible.

• export_format ('csv', 'xlsx', 'none'; optional): Denotes the type of the export data file,

Defaults to 'none'

• export_headers ('none', 'ids', 'names', 'display'; optional): Denotes the format of the headers in the export data file.

If 'none', there will be no header. If 'display', then the header of the data file will be be how it is currently displayed. Note that 'display' is only supported for 'xlsx' export_format and will behave like 'names' for 'csv' export format. If 'ids' or 'names', then the headers of data file will be the column id or the column names, respectively

• fill_width (Bool; optional): fill_width toggles between a set of CSS for two common behaviors:

True: The table container's width will grow to fill the available space; False: The table container's width will equal the width of its content.

• filter_action ('custom', 'native', 'none' | lists containing elements type, operator - type ('custom', 'native'; required) - operator ('and', 'or'; optional); optional): The filter_action property controls the behavior of the filtering UI.

If 'none', then the filtering UI is not displayed. If 'native', then the filtering UI is displayed and the filtering logic is handled by the table. That is, it is performed on the data that exists in the data property. If 'custom', then the filtering UI is displayed but it is the responsibility of the developer to program the filtering through a callback (where filter_query or derived_filter_query_structure would be the input and data would be the output).

• filter_options (lists containing elements case, placeholdertext - case ('sensitive', 'insensitive'; optional): (default: 'sensitive') Determine whether the applicable filter relational operators will default to sensitive or insensitive comparison. - `placeholdertext(String; optional): (default: 'filter data...') The filter cell placeholder text.; optional): There are twofilter_options` props in the table.

This is the table-level filteroptions prop and there is also the column-level `filteroptionsprop. If the column-levelfilteroptionsprop is set it overrides the table-levelfilteroptions` prop for that column.

• filter_query (String; optional): If filter_action is enabled, then the current filtering

string is represented in this filter_query property.

• fixed_columns (lists containing elements data, headers - data (0; optional): Example {'headers':False, 'data':0} No columns are fixed (the default) - headers (false; optional) | lists containing elements data, headers - data (optional): Example {'headers':True, 'data':1} one column is fixed. - headers (true; required); optional): fixed_columns will "fix" the set of columns so that

they remain visible when scrolling horizontally across the unfixed columns. fixed_columns fixes columns from left-to-right. If headers is False, no columns are fixed. If headers is True, all operation columns (see row_deletable and row_selectable) are fixed. Additional data columns can be fixed by assigning a number to data.

Note that fixing columns introduces some changes to the underlying markup of the table and may impact the way that your columns are rendered or sized. View the documentation examples to learn more.

• fixed_rows (lists containing elements data, headers - data (0; optional): Example {'headers':False, 'data':0} No rows are fixed (the default) - headers (false; optional) | lists containing elements data, headers - data (optional): Example {'headers':True, 'data':1} one row is fixed. - headers (true; required); optional): fixed_rows will "fix" the set of rows so that

they remain visible when scrolling vertically down the table. fixed_rows fixes rows from top-to-bottom, starting from the headers. If headers is False, no rows are fixed. If headers is True, all header and filter rows (see filter_action) are fixed. Additional data rows can be fixed by assigning a number to data. Note that fixing rows introduces some changes to the underlying markup of the table and may impact the way that your columns are rendered or sized. View the documentation examples to learn more.

• hidden_columns (Array of Strings; optional): List of columns ids of the columns that are currently hidden.

See the associated nested prop columns.hideable.

• include_headers_on_copy_paste (Bool; optional): If true, headers are included when copying from the table to different

tabs and elsewhere. Note that headers are ignored when copying from the table onto itself and between two tables within the same tab.

• is_focused (Bool; optional): If True, then the active_cell is in a focused state.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• locale_format (optional):The localization specific formatting information applied to all columns in the table.

This prop is derived from the d3.formatLocale data structure specification. When left unspecified, each individual nested prop will default to a pre-determined value.. localeformat has the following type: lists containing elements symbol, decimal, group, grouping, numerals, percent, separate4digits - symbol (Array of Strings; optional): (default: ['$', '']). A list of two strings representing the prefix and suffix symbols. Typically used for currency, and implemented using d3's currency format, but you can use this for other symbols such as measurement units. - decimal (String; optional): (default: '.'). The string used for the decimal separator. - group (String; optional): (default: ','). The string used for the groups separator. - grouping (Array of s; optional): (default: [3]). A list of integers representing the grouping pattern. - numerals (Array of Strings; optional): A list of ten strings used as replacements for numbers 0-9. - percent (String; optional): (default: '%'). The string used for the percentage symbol. - separate_4digits (Bool; optional): (default: True). Separate integers with 4-digits or less.

• markdown_options (optional):The markdown_options property allows customization of the markdown cells behavior.. markdownoptions has the following type: lists containing elements linktarget, html - link_target (String | 'blank', 'parent', 'self', 'top'; optional): (default: 'blank'). The link's behavior (blank opens the link in a

new tab, _parent opens the link in the parent frame, _self opens the link in the current tab, and _top opens the link in the top frame) or a string - html (Bool; optional): (default: False) If True, html may be used in markdown cells Be careful enabling html if the content being rendered can come from an untrusted user, as this may create an XSS vulnerability.

• merge_duplicate_headers (Bool; optional): If True, then column headers that have neighbors with duplicate names

will be merged into a single cell. This will be applied for single column headers and multi-column headers.

• page_action ('custom', 'native', 'none'; optional): page_action refers to a mode of the table where

not all of the rows are displayed at once: only a subset are displayed (a "page") and the next subset of rows can viewed by clicking "Next" or "Previous" buttons at the bottom of the page. Pagination is used to improve performance: instead of rendering all of the rows at once (which can be expensive), we only display a subset of them. With pagination, we can either page through data that exists in the table (e.g. page through 10,000 rows in data 100 rows at a time) or we can update the data on-the-fly with callbacks when the user clicks on the "Previous" or "Next" buttons. These modes can be toggled with this page_action parameter: 'native': all data is passed to the table up-front, paging logic is handled by the table; 'custom': data is passed to the table one page at a time, paging logic is handled via callbacks; 'none': disables paging, render all of the data at once.

• page_count (optional): page_count represents the number of the pages in the

paginated table. This is really only useful when performing backend pagination, since the front end is able to use the full size of the table to calculate the number of pages.

• page_current (optional): page_current represents which page the user is on.

Use this property to index through data in your callbacks with backend paging.

• page_size (optional): page_size represents the number of rows that will be

displayed on a particular page when page_action is 'custom' or 'native'

• persisted_props (Array of 'columns.name', 'data', 'filterquery', 'hiddencolumns', 'pagecurrent', 'selectedcolumns', 'selectedrows', 'sortby's; optional): Properties whose user interactions will persist after refreshing the

component or the page.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, any persisted_props that the user has changed while using the app will keep those changes, as long as the new prop value also matches what was given originally. Used in conjunction with persistence_type and persisted_props.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• row_deletable (Bool; optional): If True, then a x will appear next to each row

and the user can delete the row.

• row_selectable ('single', 'multi', false; optional): If single, then the user can select a single row

via a radio button that will appear next to each row. If multi, then the user can select multiple rows via a checkbox that will appear next to each row. If false, then the user will not be able to select rows and no additional UI elements will appear. When a row is selected, its index will be contained in selected_rows.

• selected_cells (Array of lists containing elements row, column, rowid, columnid - row (optional) - column (optional) - row_id (String; optional) - column_id (String; optional)s; optional): selected_cells represents the set of cells that are selected,

as an array of objects, each item similar to active_cell. Multiple cells can be selected by holding down shift and clicking on a different cell or holding down shift and navigating with the arrow keys.

• selected_columns (Array of Strings; optional): selected_columns contains the ids of columns that

are selected via the UI elements that appear when column_selectable is 'single' or 'multi'.

• selected_row_ids (Array of Strings; optional): selected_row_ids contains the ids of rows that

are selected via the UI elements that appear when row_selectable is 'single' or 'multi'.

• selected_rows (Array of s; optional): selected_rows contains the indices of rows that

are selected via the UI elements that appear when row_selectable is 'single' or 'multi'.

• sort_action ('custom', 'native', 'none'; optional): The sort_action property enables data to be

sorted on a per-column basis. If 'none', then the sorting UI is not displayed. If 'native', then the sorting UI is displayed and the sorting logic is handled by the table. That is, it is performed on the data that exists in the data property. If 'custom', the the sorting UI is displayed but it is the responsibility of the developer to program the sorting through a callback (where sort_by would be the input and data would be the output). Clicking on the sort arrows will update the sort_by property.

• sort_as_null (Array of String | Bools; optional): An array of string, number and boolean values that are treated as None

(i.e. ignored and always displayed last) when sorting. This value will be used by columns without sort_as_null. Defaults to [].

• sort_by (Array of lists containing elements columnid, direction - `columnid(String; required) -direction('asc', 'desc'; required)s; optional):sort_by` describes the current state

of the sorting UI. That is, if the user clicked on the sort arrow of a column, then this property will be updated with the column ID and the direction (asc or desc) of the sort. For multi-column sorting, this will be a list of sorting parameters, in the order in which they were clicked.

• sort_mode ('single', 'multi'; optional): Sorting can be performed across multiple columns

(e.g. sort by country, sort within each country, sort by year) or by a single column. NOTE - With multi-column sort, it's currently not possible to determine the order in which the columns were sorted through the UI. See https://github.com/plotly/dash-table/issues/170

• start_cell (lists containing elements row, column, rowid, columnid - row (optional) - column (optional) - row_id (String; optional) - column_id (String; optional); optional): When selecting multiple cells

(via clicking on a cell and then shift-clicking on another cell), start_cell represents the [row, column] coordinates of the cell in one of the corners of the region. end_cell represents the coordinates of the other corner.

• style_as_list_view (Bool; optional): If True, then the table will be styled like a list view

and not have borders between the columns.

• style_cell (Dict; optional): CSS styles to be applied to each individual cell of the table.

This includes the header cells, the data cells, and the filter cells.

• style_cell_conditional (Array of lists containing elements if - if (lists containing elements columnid, columntype - column_id (String | Array of Strings; optional) - column_type ('any', 'numeric', 'text', 'datetime'; optional); optional)s; optional): Conditional CSS styles for the cells.

This can be used to apply styles to cells on a per-column basis.

• style_data (Dict; optional): CSS styles to be applied to each individual data cell.

That is, unlike style_cell, it excludes the header and filter cells.

• style_data_conditional (Array of lists containing elements if - if (lists containing elements columnid, columntype, filterquery, state, rowindex, columneditable - `columnid(String | Array of Strings; optional) -columntype('any', 'numeric', 'text', 'datetime'; optional) -filterquery(String; optional) -state('active', 'selected'; optional) -rowindex('odd', 'even' | Array of s; optional) -columneditable` (Bool; optional); optional)s; optional): Conditional CSS styles for the data cells.

This can be used to apply styles to data cells on a per-column basis.

• style_filter (Dict; optional): CSS styles to be applied to the filter cells.

Note that this may change in the future as we build out a more complex filtering UI.

• style_filter_conditional (Array of lists containing elements if - if (lists containing elements columnid, columntype, columneditable - `columnid(String | Array of Strings; optional) -columntype('any', 'numeric', 'text', 'datetime'; optional) -columneditable` (Bool; optional); optional)s; optional): Conditional CSS styles for the filter cells.

This can be used to apply styles to filter cells on a per-column basis.

• style_header (Dict; optional): CSS styles to be applied to each individual header cell.

That is, unlike style_cell, it excludes the data and filter cells.

• style_header_conditional (Array of lists containing elements if - if (lists containing elements columnid, columntype, headerindex, columneditable - column_id (String | Array of Strings; optional) - column_type ('any', 'numeric', 'text', 'datetime'; optional) - header_index (Array of s | 'odd', 'even'; optional) - column_editable (Bool; optional); optional)s; optional): Conditional CSS styles for the header cells.

This can be used to apply styles to header cells on a per-column basis.

• style_table (Dict; optional): CSS styles to be applied to the outer table container.

This is commonly used for setting properties like the width or the height of the table.

• tooltip (optional):tooltip is the column based tooltip configuration applied to all rows. The key is the column

id and the value is a tooltip configuration. Example: {i: {'value': i, 'usewith: 'both'} for i in df.columns}. tooltip has the following type: Dict with Strings as keys and values of type String | lists containing elements delay, duration, type, usewith, value - delay (optional): Represents the delay in milliseconds before the tooltip is shown when hovering a cell. This overrides the table's tooltip_delay property. If set to None, the tooltip will be shown immediately. - duration (optional): represents the duration in milliseconds during which the tooltip is shown when hovering a cell. This overrides the table's tooltip_duration property. If set to None, the tooltip will not disappear. - type ('text', 'markdown'; optional): refers to the type of tooltip syntax used for the tooltip generation. Can either be markdown or text. Defaults to text. - use_with ('both', 'data', 'header'; optional): Refers to whether the tooltip will be shown only on data or headers. Can be both, data, header. Defaults to both. - value (String; required): refers to the syntax-based content of the tooltip. This value is required. Alternatively, the value of the property can also be a plain string. The text syntax will be used in that case.

• tooltip_conditional (optional):tooltip_conditional represents the tooltip shown

for different columns and cells. This property allows you to specify different tooltips depending on certain conditions. For example, you may have different tooltips in the same column based on the value of a certain data property. Priority is from first to last defined conditional tooltip in the list. Higher priority (more specific) conditional tooltips should be put at the beginning of the list.. tooltipconditional has the following type: Array of lists containing elements delay, duration, if, type, value - delay (optional): The delay represents the delay in milliseconds before the tooltip is shown when hovering a cell. This overrides the table's `tooltipdelayproperty. If set toNone, the tooltip will be shown immediately. -duration(optional): Thedurationrepresents the duration in milliseconds during which the tooltip is shown when hovering a cell. This overrides the table'stooltipdurationproperty. If set toNone, the tooltip will not disappear. -if` (lists containing elements columnid, filterquery, rowindex - column_id (String; optional): column_id refers to the column ID that must be matched. - filter_query (String; optional): filter_query refers to the query that must evaluate to True. - row_index ('odd', 'even'; optional): row_index refers to the index of the row in the source data.; required): The if refers to the condition that needs to be fulfilled in order for the associated tooltip configuration to be used. If multiple conditions are defined, all conditions must be met for the tooltip to be used by a cell. - type ('text', 'markdown'; optional): The type refers to the type of tooltip syntax used for the tooltip generation. Can either be markdown or text. Defaults to text. - value (String; required): The value refers to the syntax-based content of the tooltip. This value is required.s

• tooltip_data (optional):tooltip_data represents the tooltip shown

for different columns and cells. A list of dicts for which each key is a column id and the value is a tooltip configuration.. tooltipdata has the following type: Array of Dict with Strings as keys and values of type String | lists containing elements delay, duration, type, value - delay (optional): The delay represents the delay in milliseconds before the tooltip is shown when hovering a cell. This overrides the table's `tooltipdelayproperty. If set toNone, the tooltip will be shown immediately. -duration(optional): Thedurationrepresents the duration in milliseconds during which the tooltip is shown when hovering a cell. This overrides the table'stooltip_durationproperty. If set toNone, the tooltip will not disappear. Alternatively, the value of the property can also be a plain string. Thetextsyntax will be used in that case. -type('text', 'markdown'; optional): For each tooltip configuration, Thetyperefers to the type of tooltip syntax used for the tooltip generation. Can either bemarkdownortext. Defaults totext. -value(String; required): Thevalue` refers to the syntax-based content of the tooltip. This value is required.s

• tooltip_delay (optional): tooltip_delay represents the table-wide delay in milliseconds before

the tooltip is shown when hovering a cell. If set to None, the tooltip will be shown immediately. Defaults to 350.

• tooltip_duration (optional): tooltip_duration represents the table-wide duration in milliseconds

during which the tooltip will be displayed when hovering a cell. If set to None, the tooltip will not disappear. Defaults to 2000.

• tooltip_header (optional):tooltip_header represents the tooltip shown

for each header column and optionally each header row. Example to show long column names in a tooltip: {i: i for i in df.columns}. Example to show different column names in a tooltip: {'Rep': 'Republican', 'Dem': 'Democrat'}. If the table has multiple rows of headers, then use a list as the value of the tooltip_header items.. tooltipheader has the following type: Dict with Strings as keys and values of type String | lists containing elements delay, duration, type, value - delay (optional): The delay represents the delay in milliseconds before the tooltip is shown when hovering a cell. This overrides the table's `tooltipdelayproperty. If set toNone, the tooltip will be shown immediately. -duration(optional): Thedurationrepresents the duration in milliseconds during which the tooltip is shown when hovering a cell. This overrides the table'stooltip_durationproperty. If set toNone, the tooltip will not disappear. Alternatively, the value of the property can also be a plain string. Thetextsyntax will be used in that case. -type('text', 'markdown'; optional): For each tooltip configuration, Thetyperefers to the type of tooltip syntax used for the tooltip generation. Can either bemarkdownortext. Defaults totext. -value(String; required): Thevaluerefers to the syntax-based content of the tooltip. This value is required. | Array of null | String | lists containing elements delay, duration, type, value -delay(optional) -duration(optional) -type('text', 'markdown'; optional) -value` (String; required)s

• virtualization (Bool; optional): This property tells the table to use virtualization when rendering.

Assumptions are that: the width of the columns is fixed; the height of the rows is always the same; and runtime styling changes will not affect width and height vs. first rendering

dcc_checklist(;kwargs...)

A Checklist component Checklist is a component that encapsulates several checkboxes. The values and labels of the checklist are specified in the options property and the checked items are specified with the value property. Each checkbox is rendered as an input with a surrounding label.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): The class of the container (div)
• inline (Bool; optional): Indicates whether the options labels should be displayed inline (true=horizontal)

or in a block (false=vertical).

• inputClassName (String; optional): The class of the <input> checkbox element
• inputStyle (Dict; optional): The style of the <input> checkbox element
• labelClassName (String; optional): The class of the <label> that wraps the checkbox input

and the option's label

• labelStyle (Dict; optional): The style of the <label> that wraps the checkbox input

and the option's label

• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• options (optional):An array of options. options has the following type: Array of String | Bools | Dict | Array of lists containing elements label, value, disabled, title - label (a list of or a singular dash component, string or number; required): The option's label - value (String | Bool; required): The value of the option. This value

corresponds to the items specified in the value property. - disabled (Bool; optional): If true, this option is disabled and cannot be selected. - title (String; optional): The HTML 'title' attribute for the option. Allows for information on hover. For more information on this attribute, see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/titles

• persisted_props (Array of 'value's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only value is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a value that the user has changed while using the app will keep that change, as long as the new value also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• style (Dict; optional): The style of the container (div)
• value (Array of String | Bools; optional): The currently selected value

dcc_clipboard(;kwargs...)

A Clipboard component The Clipboard component copies text to the clipboard

• id (String; optional): The ID used to identify this component.
• className (String; optional): The class name of the icon element
• content (String; optional): The text to be copied to the clipboard if the target_id is None.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): The number of times copy button was clicked
• style (Dict; optional): The icon's styles
• target_id (String | Dict; optional): The id of target component containing text to copy to the clipboard.

The inner text of the children prop will be copied to the clipboard. If none, then the text from the value prop will be copied.

• title (String; optional): The text shown as a tooltip when hovering over the copy icon.

dcc_confirmdialog(;kwargs...)

A ConfirmDialog component ConfirmDialog is used to display the browser's native "confirm" modal, with an optional message and two buttons ("OK" and "Cancel"). This ConfirmDialog can be used in conjunction with buttons when the user is performing an action that should require an extra step of verification.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• cancel_n_clicks (optional): Number of times the popup was canceled.
• cancel_n_clicks_timestamp (optional): Last time the cancel button was clicked.
• displayed (Bool; optional): Set to true to send the ConfirmDialog.
• message (String; optional): Message to show in the popup.
• submit_n_clicks (optional): Number of times the submit button was clicked
• submit_n_clicks_timestamp (optional): Last time the submit button was clicked.

dcc_confirmdialogprovider(;kwargs...)
dcc_confirmdialogprovider(children::Any, kwargs...)
dcc_confirmdialogprovider(children_maker::Function, kwargs...)

A ConfirmDialogProvider component A wrapper component that will display a confirmation dialog when its child component has been clicked on.

For example:

dcc.ConfirmDialogProvider(
    html.Button('click me', id='btn'),
    message='Danger - Are you sure you want to continue.'
    id='confirm')

• children (Bool | Real | String | Dict | Array; optional): The children to hijack clicks from and display the popup.
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• cancel_n_clicks (optional): Number of times the popup was canceled.
• cancel_n_clicks_timestamp (optional): Last time the cancel button was clicked.
• displayed (Bool; optional): Is the modal currently displayed.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• message (String; optional): Message to show in the popup.
• submit_n_clicks (optional): Number of times the submit was clicked
• submit_n_clicks_timestamp (optional): Last time the submit button was clicked.

dcc_datepickerrange(;kwargs...)

A DatePickerRange component DatePickerRange is a tailor made component designed for selecting timespan across multiple days off of a calendar.

The DatePicker integrates well with the Python datetime module with the startDate and endDate being returned in a string format suitable for creating datetime objects.

This component is based off of Airbnb's react-dates react component which can be found here: https://github.com/airbnb/react-dates

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• calendar_orientation ('vertical', 'horizontal'; optional): Orientation of calendar, either vertical or horizontal.

Valid options are 'vertical' or 'horizontal'.

• className (String; optional): Appends a CSS class to the wrapper div component.
• clearable (Bool; optional): Whether or not the dropdown is "clearable", that is, whether or

not a small "x" appears on the right of the dropdown that removes the selected value.

• day_size (optional): Size of rendered calendar days, higher number

means bigger day size and larger calendar overall

• disabled (Bool; optional): If True, no dates can be selected.
• disabled_days (Array of Strings; optional): Specifies additional days between mindateallowed and maxdateallowed

that should be disabled. Accepted datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• display_format (String; optional): Specifies the format that the selected dates will be displayed

valid formats are variations of "MM YY DD". For example: "MM YY DD" renders as '05 10 97' for May 10th 1997 "MMMM, YY" renders as 'May, 1997' for May 10th 1997 "M, D, YYYY" renders as '07, 10, 1997' for September 10th 1997 "MMMM" renders as 'May' for May 10 1997

• end_date (String; optional): Specifies the ending date for the component.

Accepts datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• end_date_id (String; optional): The HTML element ID of the end date input field.

Not used by Dash, only by CSS.

• end_date_placeholder_text (String; optional): Text that will be displayed in the second input

box of the date picker when no date is selected. Default value is 'End Date'

• first_day_of_week (0, 1, 2, 3, 4, 5, 6; optional): Specifies what day is the first day of the week, values must be

from [0, ..., 6] with 0 denoting Sunday and 6 denoting Saturday

• initial_visible_month (String; optional): Specifies the month that is initially presented when the user

opens the calendar. Accepts datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• is_RTL (Bool; optional): Determines whether the calendar and days operate

from left to right or from right to left

• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• max_date_allowed (String; optional): Specifies the highest selectable date for the component.

Accepts datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• min_date_allowed (String; optional): Specifies the lowest selectable date for the component.

Accepts datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• minimum_nights (optional): Specifies a minimum number of nights that must be selected between

the startDate and the endDate

• month_format (String; optional): Specifies the format that the month will be displayed in the calendar,

valid formats are variations of "MM YY". For example: "MM YY" renders as '05 97' for May 1997 "MMMM, YYYY" renders as 'May, 1997' for May 1997 "MMM, YY" renders as 'Sep, 97' for September 1997

• number_of_months_shown (optional): Number of calendar months that are shown when calendar is opened
• persisted_props (Array of 'startdate', 'enddate's; optional): Properties whose user interactions will persist after refreshing the

component or the page.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, any persisted_props that the user has changed while using the app will keep those changes, as long as the new prop value also matches what was given originally. Used in conjunction with persistence_type and persisted_props.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• reopen_calendar_on_clear (Bool; optional): If True, the calendar will automatically open when cleared
• show_outside_days (Bool; optional): If True the calendar will display days that rollover into

the next month

• start_date (String; optional): Specifies the starting date for the component.

Accepts datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• start_date_id (String; optional): The HTML element ID of the start date input field.

Not used by Dash, only by CSS.

• start_date_placeholder_text (String; optional): Text that will be displayed in the first input

box of the date picker when no date is selected. Default value is 'Start Date'

• stay_open_on_select (Bool; optional): If True the calendar will not close when the user has selected a value

and will wait until the user clicks off the calendar

• style (Dict; optional): CSS styles appended to wrapper div
• updatemode ('singledate', 'bothdates'; optional): Determines when the component should update

its value. If bothdates, then the DatePicker will only trigger its value when the user has finished picking both dates. If singledate, then the DatePicker will update its value as one date is picked.

• with_full_screen_portal (Bool; optional): If True, calendar will open in a full screen overlay portal, will

take precedent over 'withPortal' if both are set to true, not supported on vertical calendar

• with_portal (Bool; optional): If True, calendar will open in a screen overlay portal,

not supported on vertical calendar

dcc_datepickersingle(;kwargs...)

A DatePickerSingle component DatePickerSingle is a tailor made component designed for selecting a single day off of a calendar.

The DatePicker integrates well with the Python datetime module with the startDate and endDate being returned in a string format suitable for creating datetime objects.

This component is based off of Airbnb's react-dates react component which can be found here: https://github.com/airbnb/react-dates

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• calendar_orientation ('vertical', 'horizontal'; optional): Orientation of calendar, either vertical or horizontal.

Valid options are 'vertical' or 'horizontal'.

• className (String; optional): Appends a CSS class to the wrapper div component.
• clearable (Bool; optional): Whether or not the dropdown is "clearable", that is, whether or

not a small "x" appears on the right of the dropdown that removes the selected value.

• date (String; optional): Specifies the starting date for the component, best practice is to pass

value via datetime object

• day_size (optional): Size of rendered calendar days, higher number

means bigger day size and larger calendar overall

• disabled (Bool; optional): If True, no dates can be selected.
• disabled_days (Array of Strings; optional): Specifies additional days between mindateallowed and maxdateallowed

that should be disabled. Accepted datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• display_format (String; optional): Specifies the format that the selected dates will be displayed

valid formats are variations of "MM YY DD". For example: "MM YY DD" renders as '05 10 97' for May 10th 1997 "MMMM, YY" renders as 'May, 1997' for May 10th 1997 "M, D, YYYY" renders as '07, 10, 1997' for September 10th 1997 "MMMM" renders as 'May' for May 10 1997

• first_day_of_week (0, 1, 2, 3, 4, 5, 6; optional): Specifies what day is the first day of the week, values must be

from [0, ..., 6] with 0 denoting Sunday and 6 denoting Saturday

• initial_visible_month (String; optional): Specifies the month that is initially presented when the user

opens the calendar. Accepts datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• is_RTL (Bool; optional): Determines whether the calendar and days operate

from left to right or from right to left

• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• max_date_allowed (String; optional): Specifies the highest selectable date for the component.

Accepts datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• min_date_allowed (String; optional): Specifies the lowest selectable date for the component.

Accepts datetime.datetime objects or strings in the format 'YYYY-MM-DD'

• month_format (String; optional): Specifies the format that the month will be displayed in the calendar,

valid formats are variations of "MM YY". For example: "MM YY" renders as '05 97' for May 1997 "MMMM, YYYY" renders as 'May, 1997' for May 1997 "MMM, YY" renders as 'Sep, 97' for September 1997

• number_of_months_shown (optional): Number of calendar months that are shown when calendar is opened
• persisted_props (Array of 'date's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only date is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a date that the user has changed while using the app will keep that change, as long as the new date also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• placeholder (String; optional): Text that will be displayed in the input

box of the date picker when no date is selected. Default value is 'Start Date'

• reopen_calendar_on_clear (Bool; optional): If True, the calendar will automatically open when cleared
• show_outside_days (Bool; optional): If True the calendar will display days that rollover into

the next month

• stay_open_on_select (Bool; optional): If True the calendar will not close when the user has selected a value

and will wait until the user clicks off the calendar

• style (Dict; optional): CSS styles appended to wrapper div
• with_full_screen_portal (Bool; optional): If True, calendar will open in a full screen overlay portal, will

take precedent over 'withPortal' if both are set to True, not supported on vertical calendar

• with_portal (Bool; optional): If True, calendar will open in a screen overlay portal,

not supported on vertical calendar

dcc_download(;kwargs...)

A Download component The Download component opens a download dialog when the data property changes.

• id (String; optional): The ID of this component, used to identify dash components in callbacks.
• base64 (Bool; optional): Default value for base64, used when not set as part of the data property.
• data (lists containing elements filename, content, base64, type - filename (String; required): Suggested filename in the download dialogue. - content (String; required): File content. - base64 (Bool; optional): Set to true, when data is base64 encoded. - type (String; optional): Blob type, usually a MIME-type.; optional): On change, a download is invoked.
• type (String; optional): Default value for type, used when not set as part of the data property.

dcc_dropdown(;kwargs...)

A Dropdown component Dropdown is an interactive dropdown element for selecting one or more items. The values and labels of the dropdown items are specified in the options property and the selected item(s) are specified with the value property.

Use a dropdown when you have many options (more than 5) or when you are constrained for space. Otherwise, you can use RadioItems or a Checklist, which have the benefit of showing the users all of the items at once.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): className of the dropdown element
• clearable (Bool; optional): Whether or not the dropdown is "clearable", that is, whether or

not a small "x" appears on the right of the dropdown that removes the selected value.

• disabled (Bool; optional): If true, this dropdown is disabled and the selection cannot be changed.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• maxHeight (optional): height of the options dropdown.
• multi (Bool; optional): If true, the user can select multiple values
• optionHeight (optional): height of each option. Can be increased when label lengths would wrap around
• options (optional):An array of options {label: [string|number], value: [string|number]},

an optional disabled field can be used for each option. options has the following type: Array of String | Bools | Dict | Array of lists containing elements label, value, disabled, title, search - label (a list of or a singular dash component, string or number; required): The option's label - value (String | Bool; required): The value of the option. This value corresponds to the items specified in the value property. - disabled (Bool; optional): If true, this option is disabled and cannot be selected. - title (String; optional): The HTML 'title' attribute for the option. Allows for information on hover. For more information on this attribute, see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/title - search (String; optional): Optional search value for the option, to use if the label is a component or provide a custom search value different from the label. If no search value and the label is a component, the value will be used for search.s

• persisted_props (Array of 'value's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only value is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a value that the user has changed while using the app will keep that change, as long as the new value also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• placeholder (String; optional): The grey, default text shown when no option is selected
• search_value (String; optional): The value typed in the DropDown for searching.
• searchable (Bool; optional): Whether to enable the searching feature or not
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• value (String | Bool | Array of String | Bools; optional): The value of the input. If multi is false (the default)

then value is just a string that corresponds to the values provided in the options property. If multi is true, then multiple values can be selected at once, and value is an array of items with values corresponding to those in the options prop.

dcc_geolocation(;kwargs...)

A Geolocation component The CurrentLocation component gets geolocation of the device from the web browser. See more info here: https://developer.mozilla.org/en-US/docs/Web/API/Geolocation_API

• id (String; optional): The ID used to identify this component in Dash callbacks.
• high_accuracy (Bool; optional): If true and if the device is able to provide a more accurate position,

it will do so. Note that this can result in slower response times or increased power consumption (with a GPS chip on a mobile device for example). If false (the default value), the device can save resources by responding more quickly and/or using less power.

• local_date (String; optional): The local date and time when the device position was updated.

Format: MM/DD/YYYY, hh:mm:ss p where p is AM or PM

• maximum_age (optional): The maximum age in milliseconds of a possible cached position that is acceptable to return. If set to 0,

it means that the device cannot use a cached position and must attempt to retrieve the real current position. If set to Infinity the device must return a cached position regardless of its age. Default: 0.

• position (lists containing elements lat, lon, accuracy, alt, altaccuracy, heading, speed - lat (optional) - lon (optional) - accuracy (optional) - alt (optional) - `altaccuracy(optional) -heading(optional) -speed(optional); optional): The position of the device.lat,lon, andaccuracy` will always be returned. The other data will be included

when available, otherwise it will be NaN.

  `lat` is latitude in degrees.
  `lon` is longitude in degrees.
  `accuracy` is the accuracy of the lat/lon in meters.    *

  `alt` is altitude above mean sea level in meters.
  `alt_accuracy` is the accuracy of the altitude  in meters.
  `heading` is the compass heading in degrees.
  `speed` is the  speed in meters per second.

• position_error (lists containing elements code, message - code (optional) - message (String; optional); optional): Position error
• show_alert (Bool; optional): If true, error messages will be displayed as an alert
• timeout (optional): The maximum length of time (in milliseconds) the device is allowed to take in order to return a position.

The default value is Infinity, meaning that data will not be return until the position is available.

• timestamp (optional): The Unix timestamp from when the position was updated
• update_now (Bool; optional): Forces a one-time update of the position data. If set to True in a callback, the browser will update the position data and reset update_now back to False. This can, for example, be used to update the

position with a button or an interval timer.

dcc_graph(;kwargs...)

A Graph component Graph can be used to render any plotly.js-powered data visualization.

You can define callbacks based on user interaction with Graphs such as hovering, clicking or selecting

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• animate (Bool; optional): Beta: If true, animate between updates using

plotly.js's animate function

• animation_options (Dict; optional): Beta: Object containing animation settings.

Only applies if animate is true

• className (String; optional): className of the parent div
• clear_on_unhover (Bool; optional): If True, clear_on_unhover will clear the hoverData property

when the user "unhovers" from a point. If False, then the hoverData property will be equal to the data from the last point that was hovered over.

• clickAnnotationData (Dict; optional): Data from latest click annotation event. Read-only.
• clickData (Dict; optional): Data from latest click event. Read-only.
• config (optional):Plotly.js config options.

See https://plotly.com/javascript/configuration-options/ for more info.. config has the following type: lists containing elements staticPlot, plotlyServerURL, editable, editSelection, edits, autosizable, responsive, queueLength, fillFrame, frameMargins, scrollZoom, doubleClick, doubleClickDelay, showTips, showAxisDragHandles, showAxisRangeEntryBoxes, showLink, sendData, linkText, displayModeBar, showSendToCloud, showEditInChartStudio, modeBarButtonsToRemove, modeBarButtonsToAdd, modeBarButtons, toImageButtonOptions, displaylogo, watermark, plotGlPixelRatio, topojsonURL, mapboxAccessToken, locale, locales - staticPlot (Bool; optional): No interactivity, for export or image generation - plotlyServerURL (String; optional): Base URL for a Plotly cloud instance, if showSendToCloud is enabled - editable (Bool; optional): We can edit titles, move annotations, etc - sets all pieces of edits unless a separate edits config item overrides individual parts - editSelection (Bool; optional): Enables moving selections - edits (optional):A set of editable properties. edits has the following type: lists containing elements annotationPosition, annotationTail, annotationText, axisTitleText, colorbarPosition, colorbarTitleText, legendPosition, legendText, shapePosition, titleText - annotationPosition (Bool; optional): The main anchor of the annotation, which is the text (if no arrow) or the arrow (which drags the whole thing leaving the arrow length & direction unchanged) - annotationTail (Bool; optional): Just for annotations with arrows, change the length and direction of the arrow - annotationText (Bool; optional) - axisTitleText (Bool; optional) - colorbarPosition (Bool; optional) - colorbarTitleText (Bool; optional) - legendPosition (Bool; optional) - legendText (Bool; optional): Edit the trace name fields from the legend - shapePosition (Bool; optional) - titleText (Bool; optional): The global layout.title - autosizable (Bool; optional): DO autosize once regardless of layout.autosize (use default width or height values otherwise) - responsive (Bool; optional): Whether to change layout size when the window size changes - queueLength (optional): Set the length of the undo/redo queue - fillFrame (Bool; optional): If we DO autosize, do we fill the container or the screen? - frameMargins (optional): If we DO autosize, set the frame margins in percents of plot size - scrollZoom (Bool; optional): Mousewheel or two-finger scroll zooms the plot - doubleClick (false, 'reset', 'autosize', 'reset+autosize'; optional): Double click interaction (false, 'reset', 'autosize' or 'reset+autosize') - doubleClickDelay (optional): Delay for registering a double-click event in ms. The minimum value is 100 and the maximum value is 1000. By default this is 300. - showTips (Bool; optional): New users see some hints about interactivity - showAxisDragHandles (Bool; optional): Enable axis pan/zoom drag handles - showAxisRangeEntryBoxes (Bool; optional): Enable direct range entry at the pan/zoom drag points (drag handles must be enabled above) - showLink (Bool; optional): Link to open this plot in plotly - sendData (Bool; optional): If we show a link, does it contain data or just link to a plotly file? - linkText (String; optional): Text appearing in the sendData link - displayModeBar (true, false, 'hover'; optional): Display the mode bar (true, false, or 'hover') - showSendToCloud (Bool; optional): Should we include a modebar button to send this data to a Plotly Cloud instance, linked by plotlyServerURL. By default this is false. - showEditInChartStudio (Bool; optional): Should we show a modebar button to send this data to a Plotly Chart Studio plot. If both this and showSendToCloud are selected, only showEditInChartStudio will be honored. By default this is false. - modeBarButtonsToRemove (Array; optional): Remove mode bar button by name. All modebar button names at https://github.com/plotly/plotly.js/blob/master/src/components/modebar/buttons.js Common names include: sendDataToCloud; (2D) zoom2d, pan2d, select2d, lasso2d, zoomIn2d, zoomOut2d, autoScale2d, resetScale2d; (Cartesian) hoverClosestCartesian, hoverCompareCartesian; (3D) zoom3d, pan3d, orbitRotation, tableRotation, handleDrag3d, resetCameraDefault3d, resetCameraLastSave3d, hoverClosest3d; (Geo) zoomInGeo, zoomOutGeo, resetGeo, hoverClosestGeo; hoverClosestGl2d, hoverClosestPie, toggleHover, resetViews. - modeBarButtonsToAdd (Array; optional): Add mode bar button using config objects - modeBarButtons (Bool | Real | String | Dict | Array; optional): Fully custom mode bar buttons as nested array, where the outer arrays represents button groups, and the inner arrays have buttons config objects or names of default buttons - toImageButtonOptions (optional):Modifications to how the toImage modebar button works. toImageButtonOptions has the following type: lists containing elements format, filename, width, height, scale - format ('jpeg', 'png', 'webp', 'svg'; optional): The file format to create - filename (String; optional): The name given to the downloaded file - width (optional): Width of the downloaded file, in px - height (optional): Height of the downloaded file, in px - scale (optional): Extra resolution to give the file after rendering it with the given width and height - displaylogo (Bool; optional): Add the plotly logo on the end of the mode bar - watermark (Bool; optional): Add the plotly logo even with no modebar - plotGlPixelRatio (optional): Increase the pixel ratio for Gl plot images - topojsonURL (String; optional): URL to topojson files used in geo charts - mapboxAccessToken (Bool | Real | String | Dict | Array; optional): Mapbox access token (required to plot mapbox trace types) If using an Mapbox Atlas server, set this option to '', so that plotly.js won't attempt to authenticate to the public Mapbox server. - locale (String; optional): The locale to use. Locales may be provided with the plot (locales below) or by loading them on the page, see: https://github.com/plotly/plotly.js/blob/master/dist/README.md#to-include-localization - locales (Dict; optional): Localization definitions, if you choose to provide them with the plot rather than registering them globally.

• extendData (Array | Dict; optional): Data that should be appended to existing traces. Has the form

[updateData, traceIndices, maxPoints], where updateData is an object containing the data to extend, traceIndices (optional) is an array of trace indices that should be extended, and maxPoints (optional) is either an integer defining the maximum number of points allowed or an object with key:value pairs matching updateData Reference the Plotly.extendTraces API for full usage: https://plotly.com/javascript/plotlyjs-function-reference/#plotlyextendtraces

• figure (lists containing elements data, layout, frames - data (Array of Dicts; optional) - layout (Dict; optional) - frames (Array of Dicts; optional); optional): Plotly figure object. See schema:

https://plotly.com/javascript/reference

config is set separately by the config property

• hoverData (Dict; optional): Data from latest hover event. Read-only.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• mathjax (Bool; optional): If true, loads mathjax v3 (tex-svg) into the page and use it in the graph
• prependData (Array | Dict; optional): Data that should be prepended to existing traces. Has the form

[updateData, traceIndices, maxPoints], where updateData is an object containing the data to prepend, traceIndices (optional) is an array of trace indices that should be prepended, and maxPoints (optional) is either an integer defining the maximum number of points allowed or an object with key:value pairs matching updateData Reference the Plotly.prependTraces API for full usage: https://plotly.com/javascript/plotlyjs-function-reference/#plotlyprependtraces

• relayoutData (Dict; optional): Data from latest relayout event which occurs

when the user zooms or pans on the plot or other layout-level edits. Has the form {<attr string>: <value>} describing the changes made. Read-only.

• responsive (true, false, 'auto'; optional): If True, the Plotly.js plot will be fully responsive to window resize

and parent element resize event. This is achieved by overriding config.responsive to True, figure.layout.autosize to True and unsetting figure.layout.height and figure.layout.width. If False, the Plotly.js plot not be responsive to window resize and parent element resize event. This is achieved by overriding config.responsive to False and figure.layout.autosize to False. If 'auto' (default), the Graph will determine if the Plotly.js plot can be made fully responsive (True) or not (False) based on the values in config.responsive, figure.layout.autosize, figure.layout.height, figure.layout.width. This is the legacy behavior of the Graph component.

Needs to be combined with appropriate dimension / styling through the style prop to fully take effect.

• restyleData (Array; optional): Data from latest restyle event which occurs

when the user toggles a legend item, changes parcoords selections, or other trace-level edits. Has the form [edits, indices], where edits is an object {<attr string>: <value>} describing the changes made, and indices is an array of trace indices that were edited. Read-only.

• selectedData (Dict; optional): Data from latest select event. Read-only.
• style (Dict; optional): Generic style overrides on the plot div

dcc_input(;kwargs...)

An Input component A basic HTML input control for entering text, numbers, or passwords.

Note that checkbox and radio types are supported through the Checklist and RadioItems component. Dates, times, and file uploads are also supported through separate components.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• autoComplete (String; optional): This attribute indicates whether the value of the control can be automatically completed by the browser.
• autoFocus ('autoFocus', 'autofocus', 'AUTOFOCUS' | Bool; optional): The element should be automatically focused after the page loaded.

autoFocus is an HTML boolean attribute - it is enabled by a boolean or 'autoFocus'. Alternative capitalizations autofocus & AUTOFOCUS are also acccepted.

• className (String; optional): The class of the input element
• debounce (Bool; optional): If true, changes to input will be sent back to the Dash server only on enter or when losing focus.

If it's false, it will sent the value back on every change.

• disabled ('disabled', 'DISABLED' | Bool; optional): If true, the input is disabled and can't be clicked on.

disabled is an HTML boolean attribute - it is enabled by a boolean or 'disabled'. Alternative capitalizations DISABLED

• inputMode ('verbatim', 'latin', 'latin-name', 'latin-prose', 'full-width-latin', 'kana', 'katakana', 'numeric', 'tel', 'email', 'url'; optional): Provides a hint to the browser as to the type of data that might be

entered by the user while editing the element or its contents.

• list (String; optional): Identifies a list of pre-defined options to suggest to the user.

The value must be the id of a <datalist> element in the same document. The browser displays only options that are valid values for this input element. This attribute is ignored when the type attribute's value is hidden, checkbox, radio, file, or a button type.

• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• max (String; optional): The maximum (numeric or date-time) value for this item, which must not be less than its minimum (min attribute) value.
• maxLength (String; optional): If the value of the type attribute is text, email, search, password, tel, or url, this attribute specifies the maximum number of characters (in UTF-16 code units) that the user can enter. For other control types, it is ignored. It can exceed the value of the size attribute. If it is not specified, the user can enter an unlimited number of characters. Specifying a negative number results in the default behavior (i.e. the user can enter an unlimited number of characters). The constraint is evaluated only when the value of the attribute has been changed.
• min (String; optional): The minimum (numeric or date-time) value for this item, which must not be greater than its maximum (max attribute) value.
• minLength (String; optional): If the value of the type attribute is text, email, search, password, tel, or url, this attribute specifies the minimum number of characters (in Unicode code points) that the user can enter. For other control types, it is ignored.
• multiple (Bool; optional): This Boolean attribute indicates whether the user can enter more than one value. This attribute applies when the type attribute is set to email or file, otherwise it is ignored.
• n_blur (optional): Number of times the input lost focus.
• n_blur_timestamp (optional): Last time the input lost focus.
• n_submit (optional): Number of times the Enter key was pressed while the input had focus.
• n_submit_timestamp (optional): Last time that Enter was pressed.
• name (String; optional): The name of the control, which is submitted with the form data.
• pattern (String; optional): A regular expression that the control's value is checked against. The pattern must match the entire value, not just some subset. Use the title attribute to describe the pattern to help the user. This attribute applies when the value of the type attribute is text, search, tel, url, email, or password, otherwise it is ignored. The regular expression language is the same as JavaScript RegExp algorithm, with the 'u' parameter that makes it treat the pattern as a sequence of unicode code points. The pattern is not surrounded by forward slashes.
• persisted_props (Array of 'value's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only value is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a value that the user has changed while using the app will keep that change, as long as the new value also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• placeholder (String; optional): A hint to the user of what can be entered in the control . The placeholder text must not contain carriage returns or line-feeds. Note: Do not use the placeholder attribute instead of a <label> element, their purposes are different. The <label> attribute describes the role of the form element (i.e. it indicates what kind of information is expected), and the placeholder attribute is a hint about the format that the content should take. There are cases in which the placeholder attribute is never displayed to the user, so the form must be understandable without it.
• readOnly (Bool | 'readOnly', 'readonly', 'READONLY'; optional): This attribute indicates that the user cannot modify the value of the control. The value of the attribute is irrelevant. If you need read-write access to the input value, do not add the "readonly" attribute. It is ignored if the value of the type attribute is hidden, range, color, checkbox, radio, file, or a button type (such as button or submit).

readOnly is an HTML boolean attribute - it is enabled by a boolean or 'readOnly'. Alternative capitalizations readonly & READONLY are also acccepted.

• required ('required', 'REQUIRED' | Bool; optional): This attribute specifies that the user must fill in a value before submitting a form. It cannot be used when the type attribute is hidden, image, or a button type (submit, reset, or button). The :optional and :required CSS pseudo-classes will be applied to the field as appropriate.

required is an HTML boolean attribute - it is enabled by a boolean or 'required'. Alternative capitalizations REQUIRED are also acccepted.

• selectionDirection (String; optional): The direction in which selection occurred. This is "forward" if the selection was made from left-to-right in an LTR locale or right-to-left in an RTL locale, or "backward" if the selection was made in the opposite direction. On platforms on which it's possible this value isn't known, the value can be "none"; for example, on macOS, the default direction is "none", then as the user begins to modify the selection using the keyboard, this will change to reflect the direction in which the selection is expanding.
• selectionEnd (String; optional): The offset into the element's text content of the last selected character. If there's no selection, this value indicates the offset to the character following the current text input cursor position (that is, the position the next character typed would occupy).
• selectionStart (String; optional): The offset into the element's text content of the first selected character. If there's no selection, this value indicates the offset to the character following the current text input cursor position (that is, the position the next character typed would occupy).
• size (String; optional): The initial size of the control. This value is in pixels unless the value of the type attribute is text or password, in which case it is an integer number of characters. Starting in, this attribute applies only when the type attribute is set to text, search, tel, url, email, or password, otherwise it is ignored. In addition, the size must be greater than zero. If you do not specify a size, a default value of 20 is used.' simply states "the user agent should ensure that at least that many characters are visible", but different characters can have different widths in certain fonts. In some browsers, a certain string with x characters will not be entirely visible even if size is defined to at least x.
• spellCheck ('true', 'false' | Bool; optional): Setting the value of this attribute to true indicates that the element needs to have its spelling and grammar checked. The value default indicates that the element is to act according to a default behavior, possibly based on the parent element's own spellcheck value. The value false indicates that the element should not be checked.
• step (String; optional): Works with the min and max attributes to limit the increments at which a numeric or date-time value can be set. It can be the string any or a positive floating point number. If this attribute is not set to any, the control accepts only values at multiples of the step value greater than the minimum.
• style (Dict; optional): The input's inline styles
• type ('text', 'number', 'password', 'email', 'range', 'search', 'tel', 'url', 'hidden'; optional): The type of control to render.
• value (String; optional): The value of the input

dcc_interval(;kwargs...)

An Interval component A component that repeatedly increments a counter n_intervals with a fixed time delay between each increment. Interval is good for triggering a component on a recurring basis. The time delay is set with the property "interval" in milliseconds.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• disabled (Bool; optional): If True, the counter will no longer update
• interval (optional): This component will increment the counter n_intervals every

interval milliseconds

• max_intervals (optional): Number of times the interval will be fired.

If -1, then the interval has no limit (the default) and if 0 then the interval stops running.

• n_intervals (optional): Number of times the interval has passed

dcc_link(;kwargs...)
dcc_link(children::Any, kwargs...)
dcc_link(children_maker::Function, kwargs...)

A Link component Link allows you to create a clickable link within a multi-page app.

For links with destinations outside the current app, html.A is a better component to use.

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): Often used with CSS to style elements with common properties.
• href (String; required): The URL of a linked resource.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• refresh (Bool; optional): Controls whether or not the page will refresh when the link is clicked
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• target (String; optional): Specifies where to open the link reference.
• title (String; optional): Adds the title attribute to your link, which can contain supplementary

information.

dcc_loading(;kwargs...)
dcc_loading(children::Any, kwargs...)
dcc_loading(children_maker::Function, kwargs...)

A Loading component A Loading component that wraps any other component and displays a spinner until the wrapped component has rendered.

• children (Array of a list of or a singular dash component, string or numbers | a list of or a singular dash component, string or number; optional): Array that holds components to render
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): Additional CSS class for the spinner root DOM node
• color (String; optional): Primary colour used for the loading spinners
• debug (Bool; optional): If true, the spinner will display the componentname and propname

while loading

• fullscreen (Bool; optional): Boolean that makes the spinner display full-screen
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• parent_className (String; optional): Additional CSS class for the outermost dcc.Loading parent div DOM node
• parent_style (Dict; optional): Additional CSS styling for the outermost dcc.Loading parent div DOM node
• style (Dict; optional): Additional CSS styling for the spinner root DOM node
• type ('graph', 'cube', 'circle', 'dot', 'default'; optional): Property that determines which spinner to show

one of 'graph', 'cube', 'circle', 'dot', or 'default'.

dcc_location(;kwargs...)

A Location component Update and track the current window.location object through the window.history state. Use in conjunction with the dash_core_components.Link component to make apps with multiple pages.

• id (String; required): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• hash (String; optional): hash in window.location - e.g., "#myhash"
• href (String; optional): href in window.location - e.g., "/my/full/pathname?myargument=1#myhash"
• pathname (String; optional): pathname in window.location - e.g., "/my/full/pathname"
• refresh ('callback-nav' | Bool; optional): Use True to navigate outside the Dash app or to manually refresh a page.

Use False if the same callback that updates the Location component is also updating the page content - typically used in multi-page apps that do not use Pages. Use 'callback-nav' if you are updating the URL in a callback, or a different callback will respond to the new Location with updated content. This is typical with multi-page apps that use Pages. This will allow for navigating to a new page without refreshing the page.

• search (String; optional): search in window.location - e.g., "?myargument=1"

dcc_logoutbutton(;kwargs...)

A LogoutButton component Logout button to submit a form post request to the logout_url prop. Usage is intended for dash-deployment-server authentication.

DDS usage:

dcc.LogoutButton(logout_url=os.getenv('DASH_LOGOUT_URL'))

Custom usage:

• Implement a login mechanism.
• Create a flask route with a post method handler.

@app.server.route('/logout', methods=['POST'])

• The logout route should perform what's necessary for the user to logout.
• If you store the session in a cookie, clear the cookie:

rep = flask.Response(); rep.set_cookie('session', '', expires=0)

• Create a logout button component and assign it the logout_url

dcc.LogoutButton(logout_url='/logout')

See https://dash.plotly.com/dash-core-components/logout_button for more documentation and examples.

• id (String; optional): Id of the button.
• className (String; optional): CSS class for the button.
• label (String; optional): Text of the button
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• logout_url (String; optional): Url to submit a post logout request.
• method (String; optional): Http method to submit the logout form.
• style (Dict; optional): Style of the button

dcc_markdown(;kwargs...)
dcc_markdown(children::Any, kwargs...)
dcc_markdown(children_maker::Function, kwargs...)

A Markdown component A component that renders Markdown text as specified by the GitHub Markdown spec. These component uses react-markdown under the hood.

• children (String | Array of Strings; optional): A markdown string (or array of strings) that adheres to the CommonMark spec
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): Class name of the container element
• dangerously_allow_html (Bool; optional): A boolean to control raw HTML escaping.

Setting HTML from code is risky because it's easy to inadvertently expose your users to a cross-site scripting (XSS) (https://en.wikipedia.org/wiki/Cross-site_scripting) attack.

• dedent (Bool; optional): Remove matching leading whitespace from all lines.

Lines that are empty, or contain only whitespace, are ignored. Both spaces and tab characters are removed, but only if they match; we will not convert tabs to spaces or vice versa.

• highlight_config (lists containing elements theme - theme ('dark', 'light'; optional): Color scheme; default 'light'; optional): Config options for syntax highlighting.
• link_target (String; optional): A string for the target attribute to use on links (such as "_blank")
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• mathjax (Bool; optional): If true, loads mathjax v3 (tex-svg) into the page and use it in the markdown
• style (Dict; optional): User-defined inline styles for the rendered Markdown

dcc_radioitems(;kwargs...)

A RadioItems component RadioItems is a component that encapsulates several radio item inputs. The values and labels of the RadioItems is specified in the options property and the seleced item is specified with the value property. Each radio item is rendered as an input with a surrounding label.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): The class of the container (div)
• inline (Bool; optional): Indicates whether the options labels should be displayed inline (true=horizontal)

or in a block (false=vertical).

• inputClassName (String; optional): The class of the <input> radio element
• inputStyle (Dict; optional): The style of the <input> radio element
• labelClassName (String; optional): The class of the <label> that wraps the radio input

and the option's label

• labelStyle (Dict; optional): The style of the <label> that wraps the radio input

and the option's label

• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• options (optional):An array of options, or inline dictionary of options. options has the following type: Array of String | Bools | Dict | Array of lists containing elements label, value, disabled, title - label (a list of or a singular dash component, string or number; required): The option's label - value (String | Bool; required): The value of the option. This value

corresponds to the items specified in the value property. - disabled (Bool; optional): If true, this option is disabled and cannot be selected. - title (String; optional): The HTML 'title' attribute for the option. Allows for information on hover. For more information on this attribute, see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/titles

• persisted_props (Array of 'value's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only value is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a value that the user has changed while using the app will keep that change, as long as the new value also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• style (Dict; optional): The style of the container (div)
• value (String | Bool; optional): The currently selected value

dcc_rangeslider(;kwargs...)

A RangeSlider component A double slider with two handles. Used for specifying a range of numerical values.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• allowCross (Bool; optional): allowCross could be set as true to allow those handles to cross.
• className (String; optional): Additional CSS class for the root DOM node
• count (optional): Determine how many ranges to render, and multiple handles

will be rendered (number + 1).

• disabled (Bool; optional): If true, the handles can't be moved.
• dots (Bool; optional): When the step value is greater than 1,

you can set the dots to true if you want to render the slider with dots.

• drag_value (Array of s; optional): The value of the input during a drag
• included (Bool; optional): If the value is true, it means a continuous

value is included. Otherwise, it is an independent value.

• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• marks (Dict with Strings as keys and values of type String | lists containing elements label, style - label (String; optional) - style (Dict; optional); optional): Marks on the slider.

The key determines the position (a number), and the value determines what will show. If you want to set the style of a specific mark point, the value should be an object which contains style and label properties.

• max (optional): Maximum allowed value of the slider
• min (optional): Minimum allowed value of the slider
• persisted_props (Array of 'value's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only value is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a value that the user has changed while using the app will keep that change, as long as the new value also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• pushable (Bool; optional): pushable could be set as true to allow pushing of

surrounding handles when moving an handle. When set to a number, the number will be the minimum ensured distance between handles.

• step (optional): Value by which increments or decrements are made
• tooltip (optional):Configuration for tooltips describing the current slider values. tooltip has the following type: lists containing elements alwaysvisible, placement - `alwaysvisible` (Bool; optional): Determines whether tooltips should always be visible

(as opposed to the default, visible on hover) - placement ('left', 'right', 'top', 'bottom', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight'; optional): Determines the placement of tooltips See https://github.com/react-component/tooltip#api top/bottom{*} sets the origin of the tooltip, so e.g. topLeft will in reality appear to be on the top right of the handle

• updatemode ('mouseup', 'drag'; optional): Determines when the component should update its value

property. If mouseup (the default) then the slider will only trigger its value when the user has finished dragging the slider. If drag, then the slider will update its value continuously as it is being dragged. Note that for the latter case, the drag_value property could be used instead.

• value (Array of s; optional): The value of the input
• vertical (Bool; optional): If true, the slider will be vertical
• verticalHeight (optional): The height, in px, of the slider if it is vertical.

dcc_send_bytes(src::AbstractVector{UInt8}, filename; type = nothing)
dcc_send_bytes(writer::Function, data, filename; type = nothing)

Convert vector of bytes into the format expected by the Download component. writer function must have signature (io::IO, data)

Examples

Sending binary content

file_data = read("path/to/file")
callback!(app, Output("download", "data"), Input("download-btn", "n_clicks"), prevent_initial_call = true) do n_clicks
    return dcc_send_bytes(file_data, "filename.fl")
end

Sending DataFrame in Arrow format

using DataFrames, Arrow
...
df = DataFrame(...)
callback!(app, Output("download", "data"), Input("download-btn", "n_clicks"), prevent_initial_call = true) do n_clicks
    return dcc_send_bytes(Arrow.write, df, "df.arr")
end

dbc_send_file(path::AbstractString, filename = nothing; type = nothing)

Convert a file into the format expected by the Download component.

Arguments

• path - path to the file to be sent
• filename - name of the file, if not provided the original filename is used
• type - type of the file (optional, passed to Blob in the javascript layer)

dcc_send_data(src::AbstractString, filename; type = nothing)
dcc_send_data(writer::Function, data, filename; type = nothing)

Convert string into the format expected by the Download component. writer function must have signature (io::IO, data)

Examples

Sending string content

text_data = "this is the test"
callback!(app, Output("download", "data"), Input("download-btn", "n_clicks"), prevent_initial_call = true) do n_clicks
    return dcc_send_string(text_data, "text.txt")
end

Sending DataFrame in CSV format

using DataFrames, CSV
...
df = DataFrame(...)
callback!(app, Output("download", "data"), Input("download-btn", "n_clicks"), prevent_initial_call = true) do n_clicks
    return dcc_send_string(CSV.write, df, "df.csv")
end

dcc_slider(;kwargs...)

A Slider component A slider component with a single handle.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): Additional CSS class for the root DOM node
• disabled (Bool; optional): If true, the handles can't be moved.
• dots (Bool; optional): When the step value is greater than 1,

you can set the dots to true if you want to render the slider with dots.

• drag_value (optional): The value of the input during a drag
• included (Bool; optional): If the value is true, it means a continuous

value is included. Otherwise, it is an independent value.

• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• marks (Dict with Strings as keys and values of type String | lists containing elements label, style - label (String; optional) - style (Dict; optional); optional): Marks on the slider.

The key determines the position (a number), and the value determines what will show. If you want to set the style of a specific mark point, the value should be an object which contains style and label properties.

• max (optional): Maximum allowed value of the slider
• min (optional): Minimum allowed value of the slider
• persisted_props (Array of 'value's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only value is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a value that the user has changed while using the app will keep that change, as long as the new value also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• step (optional): Value by which increments or decrements are made
• tooltip (optional):Configuration for tooltips describing the current slider value. tooltip has the following type: lists containing elements alwaysvisible, placement - `alwaysvisible` (Bool; optional): Determines whether tooltips should always be visible

(as opposed to the default, visible on hover) - placement ('left', 'right', 'top', 'bottom', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight'; optional): Determines the placement of tooltips See https://github.com/react-component/tooltip#api top/bottom{*} sets the origin of the tooltip, so e.g. topLeft will in reality appear to be on the top right of the handle

• updatemode ('mouseup', 'drag'; optional): Determines when the component should update its value

property. If mouseup (the default) then the slider will only trigger its value when the user has finished dragging the slider. If drag, then the slider will update its value continuously as it is being dragged. If you want different actions during and after drag, leave updatemode as mouseup and use drag_value for the continuously updating value.

• value (optional): The value of the input
• vertical (Bool; optional): If true, the slider will be vertical
• verticalHeight (optional): The height, in px, of the slider if it is vertical.

dcc_store(;kwargs...)

A Store component Easily keep data on the client side with this component. The data is not inserted in the DOM. Data can be in memory, localStorage or sessionStorage. The data will be kept with the id as key.

• id (String; required): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• clear_data (Bool; optional): Set to true to remove the data contained in data_key.
• data (Dict | Array | String | Bool; optional): The stored data for the id.
• modified_timestamp (optional): The last time the storage was modified.
• storage_type ('local', 'session', 'memory'; optional): The type of the web storage.

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

dcc_tab(;kwargs...)
dcc_tab(children::Any, kwargs...)
dcc_tab(children_maker::Function, kwargs...)

A Tab component Part of dcc.Tabs - this is the child Tab component used to render a tabbed page. Its children will be set as the content of that tab, which if clicked will become visible.

• children (a list of or a singular dash component, string or number; optional): The content of the tab - will only be displayed if this tab is selected
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): Appends a class to the Tab component.
• disabled (Bool; optional): Determines if tab is disabled or not - defaults to false
• disabled_className (String; optional): Appends a class to the Tab component when it is disabled.
• disabled_style (Dict; optional): Overrides the default (inline) styles when disabled
• label (String; optional): The tab's label
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• selected_className (String; optional): Appends a class to the Tab component when it is selected.
• selected_style (Dict; optional): Overrides the default (inline) styles for the Tab component when it is selected.
• style (Dict; optional): Overrides the default (inline) styles for the Tab component.
• value (String; optional): Value for determining which Tab is currently selected

dcc_tabs(;kwargs...)
dcc_tabs(children::Any, kwargs...)
dcc_tabs(children_maker::Function, kwargs...)

A Tabs component A Dash component that lets you render pages with tabs - the Tabs component's children can be dcc.Tab components, which can hold a label that will be displayed as a tab, and can in turn hold children components that will be that tab's content.

• children (Array of a list of or a singular dash component, string or numbers | a list of or a singular dash component, string or number; optional): Array that holds Tab components
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• className (String; optional): Appends a class to the Tabs container holding the individual Tab components.
• colors (lists containing elements border, primary, background - border (String; optional) - primary (String; optional) - background (String; optional); optional): Holds the colors used by the Tabs and Tab components. If you set these, you should specify colors for all properties, so:

colors: { border: '#d6d6d6', primary: '#1975FA', background: '#f9f9f9' }

• content_className (String; optional): Appends a class to the Tab content container holding the children of the Tab that is selected.
• content_style (Dict; optional): Appends (inline) styles to the tab content container holding the children of the Tab that is selected.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• mobile_breakpoint (optional): Breakpoint at which tabs are rendered full width (can be 0 if you don't want full width tabs on mobile)
• parent_className (String; optional): Appends a class to the top-level parent container holding both the Tabs container and the content container.
• parent_style (Dict; optional): Appends (inline) styles to the top-level parent container holding both the Tabs container and the content container.
• persisted_props (Array of 'value's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only value is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a value that the user has changed while using the app will keep that change, as long as the new value also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• style (Dict; optional): Appends (inline) styles to the Tabs container holding the individual Tab components.
• value (String; optional): The value of the currently selected Tab
• vertical (Bool; optional): Renders the tabs vertically (on the side)

dcc_textarea(;kwargs...)

A Textarea component A basic HTML textarea for entering multiline text.

• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Defines a keyboard shortcut to activate or add focus to the element.
• autoFocus (String; optional): The element should be automatically focused after the page loaded.
• className (String; optional): Often used with CSS to style elements with common properties.
• cols (String; optional): Defines the number of columns in a textarea.
• contentEditable (String | Bool; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disabled (String | Bool; optional): Indicates whether the user can interact with the element.
• draggable ('true', 'false' | Bool; optional): Defines whether the element can be dragged.
• form (String; optional): Indicates the form that is the owner of the element.
• hidden (String; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• maxLength (String; optional): Defines the maximum number of characters allowed in the element.
• minLength (String; optional): Defines the minimum number of characters allowed in the element.
• n_blur (optional): Number of times the textarea lost focus.
• n_blur_timestamp (optional): Last time the textarea lost focus.
• n_clicks (optional): Number of times the textarea has been clicked.
• n_clicks_timestamp (optional): Last time the textarea was clicked.
• name (String; optional): Name of the element. For example used by the server to identify the fields in form submits.
• persisted_props (Array of 'value's; optional): Properties whose user interactions will persist after refreshing the

component or the page. Since only value is allowed this prop can normally be ignored.

• persistence (Bool | String; optional): Used to allow user interactions in this component to be persisted when

the component - or the page - is refreshed. If persisted is truthy and hasn't changed from its previous value, a value that the user has changed while using the app will keep that change, as long as the new value also matches what was given originally. Used in conjunction with persistence_type.

• persistence_type ('local', 'session', 'memory'; optional): Where persisted user changes will be stored:

memory: only kept in memory, reset on page refresh. local: window.localStorage, data is kept after the browser quit. session: window.sessionStorage, data is cleared once the browser quit.

• placeholder (String; optional): Provides a hint to the user of what can be entered in the field.
• readOnly (Bool | 'readOnly', 'readonly', 'READONLY'; optional): Indicates whether the element can be edited.

readOnly is an HTML boolean attribute - it is enabled by a boolean or 'readOnly'. Alternative capitalizations readonly & READONLY are also acccepted.

• required ('required', 'REQUIRED' | Bool; optional): Indicates whether this element is required to fill out or not.

required is an HTML boolean attribute - it is enabled by a boolean or 'required'. Alternative capitalizations REQUIRED are also acccepted.

• rows (String; optional): Defines the number of rows in a text area.
• spellCheck ('true', 'false' | Bool; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• value (String; optional): The value of the textarea
• wrap (String; optional): Indicates whether the text should be wrapped.

dcc_tooltip(;kwargs...)
dcc_tooltip(children::Any, kwargs...)
dcc_tooltip(children_maker::Function, kwargs...)

A Tooltip component A tooltip with an absolute position.

• children (a list of or a singular dash component, string or number; optional): The contents of the tooltip
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• background_color (String; optional): Color of the tooltip background, as a CSS color string.
• bbox (lists containing elements x0, y0, x1, y1 - x0 (optional) - y0 (optional) - x1 (optional) - y1 (optional); optional): The bounding box coordinates of the item to label, in px relative to

the positioning parent of the Tooltip component.

• border_color (String; optional): Color of the tooltip border, as a CSS color string.
• className (String; optional): The class of the tooltip
• direction ('top', 'right', 'bottom', 'left'; optional): The side of the bbox on which the tooltip should open.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• loading_text (String; optional): The text displayed in the tooltip while loading
• show (Bool; optional): Whether to show the tooltip
• style (Dict; optional): The style of the tooltip
• targetable (Bool; optional): Whether the tooltip itself can be targeted by pointer events.

For tooltips triggered by hover events, typically this should be left false to avoid the tooltip interfering with those same events.

• zindex (optional): The z-index CSS property to assign to the tooltip. Components with

higher values will be displayed on top of components with lower values.

dcc_upload(;kwargs...)
dcc_upload(children::Any, kwargs...)
dcc_upload(children_maker::Function, kwargs...)

An Upload component Upload components allow your app to accept user-uploaded files via drag'n'drop

• children (a list of or a singular dash component, string or number | String; optional): Contents of the upload component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accept (String; optional): Allow specific types of files.

See https://github.com/okonet/attr-accept for more information. Keep in mind that mime type determination is not reliable across platforms. CSV files, for example, are reported as text/plain under macOS but as application/vnd.ms-excel under Windows. In some cases there might not be a mime type set at all. See: https://github.com/react-dropzone/react-dropzone/issues/276

• className (String; optional): HTML class name of the component
• className_active (String; optional): HTML class name of the component while active
• className_disabled (String; optional): HTML class name of the component if disabled
• className_reject (String; optional): HTML class name of the component if rejected
• contents (String | Array of Strings; optional): The contents of the uploaded file as a binary string
• disable_click (Bool; optional): Disallow clicking on the component to open the file dialog
• disabled (Bool; optional): Enable/disable the upload component entirely
• filename (String | Array of Strings; optional): The name of the file(s) that was(were) uploaded.

Note that this does not include the path of the file (for security reasons).

• last_modified (Array of s; optional): The last modified date of the file that was uploaded in unix time

(seconds since 1970).

• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• max_size (optional): Maximum file size in bytes. If -1, then infinite
• min_size (optional): Minimum file size in bytes
• multiple (Bool; optional): Allow dropping multiple files
• style (Dict; optional): CSS styles to apply
• style_active (Dict; optional): CSS styles to apply while active
• style_disabled (Dict; optional): CSS styles if disabled
• style_reject (Dict; optional): CSS styles if rejected

Activate the dev tools, called by run_server.

If a parameter can be set by an environment variable, that is listed as: env: DASH_**** 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

Arguments

• debug::Bool - 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$.

• dev_tools_ui::Bool - Show the dev tools UI. env: $DASH_UI$

• dev_tools_props_check::Bool - Validate the types and values of Dash component props. env: $DASH_PROPS_CHECK$

• dev_tools_serve_dev_bundles::Bool - Serve the dev bundles. Production bundles do not necessarily include all the dev tools code. env: $DASH_SERVE_DEV_BUNDLES$

• dev_tools_hot_reload::Bool - Activate hot reloading when app, assets, and component files change. env: $DASH_HOT_RELOAD$

• dev_tools_hot_reload_interval::Float64 - Interval in seconds for the client to request the reload hash. Default 3. env: $DASH_HOT_RELOAD_INTERVAL$

• dev_tools_hot_reload_watch_interval::Float64 - Interval in seconds for the server to check asset and component folders for changes. Default 0.5. env: $DASH_HOT_RELOAD_WATCH_INTERVAL$

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

html_a(;kwargs...)
html_a(children::Any, kwargs...)
html_a(children_maker::Function, kwargs...)

An A component A is a wrapper for the <a> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• download (String; optional): Indicates that the hyperlink is to be used for downloading a resource.
• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• href (String; optional): The URL of a linked resource.
• hrefLang (String; optional): Specifies the language of the linked resource.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• media (String; optional): Specifies a hint of the media for which the linked resource was designed.
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• referrerPolicy (String; optional): Specifies which referrer is sent when fetching the resource.
• rel (String; optional): Specifies the relationship of the target object to the link object.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• shape (String; optional)
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• target (String; optional): Specifies where to open the linked document (in the case of an <a> element) or where to display the response received (in the case of a <form> element)
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_abbr(;kwargs...)
html_abbr(children::Any, kwargs...)
html_abbr(children_maker::Function, kwargs...)

An Abbr component Abbr is a wrapper for the <abbr> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/abbr

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_acronym(;kwargs...)
html_acronym(children::Any, kwargs...)
html_acronym(children_maker::Function, kwargs...)

An Acronym component Acronym is a wrapper for the <acronym> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/acronym

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_address(;kwargs...)
html_address(children::Any, kwargs...)
html_address(children_maker::Function, kwargs...)

An Address component Address is a wrapper for the <address> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/address

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_area(;kwargs...)
html_area(children::Any, kwargs...)
html_area(children_maker::Function, kwargs...)

An Area component Area is a wrapper for the <area> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/area

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• alt (String; optional): Alternative text in case an image can't be displayed.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• coords (String; optional): A set of values specifying the coordinates of the hot-spot region.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• download (String; optional): Indicates that the hyperlink is to be used for downloading a resource.
• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• href (String; optional): The URL of a linked resource.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• media (String; optional): Specifies a hint of the media for which the linked resource was designed.
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• referrerPolicy (String; optional): Specifies which referrer is sent when fetching the resource.
• rel (String; optional): Specifies the relationship of the target object to the link object.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• shape (String; optional)
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• target (String; optional): Specifies where to open the linked document (in the case of an <a> element) or where to display the response received (in the case of a <form> element)
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_article(;kwargs...)
html_article(children::Any, kwargs...)
html_article(children_maker::Function, kwargs...)

An Article component Article is a wrapper for the <article> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/article

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_aside(;kwargs...)
html_aside(children::Any, kwargs...)
html_aside(children_maker::Function, kwargs...)

An Aside component Aside is a wrapper for the <aside> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/aside

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_audio(;kwargs...)
html_audio(children::Any, kwargs...)
html_audio(children_maker::Function, kwargs...)

An Audio component Audio is a wrapper for the <audio> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/audio

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• autoPlay ('autoPlay', 'autoplay', 'AUTOPLAY' | Bool; optional): The audio or video should play as soon as possible.
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• controls ('controls', 'CONTROLS' | Bool; optional): Indicates whether the browser should show playback controls to the user.
• crossOrigin (String; optional): How the element handles cross-origin requests
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• loop ('loop', 'LOOP' | Bool; optional): Indicates whether the media should start playing from the start when it's finished.
• muted ('muted', 'MUTED' | Bool; optional): Indicates whether the audio will be initially silenced on page load.
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• preload (String; optional): Indicates whether the whole resource, parts of it or nothing should be preloaded.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• src (String; optional): The URL of the embeddable content.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_b(;kwargs...)
html_b(children::Any, kwargs...)
html_b(children_maker::Function, kwargs...)

A B component B is a wrapper for the <b> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/b

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_base(;kwargs...)
html_base(children::Any, kwargs...)
html_base(children_maker::Function, kwargs...)

A Base component Base is a wrapper for the <base> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• href (String; optional): The URL of a linked resource.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• target (String; optional): Specifies where to open the linked document (in the case of an <a> element) or where to display the response received (in the case of a <form> element)
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_basefont(;kwargs...)
html_basefont(children::Any, kwargs...)
html_basefont(children_maker::Function, kwargs...)

A Basefont component Basefont is a wrapper for the <basefont> HTML5 element.

OBSOLETE: <basefont> is included for completeness, but should be avoided as it is only supported by Internet Explorer.

For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/basefont

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_bdi(;kwargs...)
html_bdi(children::Any, kwargs...)
html_bdi(children_maker::Function, kwargs...)

A Bdi component Bdi is a wrapper for the <bdi> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdi

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_bdo(;kwargs...)
html_bdo(children::Any, kwargs...)
html_bdo(children_maker::Function, kwargs...)

A Bdo component Bdo is a wrapper for the <bdo> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdo

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_big(;kwargs...)
html_big(children::Any, kwargs...)
html_big(children_maker::Function, kwargs...)

A Big component Big is a wrapper for the <big> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/big

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_blink(;kwargs...)
html_blink(children::Any, kwargs...)
html_blink(children_maker::Function, kwargs...)

A Blink component Blink is a wrapper for the <blink> HTML5 element.

OBSOLETE: <blink> is included for completeness, but should be avoided as it is not supported by any modern browsers.

For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/blink

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_blockquote(;kwargs...)
html_blockquote(children::Any, kwargs...)
html_blockquote(children_maker::Function, kwargs...)

A Blockquote component Blockquote is a wrapper for the <blockquote> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/blockquote

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• cite (String; optional): Contains a URI which points to the source of the quote or change.
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_br(;kwargs...)
html_br(children::Any, kwargs...)
html_br(children_maker::Function, kwargs...)

A Br component Br is a wrapper for the <br> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/br

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_button(;kwargs...)
html_button(children::Any, kwargs...)
html_button(children_maker::Function, kwargs...)

A Button component Button is a wrapper for the <button> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• autoFocus ('autoFocus', 'autofocus', 'AUTOFOCUS' | Bool; optional): The element should be automatically focused after the page loaded.
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• disabled ('disabled', 'DISABLED' | Bool; optional): Indicates whether the user can interact with the element.
• draggable (String; optional): Defines whether the element can be dragged.
• form (String; optional): Indicates the form that is the owner of the element.
• formAction (String; optional): Indicates the action of the element, overriding the action defined in the <form>.
• formEncType (String; optional): If the button/input is a submit button (e.g. type="submit"), this attribute sets the encoding type to use during form submission. If this attribute is specified, it overrides the enctype attribute of the button's form owner.
• formMethod (String; optional): If the button/input is a submit button (e.g. type="submit"), this attribute sets the submission method to use during form submission (GET, POST, etc.). If this attribute is specified, it overrides the method attribute of the button's form owner.
• formNoValidate ('formNoValidate', 'formnovalidate', 'FORMNOVALIDATE' | Bool; optional): If the button/input is a submit button (e.g. type="submit"), this boolean attribute specifies that the form is not to be validated when it is submitted. If this attribute is specified, it overrides the novalidate attribute of the button's form owner.
• formTarget (String; optional): If the button/input is a submit button (e.g. type="submit"), this attribute specifies the browsing context (for example, tab, window, or inline frame) in which to display the response that is received after submitting the form. If this attribute is specified, it overrides the target attribute of the button's form owner.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• name (String; optional): Name of the element. For example used by the server to identify the fields in form submits.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• type (String; optional): Defines the type of the element.
• value (String; optional): Defines a default value which will be displayed in the element on page load.

html_canvas(;kwargs...)
html_canvas(children::Any, kwargs...)
html_canvas(children_maker::Function, kwargs...)

A Canvas component Canvas is a wrapper for the <canvas> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• height (String; optional): Specifies the height of elements listed here. For all other elements, use the CSS height property. Note: In some instances, such as <div>, this is a legacy attribute, in which case the CSS height property should be used instead.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• width (String; optional): For the elements listed here, this establishes the element's width. Note: For all other instances, such as <div>, this is a legacy attribute, in which case the CSS width property should be used instead.

html_caption(;kwargs...)
html_caption(children::Any, kwargs...)
html_caption(children_maker::Function, kwargs...)

A Caption component Caption is a wrapper for the <caption> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/caption

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_center(;kwargs...)
html_center(children::Any, kwargs...)
html_center(children_maker::Function, kwargs...)

A Center component Center is a wrapper for the <center> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/center

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_cite(;kwargs...)
html_cite(children::Any, kwargs...)
html_cite(children_maker::Function, kwargs...)

A Cite component Cite is a wrapper for the <cite> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/cite

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_code(;kwargs...)
html_code(children::Any, kwargs...)
html_code(children_maker::Function, kwargs...)

A Code component Code is a wrapper for the <code> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/code

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_col(;kwargs...)
html_col(children::Any, kwargs...)
html_col(children_maker::Function, kwargs...)

A Col component Col is a wrapper for the <col> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/col

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• span (String; optional)
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_colgroup(;kwargs...)
html_colgroup(children::Any, kwargs...)
html_colgroup(children_maker::Function, kwargs...)

A Colgroup component Colgroup is a wrapper for the <colgroup> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/colgroup

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• span (String; optional)
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_content(;kwargs...)
html_content(children::Any, kwargs...)
html_content(children_maker::Function, kwargs...)

A Content component Content is a wrapper for the <content> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/content

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_data(;kwargs...)
html_data(children::Any, kwargs...)
html_data(children_maker::Function, kwargs...)

A Data component Data is a wrapper for the <data> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/data

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• value (String; optional): Defines a default value which will be displayed in the element on page load.

html_datalist(;kwargs...)
html_datalist(children::Any, kwargs...)
html_datalist(children_maker::Function, kwargs...)

A Datalist component Datalist is a wrapper for the <datalist> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/datalist

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_dd(;kwargs...)
html_dd(children::Any, kwargs...)
html_dd(children_maker::Function, kwargs...)

A Dd component Dd is a wrapper for the <dd> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dd

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_del(;kwargs...)
html_del(children::Any, kwargs...)
html_del(children_maker::Function, kwargs...)

A Del component Del is a wrapper for the <del> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/del

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• cite (String; optional): Contains a URI which points to the source of the quote or change.
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dateTime (String; optional): Indicates the date and time associated with the element.
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_details(;kwargs...)
html_details(children::Any, kwargs...)
html_details(children_maker::Function, kwargs...)

A Details component Details is a wrapper for the <details> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• open ('open', 'OPEN' | Bool; optional): Indicates whether the contents are currently visible (in the case of a <details> element) or whether the dialog is active and can be interacted with (in the case of a <dialog> element).
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_dfn(;kwargs...)
html_dfn(children::Any, kwargs...)
html_dfn(children_maker::Function, kwargs...)

A Dfn component Dfn is a wrapper for the <dfn> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dfn

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_dialog(;kwargs...)
html_dialog(children::Any, kwargs...)
html_dialog(children_maker::Function, kwargs...)

A Dialog component Dialog is a wrapper for the <dialog> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• open ('open', 'OPEN' | Bool; optional): Indicates whether the contents are currently visible (in the case of a <details> element) or whether the dialog is active and can be interacted with (in the case of a <dialog> element).
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_div(;kwargs...)
html_div(children::Any, kwargs...)
html_div(children_maker::Function, kwargs...)

A Div component Div is a wrapper for the <div> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/div

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_dl(;kwargs...)
html_dl(children::Any, kwargs...)
html_dl(children_maker::Function, kwargs...)

A Dl component Dl is a wrapper for the <dl> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dl

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_dt(;kwargs...)
html_dt(children::Any, kwargs...)
html_dt(children_maker::Function, kwargs...)

A Dt component Dt is a wrapper for the <dt> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dt

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_em(;kwargs...)
html_em(children::Any, kwargs...)
html_em(children_maker::Function, kwargs...)

An Em component Em is a wrapper for the <em> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/em

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_embed(;kwargs...)
html_embed(children::Any, kwargs...)
html_embed(children_maker::Function, kwargs...)

An Embed component Embed is a wrapper for the <embed> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/embed

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• height (String; optional): Specifies the height of elements listed here. For all other elements, use the CSS height property. Note: In some instances, such as <div>, this is a legacy attribute, in which case the CSS height property should be used instead.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• src (String; optional): The URL of the embeddable content.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• type (String; optional): Defines the type of the element.
• width (String; optional): For the elements listed here, this establishes the element's width. Note: For all other instances, such as <div>, this is a legacy attribute, in which case the CSS width property should be used instead.

html_fieldset(;kwargs...)
html_fieldset(children::Any, kwargs...)
html_fieldset(children_maker::Function, kwargs...)

A Fieldset component Fieldset is a wrapper for the <fieldset> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/fieldset

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• disabled ('disabled', 'DISABLED' | Bool; optional): Indicates whether the user can interact with the element.
• draggable (String; optional): Defines whether the element can be dragged.
• form (String; optional): Indicates the form that is the owner of the element.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• name (String; optional): Name of the element. For example used by the server to identify the fields in form submits.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_figcaption(;kwargs...)
html_figcaption(children::Any, kwargs...)
html_figcaption(children_maker::Function, kwargs...)

A Figcaption component Figcaption is a wrapper for the <figcaption> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/figcaption

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_figure(;kwargs...)
html_figure(children::Any, kwargs...)
html_figure(children_maker::Function, kwargs...)

A Figure component Figure is a wrapper for the <figure> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/figure

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_font(;kwargs...)
html_font(children::Any, kwargs...)
html_font(children_maker::Function, kwargs...)

A Font component Font is a wrapper for the <font> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/font

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_footer(;kwargs...)
html_footer(children::Any, kwargs...)
html_footer(children_maker::Function, kwargs...)

A Footer component Footer is a wrapper for the <footer> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/footer

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_form(;kwargs...)
html_form(children::Any, kwargs...)
html_form(children_maker::Function, kwargs...)

A Form component Form is a wrapper for the <form> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accept (String; optional): List of types the server accepts, typically a file type.
• acceptCharset (String; optional): List of supported charsets.
• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• action (String; optional): The URI of a program that processes the information submitted via the form.
• aria-* (String; optional): A wildcard aria attribute
• autoComplete (String; optional): Indicates whether controls in this form can by default have their values automatically completed by the browser.
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• encType (String; optional): Defines the content type of the form data when the method is POST.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• method (String; optional): Defines which HTTP method to use when submitting the form. Can be GET (default) or POST.
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• name (String; optional): Name of the element. For example used by the server to identify the fields in form submits.
• noValidate ('noValidate', 'novalidate', 'NOVALIDATE' | Bool; optional): This attribute indicates that the form shouldn't be validated when submitted.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• target (String; optional): Specifies where to open the linked document (in the case of an <a> element) or where to display the response received (in the case of a <form> element)
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_frame(;kwargs...)
html_frame(children::Any, kwargs...)
html_frame(children_maker::Function, kwargs...)

A Frame component Frame is a wrapper for the <frame> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/frame

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_frameset(;kwargs...)
html_frameset(children::Any, kwargs...)
html_frameset(children_maker::Function, kwargs...)

A Frameset component Frameset is a wrapper for the <frameset> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/frameset

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_h1(;kwargs...)
html_h1(children::Any, kwargs...)
html_h1(children_maker::Function, kwargs...)

A H1 component H1 is a wrapper for the <h1> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h1

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_h2(;kwargs...)
html_h2(children::Any, kwargs...)
html_h2(children_maker::Function, kwargs...)

A H2 component H2 is a wrapper for the <h2> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h2

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_h3(;kwargs...)
html_h3(children::Any, kwargs...)
html_h3(children_maker::Function, kwargs...)

A H3 component H3 is a wrapper for the <h3> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h3

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_h4(;kwargs...)
html_h4(children::Any, kwargs...)
html_h4(children_maker::Function, kwargs...)

A H4 component H4 is a wrapper for the <h4> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h4

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_h5(;kwargs...)
html_h5(children::Any, kwargs...)
html_h5(children_maker::Function, kwargs...)

A H5 component H5 is a wrapper for the <h5> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h5

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_h6(;kwargs...)
html_h6(children::Any, kwargs...)
html_h6(children_maker::Function, kwargs...)

A H6 component H6 is a wrapper for the <h6> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h6

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_header(;kwargs...)
html_header(children::Any, kwargs...)
html_header(children_maker::Function, kwargs...)

A Header component Header is a wrapper for the <header> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/header

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_hgroup(;kwargs...)
html_hgroup(children::Any, kwargs...)
html_hgroup(children_maker::Function, kwargs...)

A Hgroup component Hgroup is a wrapper for the <hgroup> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/hgroup

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_hr(;kwargs...)
html_hr(children::Any, kwargs...)
html_hr(children_maker::Function, kwargs...)

A Hr component Hr is a wrapper for the <hr> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/hr

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_i(;kwargs...)
html_i(children::Any, kwargs...)
html_i(children_maker::Function, kwargs...)

An I component I is a wrapper for the <i> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/i

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_iframe(;kwargs...)
html_iframe(children::Any, kwargs...)
html_iframe(children_maker::Function, kwargs...)

An Iframe component Iframe is a wrapper for the <iframe> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• allow (String; optional): Specifies a feature-policy for the iframe.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• height (String; optional): Specifies the height of elements listed here. For all other elements, use the CSS height property. Note: In some instances, such as <div>, this is a legacy attribute, in which case the CSS height property should be used instead.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• name (String; optional): Name of the element. For example used by the server to identify the fields in form submits.
• referrerPolicy (String; optional): Specifies which referrer is sent when fetching the resource.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• sandbox (String; optional): Stops a document loaded in an iframe from using certain features (such as submitting forms or opening new windows).
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• src (String; optional): The URL of the embeddable content.
• srcDoc (String; optional)
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• width (String; optional): For the elements listed here, this establishes the element's width. Note: For all other instances, such as <div>, this is a legacy attribute, in which case the CSS width property should be used instead.

html_img(;kwargs...)
html_img(children::Any, kwargs...)
html_img(children_maker::Function, kwargs...)

An Img component Img is a wrapper for the <img> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• alt (String; optional): Alternative text in case an image can't be displayed.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• crossOrigin (String; optional): How the element handles cross-origin requests
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• height (String; optional): Specifies the height of elements listed here. For all other elements, use the CSS height property. Note: In some instances, such as <div>, this is a legacy attribute, in which case the CSS height property should be used instead.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• referrerPolicy (String; optional): Specifies which referrer is sent when fetching the resource.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• sizes (String; optional)
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• src (String; optional): The URL of the embeddable content.
• srcSet (String; optional): One or more responsive image candidates.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• useMap (String; optional)
• width (String; optional): For the elements listed here, this establishes the element's width. Note: For all other instances, such as <div>, this is a legacy attribute, in which case the CSS width property should be used instead.

html_ins(;kwargs...)
html_ins(children::Any, kwargs...)
html_ins(children_maker::Function, kwargs...)

An Ins component Ins is a wrapper for the <ins> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ins

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• cite (String; optional): Contains a URI which points to the source of the quote or change.
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dateTime (String; optional): Indicates the date and time associated with the element.
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_kbd(;kwargs...)
html_kbd(children::Any, kwargs...)
html_kbd(children_maker::Function, kwargs...)

A Kbd component Kbd is a wrapper for the <kbd> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/kbd

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_keygen(;kwargs...)
html_keygen(children::Any, kwargs...)
html_keygen(children_maker::Function, kwargs...)

A Keygen component Keygen is a wrapper for the <keygen> HTML5 element.

DEPRECATED: <keygen> is included for completeness, but should be avoided as it is not supported by all browsers and may be removed at any time from those that do support it.

For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/keygen

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_label(;kwargs...)
html_label(children::Any, kwargs...)
html_label(children_maker::Function, kwargs...)

A Label component Label is a wrapper for the <label> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/label

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• form (String; optional): Indicates the form that is the owner of the element.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• htmlFor (String; optional): Describes elements which belongs to this one.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_legend(;kwargs...)
html_legend(children::Any, kwargs...)
html_legend(children_maker::Function, kwargs...)

A Legend component Legend is a wrapper for the <legend> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/legend

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_li(;kwargs...)
html_li(children::Any, kwargs...)
html_li(children_maker::Function, kwargs...)

A Li component Li is a wrapper for the <li> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/li

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• value (String; optional): Defines a default value which will be displayed in the element on page load.

html_link(;kwargs...)
html_link(children::Any, kwargs...)
html_link(children_maker::Function, kwargs...)

A Link component Link is a wrapper for the <link> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• crossOrigin (String; optional): How the element handles cross-origin requests
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• href (String; optional): The URL of a linked resource.
• hrefLang (String; optional): Specifies the language of the linked resource.
• integrity (String; optional): Specifies a Subresource Integrity value that allows browsers to verify what they fetch.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• media (String; optional): Specifies a hint of the media for which the linked resource was designed.
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• referrerPolicy (String; optional): Specifies which referrer is sent when fetching the resource.
• rel (String; optional): Specifies the relationship of the target object to the link object.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• sizes (String; optional)
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.
• type (String; optional): Defines the type of the element.

html_main(;kwargs...)
html_main(children::Any, kwargs...)
html_main(children_maker::Function, kwargs...)

A Main component Main is a wrapper for the <main> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/main

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_mapel(;kwargs...)
html_mapel(children::Any, kwargs...)
html_mapel(children_maker::Function, kwargs...)

A MapEl component MapEl is a wrapper for the <map> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/map

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• name (String; optional): Name of the element. For example used by the server to identify the fields in form submits.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_mark(;kwargs...)
html_mark(children::Any, kwargs...)
html_mark(children_maker::Function, kwargs...)

A Mark component Mark is a wrapper for the <mark> HTML5 element. For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/mark

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_marquee(;kwargs...)
html_marquee(children::Any, kwargs...)
html_marquee(children_maker::Function, kwargs...)

A Marquee component Marquee is a wrapper for the <marquee> HTML5 element.

DEPRECATED: <marquee> is included for completeness, but should be avoided as browsers may remove it at any time.

For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/marquee

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• className (String; optional): Often used with CSS to style elements with common properties.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• loop ('loop', 'LOOP' | Bool; optional): Indicates whether the media should start playing from the start when it's finished.
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.

html_meta(;kwargs...)
html_meta(children::Any, kwargs...)
html_meta(children_maker::Function, kwargs...)

A Meta component Meta is a wrapper for the <meta> HTML5 element.

CAUTION: <meta> is included for completeness, but generally will not behave as expected since <meta> tags should be static HTML content in the <head> of the document. Dash components are dynamic <body> content.

For detailed attribute info see: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta

• children (a list of or a singular dash component, string or number; optional): The children of this component
• id (String; optional): The ID of this component, used to identify dash components

in callbacks. The ID needs to be unique across all of the components in an app.

• accessKey (String; optional): Keyboard shortcut to activate or add focus to the element.
• aria-* (String; optional): A wildcard aria attribute
• charSet (String; optional): Declares the character encoding of the page or script.
• className (String; optional): Often used with CSS to style elements with common properties.
• content (String; optional): A value associated with http-equiv or name depending on the context.
• contentEditable (String; optional): Indicates whether the element's content is editable.
• contextMenu (String; optional): Defines the ID of a <menu> element which will serve as the element's context menu.
• data-* (String; optional): A wildcard data attribute
• dir (String; optional): Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
• disable_n_clicks (Bool; optional): When True, this will disable the n_clicks prop. Use this to remove

event listeners that may interfere with screen readers.

• draggable (String; optional): Defines whether the element can be dragged.
• hidden ('hidden', 'HIDDEN' | Bool; optional): Prevents rendering of given element, while keeping child elements, e.g. script elements, active.
• httpEquiv (String; optional): Defines a pragma directive.
• key (String; optional): A unique identifier for the component, used to improve

performance by React.js while rendering components See https://reactjs.org/docs/lists-and-keys.html for more info

• lang (String; optional): Defines the language used in the element.
• loading_state (lists containing elements isloading, propname, componentname - `isloading(Bool; optional): Determines if the component is loading or not -propname(String; optional): Holds which property is loading -componentname` (String; optional): Holds the name of the component that is loading; optional): Object that holds the loading state object coming from dash-renderer
• n_clicks (optional): An integer that represents the number of times

that this element has been clicked on.

• n_clicks_timestamp (optional): An integer that represents the time (in ms since 1970)

at which n_clicks changed. This can be used to tell which button was changed most recently.

• name (String; optional): Name of the element. For example used by the server to identify the fields in form submits.
• role (String; optional): Defines an explicit role for an element for use by assistive technologies.
• spellCheck (String; optional): Indicates whether spell checking is allowed for the element.
• style (Dict; optional): Defines CSS styles which will override styles previously set.
• tabIndex (String; optional): Overrides the browser's default tab order and follows the one specified instead.
• title (String; optional): Text to be displayed in a tooltip when hovering over the element.