Add files using upload-large-folder tool

lib/python3.10/site-packages/dash/background_callback/__init__.py

@@ -0,0 +1,6 @@
+from .managers.celery_manager import (  # noqa: F401,E402
+    CeleryManager,
+)
+from .managers.diskcache_manager import (  # noqa: F401,E402
+    DiskcacheManager,
+)

lib/python3.10/site-packages/dash/background_callback/_proxy_set_props.py

@@ -0,0 +1,18 @@
+class ProxySetProps(dict):
+    """
+    Defer dictionary item setter to run a custom function on change.
+    Used by background callback manager to save the `set_props` data.
+    """
+
+    def __init__(self, on_change):
+        super().__init__()
+        self.on_change = on_change
+        self._data = {}
+
+    def __setitem__(self, key, value):
+        self.on_change(key, value)
+        self._data.setdefault(key, {})
+        self._data[key] = {**self._data[key], **value}
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)

lib/python3.10/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 <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.
+
+    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__))

lib/python3.10/site-packages/dash/dash_table/async-table.js.LICENSE.txt

@@ -0,0 +1,18 @@
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+
+/*!
+  Copyright (c) 2018 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/react-select
+*/
+
+/*!
+ * Font Awesome Free 5.15.4 by @fontawesome - https://fontawesome.com
+ * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)
+ */
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */

lib/python3.10/site-packages/dash/dash_table/bundle.js

