streamlit-nightly 1.45.1.dev20250508__py3-none-any.whl → 1.45.1.dev20250509__py3-none-any.whl

streamlit/runtime/caching/hashing.py

@@ -34,7 +34,7 @@ import weakref
 from enum import Enum
 from re import Pattern
 from types import MappingProxyType
-from typing import Any, Callable, Final, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Final, Union, cast
 
 from typing_extensions import TypeAlias
 
@@ -44,6 +44,10 @@ from streamlit.runtime.caching.cache_errors import UnhashableTypeError
 from streamlit.runtime.caching.cache_type import CacheType
 from streamlit.runtime.uploaded_file_manager import UploadedFile
 
+if TYPE_CHECKING:
+    import numpy.typing as npt
+    from PIL.Image import Image
+
 _LOGGER: Final = logger.get_logger(__name__)
 
 # If a dataframe has more than this many rows, we consider it large and hash a sample.
@@ -66,11 +70,11 @@ _CYCLE_PLACEHOLDER: Final = (
 class UserHashError(StreamlitAPIException):
     def __init__(
         self,
-        orig_exc,
-        object_to_hash,
-        hash_func,
+        orig_exc: BaseException,
+        object_to_hash: Any,
+        hash_func: Callable[[Any], Any],
         cache_type: CacheType | None = None,
-    ):
+    ) -> None:
         self.alternate_name = type(orig_exc).__name__
         self.hash_func = hash_func
         self.cache_type = cache_type
@@ -80,7 +84,11 @@ class UserHashError(StreamlitAPIException):
         super().__init__(msg)
         self.with_traceback(orig_exc.__traceback__)
 
-    def _get_message_from_func(self, orig_exc, cached_func):
+    def _get_message_from_func(
+        self,
+        orig_exc: BaseException,
+        cached_func: Any,
+    ) -> str:
         args = self._get_error_message_args(orig_exc, cached_func)
 
         return (
@@ -145,7 +153,7 @@ If you think this is actually a Streamlit bug, please
 
 def update_hash(
     val: Any,
-    hasher,
+    hasher: Any,
     cache_type: CacheType,
     hash_source: Callable[..., Any] | None = None,
     hash_funcs: HashFuncsDict | None = None,
@@ -182,13 +190,13 @@ class _HashStack:
     def __repr__(self) -> str:
         return util.repr_(self)
 
-    def push(self, val: Any):
+    def push(self, val: Any) -> None:
         self._stack[id(val)] = val
 
-    def pop(self):
+    def pop(self) -> None:
         self._stack.popitem()
 
-    def __contains__(self, val: Any):
+    def __contains__(self, val: Any) -> bool:
         return id(val) in self._stack
 
     def pretty_print(self) -> str:
@@ -247,28 +255,20 @@ def _key(obj: Any | None) -> Any:
     if obj is None:
         return None
 
-    def is_simple(obj):
+    def is_simple(obj: Any) -> bool:
         return (
-            isinstance(obj, bytes)
-            or isinstance(obj, bytearray)
-            or isinstance(obj, str)
-            or isinstance(obj, float)
-            or isinstance(obj, int)
-            or isinstance(obj, bool)
-            or isinstance(obj, uuid.UUID)
+            isinstance(obj, (bytes, bytearray, str, float, int, bool, uuid.UUID))
             or obj is None
         )
 
     if is_simple(obj):
         return obj
 
-    if isinstance(obj, tuple):
-        if all(map(is_simple, obj)):
-            return obj
+    if isinstance(obj, tuple) and all(map(is_simple, obj)):
+        return obj
 
-    if isinstance(obj, list):
-        if all(map(is_simple, obj)):
-            return ("__l", tuple(obj))
+    if isinstance(obj, list) and all(map(is_simple, obj)):
+        return ("__l", tuple(obj))
 
     if inspect.isbuiltin(obj) or inspect.isroutine(obj) or inspect.iscode(obj):
         return id(obj)
@@ -279,7 +279,9 @@ def _key(obj: Any | None) -> Any:
 class _CacheFuncHasher:
     """A hasher that can hash objects with cycles."""
 
-    def __init__(self, cache_type: CacheType, hash_funcs: HashFuncsDict | None = None):
+    def __init__(
+        self, cache_type: CacheType, hash_funcs: HashFuncsDict | None = None
+    ) -> None:
         # Can't use types as the keys in the internal _hash_funcs because
         # we always remove user-written modules from memory when rerunning a
         # script in order to reload it and grab the latest code changes.
@@ -339,7 +341,7 @@ class _CacheFuncHasher:
 
         return b
 
-    def update(self, hasher, obj: Any) -> None:
+    def update(self, hasher: Any, obj: Any) -> None:
         """Update the provided hasher with the hash of an object."""
         b = self.to_bytes(obj)
         hasher.update(b)
@@ -360,10 +362,10 @@ class _CacheFuncHasher:
             # deep, so we don't try to hash them at all.
             return self.to_bytes(id(obj))
 
-        elif isinstance(obj, bytes) or isinstance(obj, bytearray):
+        if isinstance(obj, bytes) or isinstance(obj, bytearray):
             return obj
 
-        elif type_util.get_fqn_type(obj) in self._hash_funcs:
+        if type_util.get_fqn_type(obj) in self._hash_funcs:
             # Escape hatch for unsupported objects
             hash_func = self._hash_funcs[type_util.get_fqn_type(obj)]
             try:
@@ -374,57 +376,59 @@ class _CacheFuncHasher:
                 ) from ex
             return self.to_bytes(output)
 
-        elif isinstance(obj, str):
+        if isinstance(obj, str):
             return obj.encode()
 
-        elif isinstance(obj, float):
+        if isinstance(obj, float):
             return _float_to_bytes(obj)
 
-        elif isinstance(obj, int):
+        if isinstance(obj, int):
             return _int_to_bytes(obj)
 
-        elif isinstance(obj, uuid.UUID):
+        if isinstance(obj, uuid.UUID):
             return obj.bytes
 
-        elif isinstance(obj, datetime.datetime):
+        if isinstance(obj, datetime.datetime):
             return obj.isoformat().encode()
 
-        elif isinstance(obj, (list, tuple)):
+        if isinstance(obj, (list, tuple)):
             for item in obj:
                 self.update(h, item)
             return h.digest()
 
-        elif isinstance(obj, dict):
+        if isinstance(obj, dict):
             for item in obj.items():
                 self.update(h, item)
             return h.digest()
 
-        elif obj is None:
+        if obj is None:
             return b"0"
 
-        elif obj is True:
+        if obj is True:
             return b"1"
 
-        elif obj is False:
+        if obj is False:
             return b"0"
 
-        elif not isinstance(obj, type) and dataclasses.is_dataclass(obj):
+        if not isinstance(obj, type) and dataclasses.is_dataclass(obj):
             return self.to_bytes(dataclasses.asdict(obj))
-        elif isinstance(obj, Enum):
+        if isinstance(obj, Enum):
             return str(obj).encode()
 
-        elif type_util.is_type(obj, "pandas.core.series.Series"):
+        if type_util.is_type(obj, "pandas.core.series.Series"):
             import pandas as pd
 
-            obj = cast("pd.Series", obj)
-            self.update(h, obj.size)
-            self.update(h, obj.dtype.name)
+            series_obj: pd.Series = cast("pd.Series", obj)
+            self.update(h, series_obj.size)
+            self.update(h, series_obj.dtype.name)
 
-            if len(obj) >= _PANDAS_ROWS_LARGE:
-                obj = obj.sample(n=_PANDAS_SAMPLE_SIZE, random_state=0)
+            if len(series_obj) >= _PANDAS_ROWS_LARGE:
+                series_obj = series_obj.sample(n=_PANDAS_SAMPLE_SIZE, random_state=0)
 
             try:
-                self.update(h, pd.util.hash_pandas_object(obj).to_numpy().tobytes())
+                self.update(
+                    h, pd.util.hash_pandas_object(series_obj).to_numpy().tobytes()
+                )
                 return h.digest()
             except TypeError:
                 _LOGGER.warning(
@@ -434,22 +438,22 @@ class _CacheFuncHasher:
 
                 # Use pickle if pandas cannot hash the object for example if
                 # it contains unhashable objects.
-                return b"%s" % pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
+                return b"%s" % pickle.dumps(series_obj, pickle.HIGHEST_PROTOCOL)
 
         elif type_util.is_type(obj, "pandas.core.frame.DataFrame"):
             import pandas as pd
 
-            obj = cast("pd.DataFrame", obj)
-            self.update(h, obj.shape)
+            df_obj: pd.DataFrame = cast("pd.DataFrame", obj)
+            self.update(h, df_obj.shape)
 
-            if len(obj) >= _PANDAS_ROWS_LARGE:
-                obj = obj.sample(n=_PANDAS_SAMPLE_SIZE, random_state=0)
+            if len(df_obj) >= _PANDAS_ROWS_LARGE:
+                df_obj = df_obj.sample(n=_PANDAS_SAMPLE_SIZE, random_state=0)
             try:
                 column_hash_bytes = self.to_bytes(
-                    pd.util.hash_pandas_object(obj.dtypes)
+                    pd.util.hash_pandas_object(df_obj.dtypes)
                 )
                 self.update(h, column_hash_bytes)
-                values_hash_bytes = self.to_bytes(pd.util.hash_pandas_object(obj))
+                values_hash_bytes = self.to_bytes(pd.util.hash_pandas_object(df_obj))
                 self.update(h, values_hash_bytes)
                 return h.digest()
             except TypeError:
@@ -460,7 +464,7 @@ class _CacheFuncHasher:
 
                 # Use pickle if pandas cannot hash the object for example if
                 # it contains unhashable objects.
-                return b"%s" % pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
+                return b"%s" % pickle.dumps(df_obj, pickle.HIGHEST_PROTOCOL)
 
         elif type_util.is_type(obj, "polars.series.series.Series"):
             import polars as pl  # type: ignore[import-not-found]
@@ -513,39 +517,32 @@ class _CacheFuncHasher:
                 # it contains unhashable objects.
                 return b"%s" % pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
         elif type_util.is_type(obj, "numpy.ndarray"):
-            import numpy as np
-
-            # write cast type as string to make it work with our Python 3.8 tests
-            # - can be removed once we sunset support for Python 3.8
-            obj = cast("np.ndarray[Any, Any]", obj)
-            self.update(h, obj.shape)
-            self.update(h, str(obj.dtype))
+            np_obj: npt.NDArray[Any] = cast("npt.NDArray[Any]", obj)
+            self.update(h, np_obj.shape)
+            self.update(h, str(np_obj.dtype))
 
-            if obj.size >= _NP_SIZE_LARGE:
+            if np_obj.size >= _NP_SIZE_LARGE:
                 import numpy as np
 
                 state = np.random.RandomState(0)
-                obj = state.choice(obj.flat, size=_NP_SAMPLE_SIZE)
+                np_obj = state.choice(np_obj.flat, size=_NP_SAMPLE_SIZE)
 
-            self.update(h, obj.tobytes())
+            self.update(h, np_obj.tobytes())
             return h.digest()
         elif type_util.is_type(obj, "PIL.Image.Image"):
             import numpy as np
-            from PIL.Image import Image  # noqa: TC002
 
-            obj = cast("Image", obj)
+            pil_obj: Image = cast("Image", obj)
 
             # we don't just hash the results of obj.tobytes() because we want to use
             # the sampling logic for numpy data
-            np_array = np.frombuffer(obj.tobytes(), dtype="uint8")
+            np_array = np.frombuffer(pil_obj.tobytes(), dtype="uint8")
             return self.to_bytes(np_array)
 
         elif inspect.isbuiltin(obj):
             return bytes(obj.__name__.encode())
 
-        elif isinstance(obj, MappingProxyType) or isinstance(
-            obj, collections.abc.ItemsView
-        ):
+        elif isinstance(obj, (MappingProxyType, collections.abc.ItemsView)):
             return self.to_bytes(dict(obj))
 
         elif type_util.is_type(obj, "builtins.getset_descriptor"):
@@ -561,9 +558,8 @@ class _CacheFuncHasher:
             return h.digest()
 
         elif hasattr(obj, "name") and (
-            isinstance(obj, io.IOBase)
             # Handle temporary files used during testing
-            or isinstance(obj, tempfile._TemporaryFileWrapper)
+            isinstance(obj, (io.IOBase, tempfile._TemporaryFileWrapper))
         ):
             # Hash files as name + last modification date + offset.
             # NB: we're using hasattr("name") to differentiate between
@@ -579,7 +575,7 @@ class _CacheFuncHasher:
         elif isinstance(obj, Pattern):
             return self.to_bytes([obj.pattern, obj.flags])
 
-        elif isinstance(obj, io.StringIO) or isinstance(obj, io.BytesIO):
+        elif isinstance(obj, (io.StringIO, io.BytesIO)):
             # Hash in-memory StringIO/BytesIO by their full contents
             # and seek position.
             self.update(h, obj.tell())

streamlit/runtime/caching/legacy_cache_api.py

@@ -40,7 +40,7 @@ def cache(
     hash_funcs: HashFuncsDict | None = None,
     max_entries: int | None = None,
     ttl: float | None = None,
-):
+) -> F:
     """Legacy caching decorator (deprecated).
 
     Legacy caching with ``st.cache`` has been removed from Streamlit. This is

streamlit/runtime/caching/storage/in_memory_cache_storage_wrapper.py

@@ -57,7 +57,9 @@ class InMemoryCacheStorageWrapper(CacheStorage):
     it from multiple threads.
     """
 
-    def __init__(self, persist_storage: CacheStorage, context: CacheStorageContext):
+    def __init__(
+        self, persist_storage: CacheStorage, context: CacheStorageContext
+    ) -> None:
         self.function_key = context.function_key
         self.function_display_name = context.function_display_name
         self._ttl_seconds = context.ttl_seconds

streamlit/runtime/caching/storage/local_disk_cache_storage.py

@@ -120,7 +120,7 @@ class LocalDiskCacheStorage(CacheStorage):
     This is the default cache persistence layer for `@st.cache_data`.
     """
 
-    def __init__(self, context: CacheStorageContext):
+    def __init__(self, context: CacheStorageContext) -> None:
         self.function_key = context.function_key
         self.persist = context.persist
         self._ttl_seconds = context.ttl_seconds

streamlit/runtime/connection_factory.py

@@ -38,7 +38,7 @@ 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 = {
+FIRST_PARTY_CONNECTIONS: Final[dict[str, type[BaseConnection[Any]]]] = {
     "snowflake": SnowflakeConnection,
     "snowpark": SnowparkConnection,
     "sql": SQLConnection,
@@ -65,7 +65,7 @@ def _create_connection(
     connection_class: type[ConnectionClass],
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> ConnectionClass:
     """Create an instance of connection_class with the given name and kwargs.
 
@@ -76,7 +76,7 @@ def _create_connection(
     """
 
     def __create_connection(
-        name: str, connection_class: type[ConnectionClass], **kwargs
+        name: str, connection_class: type[ConnectionClass], **kwargs: Any
     ) -> ConnectionClass:
         return connection_class(connection_name=name, **kwargs)
 
@@ -103,7 +103,7 @@ def _create_connection(
     return __create_connection(name, connection_class, **kwargs)
 
 
-def _get_first_party_connection(connection_class: str):
+def _get_first_party_connection(connection_class: str) -> type[BaseConnection[Any]]:
     if connection_class in FIRST_PARTY_CONNECTIONS:
         return FIRST_PARTY_CONNECTIONS[connection_class]
 
@@ -119,7 +119,7 @@ def connection_factory(
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
     autocommit: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> SQLConnection:
     pass
 
@@ -131,7 +131,7 @@ def connection_factory(
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
     autocommit: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> SQLConnection:
     pass
 
@@ -142,7 +142,7 @@ def connection_factory(
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
     autocommit: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> SnowflakeConnection:
     pass
 
@@ -154,7 +154,7 @@ def connection_factory(
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
     autocommit: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> SnowflakeConnection:
     pass
 
@@ -164,7 +164,7 @@ def connection_factory(
     name: Literal["snowpark"],
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> SnowparkConnection:
     pass
 
@@ -175,7 +175,7 @@ def connection_factory(
     type: Literal["snowpark"],
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> SnowparkConnection:
     pass
 
@@ -186,7 +186,7 @@ def connection_factory(
     type: type[ConnectionClass],
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> ConnectionClass:
     pass
 
@@ -197,7 +197,7 @@ def connection_factory(
     type: str | None = None,
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> BaseConnection[Any]:
     pass
 

streamlit/runtime/context.py

@@ -64,7 +64,7 @@ def _normalize_header(name: str) -> str:
 
 
 class StreamlitHeaders(Mapping[str, str]):
-    def __init__(self, headers: Iterable[tuple[str, str]]):
+    def __init__(self, headers: Iterable[tuple[str, str]]) -> None:
         dict_like_headers: dict[str, list[str]] = {}
 
         for key, value in headers:
@@ -98,7 +98,7 @@ class StreamlitHeaders(Mapping[str, str]):
 
 
 class StreamlitCookies(Mapping[str, str]):
-    def __init__(self, cookies: Mapping[str, str]):
+    def __init__(self, cookies: Mapping[str, str]) -> None:
         self._cookies = MappingProxyType(cookies)
 
     @classmethod

streamlit/runtime/credentials.py

@@ -20,7 +20,7 @@ import json
 import os
 import sys
 import textwrap
-from typing import Final, NamedTuple, NoReturn
+from typing import Final, NamedTuple, NoReturn, cast
 from uuid import uuid4
 
 from streamlit import cli_util, env_util, file_util, util
@@ -116,12 +116,12 @@ class Credentials:
     _singleton: Credentials | None = None
 
     @classmethod
-    def get_current(cls):
+    def get_current(cls) -> Credentials:
         """Return the singleton instance."""
         if cls._singleton is None:
             Credentials()
 
-        return Credentials._singleton
+        return cast("Credentials", Credentials._singleton)
 
     def __init__(self):
         """Initialize class."""

streamlit/runtime/fragment.py

@@ -155,11 +155,10 @@ def _fragment(
             )
 
         return wrapper
-    else:
-        non_optional_func = func
+    non_optional_func = func
 
     @wraps(non_optional_func)
-    def wrap(*args, **kwargs):
+    def wrap(*args: Any, **kwargs: Any) -> Any:
         from streamlit.delta_generator_singletons import context_dg_stack
 
         ctx = get_script_run_ctx()
@@ -176,7 +175,7 @@ def _fragment(
         # that the fragment is associated with the correct script running.
         initialized_active_script_hash = ctx.active_script_hash
 
-        def wrapped_fragment():
+        def wrapped_fragment() -> Any:
             import streamlit as st
 
             if should_show_deprecation_warning:

streamlit/runtime/media_file_manager.py

@@ -45,7 +45,7 @@ def _get_session_id() -> str:
 class MediaFileMetadata:
     """Metadata that the MediaFileManager needs for each file it manages."""
 
-    def __init__(self, kind: MediaFileKind = MediaFileKind.MEDIA):
+    def __init__(self, kind: MediaFileKind = MediaFileKind.MEDIA) -> None:
         self._kind = kind
         self._is_marked_for_delete = False
 
@@ -80,7 +80,7 @@ class MediaFileManager:
       we should address it at some point.)
     """
 
-    def __init__(self, storage: MediaFileStorage):
+    def __init__(self, storage: MediaFileStorage) -> None:
         self._storage = storage
 
         # Dict of [file_id -> MediaFileMetadata]

streamlit/runtime/memory_media_file_storage.py

@@ -89,7 +89,7 @@ class MemoryFile(NamedTuple):
 
 
 class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
-    def __init__(self, media_endpoint: str):
+    def __init__(self, media_endpoint: str) -> None:
         """Create a new MemoryMediaFileStorage instance.
 
         Parameters

streamlit/runtime/memory_uploaded_file_manager.py

@@ -35,7 +35,7 @@ class MemoryUploadedFileManager(UploadedFileManager):
     This class can be used safely from multiple threads simultaneously.
     """
 
-    def __init__(self, upload_endpoint: str):
+    def __init__(self, upload_endpoint: str) -> None:
         self.file_storage: dict[str, dict[str, UploadedFileRec]] = defaultdict(dict)
         self.endpoint = upload_endpoint
 

streamlit/runtime/metrics_util.py

@@ -239,7 +239,7 @@ class Installation:
         return util.repr_(self)
 
     @property
-    def installation_id(self):
+    def installation_id(self) -> str:
         return self.installation_id_v3
 
 
@@ -284,7 +284,7 @@ def _get_arg_metadata(arg: object) -> str | None:
 
 
 def _get_command_telemetry(
-    _command_func: Callable[..., Any], _command_name: str, *args, **kwargs
+    _command_func: Callable[..., Any], _command_name: str, *args: Any, **kwargs: Any
 ) -> Command:
     """Get telemetry information for the given callable and its arguments."""
     arg_keywords = inspect.getfullargspec(_command_func).args
@@ -391,12 +391,11 @@ def gather_metrics(name: str, func: F | None = None) -> Callable[[F], F] | F:
             )
 
         return wrapper
-    else:
-        # To make mypy type narrow F | None -> F
-        non_optional_func = func
+    # To make mypy type narrow F | None -> F
+    non_optional_func = func
 
     @wraps(non_optional_func)
-    def wrapped_func(*args, **kwargs):
+    def wrapped_func(*args: Any, **kwargs: Any) -> Any:
         from timeit import default_timer as timer
 
         exec_start = timer()

streamlit/runtime/pages_manager.py

@@ -38,8 +38,8 @@ class PagesManager:
         self,
         main_script_path: ScriptPath,
         script_cache: ScriptCache | None = None,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> None:
         self._main_script_path = main_script_path
         self._main_script_hash: PageHash = calc_md5(main_script_path)
         self._script_cache = script_cache
@@ -135,7 +135,7 @@ class PagesManager:
                 self.intended_page_script_hash,
                 self._pages.get(fallback_page_hash, None),
             )
