streamlit-nightly 1.37.2.dev20240819__py2.py3-none-any.whl → 1.37.2.dev20240820__py2.py3-none-any.whl

streamlit/elements/image.py

@@ -25,7 +25,7 @@ import io
 import os
 import re
 from enum import IntEnum
-from typing import TYPE_CHECKING, Final, List, Literal, Sequence, Union, cast
+from typing import TYPE_CHECKING, Final, Literal, Sequence, Union, cast
 
 from typing_extensions import TypeAlias
 
@@ -54,7 +54,7 @@ PILImage: TypeAlias = Union[
     "ImageFile.ImageFile", "Image.Image", "GifImagePlugin.GifImageFile"
 ]
 AtomicImage: TypeAlias = Union[PILImage, "npt.NDArray[Any]", io.BytesIO, str, bytes]
-ImageOrImageList: TypeAlias = Union[AtomicImage, List[AtomicImage]]
+ImageOrImageList: TypeAlias = Union[AtomicImage, Sequence[AtomicImage]]
 UseColumnWith: TypeAlias = Union[Literal["auto", "always", "never"], bool, None]
 Channels: TypeAlias = Literal["RGB", "BGR"]
 ImageFormat: TypeAlias = Literal["JPEG", "PNG", "GIF"]
@@ -178,14 +178,11 @@ class ImageMixin:
 
 
 def _image_may_have_alpha_channel(image: PILImage) -> bool:
-    if image.mode in ("RGBA", "LA", "P"):
-        return True
-    else:
-        return False
+    return image.mode in ("RGBA", "LA", "P")
 
 
 def _image_is_gif(image: PILImage) -> bool:
