streamlit-nightly 1.21.1.dev20230423__py2.py3-none-any.whl → 1.21.1.dev20230425__py2.py3-none-any.whl

streamlit/elements/file_uploader.py

@@ -43,6 +43,15 @@ from streamlit.type_util import Key, LabelVisibility, maybe_raise_label_warnings
 SomeUploadedFiles = Optional[Union[UploadedFile, List[UploadedFile]]]
 
 
+TYPE_PAIRS = [
+    (".jpg", ".jpeg"),
+    (".mpg", ".mpeg"),
+    (".mp4", ".mpeg4"),
+    (".tif", ".tiff"),
+    (".htm", ".html"),
+]
+
+
 def _get_file_recs(
     widget_id: str, widget_value: Optional[FileUploaderStateProto]
 ) -> List[UploadedFileRec]:
@@ -390,6 +399,14 @@ class FileUploaderMixin:
                 for file_type in type
             ]
 
+            type = [t.lower() for t in type]
+
+            for x, y in TYPE_PAIRS:
+                if x in type and y not in type:
+                    type.append(y)
+                if y in type and x not in type:
+                    type.append(x)
+
         file_uploader_proto = FileUploaderProto()
         file_uploader_proto.label = label
         file_uploader_proto.type[:] = type if type is not None else []

streamlit/elements/layouts.py

@@ -416,8 +416,3 @@ class LayoutsMixin:
     def dg(self) -> "DeltaGenerator":
         """Get our DeltaGenerator."""
         return cast("DeltaGenerator", self)
-
-    # Deprecated beta_ functions
-    beta_container = deprecate_func_name(container, "beta_container", "2021-11-02")
-    beta_expander = deprecate_func_name(expander, "beta_expander", "2021-11-02")
-    beta_columns = deprecate_func_name(columns, "beta_columns", "2021-11-02")

streamlit/elements/lib/column_config_utils.py

