streamlit-nightly 1.31.2.dev20240212__py2.py3-none-any.whl → 1.31.2.dev20240214__py2.py3-none-any.whl

streamlit/runtime/media_file_manager.py

@@ -14,14 +14,16 @@
 
 """Provides global MediaFileManager object as `media_file_manager`."""
 
+from __future__ import annotations
+
 import collections
 import threading
-from typing import Dict, Optional, Set, Union
+from typing import Final
 
 from streamlit.logger import get_logger
 from streamlit.runtime.media_file_storage import MediaFileKind, MediaFileStorage
 
-LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 
 def _get_session_id() -> str:
@@ -80,11 +82,11 @@ class MediaFileManager:
         self._storage = storage
 
         # Dict of [file_id -> MediaFileMetadata]
-        self._file_metadata: Dict[str, MediaFileMetadata] = dict()
+        self._file_metadata: dict[str, MediaFileMetadata] = dict()
 
         # Dict[session ID][coordinates] -> file_id.
-        self._files_by_session_and_coord: Dict[
-            str, Dict[str, str]
+        self._files_by_session_and_coord: dict[
+            str, dict[str, str]
         ] = collections.defaultdict(dict)
 
         # MediaFileManager is used from multiple threads, so all operations
@@ -92,7 +94,7 @@ class MediaFileManager:
         # means taking it multiple times from the same thread will deadlock.)
         self._lock = threading.Lock()
 
-    def _get_inactive_file_ids(self) -> Set[str]:
+    def _get_inactive_file_ids(self) -> set[str]:
         """Compute the set of files that are stored in the manager, but are
         not referenced by any active session. These are files that can be
         safely deleted.
@@ -113,7 +115,7 @@ class MediaFileManager:
 
         Safe to call from any thread.
         """
-        LOGGER.debug("Removing orphaned files...")
+        _LOGGER.debug("Removing orphaned files...")
 
         with self._lock:
             for file_id in self._get_inactive_file_ids():
@@ -132,11 +134,11 @@ class MediaFileManager:
 
         Thread safety: callers must hold `self._lock`.
         """
-        LOGGER.debug("Deleting File: %s", file_id)
+        _LOGGER.debug("Deleting File: %s", file_id)
         self._storage.delete_file(file_id)
         del self._file_metadata[file_id]
 
-    def clear_session_refs(self, session_id: Optional[str] = None) -> None:
+    def clear_session_refs(self, session_id: str | None = None) -> None:
         """Remove the given session's file references.
 
         (This does not remove any files from the manager - you must call
@@ -149,17 +151,17 @@ class MediaFileManager:
         if session_id is None:
             session_id = _get_session_id()
 
-        LOGGER.debug("Disconnecting files for session with ID %s", session_id)
+        _LOGGER.debug("Disconnecting files for session with ID %s", session_id)
 
         with self._lock:
             if session_id in self._files_by_session_and_coord:
                 del self._files_by_session_and_coord[session_id]
 
-        LOGGER.debug(
+        _LOGGER.debug(
             "Sessions still active: %r", self._files_by_session_and_coord.keys()
         )
 
-        LOGGER.debug(
+        _LOGGER.debug(
             "Files: %s; Sessions with files: %s",
             len(self._file_metadata),
             len(self._files_by_session_and_coord),
@@ -167,10 +169,10 @@ class MediaFileManager:
 
     def add(
         self,
-        path_or_data: Union[bytes, str],
+        path_or_data: bytes | str,
         mimetype: str,
         coordinates: str,
-        file_name: Optional[str] = None,
+        file_name: str | None = None,
         is_for_static_download: bool = False,
     ) -> str:
         """Add a new MediaFile with the given parameters and return its URL.

streamlit/runtime/media_file_storage.py

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from abc import abstractmethod
 from enum import Enum
-from typing import Optional, Union
-
-from typing_extensions import Protocol
+from typing import Protocol
 
 
 class MediaFileKind(Enum):
@@ -43,17 +43,17 @@ class MediaFileStorage(Protocol):
     @abstractmethod
     def load_and_get_id(
         self,
-        path_or_data: Union[str, bytes],
+        path_or_data: str | bytes,
         mimetype: str,
         kind: MediaFileKind,
-        filename: Optional[str] = None,
+        filename: str | None = None,
     ) -> str:
         """Load the given file path or bytes into the manager and return
         an ID that uniquely identifies it.
 
-        It’s an error to pass a URL to this function. (Media stored at
+        It's an error to pass a URL to this function. (Media stored at
         external URLs can be served directly to the Streamlit frontend;
-        there’s no need to store this data in MediaFileStorage.)
+        there's no need to store this data in MediaFileStorage.)
 
         Parameters
         ----------
@@ -61,7 +61,7 @@ class MediaFileStorage(Protocol):
             A path to a file, or the file's raw data as bytes.
 
         mimetype
-            The media’s mimetype. Used to set the Content-Type header when
+            The media's mimetype. Used to set the Content-Type header when
             serving the media over HTTP.
 
         kind

streamlit/runtime/memory_media_file_storage.py

@@ -14,13 +14,13 @@
 
 """MediaFileStorage implementation that stores files in memory."""
 
+from __future__ import annotations
+
 import contextlib
 import hashlib
 import mimetypes
 import os.path
-from typing import Dict, List, NamedTuple, Optional, Union
-
-from typing_extensions import Final
+from typing import Final, NamedTuple
 
 from streamlit.logger import get_logger
 from streamlit.runtime.media_file_storage import (
@@ -31,7 +31,7 @@ from streamlit.runtime.media_file_storage import (
 from streamlit.runtime.stats import CacheStat, CacheStatsProvider, group_stats
 from streamlit.util import HASHLIB_KWARGS
 
-LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 # Mimetype -> filename extension map for the `get_extension_for_mimetype`
 # function. We use Python's `mimetypes.guess_extension` for most mimetypes,
@@ -42,9 +42,7 @@ PREFERRED_MIMETYPE_EXTENSION_MAP: Final = {
 }
 
 
-def _calculate_file_id(
-    data: bytes, mimetype: str, filename: Optional[str] = None
-) -> str:
+def _calculate_file_id(data: bytes, mimetype: str, filename: str | None = None) -> str:
     """Hash data, mimetype, and an optional filename to generate a stable file ID.
 
     Parameters
@@ -83,7 +81,7 @@ class MemoryFile(NamedTuple):
     content: bytes
     mimetype: str
     kind: MediaFileKind
-    filename: Optional[str]
+    filename: str | None
 
     @property
     def content_size(self) -> int:
@@ -100,15 +98,15 @@ class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
             The name of the local endpoint that media is served from.
             This endpoint should start with a forward-slash (e.g. "/media").
         """
-        self._files_by_id: Dict[str, MemoryFile] = {}
+        self._files_by_id: dict[str, MemoryFile] = {}
         self._media_endpoint = media_endpoint
 
     def load_and_get_id(
         self,
-        path_or_data: Union[str, bytes],
+        path_or_data: str | bytes,
         mimetype: str,
         kind: MediaFileKind,
-        filename: Optional[str] = None,
+        filename: str | None = None,
     ) -> str:
         """Add a file to the manager and return its ID."""
         file_data: bytes
@@ -121,7 +119,7 @@ class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
         # given ID, we don't need to create a new one.
         file_id = _calculate_file_id(file_data, mimetype, filename)
         if file_id not in self._files_by_id:
-            LOGGER.debug("Adding media file %s", file_id)
+            _LOGGER.debug("Adding media file %s", file_id)
             media_file = MemoryFile(
                 content=file_data, mimetype=mimetype, kind=kind, filename=filename
             )
@@ -167,12 +165,12 @@ class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
         except Exception as ex:
             raise MediaFileStorageError(f"Error opening '{filename}'") from ex
 
-    def get_stats(self) -> List[CacheStat]:
+    def get_stats(self) -> list[CacheStat]:
         # We operate on a copy of our dict, to avoid race conditions
         # with other threads that may be manipulating the cache.
         files_by_id = self._files_by_id.copy()
 
-        stats: List[CacheStat] = []
+        stats: list[CacheStat] = []
         for file_id, file in files_by_id.items():
             stats.append(
                 CacheStat(

streamlit/runtime/memory_session_storage.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
-from typing import List, MutableMapping, Optional
+from typing import MutableMapping
 
 from streamlit.runtime.session_manager import SessionInfo, SessionStorage
 from streamlit.util import TimedCleanupCache
@@ -59,7 +60,7 @@ class MemorySessionStorage(SessionStorage):
             maxsize=maxsize, ttl=ttl_seconds
         )
 
-    def get(self, session_id: str) -> Optional[SessionInfo]:
+    def get(self, session_id: str) -> SessionInfo | None:
         return self._cache.get(session_id, None)
 
     def save(self, session_info: SessionInfo) -> None:
@@ -68,5 +69,5 @@ class MemorySessionStorage(SessionStorage):
     def delete(self, session_id: str) -> None:
         del self._cache[session_id]
 
-    def list(self) -> List[SessionInfo]:
+    def list(self) -> list[SessionInfo]:
         return list(self._cache.values())

streamlit/runtime/memory_uploaded_file_manager.py

@@ -12,12 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import uuid
 from collections import defaultdict
-from typing import Dict, List, Sequence
+from typing import Sequence
 
 from streamlit import util
-from streamlit.logger import get_logger
 from streamlit.runtime.stats import CacheStat, group_stats
 from streamlit.runtime.uploaded_file_manager import (
     UploadedFileManager,
@@ -25,8 +26,6 @@ from streamlit.runtime.uploaded_file_manager import (
     UploadFileUrlInfo,
 )
 
-LOGGER = get_logger(__name__)
-
 
 class MemoryUploadedFileManager(UploadedFileManager):
     """Holds files uploaded by users of the running Streamlit app.
@@ -34,12 +33,12 @@ class MemoryUploadedFileManager(UploadedFileManager):
     """
 
     def __init__(self, upload_endpoint: str):
-        self.file_storage: Dict[str, Dict[str, UploadedFileRec]] = defaultdict(dict)
+        self.file_storage: dict[str, dict[str, UploadedFileRec]] = defaultdict(dict)
         self.endpoint = upload_endpoint
 
     def get_files(
         self, session_id: str, file_ids: Sequence[str]
-    ) -> List[UploadedFileRec]:
+    ) -> list[UploadedFileRec]:
         """Return a  list of UploadedFileRec for a given sequence of file_ids.
 
         Parameters
@@ -97,7 +96,7 @@ class MemoryUploadedFileManager(UploadedFileManager):
 
     def get_upload_urls(
         self, session_id: str, file_names: Sequence[str]
-    ) -> List[UploadFileUrlInfo]:
+    ) -> list[UploadFileUrlInfo]:
         """Return a list of UploadFileUrlInfo for a given sequence of file_names."""
         result = []
         for _ in file_names:
@@ -111,13 +110,13 @@ class MemoryUploadedFileManager(UploadedFileManager):
             )
         return result
 
-    def get_stats(self) -> List[CacheStat]:
+    def get_stats(self) -> list[CacheStat]:
         """Return the manager's CacheStats.
 
         Safe to call from any thread.
         """
         # Flatten all files into a single list
-        all_files: List[UploadedFileRec] = []
+        all_files: list[UploadedFileRec] = []
         # Make copy of self.file_storage for thread safety, to be sure
         # that main storage won't be changed form other thread
         file_storage_copy = self.file_storage.copy()
@@ -125,7 +124,7 @@ class MemoryUploadedFileManager(UploadedFileManager):
         for session_storage in file_storage_copy.values():
             all_files.extend(session_storage.values())
 
-        stats: List[CacheStat] = [
+        stats: list[CacheStat] = [
             CacheStat(
                 category_name="UploadedFileManager",
                 cache_name="",

streamlit/runtime/metrics_util.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import contextlib
 import inspect
 import os
@@ -21,17 +23,14 @@ import time
 import uuid
 from collections.abc import Sized
 from functools import wraps
-from timeit import default_timer as timer
-from typing import Any, Callable, List, Optional, Set, TypeVar, Union, cast, overload
-
-from typing_extensions import Final
+from typing import Any, Callable, Final, TypeVar, cast, overload
 
 from streamlit import config, util
 from streamlit.logger import get_logger
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 from streamlit.proto.PageProfile_pb2 import Argument, Command
 
-_LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 # Limit the number of commands to keep the page profile message small
 # since Segment allows only a maximum of 32kb per event.
@@ -161,11 +160,11 @@ def _get_machine_id_v3() -> str:
 
     machine_id = str(uuid.getnode())
     if os.path.isfile(_ETC_MACHINE_ID_PATH):
-        with open(_ETC_MACHINE_ID_PATH, "r") as f:
+        with open(_ETC_MACHINE_ID_PATH) as f:
             machine_id = f.read()
 
     elif os.path.isfile(_DBUS_MACHINE_ID_PATH):
-        with open(_DBUS_MACHINE_ID_PATH, "r") as f:
+        with open(_DBUS_MACHINE_ID_PATH) as f:
             machine_id = f.read()
 
     return machine_id
@@ -173,10 +172,10 @@ def _get_machine_id_v3() -> str:
 
 class Installation:
     _instance_lock = threading.Lock()
-    _instance: Optional["Installation"] = None
+    _instance: Installation | None = None
 
     @classmethod
-    def instance(cls) -> "Installation":
+    def instance(cls) -> Installation:
         """Returns the singleton Installation"""
         # We use a double-checked locking optimization to avoid the overhead
         # of acquiring the lock in the common case:
@@ -228,7 +227,7 @@ def _get_top_level_module(func: Callable[..., Any]) -> str:
     return module.__name__.split(".")[0]
 
 
-def _get_arg_metadata(arg: object) -> Optional[str]:
+def _get_arg_metadata(arg: object) -> str | None:
     """Get metadata information related to the value of the given object."""
     with contextlib.suppress(Exception):
         if isinstance(arg, (bool)):
@@ -245,8 +244,8 @@ def _get_command_telemetry(
 ) -> Command:
     """Get telemetry information for the given callable and its arguments."""
     arg_keywords = inspect.getfullargspec(_command_func).args
-    self_arg: Optional[Any] = None
-    arguments: List[Argument] = []
+    self_arg: Any | None = None
+    arguments: list[Argument] = []
     is_method = inspect.ismethod(_command_func)
     name = _command_name
 
@@ -315,7 +314,7 @@ def gather_metrics(
     ...
 
 
-def gather_metrics(name: str, func: Optional[F] = None) -> Union[Callable[[F], F], F]:
+def gather_metrics(name: str, func: F | None = None) -> Callable[[F], F] | F:
     """Function decorator to add telemetry tracking to commands.
 
     Parameters
@@ -351,11 +350,13 @@ def gather_metrics(name: str, func: Optional[F] = None) -> Union[Callable[[F], F
 
         return wrapper
     else:
-        # To make mypy type narrow Optional[F] -> F
+        # To make mypy type narrow F | None -> F
         non_optional_func = func
 
     @wraps(non_optional_func)
     def wrapped_func(*args, **kwargs):
+        from timeit import default_timer as timer
+
         exec_start = timer()
         # Local imports to prevent circular dependencies
         from streamlit.runtime.scriptrunner import get_script_run_ctx
@@ -371,8 +372,7 @@ def gather_metrics(name: str, func: Optional[F] = None) -> Union[Callable[[F], F
             < _MAX_TRACKED_COMMANDS  # Prevent too much memory usage
         )
 
-        deferred_exception: Optional[RerunException] = None
-        command_telemetry: Optional[Command] = None
+        command_telemetry: Command | None = None
 
         if ctx and tracking_activated:
             try:
@@ -421,10 +421,10 @@ def gather_metrics(name: str, func: Optional[F] = None) -> Union[Callable[[F], F
 
 
 def create_page_profile_message(
-    commands: List[Command],
+    commands: list[Command],
     exec_time: int,
     prep_time: int,
-    uncaught_exception: Optional[str] = None,
+    uncaught_exception: str | None = None,
 ) -> ForwardMsg:
     """Create and return the full PageProfile ForwardMsg."""
     msg = ForwardMsg()
@@ -435,7 +435,7 @@ def create_page_profile_message(
     msg.page_profile.headless = config.get_option("server.headless")
 
     # Collect all config options that have been manually set
-    config_options: Set[str] = set()
+    config_options: set[str] = set()
     if config._config_options:
         for option_name in config._config_options.keys():
             if not config.is_manually_set(option_name):
@@ -450,7 +450,7 @@ def create_page_profile_message(
     msg.page_profile.config.extend(config_options)
 
     # Check the predefined set of modules for attribution
-    attributions: Set[str] = {
+    attributions: set[str] = {
         attribution
         for attribution in _ATTRIBUTIONS_TO_CHECK
         if attribution in sys.modules

streamlit/runtime/runtime.py

@@ -19,9 +19,7 @@ import time
 import traceback
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Awaitable, Dict, NamedTuple, Optional, Tuple, Type
-
-from typing_extensions import Final
+from typing import TYPE_CHECKING, Awaitable, Final, NamedTuple
 
 from streamlit import config
 from streamlit.logger import get_logger
@@ -69,7 +67,7 @@ if TYPE_CHECKING:
 # Wait for the script run result for 60s and if no result is available give up
 SCRIPT_RUN_CHECK_TIMEOUT: Final = 60
 
-LOGGER: Final = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 
 class RuntimeStoppedError(Exception):
@@ -85,7 +83,7 @@ class RuntimeConfig:
 
     # DEPRECATED: We need to keep this field around for compatibility reasons, but we no
     # longer use this anywhere.
-    command_line: Optional[str]
+    command_line: str | None
 
     # The storage backend for Streamlit's MediaFileManager.
     media_file_storage: MediaFileStorage
@@ -99,7 +97,7 @@ class RuntimeConfig:
     )
 
     # The SessionManager class to be used.
-    session_manager_class: Type[SessionManager] = WebsocketSessionManager
+    session_manager_class: type[SessionManager] = WebsocketSessionManager
 
     # The SessionStorage instance for the SessionManager to use.
     session_storage: SessionStorage = field(default_factory=MemorySessionStorage)
@@ -141,7 +139,7 @@ class AsyncObjects(NamedTuple):
 
 
 class Runtime:
-    _instance: Optional[Runtime] = None
+    _instance: Runtime | None = None
 
     @classmethod
     def instance(cls) -> Runtime:
@@ -179,11 +177,11 @@ class Runtime:
         Runtime._instance = self
 
         # Will be created when we start.
-        self._async_objs: Optional[AsyncObjects] = None
+        self._async_objs: AsyncObjects | None = None
 
         # The task that runs our main loop. We need to save a reference
         # to it so that it doesn't get garbage collected while running.
-        self._loop_coroutine_task: Optional[asyncio.Task[None]] = None
+        self._loop_coroutine_task: asyncio.Task[None] | None = None
 
         self._main_script_path = config.script_path
         self._is_hello = config.is_hello
@@ -247,7 +245,7 @@ class Runtime:
     # happen to be threadsafe. This may change with future SessionManager implementations,
     # at which point we'll need to formalize our thread safety rules for each
     # SessionManager method.
-    def get_client(self, session_id: str) -> Optional[SessionClient]:
+    def get_client(self, session_id: str) -> SessionClient | None:
         """Get the SessionClient for the given session_id, or None
         if no such session exists.
 
@@ -304,7 +302,7 @@ class Runtime:
             if self._state in (RuntimeState.STOPPING, RuntimeState.STOPPED):
                 return
 
-            LOGGER.debug("Runtime stopping...")
+            _LOGGER.debug("Runtime stopping...")
             self._set_state(RuntimeState.STOPPING)
             async_objs.must_stop.set()
 
@@ -322,9 +320,9 @@ class Runtime:
     def connect_session(
         self,
         client: SessionClient,
-        user_info: Dict[str, Optional[str]],
-        existing_session_id: Optional[str] = None,
-        session_id_override: Optional[str] = None,
+        user_info: dict[str, str | None],
+        existing_session_id: str | None = None,
+        session_id_override: str | None = None,
     ) -> str:
         """Create a new session (or connect to an existing one) and return its unique ID.
 
@@ -383,9 +381,9 @@ class Runtime:
     def create_session(
         self,
         client: SessionClient,
-        user_info: Dict[str, Optional[str]],
-        existing_session_id: Optional[str] = None,
-        session_id_override: Optional[str] = None,
+        user_info: dict[str, str | None],
+        existing_session_id: str | None = None,
+        session_id_override: str | None = None,
     ) -> str:
         """Create a new session (or connect to an existing one) and return its unique ID.
 
@@ -394,7 +392,7 @@ class Runtime:
         This method is simply an alias for connect_session added for backwards
         compatibility.
         """
-        LOGGER.warning("create_session is deprecated! Use connect_session instead.")
+        _LOGGER.warning("create_session is deprecated! Use connect_session instead.")
         return self.connect_session(
             client=client,
             user_info=user_info,
@@ -478,7 +476,7 @@ class Runtime:
 
         session_info = self._session_mgr.get_active_session_info(session_id)
         if session_info is None:
-            LOGGER.debug(
+            _LOGGER.debug(
                 "Discarding BackMsg for disconnected session (id=%s)", session_id
             )
             return
@@ -508,7 +506,7 @@ class Runtime:
 
         session_info = self._session_mgr.get_active_session_info(session_id)
         if session_info is None:
-            LOGGER.debug(
+            _LOGGER.debug(
                 "Discarding BackMsg Exception for disconnected session (id=%s)",
                 session_id,
             )
@@ -517,7 +515,7 @@ class Runtime:
         session_info.session.handle_backmsg_exception(exc)
 
     @property
-    async def is_ready_for_browser_connection(self) -> Tuple[bool, str]:
+    async def is_ready_for_browser_connection(self) -> tuple[bool, str]:
         if self._state not in (
             RuntimeState.INITIAL,
             RuntimeState.STOPPING,
@@ -527,7 +525,7 @@ class Runtime:
 
         return False, "unavailable"
 
-    async def does_script_run_without_error(self) -> Tuple[bool, str]:
+    async def does_script_run_without_error(self) -> tuple[bool, str]:
         """Load and execute the app's script to verify it runs without an error.
 
         Returns
@@ -572,7 +570,7 @@ class Runtime:
             session.shutdown()
 
     def _set_state(self, new_state: RuntimeState) -> None:
-        LOGGER.debug("Runtime state: %s -> %s", self._state, new_state)
+        _LOGGER.debug("Runtime state: %s -> %s", self._state, new_state)
         self._state = new_state
 
     async def _loop_coroutine(self) -> None:
@@ -655,7 +653,7 @@ class Runtime:
         except Exception as e:
             async_objs.stopped.set_exception(e)
             traceback.print_exc()
-            LOGGER.info(
+            _LOGGER.info(
                 """
 Please report this bug at https://github.com/streamlit/streamlit/issues.
 """
@@ -689,13 +687,13 @@ Please report this bug at https://github.com/streamlit/streamlit/issues.
             ):
                 # This session has probably cached this message. Send
                 # a reference instead.
-                LOGGER.debug("Sending cached message ref (hash=%s)", msg.hash)
+                _LOGGER.debug("Sending cached message ref (hash=%s)", msg.hash)
                 msg_to_send = create_reference_msg(msg)
 
             # Cache the message so it can be referenced in the future.
             # If the message is already cached, this will reset its
             # age.
-            LOGGER.debug("Caching message (hash=%s)", msg.hash)
+            _LOGGER.debug("Caching message (hash=%s)", msg.hash)
             self._message_cache.add_message(
                 msg, session_info.session, session_info.script_run_count
             )
@@ -706,7 +704,7 @@ Please report this bug at https://github.com/streamlit/streamlit/issues.
             msg.WhichOneof("type") == "script_finished"
             and msg.script_finished == ForwardMsg.FINISHED_SUCCESSFULLY
         ):
-            LOGGER.debug(
+            _LOGGER.debug(
                 "Script run finished successfully; "
                 "removing expired entries from MessageCache "
                 "(max_age=%s)",