-    return bool(image.format == "GIF")
+    return image.format == "GIF"
 
 
 def _validate_image_format_string(
@@ -199,7 +196,7 @@ def _validate_image_format_string(
     "GIF" if the image is a GIF, and "JPEG" otherwise.
     """
     format = format.upper()
-    if format == "JPEG" or format == "PNG":
+    if format in {"JPEG", "PNG"}:
         return cast(ImageFormat, format)
 
     # We are forgiving on the spelling of JPEG
@@ -509,30 +506,23 @@ def marshall_images(
 
     # Turn single image and caption into one element list.
     images: Sequence[AtomicImage]
-    if isinstance(image, list):
-        images = image
+    if isinstance(image, (list, set, tuple)):
+        images = list(image)
     elif isinstance(image, np.ndarray) and len(cast(NumpyShape, image.shape)) == 4:
         images = _4d_to_list_3d(image)
     else:
-        images = [image]
+        images = [image]  # type: ignore
 
     if isinstance(caption, list):
         captions: Sequence[str | None] = caption
+    elif isinstance(caption, str):
+        captions = [caption]
+    elif isinstance(caption, np.ndarray) and len(cast(NumpyShape, caption.shape)) == 1:
+        captions = caption.tolist()
+    elif caption is None:
+        captions = [None] * len(images)
     else:
-        if isinstance(caption, str):
-            captions = [caption]
-        # You can pass in a 1-D Numpy array as captions.
-        elif (
-            isinstance(caption, np.ndarray)
-            and len(cast(NumpyShape, caption.shape)) == 1
-        ):
-            captions = caption.tolist()
-        # If there are no captions then make the captions list the same size
-        # as the images list.
-        elif caption is None:
-            captions = [None] * len(images)
-        else:
-            captions = [str(caption)]
+        captions = [str(caption)]
 
     assert isinstance(
         captions, list

streamlit/elements/lib/policies.py

@@ -19,7 +19,10 @@ from typing import TYPE_CHECKING, Any, Final, Sequence
 from streamlit import config, errors, logger, runtime
 from streamlit.elements.form_utils import is_in_form
 from streamlit.errors import StreamlitAPIException, StreamlitAPIWarning
-from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
+from streamlit.runtime.scriptrunner_utils.script_run_context import (
+    get_script_run_ctx,
+    in_cached_function,
+)
 from streamlit.runtime.state import WidgetCallback, get_session_state
 
 if TYPE_CHECKING:
@@ -114,14 +117,12 @@ def check_cache_replay_rules() -> None:
     If there are other similar checks in the future, we could extend this
     function to check for those as well. And rename it to check_widget_usage_rules.
     """
-    if runtime.exists():
-        ctx = get_script_run_ctx()
-        if ctx and ctx.disallow_cached_widget_usage:
-            from streamlit import exception
-
-            # We use an exception here to show a proper stack trace
-            # that indicates to the user where the issue is.
-            exception(CachedWidgetWarning())
+    if in_cached_function.get():
+        from streamlit import exception
+
+        # We use an exception here to show a proper stack trace
+        # that indicates to the user where the issue is.
+        exception(CachedWidgetWarning())
 
 
 _fragment_writes_widget_to_outside_error = (

streamlit/runtime/caching/__init__.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from streamlit.runtime.caching.cache_data_api import (
     CACHE_DATA_MESSAGE_REPLAY_CTX,
@@ -33,7 +33,6 @@ if TYPE_CHECKING:
     from google.protobuf.message import Message
 
     from streamlit.proto.Block_pb2 import Block
-    from streamlit.runtime.state.common import WidgetMetadata
 
 
 def save_element_message(
@@ -73,14 +72,6 @@ def save_block_message(
     )
 
 
-def save_widget_metadata(metadata: WidgetMetadata[Any]) -> None:
-    """Save a widget's metadata to a thread-local callstack, so the widget
-    can be registered again when that widget is replayed.
-    """
-    CACHE_DATA_MESSAGE_REPLAY_CTX.save_widget_metadata(metadata)
-    CACHE_RESOURCE_MESSAGE_REPLAY_CTX.save_widget_metadata(metadata)
-
-
 def save_media_data(image_data: bytes | str, mimetype: str, image_id: str) -> None:
     CACHE_DATA_MESSAGE_REPLAY_CTX.save_image_data(image_data, mimetype, image_id)
     CACHE_RESOURCE_MESSAGE_REPLAY_CTX.save_image_data(image_data, mimetype, image_id)
@@ -99,7 +90,6 @@ __all__ = [
     "CACHE_DOCS_URL",
     "save_element_message",
     "save_block_message",
-    "save_widget_metadata",
     "save_media_data",
     "get_data_cache_stats_provider",
     "get_resource_cache_stats_provider",

streamlit/runtime/caching/cache_data_api.py

@@ -47,9 +47,7 @@ from streamlit.runtime.caching.cache_utils import (
 from streamlit.runtime.caching.cached_message_replay import (
     CachedMessageReplayContext,
     CachedResult,
-    ElementMsgData,
     MsgData,
-    MultiCacheResults,
     show_widget_replay_deprecation,
 )
 from streamlit.runtime.caching.storage import (
@@ -66,7 +64,6 @@ from streamlit.runtime.caching.storage.dummy_cache_storage import (
     MemoryCacheStorageManager,
 )
 from streamlit.runtime.metrics_util import gather_metrics
-from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
 from streamlit.runtime.stats import CacheStat, CacheStatsProvider, group_stats
 from streamlit.time_util import time_to_seconds
 
@@ -93,13 +90,11 @@ class CachedDataFuncInfo(CachedFuncInfo):
         persist: CachePersistType,
         max_entries: int | None,
         ttl: float | timedelta | str | None,
-        allow_widgets: bool,
         hash_funcs: HashFuncsDict | None = None,
     ):
         super().__init__(
             func,
             show_spinner=show_spinner,
-            allow_widgets=allow_widgets,
             hash_funcs=hash_funcs,
         )
         self.persist = persist
@@ -128,7 +123,6 @@ class CachedDataFuncInfo(CachedFuncInfo):
             max_entries=self.max_entries,
             ttl=self.ttl,
             display_name=self.display_name,
-            allow_widgets=self.allow_widgets,
         )
 
     def validate_params(self) -> None:
@@ -160,7 +154,6 @@ class DataCaches(CacheStatsProvider):
         max_entries: int | None,
         ttl: int | float | timedelta | str | None,
         display_name: str,
-        allow_widgets: bool,
     ) -> DataCache:
         """Return the mem cache for the given key.
 
@@ -220,7 +213,6 @@ class DataCaches(CacheStatsProvider):
                 max_entries=max_entries,
                 ttl_seconds=ttl_seconds,
                 display_name=display_name,
-                allow_widgets=allow_widgets,
             )
             self._function_caches[key] = cache
             return cache
@@ -443,9 +435,11 @@ class CacheDataAPI:
 
         experimental_allow_widgets : bool
             Allow widgets to be used in the cached function. Defaults to False.
-            Support for widgets in cached functions is currently experimental.
-            Setting this parameter to True may lead to excessive memory use since the
-            widget value is treated as an additional input parameter to the cache.
+
+            .. deprecated::
+                The cached widget replay functionality was removed in 1.38. Please
+                remove the ``experimental_allow_widgets`` parameter from your
+                caching decorators.
 
         hash_funcs : dict or None
             Mapping of types or fully qualified names to hash functions.
@@ -455,10 +449,6 @@ class CacheDataAPI:
             the provided function to generate a hash for it. See below for an example
             of how this can be used.
 
-        .. deprecated::
-            ``experimental_allow_widgets`` is deprecated and will be removed in
-            a later version.
-
         Example
         -------
         >>> import streamlit as st
@@ -574,7 +564,6 @@ class CacheDataAPI:
                     show_spinner=show_spinner,
                     max_entries=max_entries,
                     ttl=ttl,
-                    allow_widgets=experimental_allow_widgets,
                     hash_funcs=hash_funcs,
                 )
             )
@@ -589,7 +578,6 @@ class CacheDataAPI:
                 show_spinner=show_spinner,
                 max_entries=max_entries,
                 ttl=ttl,
-                allow_widgets=experimental_allow_widgets,
                 hash_funcs=hash_funcs,
             )
         )
@@ -611,7 +599,6 @@ class DataCache(Cache):
         max_entries: int | None,
         ttl_seconds: float | None,
         display_name: str,
-        allow_widgets: bool = False,
     ):
         super().__init__()
         self.key = key
@@ -620,7 +607,6 @@ class DataCache(Cache):
         self.ttl_seconds = ttl_seconds
         self.max_entries = max_entries
         self.persist = persist
-        self.allow_widgets = allow_widgets
 
     def get_stats(self) -> list[CacheStat]:
         if isinstance(self.storage, CacheStatsProvider):
@@ -641,21 +627,12 @@ class DataCache(Cache):
 
         try:
             entry = pickle.loads(pickled_entry)
-            if not isinstance(entry, MultiCacheResults):
+            if not isinstance(entry, CachedResult):
                 # Loaded an old cache file format, remove it and let the caller
                 # rerun the function.
                 self.storage.delete(key)
                 raise CacheKeyNotFoundError()
-
-            ctx = get_script_run_ctx()
-            if not ctx:
-                raise CacheKeyNotFoundError()
-
-            widget_key = entry.get_current_widget_key(ctx, CacheType.DATA)
-            if widget_key in entry.results:
-                return entry.results[widget_key]
-            else:
-                raise CacheKeyNotFoundError()
+            return entry
         except pickle.UnpicklingError as exc:
             raise CacheError(f"Failed to unpickle {key}") from exc
 
@@ -664,43 +641,13 @@ class DataCache(Cache):
         """Write a value and associated messages to the cache.
         The value must be pickleable.
         """
-        ctx = get_script_run_ctx()
-        if ctx is None:
-            return
-
-        main_id = st._main.id
-        sidebar_id = st.sidebar.id
-
-        if self.allow_widgets:
-            widgets = {
-                msg.widget_metadata.widget_id
-                for msg in messages
-                if isinstance(msg, ElementMsgData) and msg.widget_metadata is not None
-            }
-        else:
-            widgets = set()
-
-        multi_cache_results: MultiCacheResults | None = None
-
-        # Try to find in cache storage, then falling back to a new result instance
-        try:
-            multi_cache_results = self._read_multi_results_from_storage(key)
-        except (CacheKeyNotFoundError, pickle.UnpicklingError):
-            pass
-
-        if multi_cache_results is None:
-            multi_cache_results = MultiCacheResults(widget_ids=widgets, results={})
-        multi_cache_results.widget_ids.update(widgets)
-        widget_key = multi_cache_results.get_current_widget_key(ctx, CacheType.DATA)
-
-        result = CachedResult(value, messages, main_id, sidebar_id)
-        multi_cache_results.results[widget_key] = result
-
         try:
-            pickled_entry = pickle.dumps(multi_cache_results)
+            main_id = st._main.id
+            sidebar_id = st.sidebar.id
+            entry = CachedResult(value, messages, main_id, sidebar_id)
+            pickled_entry = pickle.dumps(entry)
         except (pickle.PicklingError, TypeError) as exc:
             raise CacheError(f"Failed to pickle {key}") from exc
-
         self.storage.set(key, pickled_entry)
 
     def _clear(self, key: str | None = None) -> None:
@@ -708,22 +655,3 @@ class DataCache(Cache):
             self.storage.clear()
         else:
             self.storage.delete(key)
-
-    def _read_multi_results_from_storage(self, key: str) -> MultiCacheResults:
-        """Look up the results from storage and ensure it has the right type.
-
-        Raises a `CacheKeyNotFoundError` if the key has no entry, or if the
-        entry is malformed.
-        """
-        try:
-            pickled = self.storage.get(key)
-        except CacheStorageKeyNotFoundError as e:
-            raise CacheKeyNotFoundError(str(e)) from e
-
-        maybe_results = pickle.loads(pickled)
-
-        if isinstance(maybe_results, MultiCacheResults):
-            return maybe_results
-        else:
-            self.storage.delete(key)
-            raise CacheKeyNotFoundError()

streamlit/runtime/caching/cache_errors.py

@@ -29,7 +29,7 @@ CACHE_DOCS_URL = "https://docs.streamlit.io/develop/concepts/architecture/cachin
 def get_cached_func_name_md(func: Any) -> str:
     """Get markdown representation of the function name."""
     if hasattr(func, "__name__"):
-        return "`%s()`" % func.__name__
+        return f"`{func.__name__}()`"
     elif hasattr(type(func), "__name__"):
         return f"`{type(func).__name__}`"
     return f"`{type(func)}`"
@@ -105,9 +105,10 @@ class CacheReplayClosureError(StreamlitAPIException):
 
         msg = (
             f"""
-While running {func_name}, a streamlit element is called on some layout block created outside the function.
-This is incompatible with replaying the cached effect of that element, because the
-the referenced block might not exist when the replay happens.
+While running {func_name}, a streamlit element is called on some layout block
+created outside the function. This is incompatible with replaying the cached
+effect of that element, because the the referenced block might not exist when
+the replay happens.
 
 How to fix this:
 * Move the creation of $THING inside {func_name}.
@@ -124,11 +125,14 @@ class UnserializableReturnValueError(MarkdownFormattedException):
         MarkdownFormattedException.__init__(
             self,
             f"""
-            Cannot serialize the return value (of type {get_return_value_type(return_value)}) in {get_cached_func_name_md(func)}.
-            `st.cache_data` uses [pickle](https://docs.python.org/3/library/pickle.html) to
-            serialize the function’s return value and safely store it in the cache without mutating the original object. Please convert the return value to a pickle-serializable type.
-            If you want to cache unserializable objects such as database connections or Tensorflow
-            sessions, use `st.cache_resource` instead (see [our docs]({CACHE_DOCS_URL}) for differences).""",
+            Cannot serialize the return value (of type {get_return_value_type(return_value)})
+            in {get_cached_func_name_md(func)}. `st.cache_data` uses
+            [pickle](https://docs.python.org/3/library/pickle.html) to serialize the
+            function's return value and safely store it in the cache
+            without mutating the original object. Please convert the return value to a
+            pickle-serializable type. If you want to cache unserializable objects such
+            as database connections or Tensorflow sessions, use `st.cache_resource`
+            instead (see [our docs]({CACHE_DOCS_URL}) for differences).""",
         )
 
 

streamlit/runtime/caching/cache_resource_api.py

@@ -37,13 +37,10 @@ from streamlit.runtime.caching.cache_utils import (
 from streamlit.runtime.caching.cached_message_replay import (
     CachedMessageReplayContext,
     CachedResult,
-    ElementMsgData,
     MsgData,
-    MultiCacheResults,
     show_widget_replay_deprecation,
 )
 from streamlit.runtime.metrics_util import gather_metrics
-from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
 from streamlit.runtime.stats import CacheStat, CacheStatsProvider, group_stats
 from streamlit.time_util import time_to_seconds
 
@@ -83,7 +80,6 @@ class ResourceCaches(CacheStatsProvider):
         max_entries: int | float | None,
         ttl: float | timedelta | str | None,
         validate: ValidateFunc | None,
-        allow_widgets: bool,
     ) -> ResourceCache:
         """Return the mem cache for the given key.
 
@@ -114,7 +110,6 @@ class ResourceCaches(CacheStatsProvider):
                 max_entries=max_entries,
                 ttl_seconds=ttl_seconds,
                 validate=validate,
-                allow_widgets=allow_widgets,
             )
             self._function_caches[key] = cache
             return cache
@@ -155,13 +150,11 @@ class CachedResourceFuncInfo(CachedFuncInfo):
         max_entries: int | None,
         ttl: float | timedelta | str | None,
         validate: ValidateFunc | None,
-        allow_widgets: bool,
         hash_funcs: HashFuncsDict | None = None,
     ):
         super().__init__(
             func,
             show_spinner=show_spinner,
-            allow_widgets=allow_widgets,
             hash_funcs=hash_funcs,
         )
         self.max_entries = max_entries
@@ -188,7 +181,6 @@ class CachedResourceFuncInfo(CachedFuncInfo):
             max_entries=self.max_entries,
             ttl=self.ttl,
             validate=self.validate,
-            allow_widgets=self.allow_widgets,
         )
 
 
@@ -315,9 +307,11 @@ class CacheResourceAPI:
 
         experimental_allow_widgets : bool
             Allow widgets to be used in the cached function. Defaults to False.
-            Support for widgets in cached functions is currently experimental.
-            Setting this parameter to True may lead to excessive memory use since the
-            widget value is treated as an additional input parameter to the cache.
+
+            .. deprecated::
+                The cached widget replay functionality was removed in 1.38. Please
+                remove the ``experimental_allow_widgets`` parameter from your
+                caching decorators.
 
         hash_funcs : dict or None
             Mapping of types or fully qualified names to hash functions.
@@ -327,10 +321,6 @@ class CacheResourceAPI:
             the provided function to generate a hash for it. See below for an example
             of how this can be used.
 
-        .. deprecated::
-            ``experimental_allow_widgets`` is deprecated and will be removed in
-            a later version.
-
         Example
         -------
         >>> import streamlit as st
@@ -426,7 +416,6 @@ class CacheResourceAPI:
                     max_entries=max_entries,
                     ttl=ttl,
                     validate=validate,
-                    allow_widgets=experimental_allow_widgets,
                     hash_funcs=hash_funcs,
                 )
             )
@@ -438,7 +427,6 @@ class CacheResourceAPI:
                 max_entries=max_entries,
                 ttl=ttl,
                 validate=validate,
-                allow_widgets=experimental_allow_widgets,
                 hash_funcs=hash_funcs,
             )
         )
@@ -459,17 +447,15 @@ class ResourceCache(Cache):
         ttl_seconds: float,
         validate: ValidateFunc | None,
         display_name: str,
-        allow_widgets: bool,
     ):
         super().__init__()
         self.key = key
         self.display_name = display_name
-        self._mem_cache: TTLCache[str, MultiCacheResults] = TTLCache(
+        self._mem_cache: TTLCache[str, CachedResult] = TTLCache(
             maxsize=max_entries, ttl=ttl_seconds, timer=cache_utils.TTLCACHE_TIMER
         )
         self._mem_cache_lock = threading.Lock()
         self.validate = validate
-        self.allow_widgets = allow_widgets
 
     @property
     def max_entries(self) -> float:
@@ -488,24 +474,11 @@ class ResourceCache(Cache):
                 # key does not exist in cache.
                 raise CacheKeyNotFoundError()
 
-            multi_results: MultiCacheResults = self._mem_cache[key]
-
-            ctx = get_script_run_ctx()
-            if not ctx:
-                # ScriptRunCtx does not exist (we're probably running in "raw" mode).
-                raise CacheKeyNotFoundError()
-
-            widget_key = multi_results.get_current_widget_key(ctx, CacheType.RESOURCE)
-            if widget_key not in multi_results.results:
-                # widget_key does not exist in cache (this combination of widgets hasn't been
-                # seen for the value_key yet).
-                raise CacheKeyNotFoundError()
-
-            result = multi_results.results[widget_key]
+            result = self._mem_cache[key]
 
             if self.validate is not None and not self.validate(result.value):
                 # Validate failed: delete the entry and raise an error.
-                del multi_results.results[widget_key]
+                del self._mem_cache[key]
                 raise CacheKeyNotFoundError()
 
             return result
@@ -513,33 +486,11 @@ class ResourceCache(Cache):
     @gather_metrics("_cache_resource_object")
     def write_result(self, key: str, value: Any, messages: list[MsgData]) -> None:
         """Write a value and associated messages to the cache."""
-        ctx = get_script_run_ctx()
-        if ctx is None:
-            return
-
         main_id = st._main.id
         sidebar_id = st.sidebar.id
-        if self.allow_widgets:
-            widgets = {
-                msg.widget_metadata.widget_id
-                for msg in messages
-                if isinstance(msg, ElementMsgData) and msg.widget_metadata is not None
-            }
-        else:
-            widgets = set()
 
         with self._mem_cache_lock:
-            try:
-                multi_results = self._mem_cache[key]
-            except KeyError:
-                multi_results = MultiCacheResults(widget_ids=widgets, results={})
-
-            multi_results.widget_ids.update(widgets)
-            widget_key = multi_results.get_current_widget_key(ctx, CacheType.RESOURCE)
-
-            result = CachedResult(value, messages, main_id, sidebar_id)
-            multi_results.results[widget_key] = result
-            self._mem_cache[key] = multi_results
+            self._mem_cache[key] = CachedResult(value, messages, main_id, sidebar_id)
 
     def _clear(self, key: str | None = None) -> None:
         with self._mem_cache_lock:

streamlit/runtime/caching/cache_utils.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import functools
 import hashlib
 import inspect
@@ -125,12 +126,10 @@ class CachedFuncInfo:
         self,
         func: FunctionType,
         show_spinner: bool | str,
-        allow_widgets: bool,
         hash_funcs: HashFuncsDict | None,
     ):
         self.func = func
         self.show_spinner = show_spinner