@@ -0,0 +1,371 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+import pandas as pd
+import pyarrow as pa
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+from streamlit.proto.Arrow_pb2 import Arrow as ArrowProto
+
+# The index identifier can be used to apply configuration options
+IndexIdentifierType = Literal["index"]
+INDEX_IDENTIFIER: IndexIdentifierType = "index"
+
+# This is used as prefix for columns that are configured via the numerical position.
+# The integer value is converted into a string key with this prefix.
+# This needs to match with the prefix configured in the frontend.
+_NUMERICAL_POSITION_PREFIX = "col:"
+
+ColumnWidth = Literal["small", "medium", "large"]
+
+# Type alias that represents all available column types
+# which are configurable by the user.
+ColumnType: TypeAlias = Literal[
+    "object", "text", "number", "checkbox", "selectbox", "list"
+]
+
+
+# The column data kind is used to describe the type of the data within the column.
+class ColumnDataKind(str, Enum):
+    INTEGER = "integer"
+    FLOAT = "float"
+    DATE = "date"
+    TIME = "time"
+    DATETIME = "datetime"
+    BOOLEAN = "boolean"
+    STRING = "string"
+    TIMEDELTA = "timedelta"
+    PERIOD = "period"
+    INTERVAL = "interval"
+    BYTES = "bytes"
+    DECIMAL = "decimal"
+    COMPLEX = "complex"
+    LIST = "list"
+    DICT = "dict"
+    EMPTY = "empty"
+    UNKNOWN = "unknown"
+
+
+# The dataframe schema is just a list of column data kinds
+# based on the order of the columns in the underlying dataframe.
+# The index column(s) are attached at the beginning of the list.
+DataframeSchema: TypeAlias = List[ColumnDataKind]
+
+
+def _determine_data_kind_via_arrow(field: pa.Field) -> ColumnDataKind:
+    """Determine the data kind via the arrow type information.
+
+    The column data kind refers to the shared data type of the values
+    in the column (e.g. integer, float, string, bool).
+
+    Parameters
+    ----------
+
+    field : pa.Field
+        The arrow field from the arrow table schema.
+
+    Returns
+    -------
+    ColumnDataKind
+        The data kind of the field.
+    """
+    field_type = field.type
+    if pa.types.is_integer(field_type):
+        return ColumnDataKind.INTEGER
+
+    if pa.types.is_floating(field_type):
+        return ColumnDataKind.FLOAT
+
+    if pa.types.is_boolean(field_type):
+        return ColumnDataKind.BOOLEAN
+
+    if pa.types.is_string(field_type):
+        return ColumnDataKind.STRING
+
+    if pa.types.is_date(field_type):
+        return ColumnDataKind.DATE
+
+    if pa.types.is_time(field_type):
+        return ColumnDataKind.TIME
+
+    if pa.types.is_timestamp(field_type):
+        return ColumnDataKind.DATETIME
+
+    if pa.types.is_duration(field_type):
+        return ColumnDataKind.TIMEDELTA
+
+    if pa.types.is_list(field_type):
+        return ColumnDataKind.LIST
+
+    if pa.types.is_decimal(field_type):
+        return ColumnDataKind.DECIMAL
+
+    if pa.types.is_null(field_type):
+        return ColumnDataKind.EMPTY
+
+    # Interval does not seem to work correctly:
+    # if pa.types.is_interval(field_type):
+    #     return ColumnDataKind.INTERVAL
+
+    if pa.types.is_binary(field_type):
+        return ColumnDataKind.BYTES
+
+    if pa.types.is_struct(field_type):
+        return ColumnDataKind.DICT
+
+    return ColumnDataKind.UNKNOWN
+
+
+def _determine_data_kind_via_pandas_dtype(
+    column: pd.Series | pd.Index,
+) -> ColumnDataKind:
+    """Determine the data kind by using the pandas dtype.
+
+    The column data kind refers to the shared data type of the values
+    in the column (e.g. integer, float, string, bool).
+
+    Parameters
+    ----------
+    column : pd.Series, pd.Index
+        The column for which the data kind should be determined.
+
+    Returns
+    -------
+    ColumnDataKind
+        The data kind of the column.
+    """
+    column_dtype = column.dtype
+    if pd.api.types.is_bool_dtype(column_dtype):
+        return ColumnDataKind.BOOLEAN
+
+    if pd.api.types.is_integer_dtype(column_dtype):
+        return ColumnDataKind.INTEGER
+
+    if pd.api.types.is_float_dtype(column_dtype):
+        return ColumnDataKind.FLOAT
+
+    if pd.api.types.is_datetime64_any_dtype(column_dtype):
+        return ColumnDataKind.DATETIME
+
+    if pd.api.types.is_timedelta64_dtype(column_dtype):
+        return ColumnDataKind.TIMEDELTA
+
+    if pd.api.types.is_period_dtype(column_dtype):
+        return ColumnDataKind.PERIOD
+
+    if pd.api.types.is_interval_dtype(column_dtype):
+        return ColumnDataKind.INTERVAL
+
+    if pd.api.types.is_complex_dtype(column_dtype):
+        return ColumnDataKind.COMPLEX
+
+    if pd.api.types.is_object_dtype(
+        column_dtype
+    ) is False and pd.api.types.is_string_dtype(column_dtype):
+        # The is_string_dtype
+        return ColumnDataKind.STRING
+
+    return ColumnDataKind.UNKNOWN
+
+
+def _determine_data_kind_via_inferred_type(
+    column: pd.Series | pd.Index,
+) -> ColumnDataKind:
+    """Determine the data kind by inferring it from the underlying data.
+
+    The column data kind refers to the shared data type of the values
+    in the column (e.g. integer, float, string, bool).
+
+    Parameters
+    ----------
+    column : pd.Series, pd.Index
+        The column to determine the data kind for.
+
+    Returns
+    -------
+    ColumnDataKind
+        The data kind of the column.
+    """
+
+    inferred_type = pd.api.types.infer_dtype(column)
+
+    if inferred_type == "string":
+        return ColumnDataKind.STRING
+
+    if inferred_type == "bytes":
+        return ColumnDataKind.BYTES
+
+    if inferred_type in ["floating", "mixed-integer-float"]:
+        return ColumnDataKind.FLOAT
+
+    if inferred_type == "integer":
+        return ColumnDataKind.INTEGER
+
+    if inferred_type == "decimal":
+        return ColumnDataKind.DECIMAL
+
+    if inferred_type == "complex":
+        return ColumnDataKind.COMPLEX
+
+    if inferred_type == "boolean":
+        return ColumnDataKind.BOOLEAN
+
+    if inferred_type in ["datetime64", "datetime"]:
+        return ColumnDataKind.DATETIME
+
+    if inferred_type == "date":
+        return ColumnDataKind.DATE
+
+    if inferred_type in ["timedelta64", "timedelta"]:
+        return ColumnDataKind.TIMEDELTA
+
+    if inferred_type == "time":
+        return ColumnDataKind.TIME
+
+    if inferred_type == "period":
+        return ColumnDataKind.PERIOD
+
+    if inferred_type == "interval":
+        return ColumnDataKind.INTERVAL
+
+    if inferred_type == "empty":
+        return ColumnDataKind.EMPTY
+
+    # TODO(lukasmasuch): Unused types: mixed, unknown-array, categorical, mixed-integer
+    return ColumnDataKind.UNKNOWN
+
+
+def _determine_data_kind(
+    column: pd.Series | pd.Index, field: Optional[pa.Field] = None
+) -> ColumnDataKind:
+    """Determine the data kind of a column.
+
+    The column data kind refers to the shared data type of the values
+    in the column (e.g. integer, float, string, bool).
+
+    Parameters
+    ----------
+    column : pd.Series, pd.Index
+        The column to determine the data kind for.
+    field : pa.Field, optional
+        The arrow field from the arrow table schema.
+
+    Returns
+    -------
+    ColumnDataKind
+        The data kind of the column.
+    """
+
+    if pd.api.types.is_categorical_dtype(column.dtype):
+        # Categorical columns can have different underlying data kinds
+        # depending on the categories.
+        return _determine_data_kind_via_inferred_type(column.dtype.categories)
+
+    if field is not None:
+        data_kind = _determine_data_kind_via_arrow(field)
+        if data_kind != ColumnDataKind.UNKNOWN:
+            return data_kind
+
+    if column.dtype.name == "object":
+        # If dtype is object, we need to infer the type from the column
+        return _determine_data_kind_via_inferred_type(column)
+    return _determine_data_kind_via_pandas_dtype(column)
+
+
+def determine_dataframe_schema(
+    data_df: pd.DataFrame, arrow_schema: pa.Schema
+) -> DataframeSchema:
+    """Determine the schema of a dataframe.
+
+    Parameters
+    ----------
+    data_df : pd.DataFrame
+        The dataframe to determine the schema of.
+    arrow_schema : pa.Schema
+        The Arrow schema of the dataframe.
+
+    Returns
+    -------
+
+    DataframeSchema
+        A list that contains the detected data type for the index and columns.
+        It starts with the index and then contains the columns in the original order.
+    """
+
+    dataframe_schema: DataframeSchema = []
+
+    # Add type of index:
+    dataframe_schema.append(_determine_data_kind(data_df.index))
+
+    # Add types for all columns:
+    for i, column in enumerate(data_df.items()):
+        _, column_data = column
+        dataframe_schema.append(
+            _determine_data_kind(column_data, arrow_schema.field(i))
+        )
+    return dataframe_schema
+
+
+class ColumnConfig(TypedDict, total=False):
+    title: Optional[str]
+    width: Optional[Literal["small", "medium", "large"]]
+    hidden: Optional[bool]
+    disabled: Optional[bool]
+    required: Optional[bool]
+    alignment: Optional[Literal["left", "center", "right"]]
+    help: Optional[str]
+    type: Optional[ColumnType]
+    type_options: Optional[Dict[str, Any]]
+
+
+# A mapping of column names/IDs to column configs.
+ColumnConfigMapping: TypeAlias = Dict[Union[IndexIdentifierType, str], ColumnConfig]
+
+
+def marshall_column_config(
+    proto: ArrowProto, column_config_mapping: ColumnConfigMapping
+) -> None:
+    """Marshall the column config into the Arrow proto.
+
+    Parameters
+    ----------
+    proto : ArrowProto
+        The proto to marshall into.
+
+    column_config_mapping : ColumnConfigMapping
+        The column config to marshall.
+    """
+
+    # Ignore all None values and prefix columns specified by numerical index
+    def remove_none_values(input_dict: Dict[Any, Any]) -> Dict[Any, Any]:
+        new_dict = {}
+        for key, val in input_dict.items():
+            if isinstance(val, dict):
+                val = remove_none_values(val)
+            if val is not None:
+                new_dict[key] = val
+        return new_dict
+
+    proto.columns = json.dumps(
+        {
+            (f"{_NUMERICAL_POSITION_PREFIX}{str(k)}" if isinstance(k, int) else k): v
+            for (k, v) in remove_none_values(column_config_mapping).items()
+        }
+    )

