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

streamlit/external/langchain/streamlit_callback_handler.py

@@ -27,13 +27,15 @@ compatible API continues to exist.
 
 Any major change to the StreamlitCallbackHandler should be tested by importing
 the API *from LangChain itself*.
+
+This module is lazy-loaded.
 """
 
 from __future__ import annotations
 
 import time
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict, List, NamedTuple, Optional
+from typing import TYPE_CHECKING, Any, NamedTuple
 
 from langchain.callbacks.base import (  # type: ignore[import-not-found, unused-ignore]
     BaseCallbackHandler,
@@ -150,18 +152,18 @@ class LLMThought:
 
         self._state = LLMThoughtState.THINKING
         self._llm_token_stream = ""
-        self._llm_token_stream_placeholder: Optional[DeltaGenerator] = None
-        self._last_tool: Optional[ToolRecord] = None
+        self._llm_token_stream_placeholder: DeltaGenerator | None = None
+        self._last_tool: ToolRecord | None = None
         self._collapse_on_complete = collapse_on_complete
         self._labeler = labeler
 
     @property
-    def container(self) -> "StatusContainer":
+    def container(self) -> StatusContainer:
         """The container we're writing into."""
         return self._container
 
     @property
-    def last_tool(self) -> Optional[ToolRecord]:
+    def last_tool(self) -> ToolRecord | None:
         """The last tool executed by this thought"""
         return self._last_tool
 
@@ -172,7 +174,7 @@ class LLMThought:
         self._llm_token_stream = ""
         self._llm_token_stream_placeholder = None
 
-    def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str]) -> None:
+    def on_llm_start(self, serialized: dict[str, Any], prompts: list[str]) -> None:
         self._reset_llm_token_stream()
 
     def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
@@ -194,7 +196,7 @@ class LLMThought:
         self._state = LLMThoughtState.ERROR
 
     def on_tool_start(
-        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+        self, serialized: dict[str, Any], input_str: str, **kwargs: Any
     ) -> None:
         # Called with the name of the tool we're about to run (in `serialized[name]`),
         # and its input. We change our container's label to be the tool name.
@@ -212,9 +214,9 @@ class LLMThought:
     def on_tool_end(
         self,
         output: str,
-        color: Optional[str] = None,
-        observation_prefix: Optional[str] = None,
-        llm_prefix: Optional[str] = None,
+        color: str | None = None,
+        observation_prefix: str | None = None,
+        llm_prefix: str | None = None,
         **kwargs: Any,
     ) -> None:
         self._container.markdown(output)
@@ -225,7 +227,7 @@ class LLMThought:
         self._container.update(state="error")
 
     def on_agent_action(
-        self, action: AgentAction, color: Optional[str] = None, **kwargs: Any
+        self, action: AgentAction, color: str | None = None, **kwargs: Any
     ) -> Any:
         # Called when we're about to kick off a new tool. The `action` data
         # tells us the tool we're about to use, and the input we'll give it.
@@ -233,7 +235,7 @@ class LLMThought:
         # when `on_tool_start` is called immediately after.
         pass
 
-    def complete(self, final_label: Optional[str] = None) -> None:
+    def complete(self, final_label: str | None = None) -> None:
         """Finish the thought."""
         if final_label is None and self._state == LLMThoughtState.RUNNING_TOOL:
             assert (
@@ -268,7 +270,7 @@ class StreamlitCallbackHandler(BaseCallbackHandler):
         max_thought_containers: int = 4,
         expand_new_thoughts: bool = False,
         collapse_completed_thoughts: bool = False,
-        thought_labeler: Optional[LLMThoughtLabeler] = None,
+        thought_labeler: LLMThoughtLabeler | None = None,
     ):
         """Construct a new StreamlitCallbackHandler. This CallbackHandler is geared
         towards use with a LangChain Agent; it displays the Agent's LLM and tool-usage
@@ -305,8 +307,8 @@ class StreamlitCallbackHandler(BaseCallbackHandler):
         """
         self._parent_container = parent_container
         self._history_parent = parent_container.container()
-        self._current_thought: Optional[LLMThought] = None
-        self._completed_thoughts: List[LLMThought] = []
+        self._current_thought: LLMThought | None = None
+        self._completed_thoughts: list[LLMThought] = []
         self._max_thought_containers = max(max_thought_containers, 1)
         self._expand_new_thoughts = expand_new_thoughts
         self._collapse_completed_thoughts = collapse_completed_thoughts
