streamlit-nightly 1.45.2.dev20250527__py3-none-any.whl → 1.45.2.dev20250528__py3-none-any.whl

streamlit/elements/widgets/color_picker.py

@@ -195,6 +195,7 @@ class ColorPickerMixin:
             "color_picker",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             value=str(value),
             help=help,
@@ -206,25 +207,19 @@ class ColorPickerMixin:
 
         # make sure the value is a string
         if not isinstance(value, str):
-            raise StreamlitAPIException(
-                """
-                Color Picker Value has invalid type: %s. Expects a hex string
-                like '#00FFAA' or '#000'.
-                """
-                % type(value).__name__
-            )
+            raise StreamlitAPIException(f"""
+Color Picker Value has invalid type: {type(value).__name__}. Expects a hex string
+like '#00FFAA' or '#000'.
+""")
 
         # validate the value and expects a hex string
         match = re.match(r"^#(?:[0-9a-fA-F]{3}){1,2}$", value)
 
         if not match:
-            raise StreamlitAPIException(
-                """
-                '%s' is not a valid hex code for colors. Valid ones are like
-                '#00FFAA' or '#000'.
-                """
-                % value
-            )
+            raise StreamlitAPIException(f"""
+'{value}' is not a valid hex code for colors. Valid ones are like
+'#00FFAA' or '#000'.
+""")
 
         color_picker_proto = ColorPickerProto()
         color_picker_proto.id = element_id

streamlit/elements/widgets/data_editor.py

@@ -370,8 +370,8 @@ def _apply_row_additions(
         # Row cannot be added -> skip it and log a warning.
         _LOGGER.warning(
             "Cannot automatically add row for the index "
-            f"of type {type(df.index).__name__} without an explicit index value. "
-            "Row addition skipped."
+            "of type %s without an explicit index value. Row addition skipped.",
+            type(df.index).__name__,
         )
 
 
@@ -933,6 +933,7 @@ class DataEditorMixin:
             "data_editor",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             data=arrow_bytes,
             width=width,
             height=height,

streamlit/elements/widgets/file_uploader.py

@@ -441,6 +441,7 @@ class FileUploaderMixin:
             "file_uploader",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             type=type,
             accept_multiple_files=accept_multiple_files,

streamlit/elements/widgets/multiselect.py

@@ -449,6 +449,7 @@ class MultiSelectMixin:
             widget_name,
             user_key=key,
             form_id=form_id,
+            dg=self.dg,
             label=label,
             options=formatted_options,
             default=default_values,

streamlit/elements/widgets/number_input.py

@@ -443,6 +443,7 @@ class NumberInputMixin:
             "number_input",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             min_value=min_value,
             max_value=max_value,

streamlit/elements/widgets/radio.py

@@ -341,6 +341,7 @@ class RadioMixin:
             "radio",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             options=[str(format_func(option)) for option in opt],
             index=index,
@@ -351,7 +352,7 @@ class RadioMixin:
 
         if not isinstance(index, int) and index is not None:
             raise StreamlitAPIException(
-                "Radio Value has invalid type: %s" % type(index).__name__
+                f"Radio Value has invalid type: {type(index).__name__}"
             )
 
         if index is not None and len(opt) > 0 and not 0 <= index < len(opt):

streamlit/elements/widgets/select_slider.py

@@ -370,6 +370,7 @@ class SelectSliderMixin:
             "select_slider",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             options=[str(format_func(option)) for option in opt],
             value=slider_value,

streamlit/elements/widgets/selectbox.py

@@ -495,7 +495,7 @@ class SelectboxMixin:
 
         if not isinstance(index, int) and index is not None:
             raise StreamlitAPIException(
-                "Selectbox Value has invalid type: %s" % type(index).__name__
+                f"Selectbox Value has invalid type: {type(index).__name__}"
             )
 
         if index is not None and len(opt) > 0 and not 0 <= index < len(opt):
@@ -519,6 +519,7 @@ class SelectboxMixin:
             "selectbox",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             options=formatted_options,
             index=index,

streamlit/elements/widgets/slider.py

@@ -118,6 +118,15 @@ DAYS_TO_MICROS: Final = 24 * 60 * 60 * SECONDS_TO_MICROS
 
 UTC_EPOCH: Final = datetime(1970, 1, 1, tzinfo=timezone.utc)
 
+SUPPORTED_TYPES: Final = {
+    Integral: SliderProto.INT,
+    Real: SliderProto.FLOAT,
+    datetime: SliderProto.DATETIME,
+    date: SliderProto.DATE,
+    time: SliderProto.TIME,
+}
+TIMELIKE_TYPES: Final = (SliderProto.DATETIME, SliderProto.TIME, SliderProto.DATE)
+
 
 def _time_to_datetime(time_: time) -> datetime:
     # Note, here we pick an arbitrary date well after Unix epoch.
@@ -665,6 +674,7 @@ class SliderMixin:
             "slider",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             min_value=min_value,
             max_value=max_value,
@@ -675,15 +685,6 @@ class SliderMixin:
             width=width,
         )
 