-        elif self.intended_page_name:
+        if self.intended_page_name:
             # If a user navigates directly to a non-main page of an app, the
             # the page name can identify the page script to run
             return next(

streamlit/runtime/runtime.py

@@ -167,7 +167,7 @@ class Runtime:
         """
         return cls._instance is not None
 
-    def __init__(self, config: RuntimeConfig):
+    def __init__(self, config: RuntimeConfig) -> None:
         """Create a Runtime instance. It won't be started yet.
 
         Runtime is *not* thread-safe. Its public methods are generally

streamlit/runtime/runtime_util.py

@@ -31,7 +31,7 @@ _LOGGER: Final = getLogger(__name__)
 class MessageSizeError(MarkdownFormattedException):
     """Exception raised when a websocket message is larger than the configured limit."""
 
-    def __init__(self, failed_msg_str: Any):
+    def __init__(self, failed_msg_str: Any) -> None:
         msg = self._get_message(failed_msg_str)
         super().__init__(msg)
 
@@ -55,7 +55,7 @@ of the client's browser and the Streamlit server._
 class BadDurationStringError(StreamlitAPIException):
     """Raised when a bad duration argument string is passed."""
 
-    def __init__(self, duration: str):
+    def __init__(self, duration: str) -> None:
         MarkdownFormattedException.__init__(
             self,
             "TTL string doesn't look right. It should be formatted as"