streamlit 1.45.1__py3-none-any.whl → 1.46.1__py3-none-any.whl

streamlit/elements/lib/image_utils.py

@@ -97,12 +97,12 @@ def _validate_image_format_string(
     - For all other strings, return "PNG" if the image has an alpha channel,
     "GIF" if the image is a GIF, and "JPEG" otherwise.
     """
-    format = format.upper()
-    if format in {"JPEG", "PNG"}:
-        return cast("ImageFormat", format)
+    img_format = format.upper()
+    if img_format in {"JPEG", "PNG"}:
+        return cast("ImageFormat", img_format)
 
     # We are forgiving on the spelling of JPEG
-    if format == "JPG":
+    if img_format == "JPG":
         return "JPEG"
 
     pil_image: PILImage
@@ -122,7 +122,7 @@ def _validate_image_format_string(
     return "JPEG"
 
 
-def _PIL_to_bytes(
+def _pil_to_bytes(
     image: PILImage,
     format: ImageFormat = "JPEG",
     quality: int = 100,
@@ -139,7 +139,7 @@ def _PIL_to_bytes(
     return tmp.getvalue()
 
 
-def _BytesIO_to_bytes(data: io.BytesIO) -> bytes:
+def _bytesio_to_bytes(data: io.BytesIO) -> bytes:
     data.seek(0)
     return data.getvalue()
 
@@ -149,9 +149,9 @@ def _np_array_to_bytes(array: npt.NDArray[Any], output_format: str = "JPEG") ->
     from PIL import Image
 
     img = Image.fromarray(array.astype(np.uint8))
-    format = _validate_image_format_string(img, output_format)
+    img_format = _validate_image_format_string(img, output_format)
 
-    return _PIL_to_bytes(img, format)
+    return _pil_to_bytes(img, img_format)
 
 
 def _verify_np_shape(array: npt.NDArray[Any]) -> npt.NDArray[Any]:
@@ -160,8 +160,7 @@ def _verify_np_shape(array: npt.NDArray[Any]) -> npt.NDArray[Any]:
         raise StreamlitAPIException("Numpy shape has to be of length 2 or 3.")
     if len(shape) == 3 and shape[-1] not in (1, 3, 4):
         raise StreamlitAPIException(
-            "Channel can only be 1, 3, or 4 got %d. Shape is %s"
-            % (shape[-1], str(shape))
+            f"Channel can only be 1, 3, or 4 got {shape[-1]}. Shape is {shape}"
         )
 
     # If there's only one channel, convert is to x, y
@@ -199,11 +198,11 @@ def _ensure_image_size_and_format(
         # versions. The types don't seem to reflect this, though, hence the type: ignore
         # below.
         pil_image = pil_image.resize((width, new_height), resample=Image.BILINEAR)  # type: ignore[attr-defined]
-        return _PIL_to_bytes(pil_image, format=image_format, quality=90)
+        return _pil_to_bytes(pil_image, format=image_format, quality=90)
 
     if pil_image.format != image_format:
         # We need to reformat the image.
-        return _PIL_to_bytes(pil_image, format=image_format, quality=90)
+        return _pil_to_bytes(pil_image, format=image_format, quality=90)
 
     # No resizing or reformatting necessary - return the original bytes.
     return image_data
@@ -216,16 +215,13 @@ def _clip_image(image: npt.NDArray[Any], clamp: bool) -> npt.NDArray[Any]:
     if issubclass(image.dtype.type, np.floating):
         if clamp:
             data = np.clip(image, 0, 1.0)
-        else:
-            if np.amin(image) < 0.0 or np.amax(image) > 1.0:
-                raise RuntimeError("Data is outside [0.0, 1.0] and clamp is not set.")
+        elif np.amin(image) < 0.0 or np.amax(image) > 1.0:
+            raise RuntimeError("Data is outside [0.0, 1.0] and clamp is not set.")
         data = data * 255
-    else:
-        if clamp:
-            data = np.clip(image, 0, 255)
-        else:
-            if np.amin(image) < 0 or np.amax(image) > 255:
-                raise RuntimeError("Data is outside [0, 255] and clamp is not set.")
+    elif clamp:
+        data = np.clip(image, 0, 255)
+    elif np.amin(image) < 0 or np.amax(image) > 255:
+        raise RuntimeError("Data is outside [0, 255] and clamp is not set.")
     return data
 
 
@@ -301,14 +297,14 @@ def image_to_url(
 
     # PIL Images
     elif isinstance(image, (ImageFile.ImageFile, Image.Image)):
-        format = _validate_image_format_string(image, output_format)
-        image_data = _PIL_to_bytes(image, format)
+        img_format = _validate_image_format_string(image, output_format)
+        image_data = _pil_to_bytes(image, img_format)
 
     # BytesIO
     # Note: This doesn't support SVG. We could convert to png (cairosvg.svg2png)
     # or just decode BytesIO to string and handle that way.
     elif isinstance(image, io.BytesIO):
-        image_data = _BytesIO_to_bytes(image)
+        image_data = _bytesio_to_bytes(image)
 
     # Numpy Arrays (ie opencv)
     elif isinstance(image, np.ndarray):
@@ -338,9 +334,8 @@ def image_to_url(
         url = runtime.get_instance().media_file_mgr.add(image_data, mimetype, image_id)
         caching.save_media_data(image_data, mimetype, image_id)
         return url
-    else:
-        # When running in "raw mode", we can't access the MediaFileManager.
-        return ""
+    # When running in "raw mode", we can't access the MediaFileManager.
+    return ""
 
 
 def _4d_to_list_3d(array: npt.NDArray[Any]) -> list[npt.NDArray[Any]]:
@@ -363,7 +358,7 @@ def marshall_images(
     Parameters
     ----------
     coordinates
-        A string indentifying the images' location in the frontend.
+        A string identifying the images' location in the frontend.
     image
         The image or images to include in the ImageListProto.
     caption
@@ -420,25 +415,29 @@ def marshall_images(
     else:
         captions = [str(caption)]
 
-    assert isinstance(captions, list), (
-        "If image is a list then caption should be as well"
-    )
-    assert len(captions) == len(images), "Cannot pair %d captions with %d images." % (
-        len(captions),
-        len(images),
-    )
+    if not isinstance(captions, list):
+        raise StreamlitAPIException(
+            "If image is a list then caption should be a list as well."
+        )
+
+    if len(captions) != len(images):
+        raise StreamlitAPIException(
+            f"Cannot pair {len(captions)} captions with {len(images)} images."
+        )
 
     proto_imgs.width = int(width)
     # Each image in an image list needs to be kept track of at its own coordinates.
-    for coord_suffix, (image, caption) in enumerate(zip(images, captions)):
+    for coord_suffix, (single_image, single_caption) in enumerate(
+        zip(images, captions)
+    ):
         proto_img = proto_imgs.imgs.add()
-        if caption is not None:
-            proto_img.caption = str(caption)
+        if single_caption is not None:
+            proto_img.caption = str(single_caption)
 
         # We use the index of the image in the input image list to identify this image inside
         # MediaFileManager. For this, we just add the index to the image's "coordinates".
-        image_id = "%s-%i" % (coordinates, coord_suffix)
+        image_id = f"{coordinates}-{coord_suffix}"
 
         proto_img.url = image_to_url(
-            image, width, clamp, channels, output_format, image_id
+            single_image, width, clamp, channels, output_format, image_id
         )

streamlit/elements/lib/js_number.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import numbers
 
 
-class JSNumberBoundsException(Exception):
+class JSNumberBoundsException(Exception):  # noqa: N818
     pass
 
 
@@ -67,7 +67,7 @@ class JSNumber:
             raise JSNumberBoundsException(
                 f"{value_name} ({value}) must be >= -((1 << 53) - 1)"
             )
-        elif value > cls.MAX_SAFE_INTEGER:
+        if value > cls.MAX_SAFE_INTEGER:
             raise JSNumberBoundsException(
                 f"{value_name} ({value}) must be <= (1 << 53) - 1"
             )
@@ -95,11 +95,11 @@ class JSNumber:
 
         if not isinstance(value, (numbers.Integral, float)):
             raise JSNumberBoundsException(f"{value_name} ({value}) is not a float")
-        elif value < cls.MIN_NEGATIVE_VALUE:
+        if value < cls.MIN_NEGATIVE_VALUE:
             raise JSNumberBoundsException(
                 f"{value_name} ({value}) must be >= -1.797e+308"
             )
-        elif value > cls.MAX_VALUE:
+        if value > cls.MAX_VALUE:
             raise JSNumberBoundsException(
                 f"{value_name} ({value}) must be <= 1.797e+308"
             )

streamlit/elements/lib/layout_utils.py

@@ -11,15 +11,27 @@
 # 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
 
+from dataclasses import dataclass
 from typing import Literal, Union
 
 from typing_extensions import TypeAlias
 
-from streamlit.errors import StreamlitInvalidWidthError
+from streamlit.errors import StreamlitInvalidHeightError, StreamlitInvalidWidthError
+from streamlit.proto.HeightConfig_pb2 import HeightConfig
+from streamlit.proto.WidthConfig_pb2 import WidthConfig
 
 WidthWithoutContent: TypeAlias = Union[int, Literal["stretch"]]
 Width: TypeAlias = Union[int, Literal["stretch", "content"]]
+HeightWithoutContent: TypeAlias = Union[int, Literal["stretch"]]
+Height: TypeAlias = Union[int, Literal["stretch", "content"]]
+
+
+@dataclass
+class LayoutConfig:
+    width: Width | None = None
+    height: Height | None = None
 
 
 def validate_width(width: Width, allow_content: bool = False) -> None:
@@ -49,3 +61,55 @@ def validate_width(width: Width, allow_content: bool = False) -> None:
             raise StreamlitInvalidWidthError(width, allow_content)
     elif width <= 0:
         raise StreamlitInvalidWidthError(width, allow_content)
+
+
+def validate_height(height: Height, allow_content: bool = False) -> None:
+    """Validate the height parameter.
+
+    Parameters
+    ----------
+    height : Any
+        The height value to validate.
+    allow_content : bool
+        Whether to allow "content" as a valid height value.
+
+    Raises
+    ------
+    StreamlitInvalidHeightError
+        If the height value is invalid.
+    """
+    if not isinstance(height, (int, str)):
+        raise StreamlitInvalidHeightError(height, allow_content)
+
+    if isinstance(height, str):
+        valid_strings = ["stretch"]
+        if allow_content:
+            valid_strings.append("content")
+
+        if height not in valid_strings:
+            raise StreamlitInvalidHeightError(height, allow_content)
+
+    elif height <= 0:
+        raise StreamlitInvalidHeightError(height, allow_content)
+
+
+def get_width_config(width: Width) -> WidthConfig:
+    width_config = WidthConfig()
+    if isinstance(width, int):
+        width_config.pixel_width = width
+    elif width == "content":
+        width_config.use_content = True
+    else:
+        width_config.use_stretch = True
+    return width_config
+
+
+def get_height_config(height: Height) -> HeightConfig:
+    height_config = HeightConfig()
+    if isinstance(height, int):
+        height_config.pixel_height = height
+    elif height == "content":
+        height_config.use_content = True
+    else:
+        height_config.use_stretch = True
+    return height_config

streamlit/elements/lib/mutable_status_container.py

@@ -20,6 +20,11 @@ from typing import TYPE_CHECKING, Literal, cast
 from typing_extensions import Self, TypeAlias
 
 from streamlit.delta_generator import DeltaGenerator
+from streamlit.elements.lib.layout_utils import (
+    WidthWithoutContent,
+    get_width_config,
+    validate_width,
+)
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.Block_pb2 import Block as BlockProto
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
@@ -40,6 +45,7 @@ class StatusContainer(DeltaGenerator):
         label: str,
         expanded: bool = False,
         state: States = "running",
+        width: WidthWithoutContent = "stretch",
     ) -> StatusContainer:
         expandable_proto = BlockProto.Expandable()
         expandable_proto.expanded = expanded
@@ -60,6 +66,9 @@ class StatusContainer(DeltaGenerator):
         block_proto.allow_empty = True
         block_proto.expandable.CopyFrom(expandable_proto)
 
+        validate_width(width=width)
+        block_proto.width_config.CopyFrom(get_width_config(width))
+
         delta_path: list[int] = (
             parent._active_dg._cursor.delta_path if parent._active_dg._cursor else []
         )
@@ -88,7 +97,7 @@ class StatusContainer(DeltaGenerator):
         cursor: Cursor | None,
         parent: DeltaGenerator | None,
         block_type: str | None,
-    ):
+    ) -> None:
         super().__init__(root_container, cursor, parent, block_type)
 
         # Initialized in `_create()`:
@@ -122,8 +131,10 @@ class StatusContainer(DeltaGenerator):
             The new state of the status container. This mainly changes the
             icon. If None, the state is not changed.
         """
-        assert self._current_proto is not None, "Status not correctly initialized!"
-        assert self._delta_path is not None, "Status not correctly initialized!"
+        if self._current_proto is None or self._delta_path is None:
+            raise RuntimeError(
+                "StatusContainer is not correctly initialized. This should never happen."
+            )
 
         msg = ForwardMsg()
         msg.metadata.delta_path[:] = self._delta_path

streamlit/elements/lib/options_selector_utils.py

@@ -54,10 +54,13 @@ def index_(iterable: Iterable[_Value], x: _Value) -> int:
     for i, value in enumerate(iterable):
         if x == value:
             return i
-        elif isinstance(value, float) and isinstance(x, float):
-            if abs(x - value) < _FLOAT_EQUALITY_EPSILON:
-                return i
-    raise ValueError(f"{str(x)} is not in iterable")
+        if (
+            isinstance(value, float)
+            and isinstance(x, float)
+            and abs(x - value) < _FLOAT_EQUALITY_EPSILON
+        ):
+            return i
+    raise ValueError(f"{x} is not in iterable")
 
 
 def check_and_convert_to_indices(
@@ -89,8 +92,7 @@ def get_default_indices(
     indexable_options: Sequence[T], default: Sequence[Any] | Any | None = None
 ) -> list[int]:
     default_indices = check_and_convert_to_indices(indexable_options, default)
-    default_indices = default_indices if default_indices is not None else []
-    return default_indices
+    return default_indices if default_indices is not None else []
 
 
 E1 = TypeVar("E1", bound=Enum)
@@ -102,16 +104,16 @@ _ALLOWED_ENUM_COERCION_CONFIG_SETTINGS = ("off", "nameOnly", "nameAndValue")
 def _coerce_enum(from_enum_value: E1, to_enum_class: type[E2]) -> E1 | E2:
     """Attempt to coerce an Enum value to another EnumMeta.
 
-    An Enum value of EnumMeta E1 is considered coercable to EnumType E2
+    An Enum value of EnumMeta E1 is considered coercible to EnumType E2
     if the EnumMeta __qualname__ match and the names of their members
     match as well. (This is configurable in streamlist configs)
     """
     if not isinstance(from_enum_value, Enum):
-        raise ValueError(
+        raise ValueError(  # noqa: TRY004
             f"Expected an Enum in the first argument. Got {type(from_enum_value)}"
         )
     if not isinstance(to_enum_class, EnumMeta):
-        raise ValueError(
+        raise ValueError(  # noqa: TRY004
             f"Expected an EnumMeta/Type in the second argument. Got {type(to_enum_class)}"
         )
     if isinstance(from_enum_value, to_enum_class):
@@ -146,7 +148,7 @@ def _coerce_enum(from_enum_value: E1, to_enum_class: type[E2]) -> E1 | E2:
         _LOGGER.debug("Failed to coerce %s to class %s", from_enum_value, to_enum_class)
         return from_enum_value  # do not attempt to coerce
 
-    # At this point we think the Enum is coercable, and we know
+    # At this point we think the Enum is coercible, and we know
     # E1 and E2 have the same member names. We convert from E1 to E2 using _name_
     # (since user Enum subclasses can override the .name property in 3.11)
     _LOGGER.debug("Coerced %s to class %s", from_enum_value, to_enum_class)
@@ -183,7 +185,11 @@ def maybe_coerce_enum(
 ) -> RegisterWidgetResult[T]: ...
 
 
-def maybe_coerce_enum(register_widget_result, options, opt_sequence):
+def maybe_coerce_enum(
+    register_widget_result: RegisterWidgetResult[Any],
+    options: OptionSequence[Any],
+    opt_sequence: Sequence[Any],
+) -> RegisterWidgetResult[Any]:
     """Maybe Coerce a RegisterWidgetResult with an Enum member value to
     RegisterWidgetResult[option] if option is an EnumType, otherwise just return
     the original RegisterWidgetResult.
@@ -225,7 +231,11 @@ def maybe_coerce_enum_sequence(
 ) -> RegisterWidgetResult[tuple[T, T]]: ...
 
 
-def maybe_coerce_enum_sequence(register_widget_result, options, opt_sequence):
+def maybe_coerce_enum_sequence(
+    register_widget_result: RegisterWidgetResult[list[Any] | tuple[Any, ...]],
+    options: OptionSequence[Any],
+    opt_sequence: Sequence[Any],
+) -> RegisterWidgetResult[list[Any] | tuple[Any, ...]]:
     """Maybe Coerce a RegisterWidgetResult with a sequence of Enum members as value
     to RegisterWidgetResult[Sequence[option]] if option is an EnumType, otherwise just
     return the original RegisterWidgetResult.

streamlit/elements/lib/pandas_styler_utils.py

@@ -26,6 +26,8 @@ if TYPE_CHECKING:
 
     from streamlit.proto.Arrow_pb2 import Arrow as ArrowProto
 
+from enum import Enum
+
 
 def marshall_styler(proto: ArrowProto, styler: Styler, default_uuid: str) -> None:
     """Marshall pandas.Styler into an Arrow proto.
@@ -196,27 +198,24 @@ def _pandas_style_to_css(
 
     # 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":
-        cell_selectors = [style["selector"]]
-    else:
-        cell_selectors = style["selectors"]
-
-    selectors = []
-    for cell_selector in cell_selectors:
-        selectors.append(table_selector + separator + cell_selector)
+    # > [
+    # >   {
+    # >       "props": [("color", " black"), ("background-color", "orange"), ("", "")],
+    # >       "selectors": ["row0_col0"]
+    # >   }
+    # >   ...
+    # > ]
+    cell_selectors = (
+        [style["selector"]] if style_type == "table_styles" else style["selectors"]
+    )
+
+    selectors = [
+        table_selector + separator + cell_selector for cell_selector in cell_selectors
+    ]
     selector = ", ".join(selectors)
 
     declaration_block = "; ".join(declarations)
-    rule_set = selector + " { " + declaration_block + " }"
-
-    return rule_set
+    return selector + " { " + declaration_block + " }"
 
 
 def _marshall_display_values(
@@ -266,9 +265,14 @@ def _use_display_values(df: DataFrame, styles: Mapping[str, Any]) -> DataFrame:
         rows = styles["body"]
         for row in rows:
             for cell in row:
-                if "id" in cell:
-                    if match := cell_selector_regex.match(cell["id"]):
-                        r, c = map(int, match.groups())
+                if "id" in cell and (match := cell_selector_regex.match(cell["id"])):
+                    r, c = map(int, match.groups())
+                    # Check if the display value is an Enum type. Enum values need to be
+                    # converted to their `.value` attribute to ensure proper serialization
+                    # and display logic.
+                    if isinstance(cell["display_value"], Enum):
+                        new_df.iloc[r, c] = str(cell["display_value"].value)
+                    else:
                         new_df.iloc[r, c] = str(cell["display_value"])
 
     return new_df

streamlit/elements/lib/policies.py

@@ -97,7 +97,7 @@ def check_session_state_rules(
 
 
 class CachedWidgetWarning(StreamlitAPIWarning):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(
             """
 Your script uses a widget command in a cached function
@@ -126,7 +126,7 @@ def check_cache_replay_rules() -> None:
         exception(CachedWidgetWarning())
 
 
-def check_fragment_path_policy(dg: DeltaGenerator):
+def check_fragment_path_policy(dg: DeltaGenerator) -> None:
     """Ensures that the current widget is not written outside of the
     fragment's delta path.
 
@@ -168,7 +168,7 @@ def check_widget_policies(
     default_value: Sequence[Any] | Any | None = None,
     writes_allowed: bool = True,
     enable_check_callback_rules: bool = True,
-):
+) -> None:
     """Check all widget policies for the given DeltaGenerator."""
     check_fragment_path_policy(dg)
     check_cache_replay_rules()
@@ -179,13 +179,14 @@ def check_widget_policies(
     )
 
 
-def maybe_raise_label_warnings(label: str | None, label_visibility: str | None):
+def maybe_raise_label_warnings(label: str | None, label_visibility: str | None) -> None:
     if not label:
         _LOGGER.warning(
             "`label` got an empty value. This is discouraged for accessibility "
             "reasons and may be disallowed in the future by raising an exception. "
             "Please provide a non-empty label and hide it with label_visibility "
-            "if needed."
+            "if needed.",
+            stack_info=True,
         )
     if label_visibility not in ("visible", "hidden", "collapsed"):
         raise errors.StreamlitAPIException(

streamlit/elements/lib/streamlit_plotly_theme.py

@@ -15,6 +15,60 @@
 from __future__ import annotations
 
 import contextlib
+from typing import Final
+
+# This is the streamlit theme for plotly where we pass in a template.data
+# and a template.layout.
+# Template.data is for changing specific graph properties in a general aspect
+# such as Contour plots or Waterfall plots.
+# Template.layout is for changing things such as the x axis and fonts and other
+# general layout properties for general graphs.
+# We pass in temporary colors to the frontend and the frontend will replace
+# those colors because we want to change colors based on the background color.
+# Start at #0000001 because developers may be likely to use #000000
+CATEGORY_0: Final = "#000001"
+CATEGORY_1: Final = "#000002"
+CATEGORY_2: Final = "#000003"
+CATEGORY_3: Final = "#000004"
+CATEGORY_4: Final = "#000005"
+CATEGORY_5: Final = "#000006"
+CATEGORY_6: Final = "#000007"
+CATEGORY_7: Final = "#000008"
+CATEGORY_8: Final = "#000009"
+CATEGORY_9: Final = "#000010"
+
+SEQUENTIAL_0: Final = "#000011"
+SEQUENTIAL_1: Final = "#000012"
+SEQUENTIAL_2: Final = "#000013"
+SEQUENTIAL_3: Final = "#000014"
+SEQUENTIAL_4: Final = "#000015"
+SEQUENTIAL_5: Final = "#000016"
+SEQUENTIAL_6: Final = "#000017"
+SEQUENTIAL_7: Final = "#000018"
+SEQUENTIAL_8: Final = "#000019"
+SEQUENTIAL_9: Final = "#000020"
+
+DIVERGING_0: Final = "#000021"
+DIVERGING_1: Final = "#000022"
+DIVERGING_2: Final = "#000023"
+DIVERGING_3: Final = "#000024"
+DIVERGING_4: Final = "#000025"
+DIVERGING_5: Final = "#000026"
+DIVERGING_6: Final = "#000027"
+DIVERGING_7: Final = "#000028"
+DIVERGING_8: Final = "#000029"
+DIVERGING_9: Final = "#000030"
+DIVERGING_10: Final = "#000031"
+
+INCREASING: Final = "#000032"
+DECREASING: Final = "#000033"
+TOTAL: Final = "#000034"
+
+GRAY_70: Final = "#000036"
+GRAY_90: Final = "#000037"
+BG_COLOR: Final = "#000038"
+FADED_TEXT_05: Final = "#000039"
+BG_MIX: Final = "#000040"
 
 
 def configure_streamlit_plotly_theme() -> None:
@@ -27,59 +81,6 @@ def configure_streamlit_plotly_theme() -> None:
         import plotly.graph_objects as go
         import plotly.io as pio
 
-        # This is the streamlit theme for plotly where we pass in a template.data
-        # and a template.layout.
-        # Template.data is for changing specific graph properties in a general aspect
-        # such as Contour plots or Waterfall plots.
-        # Template.layout is for changing things such as the x axis and fonts and other
-        # general layout properties for general graphs.
-        # We pass in temporary colors to the frontend and the frontend will replace
-        # those colors because we want to change colors based on the background color.
-        # Start at #0000001 because developers may be likely to use #000000
-        CATEGORY_0 = "#000001"
-        CATEGORY_1 = "#000002"
-        CATEGORY_2 = "#000003"
-        CATEGORY_3 = "#000004"
-        CATEGORY_4 = "#000005"
-        CATEGORY_5 = "#000006"
-        CATEGORY_6 = "#000007"
-        CATEGORY_7 = "#000008"
-        CATEGORY_8 = "#000009"
-        CATEGORY_9 = "#000010"
-
-        SEQUENTIAL_0 = "#000011"
-        SEQUENTIAL_1 = "#000012"
-        SEQUENTIAL_2 = "#000013"
-        SEQUENTIAL_3 = "#000014"
-        SEQUENTIAL_4 = "#000015"
-        SEQUENTIAL_5 = "#000016"
-        SEQUENTIAL_6 = "#000017"
-        SEQUENTIAL_7 = "#000018"
-        SEQUENTIAL_8 = "#000019"
-        SEQUENTIAL_9 = "#000020"
-
-        DIVERGING_0 = "#000021"
-        DIVERGING_1 = "#000022"
-        DIVERGING_2 = "#000023"
-        DIVERGING_3 = "#000024"
-        DIVERGING_4 = "#000025"
-        DIVERGING_5 = "#000026"
-        DIVERGING_6 = "#000027"
-        DIVERGING_7 = "#000028"
-        DIVERGING_8 = "#000029"
-        DIVERGING_9 = "#000030"
-        DIVERGING_10 = "#000031"
-
-        INCREASING = "#000032"
-        DECREASING = "#000033"
-        TOTAL = "#000034"
-
-        GRAY_70 = "#000036"
-        GRAY_90 = "#000037"
-        BG_COLOR = "#000038"
-        FADED_TEXT_05 = "#000039"
-        BG_MIX = "#000040"
-
         # Plotly represents continuous colorscale through an array of pairs.
         # The pair's first index is the starting point and the next pair's first index is the end point.
         # The pair's second index is the starting color and the next pair's second index is the end color.