streamlit-nightly 1.31.1.dev20240211__py2.py3-none-any.whl → 1.31.2.dev20240212__py2.py3-none-any.whl

streamlit/cli_util.py

@@ -0,0 +1,44 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2024)
+#
+# 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.
+
+""" Utilities related to the CLI."""
+
+
+def print_to_cli(message: str, **kwargs) -> None:
+    """Print a message to the terminal using click if available, else print
+    using the built-in print function.
+
+    You can provide any keyword arguments that click.secho supports.
+    """
+    try:
+        import click
+
+        click.secho(message, **kwargs)
+    except ImportError:
+        print(message, flush=True)
+
+
+def style_for_cli(message: str, **kwargs) -> str:
+    """Style a message using click if available, else return the message
+    unchanged.
+
+    You can provide any keyword arguments that click.style supports.
+    """
+
+    try:
+        import click
+
+        return click.style(message, **kwargs)
+    except ImportError:
+        return message

streamlit/config.py

@@ -14,14 +14,15 @@
 
 """Loads the configuration data."""
 
+from __future__ import annotations
+
 import copy
 import os
 import secrets
 import threading
 from collections import OrderedDict
-from typing import Any, Callable, Dict, Optional, cast
+from typing import Any, Callable
 
-import toml
 from blinker import Signal
 
 from streamlit import config_util, development, env_util, file_util, util
@@ -33,7 +34,7 @@ from streamlit.errors import StreamlitAPIException
 # Descriptions of each of the possible config sections.
 # (We use OrderedDict to make the order in which sections are declared in this
 # file be the same order as the sections appear with `streamlit config show`)
-_section_descriptions: Dict[str, str] = OrderedDict(
+_section_descriptions: dict[str, str] = OrderedDict(
     _test="Special test section just used for unit tests."
 )
 
@@ -46,10 +47,10 @@ _config_lock = threading.RLock()
 # to `streamlit run`, etc. Note that this and _config_options below are
 # OrderedDicts to ensure stable ordering when printed using
 # `streamlit config show`.
-_config_options_template: Dict[str, ConfigOption] = OrderedDict()
+_config_options_template: dict[str, ConfigOption] = OrderedDict()
 
 # Stores the current state of config options.
-_config_options: Optional[Dict[str, ConfigOption]] = None
+_config_options: dict[str, ConfigOption] | None = None
 
 
 # Indicates that a config option was defined by the user.
@@ -147,7 +148,7 @@ def get_option(key: str) -> Any:
         return config_options[key].value
 
 
-def get_options_for_section(section: str) -> Dict[str, Any]:
+def get_options_for_section(section: str) -> dict[str, Any]:
     """Get all of the config options for the given section.
 
     Run `streamlit config show` in the terminal to see all available options.
@@ -159,7 +160,7 @@ def get_options_for_section(section: str) -> Dict[str, Any]:
 
     Returns
     -------
-    Dict[str, Any]
+    dict[str, Any]
         A dict mapping the names of the options in the given section (without
         the section name as a prefix) to their values.
     """
@@ -183,14 +184,14 @@ def _create_section(section: str, description: str) -> None:
 
 def _create_option(
     key: str,
-    description: Optional[str] = None,
-    default_val: Optional[Any] = None,
+    description: str | None = None,
+    default_val: Any | None = None,
     scriptable: bool = False,
     visibility: str = "visible",
     deprecated: bool = False,
-    deprecation_text: Optional[str] = None,
-    expiration_date: Optional[str] = None,
-    replaced_by: Optional[str] = None,
+    deprecation_text: str | None = None,
+    expiration_date: str | None = None,
+    replaced_by: str | None = None,
     type_: type = str,
     sensitive: bool = False,
 ) -> ConfigOption:
@@ -260,7 +261,10 @@ def _delete_option(key: str) -> None:
     """
     try:
         del _config_options_template[key]
-        del cast(Dict[str, ConfigOption], _config_options)[key]
+        assert (
+            _config_options is not None
+        ), "_config_options should always be populated here."
+        del _config_options[key]
     except Exception:
         # We don't care if the option already doesn't exist.
         pass
@@ -707,7 +711,7 @@ _create_option(
 
 
 @_create_option("server.address")
-def _server_address() -> Optional[str]:
+def _server_address() -> str | None:
     """The address where the server will listen for client and browser
     connections. Use this if you want to bind the server to a specific address.
     If set, the server will only be accessible from this address, and not from
@@ -858,24 +862,19 @@ _create_option(
 )
 
 
-@_create_option(
-    "browser.serverPort",
-    visibility="hidden",
-    deprecated=True,
-    deprecation_text="browser.serverPort has been deprecated. It will be removed in a future version.",
-    expiration_date="2024-04-01",
-    type_=int,
-)
+@_create_option("browser.serverPort", type_=int)
 def _browser_server_port() -> int:
     """Port where users should point their browsers in order to connect to the
     app.
 
     This is used to:
-    - Set the correct URL for CORS and XSRF protection purposes.
-    - Show the URL on the terminal
-    - Open the browser
+    - Set the correct URL for XSRF protection purposes.
+    - Show the URL on the terminal (part of `streamlit run`).
+    - Open the browser automatically (part of `streamlit run`).
 
-    Don't use port 3000 which is reserved for internal development.
+    This option is for advanced use cases. To change the port of your app, use
+    `server.Port` instead. Don't use port 3000 which is reserved for internal
+    development.
 
     Default: whatever value is set in server.port.
     """
@@ -1121,9 +1120,10 @@ def is_manually_set(option_name: str) -> bool:
 def show_config() -> None:
     """Print all config options to the terminal."""
     with _config_lock:
-        config_util.show_config(
-            _section_descriptions, cast(Dict[str, ConfigOption], _config_options)
-        )
+        assert (
+            _config_options is not None
+        ), "_config_options should always be populated here."
+        config_util.show_config(_section_descriptions, _config_options)
 
 
 # Load Config Files #
@@ -1162,7 +1162,7 @@ def _set_option(key: str, value: Any, where_defined: str) -> None:
         _config_options[key].set_value(value, where_defined)
 
 
-def _update_config_with_sensitive_env_var(config_options: Dict[str, ConfigOption]):
+def _update_config_with_sensitive_env_var(config_options: dict[str, ConfigOption]):
     """Update the config system by parsing the environment variable.
 
     This should only be called from get_config_options.
@@ -1189,6 +1189,8 @@ def _update_config_with_toml(raw_toml: str, where_defined: str) -> None:
         Tells the config system where this was set.
 
     """
+    import toml
+
     parsed_config_file = toml.loads(raw_toml)
 
     for section, options in parsed_config_file.items():
@@ -1257,8 +1259,8 @@ CONFIG_FILENAMES = [
 
 
 def get_config_options(
-    force_reparse=False, options_from_flags: Optional[Dict[str, Any]] = None
-) -> Dict[str, ConfigOption]:
+    force_reparse=False, options_from_flags: dict[str, Any] | None = None
+) -> dict[str, ConfigOption]:
     """Create and return a dict mapping config option names to their values,
     returning a cached dict if possible.
 
@@ -1275,12 +1277,12 @@ def get_config_options(
     force_reparse : bool
         Force config files to be parsed so that we pick up any changes to them.
 
-    options_from_flags : Optional[Dict[str, any]
+    options_from_flags : dict[str, any] or None
         Config options that we received via CLI flag.
 
     Returns
     -------
-    Dict[str, ConfigOption]
+    dict[str, ConfigOption]
         An ordered dict that maps config option names to their values.
     """
     global _config_options

streamlit/config_util.py

@@ -12,17 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import re
-from typing import Dict
+from __future__ import annotations
 
-import click
-import toml
+import re
 
+from streamlit import cli_util
 from streamlit.config_option import ConfigOption
 
 
 def server_option_changed(
-    old_options: Dict[str, ConfigOption], new_options: Dict[str, ConfigOption]
+    old_options: dict[str, ConfigOption], new_options: dict[str, ConfigOption]
 ) -> bool:
     """Return True if and only if an option in the server section differs
     between old_options and new_options.
@@ -40,10 +39,11 @@ def server_option_changed(
 
 
 def show_config(
-    section_descriptions: Dict[str, str],
-    config_options: Dict[str, ConfigOption],
+    section_descriptions: dict[str, str],
+    config_options: dict[str, ConfigOption],
 ) -> None:
     """Print the given config sections/options to the terminal."""
+
     out = []
     out.append(
         _clean(
@@ -55,16 +55,16 @@ def show_config(
     )
 
     def append_desc(text):
-        out.append("# " + click.style(text, bold=True))
+        out.append("# " + cli_util.style_for_cli(text, bold=True))
 
     def append_comment(text):
-        out.append("# " + click.style(text))
+        out.append("# " + cli_util.style_for_cli(text))
 
     def append_section(text):
-        out.append(click.style(text, bold=True, fg="green"))
+        out.append(cli_util.style_for_cli(text, bold=True, fg="green"))
 
     def append_setting(text):
-        out.append(click.style(text, fg="green"))
+        out.append(cli_util.style_for_cli(text, fg="green"))
 
     for section, _ in section_descriptions.items():
         # We inject a fake config section used for unit tests that we exclude here as
@@ -89,7 +89,7 @@ def show_config(
 
         for key, option in section_options.items():
             key = option.key.split(".")[1]
-            description_paragraphs = _clean_paragraphs(option.description)
+            description_paragraphs = _clean_paragraphs(option.description or "")
 
             last_paragraph_idx = len(description_paragraphs) - 1
 
@@ -114,6 +114,8 @@ def show_config(
                 if i != last_paragraph_idx:
                     out.append("")
 
+            import toml
+
             toml_default = toml.dumps({"default": option.default_val})
             toml_default = toml_default[10:].strip()
 
@@ -128,7 +130,7 @@ def show_config(
                 pass
 
             if option.deprecated:
-                append_comment(click.style("DEPRECATED.", fg="yellow"))
+                append_comment(cli_util.style_for_cli("DEPRECATED.", fg="yellow"))
                 for line in _clean_paragraphs(option.deprecation_text):
                     append_comment(line)
                 append_comment(
@@ -152,10 +154,10 @@ def show_config(
 
             append_setting(toml_setting)
 
-    click.echo("\n".join(out))
+    cli_util.print_to_cli("\n".join(out))
 
 
-def _clean(txt):
+def _clean(txt: str) -> str:
     """Replace sequences of multiple spaces with a single space, excluding newlines.
 
     Preserves leading and trailing spaces, and does not modify spaces in between lines.
@@ -163,7 +165,7 @@ def _clean(txt):
     return re.sub(" +", " ", txt)
 
 
-def _clean_paragraphs(txt):
+def _clean_paragraphs(txt: str) -> list[str]:
     """Split the text into paragraphs, preserve newlines within the paragraphs."""
     # Strip both leading and trailing newlines.
     txt = txt.strip("\n")

streamlit/delta_generator.py

@@ -22,20 +22,27 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Final,
     Hashable,
     Iterable,
+    Literal,
     NoReturn,
-    Optional,
     Type,
     TypeVar,
     cast,
     overload,
 )
 