-        SUPPORTED_TYPES = {
-            Integral: SliderProto.INT,
-            Real: SliderProto.FLOAT,
-            datetime: SliderProto.DATETIME,
-            date: SliderProto.DATE,
-            time: SliderProto.TIME,
-        }
-        TIMELIKE_TYPES = (SliderProto.DATETIME, SliderProto.TIME, SliderProto.DATE)
-
         if value is None:
             # We need to know if this is a single or range slider, but don't have
             # a default value, so we check if session_state can tell us.
@@ -747,7 +748,7 @@ class SliderMixin:
             datetime_min = value[0] - timedelta(days=14)
             datetime_max = value[0] + timedelta(days=14)
 
-        DEFAULTS = {
+        defaults: Final = {
             SliderProto.INT: {
                 "min_value": 0,
                 "max_value": 100,
@@ -781,18 +782,18 @@ class SliderMixin:
         }
 
         if min_value is None:
-            min_value = DEFAULTS[data_type]["min_value"]
+            min_value = defaults[data_type]["min_value"]
         if max_value is None:
-            max_value = DEFAULTS[data_type]["max_value"]
+            max_value = defaults[data_type]["max_value"]
         if step is None:
-            step = DEFAULTS[data_type]["step"]
+            step = defaults[data_type]["step"]
             if data_type in (
                 SliderProto.DATETIME,
                 SliderProto.DATE,
             ) and max_value - min_value < timedelta(days=1):
                 step = timedelta(minutes=15)
         if format is None:
-            format = cast("str", DEFAULTS[data_type]["format"])  # noqa: A001
+            format = cast("str", defaults[data_type]["format"])  # noqa: A001
 
         if step == 0:
             raise StreamlitAPIException(
@@ -813,17 +814,13 @@ class SliderMixin:
         )
 
         if not int_args and not float_args and not timelike_args:
-            raise StreamlitAPIException(
+            msg = (
                 "Slider value arguments must be of matching types."
-                "\n`min_value` has %(min_type)s type."
-                "\n`max_value` has %(max_type)s type."
-                "\n`step` has %(step)s type."
-                % {
-                    "min_type": type(min_value).__name__,
-                    "max_type": type(max_value).__name__,
-                    "step": type(step).__name__,
-                }
+                f"\n`min_value` has {type(min_value).__name__} type."
+                f"\n`max_value` has {type(max_value).__name__} type."
+                f"\n`step` has {type(step).__name__} type."
             )
+            raise StreamlitAPIException(msg)
 
         # Ensure that the value matches arguments' types.
         all_ints = data_type == SliderProto.INT and int_args
@@ -831,17 +828,13 @@ class SliderMixin:
         all_timelikes = data_type in TIMELIKE_TYPES and timelike_args
 
         if not all_ints and not all_floats and not all_timelikes:
-            raise StreamlitAPIException(
+            msg = (
                 "Both value and arguments must be of the same type."
-                "\n`value` has %(value_type)s type."
-                "\n`min_value` has %(min_type)s type."
-                "\n`max_value` has %(max_type)s type."
-                % {
-                    "value_type": type(value).__name__,
-                    "min_type": type(min_value).__name__,
-                    "max_type": type(max_value).__name__,
-                }
+                f"\n`value` has {type(value).__name__} type."
+                f"\n`min_value` has {type(min_value).__name__} type."
+                f"\n`max_value` has {type(max_value).__name__} type."
             )
+            raise StreamlitAPIException(msg)
 
         # Ensure that min <= value(s) <= max, adjusting the bounds as necessary.
         min_value = min(min_value, max_value)

streamlit/elements/widgets/text_widgets.py

@@ -317,6 +317,7 @@ class TextWidgetsMixin:
             "text_input",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             value=value,
             max_chars=max_chars,
@@ -369,8 +370,7 @@ class TextWidgetsMixin:
             text_input_proto.type = TextInputProto.PASSWORD
         else:
             raise StreamlitAPIException(
-                "'%s' is not a valid text_input type. Valid types are 'default' and 'password'."
-                % type
+                f"'{type}' is not a valid text_input type. Valid types are 'default' and 'password'."
             )
 
         # Marshall the autocomplete param. If unspecified, this will be
@@ -622,6 +622,7 @@ class TextWidgetsMixin:
             "text_area",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             value=value,
             height=height,

streamlit/elements/widgets/time_widgets.py

@@ -523,6 +523,7 @@ class TimeWidgetsMixin:
             "time_input",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             value=parsed_time if isinstance(value, (datetime, time)) else value,
             help=help,
@@ -909,6 +910,7 @@ class TimeWidgetsMixin:
             "date_input",
             user_key=key,
             form_id=current_form_id(self.dg),
+            dg=self.dg,
             label=label,
             value=parsed,
             min_value=parsed_min_date,

streamlit/hello/animation_demo.py

@@ -42,22 +42,22 @@ def animation_demo() -> None:
     for frame_num, a in enumerate(np.linspace(0.0, 4 * np.pi, 100)):
         # Here were setting value for these two elements.
         progress_bar.progress(frame_num)
-        frame_text.text("Frame %i/100" % (frame_num + 1))
+        frame_text.text(f"Frame {frame_num + 1}/100")
 
         # Performing some fractal wizardry.
         c = separation * np.exp(1j * a)
-        Z = np.tile(x, (n, 1)) + 1j * np.tile(y, (1, m))
-        C = np.full((n, m), c)
-        M: Any = np.full((n, m), True, dtype=bool)
-        N = np.zeros((n, m))
+        z = np.tile(x, (n, 1)) + 1j * np.tile(y, (1, m))
+        c_matrix = np.full((n, m), c)
+        m_matrix: Any = np.full((n, m), True, dtype=bool)
+        n_matrix = np.zeros((n, m))
 
         for i in range(iterations):
-            Z[M] = Z[M] * Z[M] + C[M]
-            M[np.abs(Z) > 2] = False
-            N[M] = i
+            z[m_matrix] = z[m_matrix] * z[m_matrix] + c_matrix[m_matrix]
+            m_matrix[np.abs(z) > 2] = False
+            n_matrix[m_matrix] = i
 
         # Update the image placeholder by calling the image() function on it.
-        image.image(1.0 - (N / N.max()), use_container_width=True)
+        image.image(1.0 - (n_matrix / n_matrix.max()), use_container_width=True)
 
     # We clear elements by calling empty on them.
     progress_bar.empty()

streamlit/hello/dataframe_demo.py

@@ -24,8 +24,8 @@ from streamlit.hello.utils import show_code
 def data_frame_demo() -> None:
     @st.cache_data
     def get_un_data() -> pd.DataFrame:
-        AWS_BUCKET_URL = "https://streamlit-demo-data.s3-us-west-2.amazonaws.com"
-        df = pd.read_csv(AWS_BUCKET_URL + "/agri.csv.gz")
+        aws_bucket_url = "https://streamlit-demo-data.s3-us-west-2.amazonaws.com"
+        df = pd.read_csv(aws_bucket_url + "/agri.csv.gz")
         return df.set_index("Region")
 
     try:

streamlit/hello/mapping_demo.py

@@ -26,12 +26,12 @@ def mapping_demo() -> None:
     def from_data_file(filename: str) -> pd.DataFrame:
         url = (
             "https://raw.githubusercontent.com/streamlit/"
-            "example-data/master/hello/v1/%s" % filename
+            f"example-data/master/hello/v1/{filename}"
         )
         return pd.read_json(url)
 
     try:
-        ALL_LAYERS = {
+        all_layers = {
             "Bike rentals": pdk.Layer(
                 "HexagonLayer",
                 data=from_data_file("bike_rental_stats.json"),
@@ -75,7 +75,7 @@ def mapping_demo() -> None:
         st.sidebar.subheader("Map layers")
         selected_layers = [
             layer
-            for layer_name, layer in ALL_LAYERS.items()
+            for layer_name, layer in all_layers.items()
             if st.sidebar.checkbox(layer_name, True)
         ]
         if selected_layers:
@@ -95,11 +95,10 @@ def mapping_demo() -> None:
             st.error("Please choose at least one layer above.")
     except URLError as e:
         st.error(
-            """
+            f"""
             **This demo requires internet access.**
-            Connection error: %s
+            Connection error: {e.reason}
         """
-            % e.reason
         )
 
 

streamlit/logger.py

@@ -46,7 +46,7 @@ def set_log_level(level: str | int) -> None:
     elif level in {"DEBUG", logging.DEBUG}:
         log_level = logging.DEBUG
     else:
-        msg = 'undefined log level "%s"' % level
+        msg = f'undefined log level "{level}"'
         logger.critical(msg)
         sys.exit(1)
 

streamlit/runtime/app_session.py

@@ -375,8 +375,9 @@ class AppSession:
             # sometimes stays open.
             if fragment_id and not self._fragment_storage.contains(fragment_id):
                 _LOGGER.info(
-                    f"The fragment with id {fragment_id} does not exist anymore - "
-                    "it might have been removed during a preceding full-app rerun."
+                    "The fragment with id %s does not exist anymore - "
+                    "it might have been removed during a preceding full-app rerun.",
+                    fragment_id,
                 )
                 return
 
@@ -954,9 +955,10 @@ def _populate_theme_msg(msg: CustomThemeConfig, section: str = "theme") -> None:
     if base is not None:
         if base not in base_map:
             _LOGGER.warning(
-                f'"{base}" is an invalid value for theme.base.'
-                f" Allowed values include {list(base_map.keys())}."
-                ' Setting theme.base to "light".'
+                '"%s" is an invalid value for theme.base. Allowed values include %s. '
+                'Setting theme.base to "light".',
+                base,
+                list(base_map.keys()),
             )
         else:
             msg.base = base_map[base]
@@ -976,8 +978,8 @@ def _populate_theme_msg(msg: CustomThemeConfig, section: str = "theme") -> None:
             font_faces = json.loads(font_faces)
         except Exception as e:
             _LOGGER.warning(
-                "Failed to parse the theme.fontFaces config option with json.loads: "
-                f"{font_faces}.",
+                "Failed to parse the theme.fontFaces config option with json.loads: %s.",
+                font_faces,
                 exc_info=e,
             )
             font_faces = None
@@ -988,7 +990,8 @@ def _populate_theme_msg(msg: CustomThemeConfig, section: str = "theme") -> None:
                 msg.font_faces.append(ParseDict(font_face, FontFace()))
             except Exception as e:  # noqa: PERF203
                 _LOGGER.warning(
-                    f"Failed to parse the theme.fontFaces config option: {font_face}.",
+                    "Failed to parse the theme.fontFaces config option: %s.",
+                    font_face,
                     exc_info=e,
                 )
 

streamlit/runtime/caching/hashing.py

@@ -92,26 +92,25 @@ class UserHashError(StreamlitAPIException):
         args = self._get_error_message_args(orig_exc, cached_func)
 
         return (
-            """
-%(orig_exception_desc)s
+            f"""
+{args["orig_exception_desc"]}
 
-This error is likely due to a bug in %(hash_func_name)s, which is a
-user-defined hash function that was passed into the `%(cache_primitive)s` decorator of
-%(object_desc)s.
+This error is likely due to a bug in {args["hash_func_name"]}, which is a
+user-defined hash function that was passed into the `{args["cache_primitive"]}` decorator of
+{args["object_desc"]}.
 
-%(hash_func_name)s failed when hashing an object of type
-`%(failed_obj_type_str)s`.  If you don't know where that object is coming from,
+{args["hash_func_name"]} failed when hashing an object of type
+`{args["failed_obj_type_str"]}`.  If you don't know where that object is coming from,
 try looking at the hash chain below for an object that you do recognize, then
 pass that to `hash_funcs` instead:
 
 ```
-%(hash_stack)s
+{args["hash_stack"]}
 ```
 
 If you think this is actually a Streamlit bug, please
 [file a bug report here](https://github.com/streamlit/streamlit/issues/new/choose).
 """
-            % args
         ).strip("\n")
 
     def _get_error_message_args(

streamlit/runtime/caching/storage/local_disk_cache_storage.py

@@ -109,9 +109,9 @@ class LocalDiskCacheStorageManager(CacheStorageManager):
             and not math.isinf(context.ttl_seconds)
         ):
             _LOGGER.warning(
-                f"The cached function '{context.function_display_name}' has a TTL "
-                "that will be ignored. Persistent cached functions currently don't "
-                "support TTL."
+                "The cached function '%s' has a TTL that will be ignored. "
+                "Persistent cached functions currently don't support TTL.",
+                context.function_display_name,
             )
 
 

streamlit/runtime/connection_factory.py

@@ -38,13 +38,13 @@ if TYPE_CHECKING:
 #   2. Writing two new @overloads for connection_factory (one for the case where the
 #      only the connection name is specified and another when both name and type are).
 #   3. Updating test_get_first_party_connection_helper in connection_factory_test.py.
-FIRST_PARTY_CONNECTIONS: Final[dict[str, type[BaseConnection[Any]]]] = {
+_FIRST_PARTY_CONNECTIONS: Final[dict[str, type[BaseConnection[Any]]]] = {
     "snowflake": SnowflakeConnection,
     "snowpark": SnowparkConnection,
     "sql": SQLConnection,
 }
-MODULE_EXTRACTION_REGEX = re.compile(r"No module named \'(.+)\'")
-MODULES_TO_PYPI_PACKAGES: Final[dict[str, str]] = {
+_MODULE_EXTRACTION_REGEX = re.compile(r"No module named \'(.+)\'")
+_MODULES_TO_PYPI_PACKAGES: Final[dict[str, str]] = {
     "MySQLdb": "mysqlclient",
     "psycopg2": "psycopg2-binary",
     "sqlalchemy": "sqlalchemy",
@@ -52,6 +52,7 @@ MODULES_TO_PYPI_PACKAGES: Final[dict[str, str]] = {
     "snowflake.connector": "snowflake-connector-python",
     "snowflake.snowpark": "snowflake-snowpark-python",
 }
+_USE_ENV_PREFIX: Final = "env:"
 
 # The BaseConnection bound is parameterized to `Any` below as subclasses of
 # BaseConnection are responsible for binding the type parameter of BaseConnection to a
@@ -104,12 +105,12 @@ def _create_connection(
 
 
 def _get_first_party_connection(connection_class: str) -> type[BaseConnection[Any]]:
-    if connection_class in FIRST_PARTY_CONNECTIONS:
-        return FIRST_PARTY_CONNECTIONS[connection_class]
+    if connection_class in _FIRST_PARTY_CONNECTIONS:
+        return _FIRST_PARTY_CONNECTIONS[connection_class]
 
     raise StreamlitAPIException(
         f"Invalid connection '{connection_class}'. "
-        f"Supported connection classes: {FIRST_PARTY_CONNECTIONS}"
+        f"Supported connection classes: {_FIRST_PARTY_CONNECTIONS}"
     )
 
 
@@ -366,12 +367,11 @@ def connection_factory(  # type: ignore
     >>> conn = st.connection("my_sql_connection", type=SQLConnection)
 
     """
-    USE_ENV_PREFIX = "env:"
 
-    if name.startswith(USE_ENV_PREFIX):
+    if name.startswith(_USE_ENV_PREFIX):
         # It'd be nice to use str.removeprefix() here, but we won't be able to do that
         # until the minimum Python version we support is 3.9.
-        envvar_name = name[len(USE_ENV_PREFIX) :]
+        envvar_name = name[len(_USE_ENV_PREFIX) :]
         name = os.environ[envvar_name]
 
     # type is a nice kwarg name for the st.connection user but is annoying to work with
@@ -380,7 +380,7 @@ def connection_factory(  # type: ignore
     connection_class = type
 
     if connection_class is None:
-        if name in FIRST_PARTY_CONNECTIONS:
+        if name in _FIRST_PARTY_CONNECTIONS:
             # We allow users to simply write `st.connection("sql")` instead of
             # `st.connection("sql", type="sql")`.
             connection_class = _get_first_party_connection(name)
@@ -424,11 +424,11 @@ def connection_factory(  # type: ignore
         return conn
     except ModuleNotFoundError as e:
         err_string = str(e)
-        missing_module = re.search(MODULE_EXTRACTION_REGEX, err_string)
+        missing_module = re.search(_MODULE_EXTRACTION_REGEX, err_string)
 
         extra_info = "You may be missing a dependency required to use this connection."
         if missing_module:
-            pypi_package = MODULES_TO_PYPI_PACKAGES.get(missing_module.group(1))
+            pypi_package = _MODULES_TO_PYPI_PACKAGES.get(missing_module.group(1))
             if pypi_package:
                 extra_info = f"You need to install the '{pypi_package}' package to use this connection."
 

streamlit/runtime/credentials.py

@@ -29,7 +29,7 @@ from streamlit.logger import get_logger
 _LOGGER: Final = get_logger(__name__)
 
 
-_CONFIG_FILE_PATH = (
+_CONFIG_FILE_PATH: Final = (
     r"%userprofile%/.streamlit/config.toml"
     if env_util.IS_WINDOWS
     else "~/.streamlit/config.toml"
@@ -263,43 +263,30 @@ class Credentials:
                 if self.activation.is_valid:
                     self.save()
                     # IMPORTANT: Break the text below at 80 chars.
-                    TELEMETRY_TEXT = """
-  You can find our privacy policy at %(link)s
+                    telemetry_text = f"""
+  You can find our privacy policy at {cli_util.style_for_cli("https://streamlit.io/privacy-policy", underline=True)}
 
   Summary:
   - This open source library collects usage statistics.
   - We cannot see and do not store information contained inside Streamlit apps,
     such as text, charts, images, etc.
   - Telemetry data is stored in servers in the United States.
-  - If you'd like to opt out, add the following to %(config)s,
+  - If you'd like to opt out, add the following to {cli_util.style_for_cli(_CONFIG_FILE_PATH)},
     creating that file if necessary:
 
     [browser]
     gatherUsageStats = false
-""" % {
-                        "link": cli_util.style_for_cli(
-                            "https://streamlit.io/privacy-policy", underline=True
-                        ),
-                        "config": cli_util.style_for_cli(_CONFIG_FILE_PATH),
-                    }
-
-                    cli_util.print_to_cli(TELEMETRY_TEXT)
+"""
+
+                    cli_util.print_to_cli(telemetry_text)
                     if show_instructions:
                         # IMPORTANT: Break the text below at 80 chars.
-                        INSTRUCTIONS_TEXT = """
-  %(start)s
-  %(prompt)s %(hello)s
-""" % {
-                            "start": cli_util.style_for_cli(
-                                "Get started by typing:", fg="blue", bold=True
-                            ),
-                            "prompt": cli_util.style_for_cli("$", fg="blue"),
-                            "hello": cli_util.style_for_cli(
-                                "streamlit hello", bold=True
-                            ),
-                        }
-
-                        cli_util.print_to_cli(INSTRUCTIONS_TEXT)
+                        instructions_text = f"""
+  {cli_util.style_for_cli("Get started by typing:", fg="blue", bold=True)}
+  {cli_util.style_for_cli("$", fg="blue")} {cli_util.style_for_cli("streamlit hello", bold=True)}
+"""
+
+                        cli_util.print_to_cli(instructions_text)
                     activated = True
                 else:  # pragma: nocover
                     _LOGGER.error("Please try again.")

streamlit/runtime/runtime_util.py

@@ -79,8 +79,8 @@ def serialize_forward_msg(msg: ForwardMsg) -> bytes:
 
         msg_size_error = MessageSizeError(msg_str)
         _LOGGER.warning(
-            "Websocket message size limit exceeded. "
-            f"Showing error to the user: {msg_size_error}"
+            "Websocket message size limit exceeded. Showing error to the user: %s",
+            msg_size_error,
         )
         exception.marshall(msg.delta.new_element.exception, msg_size_error)
         # Deactivate caching for this error message: