From 5bf22fc7e3c392c8bd44315ca2d06d7dca7d084e Mon Sep 17 00:00:00 2001 From: sotech117 Date: Thu, 31 Jul 2025 17:27:24 -0400 Subject: add code for analysis of data --- .../site-packages/dash/dash_table/DataTable.py | 1795 ++++++++++++++++++++ 1 file changed, 1795 insertions(+) create mode 100644 venv/lib/python3.8/site-packages/dash/dash_table/DataTable.py (limited to 'venv/lib/python3.8/site-packages/dash/dash_table/DataTable.py') diff --git a/venv/lib/python3.8/site-packages/dash/dash_table/DataTable.py b/venv/lib/python3.8/site-packages/dash/dash_table/DataTable.py new file mode 100644 index 0000000..2c07912 --- /dev/null +++ b/venv/lib/python3.8/site-packages/dash/dash_table/DataTable.py @@ -0,0 +1,1795 @@ +# AUTO GENERATED FILE - DO NOT EDIT + +import typing # noqa: F401 +from typing_extensions import TypedDict, NotRequired, Literal # noqa: F401 +from dash.development.base_component import Component, _explicitize_args + +ComponentType = typing.Union[ + str, + int, + float, + Component, + None, + typing.Sequence[typing.Union[str, int, float, Component, None]], +] + +NumberType = typing.Union[ + typing.SupportsFloat, typing.SupportsInt, typing.SupportsComplex +] + + +class DataTable(Component): + """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 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. + + Keyword arguments: + + - data (list of dicts with strings as keys and values of type string | number | boolean; 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'} ]. + + - columns (list of dicts; optional): + Columns describes various aspects about each individual column. + `name` and `id` are the only required parameters. + + `columns` is a list of dicts with keys: + + - 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 | list 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 (a value equal to: '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 (a value equal to: '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 (a value equal to: 'first', 'last' | boolean | list of booleans; 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 (a value equal to: 'first', 'last' | boolean | list of booleans; 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 (a value equal to: 'first', 'last' | boolean | list of booleans; 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 (boolean; 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 (a value equal to: 'first', 'last' | boolean | list of booleans; 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 (a value equal to: 'first', 'last' | boolean | list of booleans; 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 (dict; optional): + There are two `filter_options` props in the table. This is the + column-level filter_options 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. + + `filter_options` is a dict with keys: + + - case (a value equal to: 'sensitive', 'insensitive'; optional): + (default: 'sensitive') Determine whether the applicable + filter relational operators will default to `sensitive` or + `insensitive` comparison. + + - placeholder_text (string; optional): + (default: 'filter data...') The filter cell placeholder + text. + + - format (dict; optional): + The formatting applied to the column's data. This prop is + derived from the [d3-format](https://github.com/d3/d3-format) + library specification. Apart from being structured slightly + differently (under a single prop), the usage is the same. See + also dash_table.FormatTemplate. It contains helper functions + for typical number formats. + + `format` is a dict with keys: + + - locale (dict; optional): + Represents localization specific formatting information. + When left unspecified, will use the default value provided + by d3-format. + + `locale` is a dict with keys: + + - symbol (list 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 (list of numbers; optional): + (default: [3]). A list of integers representing the + grouping pattern. The default is 3 for thousands. + + - numerals (list 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 (boolean; optional): + (default: True). Separates integers with 4-digits or + less. + + - nully (boolean | number | string | dict | list; optional): + A value that will be used in place of the Noney value + during formatting. If the value type matches the column + type, it will be formatted normally. + + - prefix (number; 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 (dict; optional): + The `on_change` behavior of the column for user-initiated + modifications. + + `on_change` is a dict with keys: + + - action (a value equal to: '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 (a value equal to: '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. + + - sort_as_null (list of string | number | booleans; 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 overrides the table-level `sort_as_None`. + + - validation (dict; optional): + The `validation` options for user input processing that can + accept, reject or apply a default value. + + `validation` is a dict with keys: + + - allow_null (boolean; optional): + Allow the use of Noney values. (undefined, None, NaN) + (default: False). + + - default (boolean | number | string | dict | list; optional): + The default value to apply with on_change.failure = + 'default'. (default: None). + + - allow_YY (boolean; optional): + This is for `datetime` columns 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 with `action: + 'coerce'`, will convert user input to a 4-digit year. + + - editable (boolean; default False): + 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. + + - fixed_columns (dict; default { headers: False, data: 0}): + `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_columns` is a dict with keys: + + - data (number; optional): + Example `{'headers':False, 'data':0}` No columns are fixed + (the default). + + - headers (boolean; optional) + + - fixed_rows (dict; default { headers: False, data: 0}): + `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. + + `fixed_rows` is a dict with keys: + + - data (number; optional): + Example `{'headers':False, 'data':0}` No rows are fixed (the + default). + + - headers (boolean; optional) + + - column_selectable (a value equal to: 'single', 'multi', false; default False): + 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`. + + - cell_selectable (boolean; default True): + If True (default), then it is possible to click and navigate table + cells. + + - row_selectable (a value equal to: 'single', 'multi', false; default False): + 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`. + + - row_deletable (boolean; optional): + If True, then a `x` will appear next to each `row` and the user + can delete the row. + + - active_cell (dict; 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. + + `active_cell` is a dict with keys: + + - row (number; optional) + + - column (number; optional) + + - row_id (string | number; optional) + + - column_id (string; optional) + + - selected_cells (list of dicts; 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_cells` is a list of dicts with keys: + + - row (number; optional) + + - column (number; optional) + + - row_id (string | number; optional) + + - column_id (string; optional) + + - selected_rows (list of numbers; optional): + `selected_rows` contains the indices of rows that are selected via + the UI elements that appear when `row_selectable` is `'single'` or + `'multi'`. + + - selected_columns (list 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 (list of string | numbers; 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'`. + + - start_cell (dict; 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. + + `start_cell` is a dict with keys: + + - row (number; optional) + + - column (number; optional) + + - row_id (string | number; optional) + + - column_id (string; optional) + + - end_cell (dict; 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. + + `end_cell` is a dict with keys: + + - row (number; optional) + + - column (number; optional) + + - row_id (string | number; optional) + + - column_id (string; optional) + + - data_previous (list 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. + + - hidden_columns (list of strings; optional): + List of columns ids of the columns that are currently hidden. See + the associated nested prop `columns.hideable`. + + - is_focused (boolean; optional): + If True, then the `active_cell` is in a focused state. + + - merge_duplicate_headers (boolean; 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. + + - data_timestamp (number; 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. + + - include_headers_on_copy_paste (boolean; default False): + 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. + + - export_columns (a value equal to: 'all', 'visible'; default 'visible'): + 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 (a value equal to: 'csv', 'xlsx', 'none'; default 'none'): + Denotes the type of the export data file, Defaults to `'none'`. + + - export_headers (a value equal to: '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 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. + + - page_action (a value equal to: 'custom', 'native', 'none'; default 'native'): + `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_current (number; default 0): + `page_current` represents which page the user is on. Use this + property to index through data in your callbacks with backend + paging. + + - page_count (number; 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_size (number; default 250): + `page_size` represents the number of rows that will be displayed + on a particular page when `page_action` is `'custom'` or + `'native'`. + + - filter_query (string; default ''): + If `filter_action` is enabled, then the current filtering string + is represented in this `filter_query` property. + + - filter_action (dict; default 'none'): + 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_action` is a a value equal to: 'custom', 'native', 'none' + | dict with keys: + + - type (a value equal to: 'custom', 'native'; required) + + - operator (a value equal to: 'and', 'or'; optional) + + - filter_options (dict; optional): + There are two `filter_options` props in the table. This is the + table-level filter_options prop and there is also the column-level + `filter_options` prop. If the column-level `filter_options` prop + is set it overrides the table-level `filter_options` prop for that + column. + + `filter_options` is a dict with keys: + + - case (a value equal to: 'sensitive', 'insensitive'; optional): + (default: 'sensitive') Determine whether the applicable filter + relational operators will default to `sensitive` or + `insensitive` comparison. + + - placeholder_text (string; optional): + (default: 'filter data...') The filter cell placeholder text. + + - sort_action (a value equal to: 'custom', 'native', 'none'; default 'none'): + 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 + 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_mode (a value equal to: 'single', 'multi'; default 'single'): + 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](https://github.com/plotly/dash-table/issues/170). + + - sort_by (list of dicts; 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_by` is a list of dicts with keys: + + - column_id (string; required) + + - direction (a value equal to: 'asc', 'desc'; required) + + - sort_as_null (list of string | number | booleans; 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_None`. Defaults to + `[]`. + + - dropdown (dict; 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` is a dict with strings as keys and values of type dict + with keys: + + - clearable (boolean; optional) + + - options (list of dicts; required) + + `options` is a list of dicts with keys: + + - label (string; required) + + - value (number | string | boolean; required) + + - dropdown_conditional (list of dicts; 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_conditional` is a list of dicts with keys: + + - clearable (boolean; optional) + + - if (dict; optional) + + `if` is a dict with keys: + + - column_id (string; optional) + + - filter_query (string; optional) + + - options (list of dicts; required) + + `options` is a list of dicts with keys: + + - label (string; required) + + - value (number | string | boolean; required) + + - dropdown_data (list of dicts; 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. + + `dropdown_data` is a list of dicts with strings as keys and values + of type dict with keys: + + - clearable (boolean; optional) + + - options (list of dicts; required) + + `options` is a list of dicts with keys: + + - label (string; required) + + - value (number | string | boolean; required) + + - tooltip (dict; 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, 'use_with: 'both'} for i + in df.columns}. + + `tooltip` is a dict with strings as keys and values of type string + | dict with keys: + + - delay (number; 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 (number; 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 (a value equal to: '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 (a value equal to: '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 (list of dicts; 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. + + `tooltip_conditional` is a list of dicts with keys: + + - delay (number; optional): + The `delay` 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 (number; optional): + The `duration` 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. + + - if (dict; 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. + + `if` is a dict with keys: + + - 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 (number | a value equal to: 'odd', 'even'; optional): + `row_index` refers to the index of the row in the source + `data`. + + - type (a value equal to: '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. + + - tooltip_data (list of dicts; 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. + + `tooltip_data` is a list of dicts with strings as keys and values + of type string | dict with keys: + + - delay (number; optional): + The `delay` 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 (number; optional): + The `duration` 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. Alternatively, the + value of the property can also be a plain string. The `text` + syntax will be used in that case. + + - type (a value equal to: 'text', 'markdown'; optional): + For each tooltip configuration, 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. + + - tooltip_header (dict; 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. + + `tooltip_header` is a dict with strings as keys and values of type + string | dict with keys: + + - delay (number; optional): + The `delay` 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 (number; optional): + The `duration` 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. Alternatively, the + value of the property can also be a plain string. The `text` + syntax will be used in that case. + + - type (a value equal to: 'text', 'markdown'; optional): + For each tooltip configuration, 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. + + Or list of a value equal to: null | string | dict with keys: + + - delay (number; optional) + + - duration (number; optional) + + - type (a value equal to: 'text', 'markdown'; optional) + + - value (string; required)s + + - tooltip_delay (number; default 350): + `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 (number; default 2000): + `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. + + - locale_format (dict; optional): + The localization specific formatting information applied to all + columns in the table. This prop is derived from the + [d3.formatLocale](https://github.com/d3/d3-format#formatLocale) + data structure specification. When left unspecified, each + individual nested prop will default to a pre-determined value. + + `locale_format` is a dict with keys: + + - symbol (list 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 (list of numbers; optional): + (default: [3]). A list of integers representing the grouping + pattern. + + - numerals (list 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 (boolean; optional): + (default: True). Separate integers with 4-digits or less. + + - style_as_list_view (boolean; default False): + If True, then the table will be styled like a list view and not + have borders between the columns. + + - fill_width (boolean; default True): + `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. + + - markdown_options (dict; default { link_target: '_blank', html: False}): + The `markdown_options` property allows customization of the + markdown cells behavior. + + `markdown_options` is a dict with keys: + + - link_target (string | a value equal to: '_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 (boolean; 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. + + - css (list of dicts; 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\"'} ]. + + `css` is a list of dicts with keys: + + - selector (string; required) + + - rule (string; required) + + - 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. + + - 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_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_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_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_cell_conditional (list of dicts; optional): + Conditional CSS styles for the cells. This can be used to apply + styles to cells on a per-column basis. + + `style_cell_conditional` is a list of dicts with keys: + + - if (dict; optional) + + `if` is a dict with keys: + + - column_id (string | list of strings; optional) + + - column_type (a value equal to: 'any', 'numeric', 'text', 'datetime'; optional) + + - style_data_conditional (list of dicts; optional): + Conditional CSS styles for the data cells. This can be used to + apply styles to data cells on a per-column basis. + + `style_data_conditional` is a list of dicts with keys: + + - if (dict; optional) + + `if` is a dict with keys: + + - column_id (string | list of strings; optional) + + - column_type (a value equal to: 'any', 'numeric', 'text', 'datetime'; optional) + + - filter_query (string; optional) + + - state (a value equal to: 'active', 'selected'; optional) + + - row_index (number | a value equal to: 'odd', 'even' | list of numbers; optional) + + - column_editable (boolean; optional) + + - style_filter_conditional (list of dicts; optional): + Conditional CSS styles for the filter cells. This can be used to + apply styles to filter cells on a per-column basis. + + `style_filter_conditional` is a list of dicts with keys: + + - if (dict; optional) + + `if` is a dict with keys: + + - column_id (string | list of strings; optional) + + - column_type (a value equal to: 'any', 'numeric', 'text', 'datetime'; optional) + + - column_editable (boolean; optional) + + - style_header_conditional (list of dicts; optional): + Conditional CSS styles for the header cells. This can be used to + apply styles to header cells on a per-column basis. + + `style_header_conditional` is a list of dicts with keys: + + - if (dict; optional) + + `if` is a dict with keys: + + - column_id (string | list of strings; optional) + + - column_type (a value equal to: 'any', 'numeric', 'text', 'datetime'; optional) + + - header_index (number | list of numbers | a value equal to: 'odd', 'even'; optional) + + - column_editable (boolean; optional) + + - virtualization (boolean; default False): + 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. + + - 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 (list 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 (list of numbers; 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 (list of string | numbers; 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 (list of strings; optional): + `derived_viewport_selected_columns` contains the ids of the + `selected_columns` that are not currently hidden. + + - derived_viewport_selected_rows (list of numbers; optional): + `derived_viewport_selected_rows` represents the indices of the + `selected_rows` from the perspective of the + `derived_viewport_indices`. + + - derived_viewport_selected_row_ids (list of string | numbers; optional): + `derived_viewport_selected_row_ids` represents the IDs of the + `selected_rows` on the currently visible page. + + - derived_virtual_data (list 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 (list of numbers; 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 (list of string | numbers; 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_rows (list of numbers; optional): + `derived_virtual_selected_rows` represents the indices of the + `selected_rows` from the perspective of the + `derived_virtual_indices`. + + - derived_virtual_selected_row_ids (list of string | numbers; optional): + `derived_virtual_selected_row_ids` represents the IDs of the + `selected_rows` as they appear after filtering and sorting, across + all pages. + + - id (string; optional): + The ID of the table. + + - loading_state (dict; optional): + Object that holds the loading state object coming from + dash-renderer. + + `loading_state` is a dict with keys: + + - is_loading (boolean; optional): + Determines if the component is loading or not. + + - prop_name (string; optional): + Holds which property is loading. + + - component_name (string; optional): + Holds the name of the component that is loading. + + - persistence (boolean | string | number; 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`. + + - persisted_props (list of a value equal to: 'columns.name', 'data', 'filter_query', 'hidden_columns', 'page_current', 'selected_columns', 'selected_rows', 'sort_by's; default [ 'columns.name', 'filter_query', 'hidden_columns', 'page_current', 'selected_columns', 'selected_rows', 'sort_by']): + Properties whose user interactions will persist after refreshing + the component or the page. + + - persistence_type (a value equal to: 'local', 'session', 'memory'; default 'local'): + 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.""" + + _children_props = [] + _base_nodes = ["children"] + _namespace = "dash_table" + _type = "DataTable" + ColumnsFilterOptions = TypedDict( + "ColumnsFilterOptions", + { + "case": NotRequired[Literal["sensitive", "insensitive"]], + "placeholder_text": NotRequired[str], + }, + ) + + ColumnsFormatLocale = TypedDict( + "ColumnsFormatLocale", + { + "symbol": NotRequired[typing.Sequence[str]], + "decimal": NotRequired[str], + "group": NotRequired[str], + "grouping": NotRequired[typing.Sequence[NumberType]], + "numerals": NotRequired[typing.Sequence[str]], + "percent": NotRequired[str], + "separate_4digits": NotRequired[bool], + }, + ) + + ColumnsFormat = TypedDict( + "ColumnsFormat", + { + "locale": NotRequired["ColumnsFormatLocale"], + "nully": NotRequired[typing.Any], + "prefix": NotRequired[NumberType], + "specifier": NotRequired[str], + }, + ) + + ColumnsOnChange = TypedDict( + "ColumnsOnChange", + { + "action": NotRequired[Literal["coerce", "none", "validate"]], + "failure": NotRequired[Literal["accept", "default", "reject"]], + }, + ) + + ColumnsValidation = TypedDict( + "ColumnsValidation", + { + "allow_null": NotRequired[bool], + "default": NotRequired[typing.Any], + "allow_YY": NotRequired[bool], + }, + ) + + Columns = TypedDict( + "Columns", + { + "id": str, + "name": typing.Union[str, typing.Sequence[str]], + "type": NotRequired[Literal["any", "numeric", "text", "datetime"]], + "presentation": NotRequired[Literal["input", "dropdown", "markdown"]], + "selectable": NotRequired[ + typing.Union[Literal["first", "last"], bool, typing.Sequence[bool]] + ], + "clearable": NotRequired[ + typing.Union[Literal["first", "last"], bool, typing.Sequence[bool]] + ], + "deletable": NotRequired[ + typing.Union[Literal["first", "last"], bool, typing.Sequence[bool]] + ], + "editable": NotRequired[bool], + "hideable": NotRequired[ + typing.Union[Literal["first", "last"], bool, typing.Sequence[bool]] + ], + "renamable": NotRequired[ + typing.Union[Literal["first", "last"], bool, typing.Sequence[bool]] + ], + "filter_options": NotRequired["ColumnsFilterOptions"], + "format": NotRequired["ColumnsFormat"], + "on_change": NotRequired["ColumnsOnChange"], + "sort_as_null": NotRequired[ + typing.Sequence[typing.Union[str, NumberType, bool]] + ], + "validation": NotRequired["ColumnsValidation"], + }, + ) + + FixedColumns = TypedDict( + "FixedColumns", {"data": NotRequired[NumberType], "headers": NotRequired[bool]} + ) + + FixedRows = TypedDict( + "FixedRows", {"data": NotRequired[NumberType], "headers": NotRequired[bool]} + ) + + ActiveCell = TypedDict( + "ActiveCell", + { + "row": NotRequired[NumberType], + "column": NotRequired[NumberType], + "row_id": NotRequired[typing.Union[str, NumberType]], + "column_id": NotRequired[str], + }, + ) + + SelectedCells = TypedDict( + "SelectedCells", + { + "row": NotRequired[NumberType], + "column": NotRequired[NumberType], + "row_id": NotRequired[typing.Union[str, NumberType]], + "column_id": NotRequired[str], + }, + ) + + StartCell = TypedDict( + "StartCell", + { + "row": NotRequired[NumberType], + "column": NotRequired[NumberType], + "row_id": NotRequired[typing.Union[str, NumberType]], + "column_id": NotRequired[str], + }, + ) + + EndCell = TypedDict( + "EndCell", + { + "row": NotRequired[NumberType], + "column": NotRequired[NumberType], + "row_id": NotRequired[typing.Union[str, NumberType]], + "column_id": NotRequired[str], + }, + ) + + FilterAction = TypedDict( + "FilterAction", + { + "type": Literal["custom", "native"], + "operator": NotRequired[Literal["and", "or"]], + }, + ) + + FilterOptions = TypedDict( + "FilterOptions", + { + "case": NotRequired[Literal["sensitive", "insensitive"]], + "placeholder_text": NotRequired[str], + }, + ) + + SortBy = TypedDict( + "SortBy", {"column_id": str, "direction": Literal["asc", "desc"]} + ) + + DropdownOptions = TypedDict( + "DropdownOptions", {"label": str, "value": typing.Union[NumberType, str, bool]} + ) + + Dropdown = TypedDict( + "Dropdown", + {"clearable": NotRequired[bool], "options": typing.Sequence["DropdownOptions"]}, + ) + + DropdownConditionalIf = TypedDict( + "DropdownConditionalIf", + {"column_id": NotRequired[str], "filter_query": NotRequired[str]}, + ) + + DropdownConditionalOptions = TypedDict( + "DropdownConditionalOptions", + {"label": str, "value": typing.Union[NumberType, str, bool]}, + ) + + DropdownConditional = TypedDict( + "DropdownConditional", + { + "clearable": NotRequired[bool], + "if": NotRequired["DropdownConditionalIf"], + "options": typing.Sequence["DropdownConditionalOptions"], + }, + ) + + DropdownDataOptions = TypedDict( + "DropdownDataOptions", + {"label": str, "value": typing.Union[NumberType, str, bool]}, + ) + + DropdownData = TypedDict( + "DropdownData", + { + "clearable": NotRequired[bool], + "options": typing.Sequence["DropdownDataOptions"], + }, + ) + + Tooltip = TypedDict( + "Tooltip", + { + "delay": NotRequired[NumberType], + "duration": NotRequired[NumberType], + "type": NotRequired[Literal["text", "markdown"]], + "use_with": NotRequired[Literal["both", "data", "header"]], + "value": str, + }, + ) + + TooltipConditionalIf = TypedDict( + "TooltipConditionalIf", + { + "column_id": NotRequired[str], + "filter_query": NotRequired[str], + "row_index": NotRequired[typing.Union[NumberType, Literal["odd", "even"]]], + }, + ) + + TooltipConditional = TypedDict( + "TooltipConditional", + { + "delay": NotRequired[NumberType], + "duration": NotRequired[NumberType], + "if": "TooltipConditionalIf", + "type": NotRequired[Literal["text", "markdown"]], + "value": str, + }, + ) + + TooltipData = TypedDict( + "TooltipData", + { + "delay": NotRequired[NumberType], + "duration": NotRequired[NumberType], + "type": NotRequired[Literal["text", "markdown"]], + "value": str, + }, + ) + + TooltipHeader = TypedDict( + "TooltipHeader", + { + "delay": NotRequired[NumberType], + "duration": NotRequired[NumberType], + "type": NotRequired[Literal["text", "markdown"]], + "value": str, + }, + ) + + LocaleFormat = TypedDict( + "LocaleFormat", + { + "symbol": NotRequired[typing.Sequence[str]], + "decimal": NotRequired[str], + "group": NotRequired[str], + "grouping": NotRequired[typing.Sequence[NumberType]], + "numerals": NotRequired[typing.Sequence[str]], + "percent": NotRequired[str], + "separate_4digits": NotRequired[bool], + }, + ) + + MarkdownOptions = TypedDict( + "MarkdownOptions", + { + "link_target": NotRequired[ + typing.Union[str, Literal["_blank", "_parent", "_self", "_top"]] + ], + "html": NotRequired[bool], + }, + ) + + Css = TypedDict("Css", {"selector": str, "rule": str}) + + StyleCellConditionalIf = TypedDict( + "StyleCellConditionalIf", + { + "column_id": NotRequired[typing.Union[str, typing.Sequence[str]]], + "column_type": NotRequired[Literal["any", "numeric", "text", "datetime"]], + }, + ) + + StyleCellConditional = TypedDict( + "StyleCellConditional", {"if": NotRequired["StyleCellConditionalIf"]} + ) + + StyleDataConditionalIf = TypedDict( + "StyleDataConditionalIf", + { + "column_id": NotRequired[typing.Union[str, typing.Sequence[str]]], + "column_type": NotRequired[Literal["any", "numeric", "text", "datetime"]], + "filter_query": NotRequired[str], + "state": NotRequired[Literal["active", "selected"]], + "row_index": NotRequired[ + typing.Union[ + NumberType, Literal["odd", "even"], typing.Sequence[NumberType] + ] + ], + "column_editable": NotRequired[bool], + }, + ) + + StyleDataConditional = TypedDict( + "StyleDataConditional", {"if": NotRequired["StyleDataConditionalIf"]} + ) + + StyleFilterConditionalIf = TypedDict( + "StyleFilterConditionalIf", + { + "column_id": NotRequired[typing.Union[str, typing.Sequence[str]]], + "column_type": NotRequired[Literal["any", "numeric", "text", "datetime"]], + "column_editable": NotRequired[bool], + }, + ) + + StyleFilterConditional = TypedDict( + "StyleFilterConditional", {"if": NotRequired["StyleFilterConditionalIf"]} + ) + + StyleHeaderConditionalIf = TypedDict( + "StyleHeaderConditionalIf", + { + "column_id": NotRequired[typing.Union[str, typing.Sequence[str]]], + "column_type": NotRequired[Literal["any", "numeric", "text", "datetime"]], + "header_index": NotRequired[ + typing.Union[ + NumberType, typing.Sequence[NumberType], Literal["odd", "even"] + ] + ], + "column_editable": NotRequired[bool], + }, + ) + + StyleHeaderConditional = TypedDict( + "StyleHeaderConditional", {"if": NotRequired["StyleHeaderConditionalIf"]} + ) + + LoadingState = TypedDict( + "LoadingState", + { + "is_loading": NotRequired[bool], + "prop_name": NotRequired[str], + "component_name": NotRequired[str], + }, + ) + + def __init__( + self, + data: typing.Optional[ + typing.Sequence[ + typing.Dict[ + typing.Union[str, float, int], typing.Union[str, NumberType, bool] + ] + ] + ] = None, + columns: typing.Optional[typing.Sequence["Columns"]] = None, + editable: typing.Optional[bool] = None, + fixed_columns: typing.Optional["FixedColumns"] = None, + fixed_rows: typing.Optional["FixedRows"] = None, + column_selectable: typing.Optional[Literal["single", "multi", False]] = None, + cell_selectable: typing.Optional[bool] = None, + row_selectable: typing.Optional[Literal["single", "multi", False]] = None, + row_deletable: typing.Optional[bool] = None, + active_cell: typing.Optional["ActiveCell"] = None, + selected_cells: typing.Optional[typing.Sequence["SelectedCells"]] = None, + selected_rows: typing.Optional[typing.Sequence[NumberType]] = None, + selected_columns: typing.Optional[typing.Sequence[str]] = None, + selected_row_ids: typing.Optional[ + typing.Sequence[typing.Union[str, NumberType]] + ] = None, + start_cell: typing.Optional["StartCell"] = None, + end_cell: typing.Optional["EndCell"] = None, + data_previous: typing.Optional[typing.Sequence[dict]] = None, + hidden_columns: typing.Optional[typing.Sequence[str]] = None, + is_focused: typing.Optional[bool] = None, + merge_duplicate_headers: typing.Optional[bool] = None, + data_timestamp: typing.Optional[NumberType] = None, + include_headers_on_copy_paste: typing.Optional[bool] = None, + export_columns: typing.Optional[Literal["all", "visible"]] = None, + export_format: typing.Optional[Literal["csv", "xlsx", "none"]] = None, + export_headers: typing.Optional[ + Literal["none", "ids", "names", "display"] + ] = None, + page_action: typing.Optional[Literal["custom", "native", "none"]] = None, + page_current: typing.Optional[NumberType] = None, + page_count: typing.Optional[NumberType] = None, + page_size: typing.Optional[NumberType] = None, + filter_query: typing.Optional[str] = None, + filter_action: typing.Optional[ + typing.Union[Literal["custom", "native", "none"], "FilterAction"] + ] = None, + filter_options: typing.Optional["FilterOptions"] = None, + sort_action: typing.Optional[Literal["custom", "native", "none"]] = None, + sort_mode: typing.Optional[Literal["single", "multi"]] = None, + sort_by: typing.Optional[typing.Sequence["SortBy"]] = None, + sort_as_null: typing.Optional[ + typing.Sequence[typing.Union[str, NumberType, bool]] + ] = None, + dropdown: typing.Optional[ + typing.Dict[typing.Union[str, float, int], "Dropdown"] + ] = None, + dropdown_conditional: typing.Optional[ + typing.Sequence["DropdownConditional"] + ] = None, + dropdown_data: typing.Optional[ + typing.Sequence[typing.Dict[typing.Union[str, float, int], "DropdownData"]] + ] = None, + tooltip: typing.Optional[ + typing.Dict[typing.Union[str, float, int], typing.Union[str, "Tooltip"]] + ] = None, + tooltip_conditional: typing.Optional[ + typing.Sequence["TooltipConditional"] + ] = None, + tooltip_data: typing.Optional[ + typing.Sequence[ + typing.Dict[ + typing.Union[str, float, int], typing.Union[str, "TooltipData"] + ] + ] + ] = None, + tooltip_header: typing.Optional[ + typing.Dict[ + typing.Union[str, float, int], + typing.Union[ + str, + "TooltipHeader", + typing.Sequence[typing.Union[Literal[None], str, "TooltipHeader"]], + ], + ] + ] = None, + tooltip_delay: typing.Optional[NumberType] = None, + tooltip_duration: typing.Optional[NumberType] = None, + locale_format: typing.Optional["LocaleFormat"] = None, + style_as_list_view: typing.Optional[bool] = None, + fill_width: typing.Optional[bool] = None, + markdown_options: typing.Optional["MarkdownOptions"] = None, + css: typing.Optional[typing.Sequence["Css"]] = None, + style_table: typing.Optional[dict] = None, + style_cell: typing.Optional[dict] = None, + style_data: typing.Optional[dict] = None, + style_filter: typing.Optional[dict] = None, + style_header: typing.Optional[dict] = None, + style_cell_conditional: typing.Optional[ + typing.Sequence["StyleCellConditional"] + ] = None, + style_data_conditional: typing.Optional[ + typing.Sequence["StyleDataConditional"] + ] = None, + style_filter_conditional: typing.Optional[ + typing.Sequence["StyleFilterConditional"] + ] = None, + style_header_conditional: typing.Optional[ + typing.Sequence["StyleHeaderConditional"] + ] = None, + virtualization: typing.Optional[bool] = None, + derived_filter_query_structure: typing.Optional[dict] = None, + derived_viewport_data: typing.Optional[typing.Sequence[dict]] = None, + derived_viewport_indices: typing.Optional[typing.Sequence[NumberType]] = None, + derived_viewport_row_ids: typing.Optional[ + typing.Sequence[typing.Union[str, NumberType]] + ] = None, + derived_viewport_selected_columns: typing.Optional[typing.Sequence[str]] = None, + derived_viewport_selected_rows: typing.Optional[ + typing.Sequence[NumberType] + ] = None, + derived_viewport_selected_row_ids: typing.Optional[ + typing.Sequence[typing.Union[str, NumberType]] + ] = None, + derived_virtual_data: typing.Optional[typing.Sequence[dict]] = None, + derived_virtual_indices: typing.Optional[typing.Sequence[NumberType]] = None, + derived_virtual_row_ids: typing.Optional[ + typing.Sequence[typing.Union[str, NumberType]] + ] = None, + derived_virtual_selected_rows: typing.Optional[ + typing.Sequence[NumberType] + ] = None, + derived_virtual_selected_row_ids: typing.Optional[ + typing.Sequence[typing.Union[str, NumberType]] + ] = None, + id: typing.Optional[typing.Union[str, dict]] = None, + loading_state: typing.Optional["LoadingState"] = None, + persistence: typing.Optional[typing.Union[bool, str, NumberType]] = None, + persisted_props: typing.Optional[ + typing.Sequence[ + Literal[ + "columns.name", + "data", + "filter_query", + "hidden_columns", + "page_current", + "selected_columns", + "selected_rows", + "sort_by", + ] + ] + ] = None, + persistence_type: typing.Optional[Literal["local", "session", "memory"]] = None, + **kwargs + ): + self._prop_names = [ + "data", + "columns", + "editable", + "fixed_columns", + "fixed_rows", + "column_selectable", + "cell_selectable", + "row_selectable", + "row_deletable", + "active_cell", + "selected_cells", + "selected_rows", + "selected_columns", + "selected_row_ids", + "start_cell", + "end_cell", + "data_previous", + "hidden_columns", + "is_focused", + "merge_duplicate_headers", + "data_timestamp", + "include_headers_on_copy_paste", + "export_columns", + "export_format", + "export_headers", + "page_action", + "page_current", + "page_count", + "page_size", + "filter_query", + "filter_action", + "filter_options", + "sort_action", + "sort_mode", + "sort_by", + "sort_as_null", + "dropdown", + "dropdown_conditional", + "dropdown_data", + "tooltip", + "tooltip_conditional", + "tooltip_data", + "tooltip_header", + "tooltip_delay", + "tooltip_duration", + "locale_format", + "style_as_list_view", + "fill_width", + "markdown_options", + "css", + "style_table", + "style_cell", + "style_data", + "style_filter", + "style_header", + "style_cell_conditional", + "style_data_conditional", + "style_filter_conditional", + "style_header_conditional", + "virtualization", + "derived_filter_query_structure", + "derived_viewport_data", + "derived_viewport_indices", + "derived_viewport_row_ids", + "derived_viewport_selected_columns", + "derived_viewport_selected_rows", + "derived_viewport_selected_row_ids", + "derived_virtual_data", + "derived_virtual_indices", + "derived_virtual_row_ids", + "derived_virtual_selected_rows", + "derived_virtual_selected_row_ids", + "id", + "loading_state", + "persistence", + "persisted_props", + "persistence_type", + ] + self._valid_wildcard_attributes = [] + self.available_properties = [ + "data", + "columns", + "editable", + "fixed_columns", + "fixed_rows", + "column_selectable", + "cell_selectable", + "row_selectable", + "row_deletable", + "active_cell", + "selected_cells", + "selected_rows", + "selected_columns", + "selected_row_ids", + "start_cell", + "end_cell", + "data_previous", + "hidden_columns", + "is_focused", + "merge_duplicate_headers", + "data_timestamp", + "include_headers_on_copy_paste", + "export_columns", + "export_format", + "export_headers", + "page_action", + "page_current", + "page_count", + "page_size", + "filter_query", + "filter_action", + "filter_options", + "sort_action", + "sort_mode", + "sort_by", + "sort_as_null", + "dropdown", + "dropdown_conditional", + "dropdown_data", + "tooltip", + "tooltip_conditional", + "tooltip_data", + "tooltip_header", + "tooltip_delay", + "tooltip_duration", + "locale_format", + "style_as_list_view", + "fill_width", + "markdown_options", + "css", + "style_table", + "style_cell", + "style_data", + "style_filter", + "style_header", + "style_cell_conditional", + "style_data_conditional", + "style_filter_conditional", + "style_header_conditional", + "virtualization", + "derived_filter_query_structure", + "derived_viewport_data", + "derived_viewport_indices", + "derived_viewport_row_ids", + "derived_viewport_selected_columns", + "derived_viewport_selected_rows", + "derived_viewport_selected_row_ids", + "derived_virtual_data", + "derived_virtual_indices", + "derived_virtual_row_ids", + "derived_virtual_selected_rows", + "derived_virtual_selected_row_ids", + "id", + "loading_state", + "persistence", + "persisted_props", + "persistence_type", + ] + self.available_wildcard_properties = [] + _explicit_args = kwargs.pop("_explicit_args") + _locals = locals() + _locals.update(kwargs) # For wildcard attrs and excess named props + args = {k: _locals[k] for k in _explicit_args} + + super(DataTable, self).__init__(**args) + + +setattr(DataTable, "__init__", _explicitize_args(DataTable.__init__)) -- cgit v1.2.3-70-g09d2