-import click
-from typing_extensions import Final, Literal
-
-from streamlit import config, cursor, env_util, logger, runtime, type_util, util
+from streamlit import (
+    cli_util,
+    config,
+    cursor,
+    env_util,
+    logger,
+    runtime,
+    type_util,
+    util,
+)
 from streamlit.cursor import Cursor
 from streamlit.elements.alert import AlertMixin
 from streamlit.elements.altair_utils import AddRowsMetadata
@@ -83,7 +90,6 @@ from streamlit.elements.widgets.text_widgets import TextWidgetsMixin
 from streamlit.elements.widgets.time_widgets import TimeWidgetsMixin
 from streamlit.elements.write import WriteMixin
 from streamlit.errors import NoSessionContext, StreamlitAPIException
-from streamlit.logger import get_logger
 from streamlit.proto import Block_pb2, ForwardMsg_pb2
 from streamlit.proto.RootContainer_pb2 import RootContainer
 from streamlit.runtime import caching, legacy_caching
@@ -99,8 +105,6 @@ if TYPE_CHECKING:
     from streamlit.elements.arrow import Data
 
 
-LOGGER: Final = get_logger(__name__)
-
 MAX_DELTA_BYTES: Final[int] = 14 * 1024 * 1024  # 14MB
 
 # List of Streamlit commands that perform a Pandas "melt" operation on
@@ -132,7 +136,7 @@ def _maybe_print_use_warning() -> None:
     if not _use_warning_has_been_displayed:
         _use_warning_has_been_displayed = True
 
-        warning = click.style("Warning:", bold=True, fg="yellow")
+        warning = cli_util.style_for_cli("Warning:", bold=True, fg="yellow")
 
         if env_util.is_repl():
             logger.get_logger("root").warning(
@@ -275,7 +279,7 @@ class DeltaGenerator(
         # Change the module of all mixin'ed functions to be st.delta_generator,
         # instead of the original module (e.g. st.elements.markdown)
         for mixin in self.__class__.__bases__:
-            for name, func in mixin.__dict__.items():
+            for _, func in mixin.__dict__.items():
                 if callable(func):
                     func.__module__ = self.__module__
 
@@ -417,7 +421,7 @@ class DeltaGenerator(
         delta_type: str,
         element_proto: Message,
         return_value: None,
-        add_rows_metadata: Optional[AddRowsMetadata] = None,
+        add_rows_metadata: AddRowsMetadata | None = None,
         element_width: int | None = None,
         element_height: int | None = None,
     ) -> DeltaGenerator:
@@ -429,7 +433,7 @@ class DeltaGenerator(
         delta_type: str,
         element_proto: Message,
         return_value: Type[NoValue],
-        add_rows_metadata: Optional[AddRowsMetadata] = None,
+        add_rows_metadata: AddRowsMetadata | None = None,
         element_width: int | None = None,
         element_height: int | None = None,
     ) -> None:
@@ -441,7 +445,7 @@ class DeltaGenerator(
         delta_type: str,
         element_proto: Message,
         return_value: Value,
-        add_rows_metadata: Optional[AddRowsMetadata] = None,
+        add_rows_metadata: AddRowsMetadata | None = None,
         element_width: int | None = None,
         element_height: int | None = None,
     ) -> Value:
@@ -453,7 +457,7 @@ class DeltaGenerator(
         delta_type: str,
         element_proto: Message,
         return_value: None = None,
-        add_rows_metadata: Optional[AddRowsMetadata] = None,
+        add_rows_metadata: AddRowsMetadata | None = None,
         element_width: int | None = None,
         element_height: int | None = None,
     ) -> DeltaGenerator:
@@ -465,7 +469,7 @@ class DeltaGenerator(
         delta_type: str,
         element_proto: Message,
         return_value: Type[NoValue] | Value | None = None,
-        add_rows_metadata: Optional[AddRowsMetadata] = None,
+        add_rows_metadata: AddRowsMetadata | None = None,
         element_width: int | None = None,
         element_height: int | None = None,
     ) -> DeltaGenerator | Value | None:
@@ -476,7 +480,7 @@ class DeltaGenerator(
         delta_type: str,
         element_proto: Message,
         return_value: Type[NoValue] | Value | None = None,
-        add_rows_metadata: Optional[AddRowsMetadata] = None,
+        add_rows_metadata: AddRowsMetadata | None = None,
         element_width: int | None = None,
         element_height: int | None = None,
     ) -> DeltaGenerator | Value | None:

streamlit/elements/image.py

@@ -19,21 +19,18 @@
 
 """Image marshalling."""
 
-import base64
+from __future__ import annotations
+
 import io
-import mimetypes
 import os
 import re
 from enum import IntEnum
-from typing import TYPE_CHECKING, List, Optional, Sequence, Union, cast
+from typing import TYPE_CHECKING, Final, List, Literal, Sequence, Union, cast
 
-import numpy as np
-from PIL import GifImagePlugin, Image, ImageFile
-from typing_extensions import Final, Literal, TypeAlias
+from typing_extensions import TypeAlias
 
 from streamlit import runtime, url_util
 from streamlit.errors import StreamlitAPIException
-from streamlit.logger import get_logger
 from streamlit.proto.Image_pb2 import ImageList as ImageListProto
 from streamlit.runtime import caching
 from streamlit.runtime.metrics_util import gather_metrics
@@ -42,11 +39,10 @@ if TYPE_CHECKING:
     from typing import Any
 
     import numpy.typing as npt
+    from PIL import GifImagePlugin, Image, ImageFile
 
     from streamlit.delta_generator import DeltaGenerator
 
-LOGGER: Final = get_logger(__name__)
-
 # This constant is related to the frontend maximum content width specified
 # in App.jsx main container
 # 730 is the max width of element-container in the frontend, and 2x is for high
@@ -54,11 +50,11 @@ LOGGER: Final = get_logger(__name__)
 MAXIMUM_CONTENT_WIDTH: Final[int] = 2 * 730
 
 PILImage: TypeAlias = Union[
-    ImageFile.ImageFile, Image.Image, GifImagePlugin.GifImageFile
+    "ImageFile.ImageFile", "Image.Image", "GifImagePlugin.GifImageFile"
 ]
 AtomicImage: TypeAlias = Union[PILImage, "npt.NDArray[Any]", io.BytesIO, str]
 ImageOrImageList: TypeAlias = Union[AtomicImage, List[AtomicImage]]
-UseColumnWith: TypeAlias = Optional[Union[Literal["auto", "always", "never"], bool]]
+UseColumnWith: TypeAlias = Union[Literal["auto", "always", "never"], bool, None]
 Channels: TypeAlias = Literal["RGB", "BGR"]
 ImageFormat: TypeAlias = Literal["JPEG", "PNG", "GIF"]
 ImageFormatOrAuto: TypeAlias = Literal[ImageFormat, "auto"]
@@ -91,8 +87,8 @@ class ImageMixin:
         image: ImageOrImageList,
         # TODO: Narrow type of caption, dependent on type of image,
         #  by way of overload
-        caption: Optional[Union[str, List[str]]] = None,
-        width: Optional[int] = None,
+        caption: str | List[str] | None = None,
+        width: int | None = None,
         use_column_width: UseColumnWith = None,
         clamp: bool = False,
         channels: Channels = "RGB",
@@ -192,7 +188,7 @@ def _image_is_gif(image: PILImage) -> bool:
 
 
 def _validate_image_format_string(
-    image_data: Union[bytes, PILImage], format: str
+    image_data: bytes | PILImage, format: str
 ) -> ImageFormat:
     """Return either "JPEG", "PNG", or "GIF", based on the input `format` string.
 
@@ -210,6 +206,8 @@ def _validate_image_format_string(
         return "JPEG"
 
     if isinstance(image_data, bytes):
+        from PIL import Image
+
         pil_image = Image.open(io.BytesIO(image_data))
     else:
         pil_image = image_data
@@ -246,6 +244,9 @@ def _BytesIO_to_bytes(data: io.BytesIO) -> bytes:
 
 
 def _np_array_to_bytes(array: "npt.NDArray[Any]", output_format="JPEG") -> bytes:
+    import numpy as np
+    from PIL import Image
+
     img = Image.fromarray(array.astype(np.uint8))
     format = _validate_image_format_string(img, output_format)
 
@@ -284,6 +285,8 @@ def _ensure_image_size_and_format(
     MAXIMUM_CONTENT_WIDTH. Ensure the image's format corresponds to the given
     ImageFormat. Return the (possibly resized and reformatted) image bytes.
     """
+    from PIL import Image
+
     pil_image = Image.open(io.BytesIO(image_data))
     actual_width, actual_height = pil_image.size
 
@@ -305,6 +308,8 @@ def _ensure_image_size_and_format(
 
 
 def _clip_image(image: "npt.NDArray[Any]", clamp: bool) -> "npt.NDArray[Any]":
+    import numpy as np
+
     data = image
     if issubclass(image.dtype.type, np.floating):
         if clamp:
@@ -337,12 +342,13 @@ def image_to_url(
     (When running in "raw" mode, we won't actually load data into the
     MediaFileManager, and we'll return an empty URL.)
     """
+    import numpy as np
+    from PIL import Image, ImageFile
 
     image_data: bytes
 
     # Strings
     if isinstance(image, str):
-
         if not os.path.isfile(image) and url_util.is_url(
             image, allowed_schemas=("http", "https", "data")
         ):
@@ -364,6 +370,8 @@ def image_to_url(
                     "<svg", '<svg xmlns="http://www.w3.org/2000/svg" ', 1
                 )
             # Convert to base64 to prevent issues with encoding:
+            import base64
+
             image_b64_encoded = base64.b64encode(image.encode("utf-8")).decode("utf-8")
             # Return SVG as data URI:
             return f"data:image/svg+xml;base64,{image_b64_encoded}"
@@ -376,6 +384,8 @@ def image_to_url(
             # When we aren't able to open the image file, we still pass the path to
             # the MediaFileManager - its storage backend may have access to files
             # that Streamlit does not.
+            import mimetypes
+
             mimetype, _ = mimetypes.guess_type(image)
             if mimetype is None:
                 mimetype = "application/octet-stream"
@@ -441,8 +451,8 @@ def image_to_url(
 def marshall_images(
     coordinates: str,
     image: ImageOrImageList,
-    caption: Optional[Union[str, "npt.NDArray[Any]", List[str]]],
-    width: Union[int, WidthBehaviour],
+    caption: str | "npt.NDArray[Any]" | List[str] | None,
+    width: int | WidthBehaviour,
     proto_imgs: ImageListProto,
     clamp: bool,
     channels: Channels = "RGB",
@@ -486,6 +496,8 @@ def marshall_images(
         Defaults to 'auto' which identifies the compression type based
         on the type and format of the image argument.
     """
+    import numpy as np
+
     channels = cast(Channels, channels.upper())
 
     # Turn single image and caption into one element list.
@@ -498,7 +510,7 @@ def marshall_images(
         images = [image]
 
     if type(caption) is list:
-        captions: Sequence[Optional[str]] = caption
+        captions: Sequence[str | None] = caption
     else:
         if isinstance(caption, str):
             captions = [caption]

streamlit/elements/write.py

@@ -16,13 +16,14 @@ from __future__ import annotations
 
 import dataclasses
 import inspect
-import json as json
+import json
 import types
 from io import StringIO
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Final,
     Generator,
     Iterable,
     List,
@@ -31,10 +32,6 @@ from typing import (
     cast,
 )
 
-import numpy as np
-from PIL import Image, ImageFile
-from typing_extensions import Final
-
 from streamlit import type_util
 from streamlit.errors import StreamlitAPIException
 from streamlit.logger import get_logger
@@ -390,6 +387,8 @@ class WriteMixin:
                 flush_buffer()
                 self.dg.dataframe(arg)
             elif type_util.is_dataframe_like(arg):
+                import numpy as np
+
                 flush_buffer()
                 if len(np.shape(arg)) > 2:
                     self.dg.text(arg)
@@ -416,7 +415,7 @@ class WriteMixin:
             elif type_util.is_sympy_expession(arg):
                 flush_buffer()
                 self.dg.latex(arg)
-            elif isinstance(arg, (ImageFile.ImageFile, Image.Image)):
+            elif type_util.is_pillow_image(arg):
                 flush_buffer()
                 self.dg.image(arg)
             elif type_util.is_keras_model(arg):