@@ -320,13 +322,13 @@ class StreamlitCallbackHandler(BaseCallbackHandler):
             raise RuntimeError("Current LLMThought is unexpectedly None!")
         return self._current_thought
 
-    def _get_last_completed_thought(self) -> Optional[LLMThought]:
+    def _get_last_completed_thought(self) -> LLMThought | None:
         """Return our most recent completed LLMThought, or None if we don't have one."""
         if len(self._completed_thoughts) > 0:
             return self._completed_thoughts[len(self._completed_thoughts) - 1]
         return None
 
-    def _complete_current_thought(self, final_label: Optional[str] = None) -> None:
+    def _complete_current_thought(self, final_label: str | None = None) -> None:
         """Complete the current thought, optionally assigning it a new label.
         Add it to our _completed_thoughts list.
         """
@@ -336,7 +338,7 @@ class StreamlitCallbackHandler(BaseCallbackHandler):
         self._current_thought = None
 
     def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+        self, serialized: dict[str, Any], prompts: list[str], **kwargs: Any
     ) -> None:
         if self._current_thought is None:
             self._current_thought = LLMThought(
@@ -361,16 +363,16 @@ class StreamlitCallbackHandler(BaseCallbackHandler):
         self._require_current_thought().on_llm_error(error, **kwargs)
 
     def on_tool_start(
-        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+        self, serialized: dict[str, Any], input_str: str, **kwargs: Any
     ) -> None:
         self._require_current_thought().on_tool_start(serialized, input_str, **kwargs)
 
     def on_tool_end(
         self,
         output: str,
-        color: Optional[str] = None,
-        observation_prefix: Optional[str] = None,
-        llm_prefix: Optional[str] = None,
+        color: str | None = None,
+        observation_prefix: str | None = None,
+        llm_prefix: str | None = None,
         **kwargs: Any,
     ) -> None:
         self._require_current_thought().on_tool_end(
@@ -382,12 +384,12 @@ class StreamlitCallbackHandler(BaseCallbackHandler):
         self._require_current_thought().on_tool_error(error, **kwargs)
 
     def on_agent_action(
-        self, action: AgentAction, color: Optional[str] = None, **kwargs: Any
+        self, action: AgentAction, color: str | None = None, **kwargs: Any
     ) -> Any:
         self._require_current_thought().on_agent_action(action, color, **kwargs)
 
     def on_agent_finish(
-        self, finish: AgentFinish, color: Optional[str] = None, **kwargs: Any
+        self, finish: AgentFinish, color: str | None = None, **kwargs: Any
     ) -> None:
         if self._current_thought is not None:
             self._current_thought.complete(

streamlit/file_util.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import contextlib
 import errno
-import fnmatch
 import io
 import os
 from pathlib import Path
@@ -29,7 +30,9 @@ CONFIG_FOLDER_NAME = ".streamlit"
 APP_STATIC_FOLDER_NAME = "static"
 
 
-def get_encoded_file_data(data, encoding="auto"):
+def get_encoded_file_data(
+    data: bytes, encoding: str = "auto"
+) -> io.StringIO | io.BytesIO:
     """Coerce bytes to a BytesIO or a StringIO.
 
     Parameters
@@ -45,16 +48,15 @@ def get_encoded_file_data(data, encoding="auto"):
 
     """
     if encoding == "auto":
-        if is_binary_string(data):
-            encoding = None
-        else:
-            # If the file does not look like a pure binary file, assume
-            # it's utf-8. It would be great if we could guess it a little
-            # more smartly here, but it is what it is!
-            encoding = "utf-8"
+        # If the file does not look like a pure binary file, assume
+        # it's utf-8. It would be great if we could guess it a little
+        # more smartly here, but it is what it is!
+        data_encoding = None if is_binary_string(data) else "utf-8"
+    else:
+        data_encoding = encoding
 
-    if encoding:
-        return io.StringIO(data.decode(encoding))
+    if data_encoding:
+        return io.StringIO(data.decode(data_encoding))
 
     return io.BytesIO(data)
 
@@ -116,7 +118,7 @@ def streamlit_write(path, binary=False):
         raise util.Error("\n".join(msg))
 
 
-def get_static_dir():
+def get_static_dir() -> str:
     """Get the folder where static HTML/JS/CSS files live."""
     dirname = os.path.dirname(os.path.normpath(__file__))
     return os.path.normpath(os.path.join(dirname, "static"))
@@ -150,7 +152,7 @@ def get_project_streamlit_file_path(*filepath):
     return os.path.join(os.getcwd(), CONFIG_FOLDER_NAME, *filepath)
 
 
-def file_is_in_folder_glob(filepath, folderpath_glob) -> bool:
+def file_is_in_folder_glob(filepath: str, folderpath_glob: str) -> bool:
     """Test whether a file is in some folder with globbing support.
 
     Parameters
@@ -169,6 +171,8 @@ def file_is_in_folder_glob(filepath, folderpath_glob) -> bool:
         else:
             folderpath_glob += "/*"
 
+    import fnmatch
+
     file_dir = os.path.dirname(filepath) + "/"
     return fnmatch.fnmatch(file_dir, folderpath_glob)
 
@@ -183,7 +187,7 @@ def get_directory_size(directory: str) -> int:
     return total_size
 
 
-def file_in_pythonpath(filepath) -> bool:
+def file_in_pythonpath(filepath: str) -> bool:
     """Test whether a filepath is in the same folder of a path specified in the PYTHONPATH env variable.
 
 

streamlit/folder_black_list.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import os
 
 from streamlit import config, file_util, util
@@ -34,7 +36,7 @@ DEFAULT_FOLDER_BLACKLIST = [
 ]
 
 
-class FolderBlackList(object):
+class FolderBlackList:
     """Implement a black list object with globbing.
 
     Note

streamlit/git_util.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import os
 import re
-from typing import Any, Optional, Tuple
+from typing import Any
 
 from streamlit import util
 
@@ -32,7 +34,7 @@ class GitRepo:
     def __init__(self, path):
         # If we have a valid repo, git_version will be a tuple of 3+ ints:
         # (major, minor, patch, possible_additional_patch_number)
-        self.git_version: Optional[Tuple[int, ...]] = None
+        self.git_version: tuple[int, ...] | None = None
 
         try:
             import git
@@ -124,7 +126,7 @@ class GitRepo:
 
         return self.repo.remote(remote_name), branch_name
 
-    def is_github_repo(self):
+    def is_github_repo(self) -> bool:
         if not self.is_valid():
             return False
 

streamlit/js_number.py

@@ -12,15 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numbers
-from typing import Optional, Union
 
 
 class JSNumberBoundsException(Exception):
     pass
 
 
-class JSNumber(object):
+class JSNumber:
     """Utility class for exposing JavaScript Number constants."""
 
     # The largest int that can be represented with perfect precision
@@ -41,7 +42,7 @@ class JSNumber(object):
     MIN_NEGATIVE_VALUE = -MAX_VALUE
 
     @classmethod
-    def validate_int_bounds(cls, value: int, value_name: Optional[str] = None) -> None:
+    def validate_int_bounds(cls, value: int, value_name: str | None = None) -> None:
         """Validate that an int value can be represented with perfect precision
         by a JavaScript Number.
 
@@ -64,17 +65,15 @@ class JSNumber(object):
 
         if value < cls.MIN_SAFE_INTEGER:
             raise JSNumberBoundsException(
-                "%s (%s) must be >= -((1 << 53) - 1)" % (value_name, value)
+                f"{value_name} ({value}) must be >= -((1 << 53) - 1)"
             )
         elif value > cls.MAX_SAFE_INTEGER:
             raise JSNumberBoundsException(
-                "%s (%s) must be <= (1 << 53) - 1" % (value_name, value)
+                f"{value_name} ({value}) must be <= (1 << 53) - 1"
             )
 
     @classmethod
-    def validate_float_bounds(
-        cls, value: Union[int, float], value_name: Optional[str]
-    ) -> None:
+    def validate_float_bounds(cls, value: int | float, value_name: str | None) -> None:
         """Validate that a float value can be represented by a JavaScript Number.
 
         Parameters
@@ -95,14 +94,12 @@ class JSNumber(object):
             value_name = "value"
 
         if not isinstance(value, (numbers.Integral, float)):
-            raise JSNumberBoundsException(
-                "%s (%s) is not a float" % (value_name, value)
-            )
+            raise JSNumberBoundsException(f"{value_name} ({value}) is not a float")
         elif value < cls.MIN_NEGATIVE_VALUE:
             raise JSNumberBoundsException(
-                "%s (%s) must be >= -1.797e+308" % (value_name, value)
+                f"{value_name} ({value}) must be >= -1.797e+308"
             )
         elif value > cls.MAX_VALUE:
             raise JSNumberBoundsException(
-                "%s (%s) must be <= 1.797e+308" % (value_name, value)
+                f"{value_name} ({value}) must be <= 1.797e+308"
             )

streamlit/logger.py

@@ -14,22 +14,22 @@
 
 """Logging module."""
 
+from __future__ import annotations
+
 import logging
 import sys
-from typing import Dict, Union
-
-from typing_extensions import Final
+from typing import Final
 
 DEFAULT_LOG_MESSAGE: Final = "%(asctime)s %(levelname) -7s " "%(name)s: %(message)s"
 
 # Loggers for each name are saved here.
-_loggers: Dict[str, logging.Logger] = {}
+_loggers: dict[str, logging.Logger] = {}
 
 # The global log level is set here across all names.
 _global_log_level = logging.INFO
 
 
-def set_log_level(level: Union[str, int]) -> None:
+def set_log_level(level: str | int) -> None:
     """Set log level."""
     logger = get_logger(__name__)
 

streamlit/net_util.py

@@ -12,25 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import socket
-from typing import Optional
+from __future__ import annotations
 
-from typing_extensions import Final
+from typing import Final
 
 from streamlit import util
 from streamlit.logger import get_logger
 
-LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 # URLs for checking the current machine's external IP address.
 _AWS_CHECK_IP: Final = "http://checkip.amazonaws.com"
 _AWS_CHECK_IP_HTTPS: Final = "https://checkip.amazonaws.com"
 
-_external_ip: Optional[str] = None
-_internal_ip: Optional[str] = None
+_external_ip: str | None = None
+_internal_ip: str | None = None
 
 
-def get_external_ip() -> Optional[str]:
+def get_external_ip() -> str | None:
     """Get the *external* IP address of the current machine.
 
     Returns
@@ -52,7 +51,7 @@ def get_external_ip() -> Optional[str]:
     if _looks_like_an_ip_adress(response):
         _external_ip = response
     else:
-        LOGGER.warning(
+        _LOGGER.warning(
             # fmt: off
             "Did not auto detect external IP.\n"
             "Please go to %s for debugging hints.",
@@ -64,7 +63,7 @@ def get_external_ip() -> Optional[str]:
     return _external_ip
 
 
-def get_internal_ip() -> Optional[str]:
+def get_internal_ip() -> str | None:
     """Get the *local* IP address of the current machine.
 
     From: https://stackoverflow.com/a/28950776
@@ -80,6 +79,8 @@ def get_internal_ip() -> Optional[str]:
     if _internal_ip is not None:
         return _internal_ip
 
+    import socket
+
     with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
         try:
             # Doesn't even have to be reachable
@@ -91,7 +92,7 @@ def get_internal_ip() -> Optional[str]:
     return _internal_ip
 
 
-def _make_blocking_http_get(url: str, timeout: float = 5) -> Optional[str]:
+def _make_blocking_http_get(url: str, timeout: float = 5) -> str | None:
     import requests
 
     try:
@@ -103,10 +104,12 @@ def _make_blocking_http_get(url: str, timeout: float = 5) -> Optional[str]:
         return None
 
 
-def _looks_like_an_ip_adress(address: Optional[str]) -> bool:
+def _looks_like_an_ip_adress(address: str | None) -> bool:
     if address is None:
         return False
 
+    import socket
+
     try:
         socket.inet_pton(socket.AF_INET, address)
         return True  # Yup, this is an IPv4 address!

streamlit/platform.py

@@ -14,6 +14,8 @@
 
 """Platform module."""
 
+from __future__ import annotations
+
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 from streamlit.runtime.scriptrunner import get_script_run_ctx
 

streamlit/runtime/__init__.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from streamlit.runtime.runtime import Runtime, RuntimeConfig, RuntimeState
 from streamlit.runtime.session_manager import (
     SessionClient,