streamlit/elements/lib/pandas_styler_utils.py

@@ -0,0 +1,275 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import TYPE_CHECKING, Any, List, Mapping, TypeVar
+
+from pandas import DataFrame
+from pandas.io.formats.style import Styler
+
+from streamlit import type_util
+from streamlit.proto.Arrow_pb2 import Arrow as ArrowProto
+
+if TYPE_CHECKING:
+    from pandas.io.formats.style import Styler
+
+
+def marshall_styler(proto: ArrowProto, styler: "Styler", default_uuid: str) -> None:
+    """Marshall pandas.Styler into an Arrow proto.
+
+    Parameters
+    ----------
+    proto : proto.Arrow
+        Output. The protobuf for Streamlit Arrow proto.
+
+    styler : pandas.Styler
+        Helps style a DataFrame or Series according to the data with HTML and CSS.
+
+    default_uuid : str
+        If pandas.Styler uuid is not provided, this value will be used.
+
+    """
+    # pandas.Styler uuid should be set before _compute is called.
+    _marshall_uuid(proto, styler, default_uuid)
+
+    # We're using protected members of pandas.Styler to get styles,
+    # which is not ideal and could break if the interface changes.
+    styler._compute()
+
+    # In Pandas 1.3.0, styler._translate() signature was changed.
+    # 2 arguments were added: sparse_index and sparse_columns.
+    # The functionality that they provide is not yet supported.
+    if type_util.is_pandas_version_less_than("1.3.0"):
+        pandas_styles = styler._translate()
+    else:
+        pandas_styles = styler._translate(False, False)
+
+    _marshall_caption(proto, styler)
+    _marshall_styles(proto, styler, pandas_styles)
+    _marshall_display_values(proto, styler.data, pandas_styles)
+
+
+def _marshall_uuid(proto: ArrowProto, styler: "Styler", default_uuid: str) -> None:
+    """Marshall pandas.Styler uuid into an Arrow proto.
+
+    Parameters
+    ----------
+    proto : proto.Arrow
+        Output. The protobuf for Streamlit Arrow proto.
+
+    styler : pandas.Styler
+        Helps style a DataFrame or Series according to the data with HTML and CSS.
+
+    default_uuid : str
+        If pandas.Styler uuid is not provided, this value will be used.
+
+    """
+    if styler.uuid is None:
+        styler.set_uuid(default_uuid)
+
+    proto.styler.uuid = str(styler.uuid)
+
+
+def _marshall_caption(proto: ArrowProto, styler: "Styler") -> None:
+    """Marshall pandas.Styler caption into an Arrow proto.
+
+    Parameters
+    ----------
+    proto : proto.Arrow
+        Output. The protobuf for Streamlit Arrow proto.
+
+    styler : pandas.Styler
+        Helps style a DataFrame or Series according to the data with HTML and CSS.
+
+    """
+    if styler.caption is not None:
+        proto.styler.caption = styler.caption
+
+
+def _marshall_styles(
+    proto: ArrowProto, styler: "Styler", styles: Mapping[str, Any]
+) -> None:
+    """Marshall pandas.Styler styles into an Arrow proto.
+
+    Parameters
+    ----------
+    proto : proto.Arrow
+        Output. The protobuf for Streamlit Arrow proto.
+
+    styler : pandas.Styler
+        Helps style a DataFrame or Series according to the data with HTML and CSS.
+
+    styles : dict
+        pandas.Styler translated styles.
+
+    """
+    css_rules = []
+
+    if "table_styles" in styles:
+        table_styles = styles["table_styles"]
+        table_styles = _trim_pandas_styles(table_styles)
+        for style in table_styles:
+            # styles in "table_styles" have a space
+            # between the uuid and selector.
+            rule = _pandas_style_to_css(
+                "table_styles", style, styler.uuid, separator=" "
+            )
+            css_rules.append(rule)
+
+    if "cellstyle" in styles:
+        cellstyle = styles["cellstyle"]
+        cellstyle = _trim_pandas_styles(cellstyle)
+        for style in cellstyle:
+            rule = _pandas_style_to_css("cell_style", style, styler.uuid)
+            css_rules.append(rule)
+
+    if len(css_rules) > 0:
+        proto.styler.styles = "\n".join(css_rules)
+
+
+M = TypeVar("M", bound=Mapping[str, Any])
+
+
+def _trim_pandas_styles(styles: List[M]) -> List[M]:
+    """Filter out empty styles.
+
+    Every cell will have a class, but the list of props
+    may just be [['', '']].
+
+    Parameters
+    ----------
+    styles : list
+        pandas.Styler translated styles.
+
+    """
+    return [x for x in styles if any(any(y) for y in x["props"])]
+
+
+def _pandas_style_to_css(
+    style_type: str,
+    style: Mapping[str, Any],
+    uuid: str,
+    separator: str = "",
+) -> str:
+    """Convert pandas.Styler translated style to CSS.
+
+    Parameters
+    ----------
+    style_type : str
+        Either "table_styles" or "cell_style".
+
+    style : dict
+        pandas.Styler translated style.
+
+    uuid : str
+        pandas.Styler uuid.
+
+    separator : str
+        A string separator used between table and cell selectors.
+
+    """
+    declarations = []
+    for css_property, css_value in style["props"]:
+        declaration = css_property.strip() + ": " + css_value.strip()
+        declarations.append(declaration)
+
+    table_selector = f"#T_{uuid}"
+
+    # In pandas < 1.1.0
+    # translated_style["cellstyle"] has the following shape:
+    # [
+    #   {
+    #       "props": [["color", " black"], ["background-color", "orange"], ["", ""]],
+    #       "selector": "row0_col0"
+    #   }
+    #   ...
+    # ]
+    #
+    # In pandas >= 1.1.0
+    # translated_style["cellstyle"] has the following shape:
+    # [
+    #   {
+    #       "props": [("color", " black"), ("background-color", "orange"), ("", "")],
+    #       "selectors": ["row0_col0"]
+    #   }
+    #   ...
+    # ]
+    if style_type == "table_styles" or (
+        style_type == "cell_style" and type_util.is_pandas_version_less_than("1.1.0")
+    ):
+        cell_selectors = [style["selector"]]
+    else:
+        cell_selectors = style["selectors"]
+
+    selectors = []
+    for cell_selector in cell_selectors:
+        selectors.append(table_selector + separator + cell_selector)
+    selector = ", ".join(selectors)
+
+    declaration_block = "; ".join(declarations)
+    rule_set = selector + " { " + declaration_block + " }"
+
+    return rule_set
+
+
+def _marshall_display_values(
+    proto: ArrowProto, df: DataFrame, styles: Mapping[str, Any]
+) -> None:
+    """Marshall pandas.Styler display values into an Arrow proto.
+
+    Parameters
+    ----------
+    proto : proto.Arrow
+        Output. The protobuf for Streamlit Arrow proto.
+
+    df : pandas.DataFrame
+        A dataframe with original values.
+
+    styles : dict
+        pandas.Styler translated styles.
+
+    """
+    new_df = _use_display_values(df, styles)
+    proto.styler.display_values = type_util.data_frame_to_bytes(new_df)
+
+
+def _use_display_values(df: DataFrame, styles: Mapping[str, Any]) -> DataFrame:
+    """Create a new pandas.DataFrame where display values are used instead of original ones.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        A dataframe with original values.
+
+    styles : dict
+        pandas.Styler translated styles.
+
+    """
+    import re
+
+    # If values in a column are not of the same type, Arrow
+    # serialization would fail. Thus, we need to cast all values
+    # of the dataframe to strings before assigning them display values.
+    new_df = df.astype(str)
+
+    cell_selector_regex = re.compile(r"row(\d+)_col(\d+)")
+    if "body" in styles:
+        rows = styles["body"]
+        for row in rows:
+            for cell in row:
+                match = cell_selector_regex.match(cell["id"])
+                if match:
+                    r, c = map(int, match.groups())
+                    new_df.iat[r, c] = str(cell["display_value"])
+
+    return new_df