@@ -0,0 +1,2 @@
+(()=>{var e,t,r,n,o={845:(e,t,r)=>{"use strict";r.d(t,{A:()=>o});var n=r(5564);function o(e,t,r){return function(){if(0===arguments.length)return r();var o=arguments[arguments.length-1];if(!(0,n.A)(o)){for(var i=0;i<e.length;){if("function"==typeof o[e[i]])return o[e[i]].apply(o,Array.prototype.slice.call(arguments,0,-1));i+=1}if(function(e){return null!=e&&"function"==typeof e["@@transducer/step"]}(o))return t.apply(null,Array.prototype.slice.call(arguments,0,-1))(o)}return r.apply(this,arguments)}}},1069:(e,t,r)=>{"use strict";function n(e,t){return Object.prototype.hasOwnProperty.call(t,e)}r.d(t,{A:()=>n})},1609:e=>{"use strict";e.exports=window.React},1647:(e,t,r)=>{"use strict";var n=(0,r(3579).A)(function(e){return null==e});t.A=n},1878:(e,t)=>{"use strict";t.A={init:function(){return this.xf["@@transducer/init"]()},result:function(e){return this.xf["@@transducer/result"](e)}}},2039:(e,t,r)=>{"use strict";var n=r(7660),o=(0,r(3579).A)(function(e){var t,r=!1;return(0,n.A)(e.length,function(){return r?t:(r=!0,t=e.apply(this,arguments))})});t.A=o},2173:(e,t,r)=>{"use strict";r.d(t,{A:()=>a});var n=r(3579),o=r(2254),i=r(2808);function a(e){return function t(r,a,s){switch(arguments.length){case 0:return t;case 1:return(0,i.A)(r)?t:(0,o.A)(function(t,n){return e(r,t,n)});case 2:return(0,i.A)(r)&&(0,i.A)(a)?t:(0,i.A)(r)?(0,o.A)(function(t,r){return e(t,a,r)}):(0,i.A)(a)?(0,o.A)(function(t,n){return e(r,t,n)}):(0,n.A)(function(t){return e(r,a,t)});default:return(0,i.A)(r)&&(0,i.A)(a)&&(0,i.A)(s)?t:(0,i.A)(r)&&(0,i.A)(a)?(0,o.A)(function(t,r){return e(t,r,s)}):(0,i.A)(r)&&(0,i.A)(s)?(0,o.A)(function(t,r){return e(t,a,r)}):(0,i.A)(a)&&(0,i.A)(s)?(0,o.A)(function(t,n){return e(r,t,n)}):(0,i.A)(r)?(0,n.A)(function(t){return e(t,a,s)}):(0,i.A)(a)?(0,n.A)(function(t){return e(r,t,s)}):(0,i.A)(s)?(0,n.A)(function(t){return e(r,a,t)}):e(r,a,s)}}}},2205:function(e,t,r){var n;n=void 0!==r.g?r.g:this,e.exports=function(e){if(e.CSS&&e.CSS.escape)return e.CSS.escape;var t=function(e){if(0==arguments.length)throw new TypeError("`CSS.escape` requires an argument.");for(var t,r=String(e),n=r.length,o=-1,i="",a=r.charCodeAt(0);++o<n;)0!=(t=r.charCodeAt(o))?i+=t>=1&&t<=31||127==t||0==o&&t>=48&&t<=57||1==o&&t>=48&&t<=57&&45==a?"\\"+t.toString(16)+" ":0==o&&1==n&&45==t||!(t>=128||45==t||95==t||t>=48&&t<=57||t>=65&&t<=90||t>=97&&t<=122)?"\\"+r.charAt(o):r.charAt(o):i+="�";return i};return e.CSS||(e.CSS={}),e.CSS.escape=t,t}(n)},2254:(e,t,r)=>{"use strict";r.d(t,{A:()=>i});var n=r(3579),o=r(2808);function i(e){return function t(r,i){switch(arguments.length){case 0:return t;case 1:return(0,o.A)(r)?t:(0,n.A)(function(t){return e(r,t)});default:return(0,o.A)(r)&&(0,o.A)(i)?t:(0,o.A)(r)?(0,n.A)(function(t){return e(t,i)}):(0,o.A)(i)?(0,n.A)(function(t){return e(r,t)}):e(r,i)}}}},2270:(e,t,r)=>{"use strict";r.d(t,{A:()=>u});var n=r(2173),o=r(1069),i=r(4279),a=r(5564),s=r(1647),u=(0,n.A)(function e(t,r,n){if(0===t.length)return r;var u=t[0];if(t.length>1){var c=!(0,s.A)(n)&&(0,o.A)(u,n)&&"object"==typeof n[u]?n[u]:(0,i.A)(t[1])?[]:{};r=e(Array.prototype.slice.call(t,1),r,c)}return function(e,t,r){if((0,i.A)(e)&&(0,a.A)(r)){var n=[].concat(r);return n[e]=t,n}var o={};for(var s in r)o[s]=r[s];return o[e]=t,o}(u,r,n)})},2314:(e,t,r)=>{"use strict";var n;r.d(t,{q$:()=>i,$b:()=>a,Ay:()=>d}),function(e){e[e.DEBUG=6]="DEBUG",e[e.NONE=7]="NONE"}(n||(n={}));var o,i=n;!function(e){e[e.TRACE=0]="TRACE",e[e.INFO=1]="INFO",e[e.WARNING=2]="WARNING",e[e.ERROR=3]="ERROR",e[e.FATAL=4]="FATAL",e[e.NONE=5]="NONE"}(o||(o={}));var a=o,s=[];s[a.TRACE]="trace",s[a.INFO]="info",s[a.WARNING]="warning",s[a.ERROR]="error",s[a.FATAL]="fatal",s[a.NONE]="none",s[i.DEBUG]="debug",s[i.NONE]="trace";var u=a.NONE,c=i.NONE;function l(e,t){if(e<t)return()=>{};var r;switch(e){case a.TRACE:case a.INFO:r=window.console.log;break;case i.DEBUG:case a.WARNING:r=window.console.warn;break;case a.ERROR:case a.FATAL:r=window.console.error;break;default:throw new Error("Unknown log ".concat(e))}var n="".concat("","[").concat(s[e].toUpperCase(),"]");return r.bind(window.console,n)}var f={setDebugLevel(e){c=e},setLogLevel(e){u=e}};Object.defineProperties(f,{trace:{get:()=>l(a.TRACE,u),configurable:!1,enumerable:!1},info:{get:()=>l(a.INFO,u),configurable:!1,enumerable:!1},warning:{get:()=>l(a.WARNING,u),configurable:!1,enumerable:!1},error:{get:()=>l(a.ERROR,u),configurable:!1,enumerable:!1},fatal:{get:()=>l(a.FATAL,u),configurable:!1,enumerable:!1},debug:{get:()=>l(i.DEBUG,c),configurable:!1,enumerable:!1}}),Object.freeze(f);var d=f},2598:(e,t,r)=>{"use strict";var n=r(3430),o=r(2254),i=r(845),a=r(8267),s=r(9607),u=r(5845),c=r(2959),l=(0,o.A)((0,i.A)(["fantasy-land/map","map"],s.A,function(e,t){switch(Object.prototype.toString.call(t)){case"[object Function]":return(0,u.A)(t.length,function(){return e.call(this,t.apply(this,arguments))});case"[object Object]":return(0,n.A)(function(r,n){return r[n]=e(t[n]),r},{},(0,c.A)(t));default:return(0,a.A)(e,t)}}));t.A=l},2808:(e,t,r)=>{"use strict";function n(e){return null!=e&&"object"==typeof e&&!0===e["@@functional/placeholder"]}r.d(t,{A:()=>n})},2959:(e,t,r)=>{"use strict";r.d(t,{A:()=>f});var n=r(3579),o=r(1069),i=Object.prototype.toString,a=function(){return"[object Arguments]"===i.call(arguments)?function(e){return"[object Arguments]"===i.call(e)}:function(e){return(0,o.A)("callee",e)}}(),s=!{toString:null}.propertyIsEnumerable("toString"),u=["constructor","valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"],c=function(){return arguments.propertyIsEnumerable("length")}(),l=function(e,t){for(var r=0;r<e.length;){if(e[r]===t)return!0;r+=1}return!1},f="function"!=typeof Object.keys||c?(0,n.A)(function(e){if(Object(e)!==e)return[];var t,r,n=[],i=c&&a(e);for(t in e)!(0,o.A)(t,e)||i&&"length"===t||(n[n.length]=t);if(s)for(r=u.length-1;r>=0;)t=u[r],(0,o.A)(t,e)&&!l(n,t)&&(n[n.length]=t),r-=1;return n}):(0,n.A)(function(e){return Object(e)!==e?[]:Object.keys(e)})},3430:(e,t,r)=>{"use strict";function n(e,t,r){for(var n=0,o=r.length;n<o;)t=e(t,r[n]),n+=1;return t}r.d(t,{A:()=>n})},3579:(e,t,r)=>{"use strict";r.d(t,{A:()=>o});var n=r(2808);function o(e){return function t(r){return 0===arguments.length||(0,n.A)(r)?t:e.apply(this,arguments)}}},3847:(e,t,r)=>{"use strict";var n=r(2173),o=r(2270),i=(0,n.A)(function(e,t,r){return(0,o.A)([e],t,r)});t.A=i},4279:(e,t)=>{"use strict";t.A=Number.isInteger||function(e){return(0|e)===e}},4296:(e,t,r)=>{var n;window,e.exports=(n=r(1609),function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=1)}([function(e,t){e.exports=n},function(e,t,r){"use strict";r.r(t),r.d(t,"asyncDecorator",function(){return a}),r.d(t,"inheritAsyncDecorator",function(){return s}),r.d(t,"isReady",function(){return u}),r.d(t,"History",function(){return f});var n=r(0);function o(e,t,r,n,o,i,a){try{var s=e[i](a),u=s.value}catch(e){return void r(e)}s.done?t(u):Promise.resolve(u).then(n,o)}function i(e){return function(){var t=this,r=arguments;return new Promise(function(n,i){var a=e.apply(t,r);function s(e){o(a,n,i,s,u,"next",e)}function u(e){o(a,n,i,s,u,"throw",e)}s(void 0)})}}var a=function(e,t){var r,o={isReady:new Promise(function(e){r=e}),get:Object(n.lazy)(function(){return Promise.resolve(t()).then(function(e){return setTimeout(i(regeneratorRuntime.mark(function e(){return regeneratorRuntime.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:return e.next=2,r(!0);case 2:o.isReady=!0;case 3:case"end":return e.stop()}},e)})),0),e})})};return Object.defineProperty(e,"_dashprivate_isLazyComponentReady",{get:function(){return o.isReady}}),o.get},s=function(e,t){Object.defineProperty(e,"_dashprivate_isLazyComponentReady",{get:function(){return u(t)}})},u=function(e){return e&&e._dashprivate_isLazyComponentReady};function c(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}var l="_dashprivate_historychange",f=function(){function e(){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e)}var t,r;return t=e,r=[{key:"dispatchChangeEvent",value:function(){window.dispatchEvent(new CustomEvent(l))}},{key:"onChange",value:function(e){return window.addEventListener(l,e),function(){return window.removeEventListener(l,e)}}}],null&&c(t.prototype,null),r&&c(t,r),Object.defineProperty(t,"prototype",{writable:!1}),e}()}]))},5564:(e,t)=>{"use strict";t.A=Array.isArray||function(e){return null!=e&&e.length>=0&&"[object Array]"===Object.prototype.toString.call(e)}},5795:e=>{"use strict";e.exports=window.ReactDOM},5845:(e,t,r)=>{"use strict";var n=r(7660),o=r(3579),i=r(2254),a=r(9034),s=(0,i.A)(function(e,t){return 1===e?(0,o.A)(t):(0,n.A)(e,(0,a.A)(e,[],t))});t.A=s},5987:(e,t,r)=>{"use strict";var n=r(2254),o=r(4279),i=r(6359),a=(0,n.A)(function(e,t){if(null!=t)return(0,o.A)(e)?(0,i.A)(e,t):t[e]});t.A=a},6120:e=>{"use strict";e.exports=window.PropTypes},6359:(e,t,r)=>{"use strict";r.d(t,{A:()=>o});var n=r(8228);function o(e,t){var r=e<0?t.length+e:e;return(0,n.A)(t)?t.charAt(r):t[r]}},7246:(e,t,r)=>{"use strict";r.d(t,{A:()=>b});var n,o,i,a=r(2039);class s{static delete(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"/";if(s.enabled()){var n=new Date(Date.now()-864e5).toUTCString();document.cookie="".concat(e,"=;expires=").concat(n,";domain=").concat(t,";path=").concat(r)}}static get(e){if(e.length&&s.enabled())return e=e.toLowerCase(),(document.cookie.split(";").map(e=>{var t=e.split("=");return{id:t[0].trim(),value:t[1]}}).find(t=>e===t.id.toLocaleLowerCase())||{}).value}static set(e,t){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"",n=arguments.length>3&&void 0!==arguments[3]?arguments[3]:"/";if(s.enabled()){var o=new Date(Date.now()+63072e7).toUTCString(),i="".concat(e,"=").concat(t,";expires=").concat(o,";domain=").concat(r,";path=").concat(n);s.get(e)&&s.delete(e,r,n),document.cookie=i}}}n=s,o="enabled",i=a.A(()=>{try{document.cookie="cookietest=1";var e=-1!==document.cookie.indexOf("cookietest=");return document.cookie="cookietest=1; expires=Thu, 01-Jan-1970 00:00:01 GMT",e}catch(e){return!1}}),(o=function(e){var t=function(e){if("object"!=typeof e||!e)return e;var t=e[Symbol.toPrimitive];if(void 0!==t){var r=t.call(e,"string");if("object"!=typeof r)return r;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(e)}(e);return"symbol"==typeof t?t:t+""}(o))in n?Object.defineProperty(n,o,{value:i,enumerable:!0,configurable:!0,writable:!0}):n[o]=i;var u,c,l,f=r(2314);function d(e,t,r){return(t=function(e){var t=function(e){if("object"!=typeof e||!e)return e;var t=e[Symbol.toPrimitive];if(void 0!==t){var r=t.call(e,"string");if("object"!=typeof r)return r;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(e)}(e);return"symbol"==typeof t?t:t+""}(t))in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}var p="dash_debug",y="dash_log";class b{static get searchParams(){return"undefined"!=typeof URL&&URL.prototype&&URL.prototype.constructor&&new URL(window.location.href).searchParams||{get:()=>null}}static get debugLevel(){var e=this.searchParams.get(p)||s.get(p);return e&&f.q$[e]||f.q$.NONE}static get logLevel(){var e=this.searchParams.get(y)||s.get(y);return e&&f.$b[e]||f.$b.ERROR}static get defaultEdge(){return"1px solid #d3d3d3"}static get activeEdge(){return b._activeEdge}static get supportsCssVariables(){return b._supportsCssVariables}}u=b,d(b,"_supportsCssVariables",Boolean(null===(c=window.CSS)||void 0===c||null===(l=c.supports)||void 0===l?void 0:l.call(c,".some-selector","var(--some-var)"))),d(b,"_activeEdge",u._supportsCssVariables?"1px solid var(--accent)":"1px solid hotpink")},7660:(e,t,r)=>{"use strict";function n(e,t){switch(e){case 0:return function(){return t.apply(this,arguments)};case 1:return function(e){return t.apply(this,arguments)};case 2:return function(e,r){return t.apply(this,arguments)};case 3:return function(e,r,n){return t.apply(this,arguments)};case 4:return function(e,r,n,o){return t.apply(this,arguments)};case 5:return function(e,r,n,o,i){return t.apply(this,arguments)};case 6:return function(e,r,n,o,i,a){return t.apply(this,arguments)};case 7:return function(e,r,n,o,i,a,s){return t.apply(this,arguments)};case 8:return function(e,r,n,o,i,a,s,u){return t.apply(this,arguments)};case 9:return function(e,r,n,o,i,a,s,u,c){return t.apply(this,arguments)};case 10:return function(e,r,n,o,i,a,s,u,c,l){return t.apply(this,arguments)};default:throw new Error("First argument to _arity must be a non-negative integer no greater than ten")}}r.d(t,{A:()=>n})},8228:(e,t,r)=>{"use strict";function n(e){return"[object String]"===Object.prototype.toString.call(e)}r.d(t,{A:()=>n})},8267:(e,t,r)=>{"use strict";function n(e,t){for(var r=0,n=t.length,o=Array(n);r<n;)o[r]=e(t[r]),r+=1;return o}r.d(t,{A:()=>n})},8935:(e,t,r)=>{"use strict";r.d(t,{Ay:()=>d,tu:()=>y});var n=r(9849),o=(0,r(2173).A)(function(e,t,r){for(var n=Math.min(t.length,r.length),o=Array(n),i=0;i<n;)o[i]=e(t[i],r[i]),i+=1;return o}),i=r(3847),a=r(1609),s=r.n(a),u=r(6120),c=r.n(u),l=r(4296),f=r(9734);class d extends a.Component{render(){return s().createElement(a.Suspense,{fallback:null},s().createElement(p,this.props))}}var p=(0,l.asyncDecorator)(d,f.A.table),y={data:c().arrayOf(c().objectOf(c().oneOfType([c().string,c().number,c().bool]))),columns:c().arrayOf(c().exact({id:c().string.isRequired,name:c().oneOfType([c().string,c().arrayOf(c().string)]).isRequired,type:c().oneOf(["any","numeric","text","datetime"]),presentation:c().oneOf(["input","dropdown","markdown"]),selectable:c().oneOfType([c().oneOf(["first","last"]),c().bool,c().arrayOf(c().bool)]),clearable:c().oneOfType([c().oneOf(["first","last"]),c().bool,c().arrayOf(c().bool)]),deletable:c().oneOfType([c().oneOf(["first","last"]),c().bool,c().arrayOf(c().bool)]),editable:c().bool,hideable:c().oneOfType([c().oneOf(["first","last"]),c().bool,c().arrayOf(c().bool)]),renamable:c().oneOfType([c().oneOf(["first","last"]),c().bool,c().arrayOf(c().bool)]),filter_options:c().shape({case:c().oneOf(["sensitive","insensitive"]),placeholder_text:c().string}),format:c().exact({locale:c().exact({symbol:c().arrayOf(c().string),decimal:c().string,group:c().string,grouping:c().arrayOf(c().number),numerals:c().arrayOf(c().string),percent:c().string,separate_4digits:c().bool}),nully:c().any,prefix:c().number,specifier:c().string}),on_change:c().exact({action:c().oneOf(["coerce","none","validate"]),failure:c().oneOf(["accept","default","reject"])}),sort_as_null:c().arrayOf(c().oneOfType([c().string,c().number,c().bool])),validation:c().exact({allow_null:c().bool,default:c().any,allow_YY:c().bool})})),editable:c().bool,fixed_columns:c().exact({data:c().number,headers:c().bool}),fixed_rows:c().exact({data:c().number,headers:c().bool}),column_selectable:c().oneOf(["single","multi",!1]),cell_selectable:c().bool,row_selectable:c().oneOf(["single","multi",!1]),row_deletable:c().bool,active_cell:c().exact({row:c().number,column:c().number,row_id:c().oneOfType([c().string,c().number]),column_id:c().string}),selected_cells:c().arrayOf(c().exact({row:c().number,column:c().number,row_id:c().oneOfType([c().string,c().number]),column_id:c().string})),selected_rows:c().arrayOf(c().number),selected_columns:c().arrayOf(c().string),selected_row_ids:c().arrayOf(c().oneOfType([c().string,c().number])),start_cell:c().exact({row:c().number,column:c().number,row_id:c().oneOfType([c().string,c().number]),column_id:c().string}),end_cell:c().exact({row:c().number,column:c().number,row_id:c().oneOfType([c().string,c().number]),column_id:c().string}),data_previous:c().arrayOf(c().object),hidden_columns:c().arrayOf(c().string),is_focused:c().bool,merge_duplicate_headers:c().bool,data_timestamp:c().number,include_headers_on_copy_paste:c().bool,export_columns:c().oneOf(["all","visible"]),export_format:c().oneOf(["csv","xlsx","none"]),export_headers:c().oneOf(["none","ids","names","display"]),page_action:c().oneOf(["custom","native","none"]),page_current:c().number,page_count:c().number,page_size:c().number,filter_query:c().string,filter_action:c().oneOfType([c().oneOf(["custom","native","none"]),c().shape({type:c().oneOf(["custom","native"]).isRequired,operator:c().oneOf(["and","or"])})]),filter_options:c().shape({case:c().oneOf(["sensitive","insensitive"]),placeholder_text:c().string}),sort_action:c().oneOf(["custom","native","none"]),sort_mode:c().oneOf(["single","multi"]),sort_by:c().arrayOf(c().exact({column_id:c().string.isRequired,direction:c().oneOf(["asc","desc"]).isRequired})),sort_as_null:c().arrayOf(c().oneOfType([c().string,c().number,c().bool])),dropdown:c().objectOf(c().exact({clearable:c().bool,options:c().arrayOf(c().exact({label:c().string.isRequired,value:c().oneOfType([c().number,c().string,c().bool]).isRequired})).isRequired})),dropdown_conditional:c().arrayOf(c().exact({clearable:c().bool,if:c().exact({column_id:c().string,filter_query:c().string}),options:c().arrayOf(c().exact({label:c().string.isRequired,value:c().oneOfType([c().number,c().string,c().bool]).isRequired})).isRequired})),dropdown_data:c().arrayOf(c().objectOf(c().exact({clearable:c().bool,options:c().arrayOf(c().exact({label:c().string.isRequired,value:c().oneOfType([c().number,c().string,c().bool]).isRequired})).isRequired}))),tooltip:c().objectOf(c().oneOfType([c().string,c().exact({delay:c().number,duration:c().number,type:c().oneOf(["text","markdown"]),use_with:c().oneOf(["both","data","header"]),value:c().string.isRequired})])),tooltip_conditional:c().arrayOf(c().exact({delay:c().number,duration:c().number,if:c().exact({column_id:c().string,filter_query:c().string,row_index:c().oneOfType([c().number,c().oneOf(["odd","even"])])}).isRequired,type:c().oneOf(["text","markdown"]),value:c().string.isRequired})),tooltip_data:c().arrayOf(c().objectOf(c().oneOfType([c().string,c().exact({delay:c().number,duration:c().number,type:c().oneOf(["text","markdown"]),value:c().string.isRequired})]))),tooltip_header:c().objectOf(c().oneOfType([c().string,c().exact({delay:c().number,duration:c().number,type:c().oneOf(["text","markdown"]),value:c().string.isRequired}),c().arrayOf(c().oneOfType([c().oneOf([null]),c().string,c().exact({delay:c().number,duration:c().number,type:c().oneOf(["text","markdown"]),value:c().string.isRequired})]))])),tooltip_delay:c().number,tooltip_duration:c().number,locale_format:c().exact({symbol:c().arrayOf(c().string),decimal:c().string,group:c().string,grouping:c().arrayOf(c().number),numerals:c().arrayOf(c().string),percent:c().string,separate_4digits:c().bool}),style_as_list_view:c().bool,fill_width:c().bool,markdown_options:c().exact({link_target:c().oneOfType([c().string,c().oneOf(["_blank","_parent","_self","_top"])]),html:c().bool}),css:c().arrayOf(c().exact({selector:c().string.isRequired,rule:c().string.isRequired})),style_table:c().object,style_cell:c().object,style_data:c().object,style_filter:c().object,style_header:c().object,style_cell_conditional:c().arrayOf(c().shape({if:c().exact({column_id:c().oneOfType([c().string,c().arrayOf(c().string)]),column_type:c().oneOf(["any","numeric","text","datetime"])})})),style_data_conditional:c().arrayOf(c().shape({if:c().exact({column_id:c().oneOfType([c().string,c().arrayOf(c().string)]),column_type:c().oneOf(["any","numeric","text","datetime"]),filter_query:c().string,state:c().oneOf(["active","selected"]),row_index:c().oneOfType([c().number,c().oneOf(["odd","even"]),c().arrayOf(c().number)]),column_editable:c().bool})})),style_filter_conditional:c().arrayOf(c().shape({if:c().exact({column_id:c().oneOfType([c().string,c().arrayOf(c().string)]),column_type:c().oneOf(["any","numeric","text","datetime"]),column_editable:c().bool})})),style_header_conditional:c().arrayOf(c().shape({if:c().exact({column_id:c().oneOfType([c().string,c().arrayOf(c().string)]),column_type:c().oneOf(["any","numeric","text","datetime"]),header_index:c().oneOfType([c().number,c().arrayOf(c().number),c().oneOf(["odd","even"])]),column_editable:c().bool})})),virtualization:c().bool,derived_filter_query_structure:c().object,derived_viewport_data:c().arrayOf(c().object),derived_viewport_indices:c().arrayOf(c().number),derived_viewport_row_ids:c().arrayOf(c().oneOfType([c().string,c().number])),derived_viewport_selected_columns:c().arrayOf(c().string),derived_viewport_selected_rows:c().arrayOf(c().number),derived_viewport_selected_row_ids:c().arrayOf(c().oneOfType([c().string,c().number])),derived_virtual_data:c().arrayOf(c().object),derived_virtual_indices:c().arrayOf(c().number),derived_virtual_row_ids:c().arrayOf(c().oneOfType([c().string,c().number])),derived_virtual_selected_rows:c().arrayOf(c().number),derived_virtual_selected_row_ids:c().arrayOf(c().oneOfType([c().string,c().number])),id:c().string,setProps:c().func,loading_state:c().shape({is_loading:c().bool,prop_name:c().string,component_name:c().string}),persistence:c().oneOfType([c().bool,c().string,c().number]),persisted_props:c().arrayOf(c().oneOf(["columns.name","data","filter_query","hidden_columns","page_current","selected_columns","selected_rows","sort_by"])),persistence_type:c().oneOf(["local","session","memory"])};d.persistenceTransforms={columns:{name:{extract:e=>n.A("name",e),apply:(e,t)=>o(i.A("name"),e,t)}}},d.defaultProps={page_action:"native",page_current:0,page_size:250,css:[],filter_query:"",filter_action:"none",sort_as_null:[],sort_action:"none",sort_mode:"single",sort_by:[],style_as_list_view:!1,derived_viewport_data:[],derived_viewport_indices:[],derived_viewport_row_ids:[],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:[],dropdown:{},dropdown_conditional:[],dropdown_data:[],fill_width:!0,filter_options:{},fixed_columns:{headers:!1,data:0},fixed_rows:{headers:!1,data:0},markdown_options:{link_target:"_blank",html:!1},tooltip:{},tooltip_conditional:[],tooltip_data:[],tooltip_header:{},tooltip_delay:350,tooltip_duration:2e3,column_selectable:!1,editable:!1,export_columns:"visible",export_format:"none",include_headers_on_copy_paste:!1,selected_cells:[],selected_columns:[],selected_rows:[],selected_row_ids:[],cell_selectable:!0,row_selectable:!1,style_table:{},style_cell_conditional:[],style_data_conditional:[],style_filter_conditional:[],style_header_conditional:[],virtualization:!1,persisted_props:["columns.name","filter_query","hidden_columns","page_current","selected_columns","selected_rows","sort_by"],persistence_type:"local"},d.propTypes=y},9034:(e,t,r)=>{"use strict";r.d(t,{A:()=>i});var n=r(7660),o=r(2808);function i(e,t,r){return function(){for(var a=[],s=0,u=e,c=0,l=!1;c<t.length||s<arguments.length;){var f;c<t.length&&(!(0,o.A)(t[c])||s>=arguments.length)?f=t[c]:(f=arguments[s],s+=1),a[c]=f,(0,o.A)(f)?l=!0:u-=1,c+=1}return!l&&u<=0?r.apply(this,a):(0,n.A)(Math.max(0,u),i(e,a,r))}}},9607:(e,t,r)=>{"use strict";var n=r(1878),o=function(){function e(e,t){this.xf=t,this.f=e}return e.prototype["@@transducer/init"]=n.A.init,e.prototype["@@transducer/result"]=n.A.result,e.prototype["@@transducer/step"]=function(e,t){return this.xf["@@transducer/step"](e,this.f(t))},e}();t.A=function(e){return function(t){return new o(e,t)}}},9734:(e,t,r)=>{"use strict";r.d(t,{A:()=>n});class n{static get xlsx(){return r.e(404).then(r.t.bind(r,7063,23))}static get hljs(){return Promise.resolve(window.hljs||r.e(254).then(r.bind(r,3948)).then(e=>e.default))}static table(){return Promise.all([r.e(254),r.e(214)]).then(r.bind(r,3838))}}},9849:(e,t,r)=>{"use strict";var n=r(2254),o=r(2598),i=r(5987),a=(0,n.A)(function(e,t){return(0,o.A)((0,i.A)(e),t)});t.A=a}},i={};function a(e){var t=i[e];if(void 0!==t)return t.exports;var r=i[e]={id:e,exports:{}};return o[e].call(r.exports,r,r.exports,a),r.exports}a.m=o,a.n=e=>{var t=e&&e.__esModule?()=>e.default:()=>e;return a.d(t,{a:t}),t},t=Object.getPrototypeOf?e=>Object.getPrototypeOf(e):e=>e.__proto__,a.t=function(r,n){if(1&n&&(r=this(r)),8&n)return r;if("object"==typeof r&&r){if(4&n&&r.__esModule)return r;if(16&n&&"function"==typeof r.then)return r}var o=Object.create(null);a.r(o);var i={};e=e||[null,t({}),t([]),t(t)];for(var s=2&n&&r;("object"==typeof s||"function"==typeof s)&&!~e.indexOf(s);s=t(s))Object.getOwnPropertyNames(s).forEach(e=>i[e]=()=>r[e]);return i.default=()=>r,a.d(o,i),o},a.d=(e,t)=>{for(var r in t)a.o(t,r)&&!a.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},a.f={},a.e=e=>Promise.all(Object.keys(a.f).reduce((t,r)=>(a.f[r](e,t),t),[])),a.u=e=>({214:"async-table",254:"async-highlight",404:"async-export"}[e]+".js"),a.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),a.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r={},n="dash_table:",a.l=(e,t,o,i)=>{if(r[e])r[e].push(t);else{var s,u;if(void 0!==o)for(var c=document.getElementsByTagName("script"),l=0;l<c.length;l++){var f=c[l];if(f.getAttribute("src")==e||f.getAttribute("data-webpack")==n+o){s=f;break}}s||(u=!0,(s=document.createElement("script")).charset="utf-8",s.timeout=120,a.nc&&s.setAttribute("nonce",a.nc),s.setAttribute("data-webpack",n+o),s.src=e),r[e]=[t];var d=(t,n)=>{s.onerror=s.onload=null,clearTimeout(p);var o=r[e];if(delete r[e],s.parentNode&&s.parentNode.removeChild(s),o&&o.forEach(e=>e(n)),t)return t(n)},p=setTimeout(d.bind(null,void 0,{type:"timeout",target:s}),12e4);s.onerror=d.bind(null,s.onerror),s.onload=d.bind(null,s.onload),u&&document.head.appendChild(s)}},a.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},(()=>{var e;a.g.importScripts&&(e=a.g.location+"");var t=a.g.document;if(!e&&t&&(t.currentScript&&"SCRIPT"===t.currentScript.tagName.toUpperCase()&&(e=t.currentScript.src),!e)){var r=t.getElementsByTagName("script");if(r.length)for(var n=r.length-1;n>-1&&(!e||!/^http(s?):/.test(e));)e=r[n--].src}if(!e)throw new Error("Automatic publicPath is not supported in this browser");e=e.replace(/^blob:/,"").replace(/#.*$/,"").replace(/\?.*$/,"").replace(/\/[^\/]+$/,"/"),a.p=e})();var s,u=function(){var e=document.currentScript;if(!e){for(var t=document.getElementsByTagName("script"),r=[],n=0;n<t.length;n++)r.push(t[n]);e=(r=r.filter(function(e){return!e.async&&!e.text&&!e.textContent})).slice(-1)[0]}return e};if(Object.defineProperty(a,"p",{get:(s=u().src.split("/").slice(0,-1).join("/")+"/",function(){return s})}),"undefined"!=typeof jsonpScriptSrc){var c=jsonpScriptSrc;jsonpScriptSrc=function(e){var t,r=(t=u(),/\/_dash-component-suites\//.test(t.src)),n=c(e);if(!r)return n;var o=n.split("/"),i=o.slice(-1)[0].split(".");return i.splice(1,0,"v6_0_4m1753987258"),o.splice(-1,1,i.join(".")),o.join("/")}}(()=>{var e={23:0};a.f.j=(t,r)=>{var n=a.o(e,t)?e[t]:void 0;if(0!==n)if(n)r.push(n[2]);else{var o=new Promise((r,o)=>n=e[t]=[r,o]);r.push(n[2]=o);var i=a.p+a.u(t),s=new Error;a.l(i,r=>{if(a.o(e,t)&&(0!==(n=e[t])&&(e[t]=void 0),n)){var o=r&&("load"===r.type?"missing":r.type),i=r&&r.target&&r.target.src;s.message="Loading chunk "+t+" failed.\n("+o+": "+i+")",s.name="ChunkLoadError",s.type=o,s.request=i,n[1](s)}},"chunk-"+t,t)}};var t=(t,r)=>{var n,o,i=r[0],s=r[1],u=r[2],c=0;if(i.some(t=>0!==e[t])){for(n in s)a.o(s,n)&&(a.m[n]=s[n]);u&&u(a)}for(t&&t(r);c<i.length;c++)o=i[c],a.o(e,o)&&e[o]&&e[o][0](),e[o]=0},r=self.webpackChunkdash_table=self.webpackChunkdash_table||[];r.forEach(t.bind(null,0)),r.push=t.bind(null,r.push.bind(r))})(),a.nc=void 0;var l={};(()=>{"use strict";a.r(l),a.d(l,{DataTable:()=>r.Ay}),a(2205);var e=a(7246),t=a(2314),r=a(8935);t.Ay.setDebugLevel(e.A.debugLevel),t.Ay.setLogLevel(e.A.logLevel)})(),window.dash_table=l})();
+//# sourceMappingURL=bundle.js.map

lib/python3.10/site-packages/narwhals/_sql/dataframe.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Protocol
+
+from narwhals._compliant.dataframe import CompliantLazyFrame
+from narwhals._compliant.typing import CompliantExprT_contra, NativeExprT, NativeFrameT
+from narwhals._translate import ToNarwhalsT_co
+
+if TYPE_CHECKING:
+    from typing_extensions import Self, TypeAlias
+
+    from narwhals._compliant.window import WindowInputs
+    from narwhals._sql.expr import SQLExpr
+
+    Incomplete: TypeAlias = Any
+
+
+class SQLLazyFrame(
+    CompliantLazyFrame[CompliantExprT_contra, NativeFrameT, ToNarwhalsT_co],
+    Protocol[CompliantExprT_contra, NativeFrameT, ToNarwhalsT_co],
+):
+    def _evaluate_window_expr(
+        self,
+        expr: SQLExpr[Self, NativeExprT],
+        /,
+        window_inputs: WindowInputs[NativeExprT],
+    ) -> NativeExprT:
+        result = expr.window_function(self, window_inputs)
+        assert len(result) == 1  # debug assertion  # noqa: S101
+        return result[0]

lib/python3.10/site-packages/narwhals/_sql/expr.py

@@ -0,0 +1,730 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Literal, Protocol, cast
+
+from narwhals._compliant.expr import LazyExpr
+from narwhals._compliant.typing import (
+    AliasNames,
+    EvalNames,
+    EvalSeries,
+    NativeExprT,
+    WindowFunction,
+)
+from narwhals._compliant.window import WindowInputs
+from narwhals._expression_parsing import (
+    combine_alias_output_names,
+    combine_evaluate_output_names,
+)
+from narwhals._sql.typing import SQLLazyFrameT
+from narwhals._utils import Implementation, Version, not_implemented
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
+    from typing_extensions import Self, TypeIs
+
+    from narwhals._compliant.typing import AliasNames, WindowFunction
+    from narwhals._expression_parsing import ExprMetadata
+    from narwhals._sql.namespace import SQLNamespace
+    from narwhals.typing import NumericLiteral, PythonLiteral, RankMethod, TemporalLiteral
+
+
+class SQLExpr(LazyExpr[SQLLazyFrameT, NativeExprT], Protocol[SQLLazyFrameT, NativeExprT]):
+    _call: EvalSeries[SQLLazyFrameT, NativeExprT]
+    _evaluate_output_names: EvalNames[SQLLazyFrameT]
+    _alias_output_names: AliasNames | None
+    _version: Version
+    _implementation: Implementation
+    _metadata: ExprMetadata | None
+    _window_function: WindowFunction[SQLLazyFrameT, NativeExprT] | None
+
+    def __init__(
+        self,
+        call: EvalSeries[SQLLazyFrameT, NativeExprT],
+        window_function: WindowFunction[SQLLazyFrameT, NativeExprT] | None = None,
+        *,
+        evaluate_output_names: EvalNames[SQLLazyFrameT],
+        alias_output_names: AliasNames | None,
+        version: Version,
+        implementation: Implementation = Implementation.DUCKDB,
+    ) -> None: ...
+
+    def __call__(self, df: SQLLazyFrameT) -> Sequence[NativeExprT]:
+        return self._call(df)
+
+    def __narwhals_namespace__(
+        self,
+    ) -> SQLNamespace[SQLLazyFrameT, Self, Any, NativeExprT]: ...
+
+    def _callable_to_eval_series(
+        self, call: Callable[..., NativeExprT], /, **expressifiable_args: Self | Any
+    ) -> EvalSeries[SQLLazyFrameT, NativeExprT]:
+        def func(df: SQLLazyFrameT) -> list[NativeExprT]:
+            native_series_list = self(df)
+            other_native_series = {
+                key: df._evaluate_expr(value)
+                if self._is_expr(value)
+                else self._lit(value)
+                for key, value in expressifiable_args.items()
+            }
+            return [
+                call(native_series, **other_native_series)
+                for native_series in native_series_list
+            ]
+
+        return func
+
+    def _push_down_window_function(
+        self, call: Callable[..., NativeExprT], /, **expressifiable_args: Self | Any
+    ) -> WindowFunction[SQLLazyFrameT, NativeExprT]:
+        def window_f(
+            df: SQLLazyFrameT, window_inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            # If a function `f` is elementwise, and `g` is another function, then
+            # - `f(g) over (window)`
+            # - `f(g over (window))
+            # are equivalent.
+            # Make sure to only use with if `call` is elementwise!
+            native_series_list = self.window_function(df, window_inputs)
+            other_native_series = {
+                key: df._evaluate_window_expr(value, window_inputs)
+                if self._is_expr(value)
+                else self._lit(value)
+                for key, value in expressifiable_args.items()
+            }
+            return [
+                call(native_series, **other_native_series)
+                for native_series in native_series_list
+            ]
+
+        return window_f
+
+    def _with_window_function(
+        self, window_function: WindowFunction[SQLLazyFrameT, NativeExprT]
+    ) -> Self:
+        return self.__class__(
+            self._call,
+            window_function,
+            evaluate_output_names=self._evaluate_output_names,
+            alias_output_names=self._alias_output_names,
+            version=self._version,
+            implementation=self._implementation,
+        )
+
+    def _with_callable(
+        self, call: Callable[..., NativeExprT], /, **expressifiable_args: Self | Any
+    ) -> Self:
+        return self.__class__(
+            self._callable_to_eval_series(call, **expressifiable_args),
+            evaluate_output_names=self._evaluate_output_names,
+            alias_output_names=self._alias_output_names,
+            version=self._version,
+            implementation=self._implementation,
+        )
+
+    def _with_elementwise(
+        self, call: Callable[..., NativeExprT], /, **expressifiable_args: Self | Any
+    ) -> Self:
+        return self.__class__(
+            self._callable_to_eval_series(call, **expressifiable_args),
+            self._push_down_window_function(call, **expressifiable_args),
+            evaluate_output_names=self._evaluate_output_names,
+            alias_output_names=self._alias_output_names,
+            version=self._version,
+            implementation=self._implementation,
+        )
+
+    def _with_binary(self, op: Callable[..., NativeExprT], other: Self | Any) -> Self:
+        return self.__class__(
+            self._callable_to_eval_series(op, other=other),
+            self._push_down_window_function(op, other=other),
+            evaluate_output_names=self._evaluate_output_names,
+            alias_output_names=self._alias_output_names,
+            version=self._version,
+            implementation=self._implementation,
+        )
+
+    def _with_alias_output_names(self, func: AliasNames | None, /) -> Self:
+        current_alias_output_names = self._alias_output_names
+        alias_output_names = (
+            None
+            if func is None
+            else func
+            if current_alias_output_names is None
+            else lambda output_names: func(current_alias_output_names(output_names))
+        )
+        return type(self)(
+            self._call,
+            self._window_function,
+            evaluate_output_names=self._evaluate_output_names,
+            alias_output_names=alias_output_names,
+            version=self._version,
+            implementation=self._implementation,
+        )
+
+    @property
+    def window_function(self) -> WindowFunction[SQLLazyFrameT, NativeExprT]:
+        def default_window_func(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            assert not inputs.order_by  # noqa: S101
+            return [
+                self._window_expression(expr, inputs.partition_by, inputs.order_by)
+                for expr in self(df)
+            ]
+
+        return self._window_function or default_window_func
+
+    def _function(self, name: str, *args: NativeExprT | PythonLiteral) -> NativeExprT:
+        return self.__narwhals_namespace__()._function(name, *args)
+
+    def _lit(self, value: Any) -> NativeExprT:
+        return self.__narwhals_namespace__()._lit(value)
+
+    def _when(self, condition: NativeExprT, value: NativeExprT) -> NativeExprT:
+        return self.__narwhals_namespace__()._when(condition, value)
+
+    def _coalesce(self, *expr: NativeExprT) -> NativeExprT:
+        return self.__narwhals_namespace__()._coalesce(*expr)
+
+    def _count_star(self) -> NativeExprT: ...
+
+    def _window_expression(
+        self,
+        expr: NativeExprT,
+        partition_by: Sequence[str | NativeExprT] = (),
+        order_by: Sequence[str | NativeExprT] = (),
+        rows_start: int | None = None,
+        rows_end: int | None = None,
+        *,
+        descending: Sequence[bool] | None = None,
+        nulls_last: Sequence[bool] | None = None,
+    ) -> NativeExprT: ...
+
+    def _cum_window_func(
+        self,
+        func_name: Literal["sum", "max", "min", "count", "product"],
+        *,
+        reverse: bool,
+    ) -> WindowFunction[SQLLazyFrameT, NativeExprT]:
+        def func(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            return [
+                self._window_expression(
+                    self._function(func_name, expr),
+                    inputs.partition_by,
+                    inputs.order_by,
+                    descending=[reverse] * len(inputs.order_by),
+                    nulls_last=[reverse] * len(inputs.order_by),
+                    rows_end=0,
+                )
+                for expr in self(df)
+            ]
+
+        return func
+
+    def _rolling_window_func(
+        self,
+        func_name: Literal["sum", "mean", "std", "var"],
+        window_size: int,
+        min_samples: int,
+        ddof: int | None = None,
+        *,
+        center: bool,
+    ) -> WindowFunction[SQLLazyFrameT, NativeExprT]:
+        supported_funcs = ["sum", "mean", "std", "var"]
+        if center:
+            half = (window_size - 1) // 2
+            remainder = (window_size - 1) % 2
+            start = -(half + remainder)
+            end = half
+        else:
+            start = -(window_size - 1)
+            end = 0
+
+        def func(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            if func_name in {"sum", "mean"}:
+                func_: str = func_name
+            elif func_name == "var" and ddof == 0:
+                func_ = "var_pop"
+            elif func_name in "var" and ddof == 1:
+                func_ = "var_samp"
+            elif func_name == "std" and ddof == 0:
+                func_ = "stddev_pop"
+            elif func_name == "std" and ddof == 1:
+                func_ = "stddev_samp"
+            elif func_name in {"var", "std"}:  # pragma: no cover
+                msg = f"Only ddof=0 and ddof=1 are currently supported for rolling_{func_name}."
+                raise ValueError(msg)
+            else:  # pragma: no cover
+                msg = f"Only the following functions are supported: {supported_funcs}.\nGot: {func_name}."
+                raise ValueError(msg)
+            window_kwargs: Any = {
+                "partition_by": inputs.partition_by,
+                "order_by": inputs.order_by,
+                "rows_start": start,
+                "rows_end": end,
+            }
+            return [
+                self._when(
+                    self._window_expression(  # type: ignore[operator]
+                        self._function("count", expr), **window_kwargs
+                    )
+                    >= self._lit(min_samples),
+                    self._window_expression(self._function(func_, expr), **window_kwargs),
+                )
+                for expr in self(df)
+            ]
+
+        return func
+
+    @classmethod
+    def _is_expr(cls, obj: Self | Any) -> TypeIs[Self]:
+        return hasattr(obj, "__narwhals_expr__")
+
+    @property
+    def _backend_version(self) -> tuple[int, ...]:
+        return self._implementation._backend_version()
+
+    @classmethod
+    def _alias_native(cls, expr: NativeExprT, name: str, /) -> NativeExprT: ...
+
+    @classmethod
+    def _from_elementwise_horizontal_op(
+        cls, func: Callable[[Iterable[NativeExprT]], NativeExprT], *exprs: Self
+    ) -> Self:
+        def call(df: SQLLazyFrameT) -> Sequence[NativeExprT]:
+            cols = (col for _expr in exprs for col in _expr(df))
+            return [func(cols)]
+
+        def window_function(
+            df: SQLLazyFrameT, window_inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            cols = (
+                col for _expr in exprs for col in _expr.window_function(df, window_inputs)
+            )
+            return [func(cols)]
+
+        context = exprs[0]
+        return cls(
+            call,
+            window_function=window_function,
+            evaluate_output_names=combine_evaluate_output_names(*exprs),
+            alias_output_names=combine_alias_output_names(*exprs),
+            version=context._version,
+            implementation=context._implementation,
+        )
+
+    # Binary
+    def __eq__(self, other: Self) -> Self:  # type: ignore[override]
+        return self._with_binary(lambda expr, other: expr.__eq__(other), other)
+
+    def __ne__(self, other: Self) -> Self:  # type: ignore[override]
+        return self._with_binary(lambda expr, other: expr.__ne__(other), other)
+
+    def __add__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__add__(other), other)
+
+    def __sub__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__sub__(other), other)
+
+    def __rsub__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: other - expr, other).alias("literal")
+
+    def __mul__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__mul__(other), other)
+
+    def __truediv__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__truediv__(other), other)
+
+    def __rtruediv__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: other / expr, other).alias("literal")
+
+    def __floordiv__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__floordiv__(other), other)
+
+    def __rfloordiv__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: other // expr, other).alias(
+            "literal"
+        )
+
+    def __pow__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__pow__(other), other)
+
+    def __rpow__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: other**expr, other).alias("literal")
+
+    def __mod__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__mod__(other), other)
+
+    def __rmod__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: other % expr, other).alias("literal")
+
+    def __ge__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__ge__(other), other)
+
+    def __gt__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__gt__(other), other)
+
+    def __le__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__le__(other), other)
+
+    def __lt__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__lt__(other), other)
+
+    def __and__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__and__(other), other)
+
+    def __or__(self, other: Self) -> Self:
+        return self._with_binary(lambda expr, other: expr.__or__(other), other)
+
+    # Aggregations
+    def all(self) -> Self:
+        def f(expr: NativeExprT) -> NativeExprT:
+            return self._coalesce(self._function("bool_and", expr), self._lit(True))  # noqa: FBT003
+
+        def window_f(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            return [
+                self._coalesce(
+                    self._window_expression(
+                        self._function("bool_and", expr), inputs.partition_by
+                    ),
+                    self._lit(True),  # noqa: FBT003
+                )
+                for expr in self(df)
+            ]
+
+        return self._with_callable(f)._with_window_function(window_f)
+
+    def any(self) -> Self:
+        def f(expr: NativeExprT) -> NativeExprT:
+            return self._coalesce(self._function("bool_or", expr), self._lit(False))  # noqa: FBT003
+
+        def window_f(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            return [
+                self._coalesce(
+                    self._window_expression(
+                        self._function("bool_or", expr), inputs.partition_by
+                    ),
+                    self._lit(False),  # noqa: FBT003
+                )
+                for expr in self(df)
+            ]
+
+        return self._with_callable(f)._with_window_function(window_f)
+
+    def max(self) -> Self:
+        return self._with_callable(lambda expr: self._function("max", expr))
+
+    def mean(self) -> Self:
+        return self._with_callable(lambda expr: self._function("mean", expr))
+
+    def median(self) -> Self:
+        return self._with_callable(lambda expr: self._function("median", expr))
+
+    def min(self) -> Self:
+        return self._with_callable(lambda expr: self._function("min", expr))
+
+    def count(self) -> Self:
+        return self._with_callable(lambda expr: self._function("count", expr))
+
+    def sum(self) -> Self:
+        def f(expr: NativeExprT) -> NativeExprT:
+            return self._coalesce(self._function("sum", expr), self._lit(0))
+
+        def window_f(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            return [
+                self._coalesce(
+                    self._window_expression(
+                        self._function("sum", expr), inputs.partition_by
+                    ),
+                    self._lit(0),
+                )
+                for expr in self(df)
+            ]
+
+        return self._with_callable(f)._with_window_function(window_f)
+
+    # Elementwise
+    def abs(self) -> Self:
+        return self._with_elementwise(lambda expr: self._function("abs", expr))
+
+    def clip(
+        self,
+        lower_bound: Self | NumericLiteral | TemporalLiteral | None,
+        upper_bound: Self | NumericLiteral | TemporalLiteral | None,
+    ) -> Self:
+        def _clip_lower(expr: NativeExprT, lower_bound: Any) -> NativeExprT:
+            return self._function("greatest", expr, lower_bound)
+
+        def _clip_upper(expr: NativeExprT, upper_bound: Any) -> NativeExprT:
+            return self._function("least", expr, upper_bound)
+
+        def _clip_both(
+            expr: NativeExprT, lower_bound: Any, upper_bound: Any
+        ) -> NativeExprT:
+            return self._function(
+                "greatest", self._function("least", expr, upper_bound), lower_bound
+            )
+
+        if lower_bound is None:
+            return self._with_elementwise(_clip_upper, upper_bound=upper_bound)
+        if upper_bound is None:
+            return self._with_elementwise(_clip_lower, lower_bound=lower_bound)
+        return self._with_elementwise(
+            _clip_both, lower_bound=lower_bound, upper_bound=upper_bound
+        )
+
+    def is_null(self) -> Self:
+        return self._with_elementwise(lambda expr: self._function("isnull", expr))
+
+    def round(self, decimals: int) -> Self:
+        return self._with_elementwise(
+            lambda expr: self._function("round", expr, self._lit(decimals))
+        )
+
+    def exp(self) -> Self:
+        return self._with_elementwise(lambda expr: self._function("exp", expr))
+
+    # Cumulative
+    def cum_sum(self, *, reverse: bool) -> Self:
+        return self._with_window_function(self._cum_window_func("sum", reverse=reverse))
+
+    def cum_max(self, *, reverse: bool) -> Self:
+        return self._with_window_function(self._cum_window_func("max", reverse=reverse))
+
+    def cum_min(self, *, reverse: bool) -> Self:
+        return self._with_window_function(self._cum_window_func("min", reverse=reverse))
+
+    def cum_count(self, *, reverse: bool) -> Self:
+        return self._with_window_function(self._cum_window_func("count", reverse=reverse))
+
+    def cum_prod(self, *, reverse: bool) -> Self:
+        return self._with_window_function(
+            self._cum_window_func("product", reverse=reverse)
+        )
+
+    # Rolling
+    def rolling_sum(self, window_size: int, *, min_samples: int, center: bool) -> Self:
+        return self._with_window_function(
+            self._rolling_window_func("sum", window_size, min_samples, center=center)
+        )
+
+    def rolling_mean(self, window_size: int, *, min_samples: int, center: bool) -> Self:
+        return self._with_window_function(
+            self._rolling_window_func("mean", window_size, min_samples, center=center)
+        )
+
+    def rolling_var(
+        self, window_size: int, *, min_samples: int, center: bool, ddof: int
+    ) -> Self:
+        return self._with_window_function(
+            self._rolling_window_func(
+                "var", window_size, min_samples, ddof=ddof, center=center
+            )
+        )
+
+    def rolling_std(
+        self, window_size: int, *, min_samples: int, center: bool, ddof: int
+    ) -> Self:
+        return self._with_window_function(
+            self._rolling_window_func(
+                "std", window_size, min_samples, ddof=ddof, center=center
+            )
+        )
+
+    # Other window functions
+    def diff(self) -> Self:
+        def func(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            return [
+                expr  # type: ignore[operator]
+                - self._window_expression(
+                    self._function("lag", expr), inputs.partition_by, inputs.order_by
+                )
+                for expr in self(df)
+            ]
+
+        return self._with_window_function(func)
+
+    def shift(self, n: int) -> Self:
+        def func(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            return [
+                self._window_expression(
+                    self._function("lag", expr, n), inputs.partition_by, inputs.order_by
+                )
+                for expr in self(df)
+            ]
+
+        return self._with_window_function(func)
+
+    def is_first_distinct(self) -> Self:
+        def func(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            # pyright checkers think the return type is `list[bool]` because of `==`
+            return [
+                cast(
+                    "NativeExprT",
+                    self._window_expression(
+                        self._function("row_number"),
+                        (*inputs.partition_by, expr),
+                        inputs.order_by,
+                    )
+                    == self._lit(1),
+                )
+                for expr in self(df)
+            ]
+
+        return self._with_window_function(func)
+
+    def is_last_distinct(self) -> Self:
+        def func(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            return [
+                cast(
+                    "NativeExprT",
+                    self._window_expression(
+                        self._function("row_number"),
+                        (*inputs.partition_by, expr),
+                        inputs.order_by,
+                        descending=[True] * len(inputs.order_by),
+                        nulls_last=[True] * len(inputs.order_by),
+                    )
+                    == self._lit(1),
+                )
+                for expr in self(df)
+            ]
+
+        return self._with_window_function(func)
+
+    def rank(self, method: RankMethod, *, descending: bool) -> Self:
+        if method in {"min", "max", "average"}:
+            func = self._function("rank")
+        elif method == "dense":
+            func = self._function("dense_rank")
+        else:  # method == "ordinal"
+            func = self._function("row_number")
+
+        def _rank(
+            expr: NativeExprT,
+            partition_by: Sequence[str | NativeExprT] = (),
+            order_by: Sequence[str | NativeExprT] = (),
+            *,
+            descending: Sequence[bool],
+            nulls_last: Sequence[bool],
+        ) -> NativeExprT:
+            count_expr = self._count_star()
+            window_kwargs: dict[str, Any] = {
+                "partition_by": partition_by,
+                "order_by": (expr, *order_by),
+                "descending": descending,
+                "nulls_last": nulls_last,
+            }
+            count_window_kwargs: dict[str, Any] = {"partition_by": (*partition_by, expr)}
+            if method == "max":
+                rank_expr = (
+                    self._window_expression(func, **window_kwargs)  # type: ignore[operator]
+                    + self._window_expression(count_expr, **count_window_kwargs)
+                    - self._lit(1)
+                )
+            elif method == "average":
+                rank_expr = self._window_expression(func, **window_kwargs) + (
+                    self._window_expression(count_expr, **count_window_kwargs)  # type: ignore[operator]
+                    - self._lit(1)
+                ) / self._lit(2.0)
+            else:
+                rank_expr = self._window_expression(func, **window_kwargs)
+            return self._when(~self._function("isnull", expr), rank_expr)  # type: ignore[operator]
+
+        def _unpartitioned_rank(expr: NativeExprT) -> NativeExprT:
+            return _rank(expr, descending=[descending], nulls_last=[True])
+
+        def _partitioned_rank(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            # node: when `descending` / `nulls_last` are supported in `.over`, they should be respected here
+            # https://github.com/narwhals-dev/narwhals/issues/2790
+            return [
+                _rank(
+                    expr,
+                    inputs.partition_by,
+                    inputs.order_by,
+                    descending=[descending] + [False] * len(inputs.order_by),
+                    nulls_last=[True] + [False] * len(inputs.order_by),
+                )
+                for expr in self(df)
+            ]
+
+        return self._with_callable(_unpartitioned_rank)._with_window_function(
+            _partitioned_rank
+        )
+
+    def is_unique(self) -> Self:
+        def _is_unique(
+            expr: NativeExprT, *partition_by: str | NativeExprT
+        ) -> NativeExprT:
+            return cast(
+                "NativeExprT",
+                self._window_expression(self._count_star(), (expr, *partition_by))
+                == self._lit(1),
+            )
+
+        def _unpartitioned_is_unique(expr: NativeExprT) -> NativeExprT:
+            return _is_unique(expr)
+
+        def _partitioned_is_unique(
+            df: SQLLazyFrameT, inputs: WindowInputs[NativeExprT]
+        ) -> Sequence[NativeExprT]:
+            assert not inputs.order_by  # noqa: S101
+            return [_is_unique(expr, *inputs.partition_by) for expr in self(df)]
+
+        return self._with_callable(_unpartitioned_is_unique)._with_window_function(
+            _partitioned_is_unique
+        )
+
+    # Other
+    def over(
+        self, partition_by: Sequence[str | NativeExprT], order_by: Sequence[str]
+    ) -> Self:
+        def func(df: SQLLazyFrameT) -> Sequence[NativeExprT]:
+            return self.window_function(df, WindowInputs(partition_by, order_by))
+
+        return self.__class__(
+            func,
+            evaluate_output_names=self._evaluate_output_names,
+            alias_output_names=self._alias_output_names,
+            version=self._version,
+            implementation=self._implementation,
+        )
+
+    arg_max: not_implemented = not_implemented()
+    arg_min: not_implemented = not_implemented()
+    arg_true: not_implemented = not_implemented()
+    drop_nulls: not_implemented = not_implemented()
+    ewm_mean: not_implemented = not_implemented()
+    gather_every: not_implemented = not_implemented()
+    head: not_implemented = not_implemented()
+    map_batches: not_implemented = not_implemented()
+    mode: not_implemented = not_implemented()
+    replace_strict: not_implemented = not_implemented()
+    sort: not_implemented = not_implemented()
+    tail: not_implemented = not_implemented()
+    sample: not_implemented = not_implemented()
+    unique: not_implemented = not_implemented()
+
+    # namespaces
+    cat: not_implemented = not_implemented()  # type: ignore[assignment]

lib/python3.10/site-packages/narwhals/_sql/group_by.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+from narwhals._compliant.group_by import CompliantGroupBy, ParseKeysGroupBy
+from narwhals._compliant.typing import CompliantLazyFrameT_co, NativeExprT_co
+from narwhals._sql.typing import SQLExprT_contra
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
+
+class SQLGroupBy(
+    ParseKeysGroupBy[CompliantLazyFrameT_co, SQLExprT_contra],
+    CompliantGroupBy[CompliantLazyFrameT_co, SQLExprT_contra],
+    Protocol[CompliantLazyFrameT_co, SQLExprT_contra, NativeExprT_co],
+):
+    _keys: list[str]
+    _output_key_names: list[str]
+
+    def _evaluate_expr(self, expr: SQLExprT_contra, /) -> Iterator[NativeExprT_co]:
+        output_names = expr._evaluate_output_names(self.compliant)
+        aliases = (
+            expr._alias_output_names(output_names)
+            if expr._alias_output_names
+            else output_names
+        )
+        native_exprs = expr(self.compliant)
+        if expr._is_multi_output_unnamed():
+            exclude = {*self._keys, *self._output_key_names}
+            for native_expr, name, alias in zip(native_exprs, output_names, aliases):
+                if name not in exclude:
+                    yield expr._alias_native(native_expr, alias)
+        else:
+            for native_expr, alias in zip(native_exprs, aliases):
+                yield expr._alias_native(native_expr, alias)
+
+    def _evaluate_exprs(
+        self, exprs: Iterable[SQLExprT_contra], /
+    ) -> Iterator[NativeExprT_co]:
+        for expr in exprs:
+            yield from self._evaluate_expr(expr)

lib/python3.10/site-packages/narwhals/_sql/namespace.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import operator
+from functools import reduce
+from typing import TYPE_CHECKING, Any, Protocol
+
+from narwhals._compliant import LazyNamespace
+from narwhals._compliant.typing import NativeExprT, NativeFrameT_co
+from narwhals._sql.typing import SQLExprT, SQLLazyFrameT
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from narwhals.typing import PythonLiteral
+
+
+class SQLNamespace(
+    LazyNamespace[SQLLazyFrameT, SQLExprT, NativeFrameT_co],
+    Protocol[SQLLazyFrameT, SQLExprT, NativeFrameT_co, NativeExprT],
+):
+    def _function(self, name: str, *args: NativeExprT | PythonLiteral) -> NativeExprT: ...
+    def _lit(self, value: Any) -> NativeExprT: ...
+    def _when(self, condition: NativeExprT, value: NativeExprT) -> NativeExprT: ...
+    def _coalesce(self, *exprs: NativeExprT) -> NativeExprT: ...
+
+    # Horizontal functions
+    def any_horizontal(self, *exprs: SQLExprT, ignore_nulls: bool) -> SQLExprT:
+        def func(cols: Iterable[NativeExprT]) -> NativeExprT:
+            it = (
+                (self._coalesce(col, self._lit(False)) for col in cols)  # noqa: FBT003
+                if ignore_nulls
+                else cols
+            )
+            return reduce(operator.or_, it)
+
+        return self._expr._from_elementwise_horizontal_op(func, *exprs)
+
+    def all_horizontal(self, *exprs: SQLExprT, ignore_nulls: bool) -> SQLExprT:
+        def func(cols: Iterable[NativeExprT]) -> NativeExprT:
+            it = (
+                (self._coalesce(col, self._lit(True)) for col in cols)  # noqa: FBT003
+                if ignore_nulls
+                else cols
+            )
+            return reduce(operator.and_, it)
+
+        return self._expr._from_elementwise_horizontal_op(func, *exprs)
+
+    def max_horizontal(self, *exprs: SQLExprT) -> SQLExprT:
+        def func(cols: Iterable[NativeExprT]) -> NativeExprT:
+            return self._function("greatest", *cols)
+
+        return self._expr._from_elementwise_horizontal_op(func, *exprs)
+
+    def min_horizontal(self, *exprs: SQLExprT) -> SQLExprT:
+        def func(cols: Iterable[NativeExprT]) -> NativeExprT:
+            return self._function("least", *cols)
+
+        return self._expr._from_elementwise_horizontal_op(func, *exprs)
+
+    def sum_horizontal(self, *exprs: SQLExprT) -> SQLExprT:
+        def func(cols: Iterable[NativeExprT]) -> NativeExprT:
+            return reduce(
+                operator.add, (self._coalesce(col, self._lit(0)) for col in cols)
+            )
+
+        return self._expr._from_elementwise_horizontal_op(func, *exprs)
+
+    # Other
+    def coalesce(self, *exprs: SQLExprT) -> SQLExprT:
+        def func(cols: Iterable[NativeExprT]) -> NativeExprT:
+            return self._coalesce(*cols)
+
+        return self._expr._from_elementwise_horizontal_op(func, *exprs)

lib/python3.10/site-packages/narwhals/_sql/typing.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, TypeVar
+
+if TYPE_CHECKING:
+    from narwhals._sql.dataframe import SQLLazyFrame
+    from narwhals._sql.expr import SQLExpr
+
+    SQLExprAny = SQLExpr[Any, Any]
+    SQLLazyFrameAny = SQLLazyFrame[Any, Any, Any]
+
+SQLExprT = TypeVar("SQLExprT", bound="SQLExprAny")
+SQLExprT_contra = TypeVar("SQLExprT_contra", bound="SQLExprAny", contravariant=True)
+SQLLazyFrameT = TypeVar("SQLLazyFrameT", bound="SQLLazyFrameAny")

lib/python3.10/site-packages/narwhals/_sql/when_then.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+from narwhals._compliant.typing import NativeExprT
+from narwhals._compliant.when_then import CompliantThen, CompliantWhen
+from narwhals._sql.typing import SQLExprT, SQLLazyFrameT
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from typing_extensions import Self
+
+    from narwhals._compliant.typing import WindowFunction
+    from narwhals._compliant.when_then import IntoExpr
+    from narwhals._compliant.window import WindowInputs
+    from narwhals._utils import _LimitedContext
+
+
+class SQLWhen(
+    CompliantWhen[SQLLazyFrameT, NativeExprT, SQLExprT],
+    Protocol[SQLLazyFrameT, NativeExprT, SQLExprT],
+):
+    @property
+    def _then(self) -> type[SQLThen[SQLLazyFrameT, NativeExprT, SQLExprT]]: ...
+
+    def __call__(self, df: SQLLazyFrameT) -> Sequence[NativeExprT]:
+        is_expr = self._condition._is_expr
+        when = df.__narwhals_namespace__()._when
+        lit = df.__narwhals_namespace__()._lit
+        condition = df._evaluate_expr(self._condition)
+        then_ = self._then_value
+        then = df._evaluate_expr(then_) if is_expr(then_) else lit(then_)
+        other_ = self._otherwise_value
+        if other_ is None:
+            result = when(condition, then)
+        else:
+            otherwise = df._evaluate_expr(other_) if is_expr(other_) else lit(other_)
+            result = when(condition, then).otherwise(otherwise)
+        return [result]
+
+    @classmethod
+    def from_expr(cls, condition: SQLExprT, /, *, context: _LimitedContext) -> Self:
+        obj = cls.__new__(cls)
+        obj._condition = condition
+        obj._then_value = None
+        obj._otherwise_value = None
+        obj._implementation = context._implementation
+        obj._version = context._version
+        return obj
+
+    def _window_function(
+        self, df: SQLLazyFrameT, window_inputs: WindowInputs[NativeExprT]
+    ) -> Sequence[NativeExprT]:
+        when = df.__narwhals_namespace__()._when
+        lit = df.__narwhals_namespace__()._lit
+        is_expr = self._condition._is_expr
+        condition = self._condition.window_function(df, window_inputs)[0]
+        then_ = self._then_value
+        then = (
+            then_.window_function(df, window_inputs)[0] if is_expr(then_) else lit(then_)
+        )
+
+        other_ = self._otherwise_value
+        if other_ is None:
+            result = when(condition, then)
+        else:
+            other = (
+                other_.window_function(df, window_inputs)[0]
+                if is_expr(other_)
+                else lit(other_)
+            )
+            result = when(condition, then).otherwise(other)
+        return [result]
+
+
+class SQLThen(
+    CompliantThen[
+        SQLLazyFrameT,
+        NativeExprT,
+        SQLExprT,
+        SQLWhen[SQLLazyFrameT, NativeExprT, SQLExprT],
+    ],
+    Protocol[SQLLazyFrameT, NativeExprT, SQLExprT],
+):
+    _window_function: WindowFunction[SQLLazyFrameT, NativeExprT] | None
+
+    @classmethod
+    def from_when(
+        cls,
+        when: SQLWhen[SQLLazyFrameT, NativeExprT, SQLExprT],
+        then: IntoExpr[NativeExprT, SQLExprT],
+        /,
+    ) -> Self:
+        when._then_value = then
+        obj = cls.__new__(cls)
+        obj._call = when
+        obj._window_function = when._window_function
+        obj._when_value = when
+        obj._evaluate_output_names = getattr(
+            then, "_evaluate_output_names", lambda _df: ["literal"]
+        )
+        obj._alias_output_names = getattr(then, "_alias_output_names", None)
+        obj._implementation = when._implementation
+        obj._version = when._version
+        return obj