-        self.allow_widgets = allow_widgets
         self.hash_funcs = hash_funcs
 
     @property
@@ -230,11 +229,9 @@ class CachedFunc:
             hash_funcs=self._info.hash_funcs,
         )
 
-        try:
+        with contextlib.suppress(CacheKeyNotFoundError):
             cached_result = cache.read_result(value_key)
             return self._handle_cache_hit(cached_result)
-        except CacheKeyNotFoundError:
-            pass
         return self._handle_cache_miss(cache, value_key, func_args, func_kwargs)
 
     def _handle_cache_hit(self, result: CachedResult) -> Any:
@@ -279,17 +276,14 @@ class CachedFunc:
             # We've acquired the lock - but another thread may have acquired it first
             # and already computed the value. So we need to test for a cache hit again,
             # before computing.
-            try:
+            with contextlib.suppress(CacheKeyNotFoundError):
                 cached_result = cache.read_result(value_key)
                 # Another thread computed the value before us. Early exit!
                 return self._handle_cache_hit(cached_result)
 
-            except CacheKeyNotFoundError:
-                pass
-
             # We acquired the lock before any other thread. Compute the value!
             with self._info.cached_message_replay_ctx.calling_cached_function(
-                self._info.func, self._info.allow_widgets
+                self._info.func
             ):
                 computed_value = self._info.func(*func_args, **func_kwargs)
 
@@ -329,8 +323,10 @@ class CachedFunc:
 
         Parameters
         ----------
+
         *args: Any
             Arguments of the cached functions.
+
         **kwargs: Any
             Keyword arguments of the cached function.
 
@@ -471,8 +467,7 @@ def _make_function_key(cache_type: CacheType, func: FunctionType) -> str:
         source_code, hasher=func_hasher, cache_type=cache_type, hash_source=func
     )
 
-    cache_key = func_hasher.hexdigest()
-    return cache_key
+    return func_hasher.hexdigest()
 
 
 def _get_positional_arg_name(func: FunctionType, arg_index: int) -> str | None: