streamlit-data-editor-plus 0.1.0__py3-none-any.whl

streamlit/runtime/stats.py

@@ -0,0 +1,356 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2026)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import itertools
+from typing import TYPE_CHECKING, Final, NamedTuple, Protocol, runtime_checkable
+
+CACHE_MEMORY_FAMILY: Final = "cache_memory_bytes"
+SESSION_EVENTS_FAMILY: Final = "session_events_total"
+SESSION_DURATION_FAMILY: Final = "session_duration_seconds_total"
+ACTIVE_SESSIONS_FAMILY: Final = "active_sessions"
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from streamlit.proto.openmetrics_data_model_pb2 import (
+        Metric as MetricProto,
+    )
+    from streamlit.proto.openmetrics_data_model_pb2 import (
+        MetricType,
+    )
+
+
+@runtime_checkable
+class Stat(Protocol):
+    """Protocol for a stat that can be serialized to OpenMetrics format.
+
+    All stats must have these fields to identify the metric family they belong to
+    and provide metadata for OpenMetrics serialization.
+    """
+
+    @property
+    def family_name(self) -> str:
+        """The name of the metric family (e.g. 'cache_memory_bytes')."""
+
+    @property
+    def type(self) -> str:
+        """The OpenMetrics type (e.g. 'gauge', 'counter')."""
+
+    @property
+    def unit(self) -> str:
+        """The unit of the metric (e.g. 'bytes')."""
+
+    @property
+    def help(self) -> str:
+        """A description of the metric."""
+
+    def to_metric_str(self) -> str:
+        """Convert this stat to an OpenMetrics-formatted string."""
+
+    def marshall_metric_proto(self, metric: MetricProto) -> None:
+        """Fill an OpenMetrics `Metric` protobuf object."""
+
+
+# TODO(vdonato): Could we use GaugeStat below and get rid of this class?
+# We'd have to make some minor changes to use the other class, but overall the
+# changes should be relatively minor.
+class CacheStat(NamedTuple):
+    """Describes a single cache entry.
+
+    Properties
+    ----------
+    category_name : str
+        A human-readable name for the cache "category" that the entry belongs
+        to - e.g. "st.memo", "session_state", etc.
+    cache_name : str
+        A human-readable name for cache instance that the entry belongs to.
+        For "st.memo" and other function decorator caches, this might be the
+        name of the cached function. If the cache category doesn't have
+        multiple separate cache instances, this can just be the empty string.
+    byte_length : int
+        The entry's memory footprint in bytes.
+    """
+
+    category_name: str
+    cache_name: str
+    byte_length: int
+
+    # Stat Protocol fields with default values for cache metrics
+    @property
+    def family_name(self) -> str:
+        return CACHE_MEMORY_FAMILY
+
+    @property
+    def type(self) -> str:
+        return "gauge"
+
+    @property
+    def unit(self) -> str:
+        return "bytes"
+
+    @property
+    def help(self) -> str:
+        return "Total memory consumed by a cache."
+
+    def to_metric_str(self) -> str:
+        return f'{self.family_name}{{cache_type="{self.category_name}",cache="{self.cache_name}"}} {self.byte_length}'
+
+    def marshall_metric_proto(self, metric: MetricProto) -> None:
+        """Fill an OpenMetrics `Metric` protobuf object."""
+        label = metric.labels.add()
+        label.name = "cache_type"
+        label.value = self.category_name
+
+        label = metric.labels.add()
+        label.name = "cache"
+        label.value = self.cache_name
+
+        metric_point = metric.metric_points.add()
+        metric_point.gauge_value.int_value = self.byte_length
+
+
+def group_cache_stats(stats: list[CacheStat]) -> list[CacheStat]:
+    """Group a list of CacheStats by category_name and cache_name and sum byte_length."""
+
+    def key_function(individual_stat: CacheStat) -> tuple[str, str]:
+        return individual_stat.category_name, individual_stat.cache_name
+
+    result: list[CacheStat] = []
+
+    sorted_stats = sorted(stats, key=key_function)
+    grouped_stats = itertools.groupby(sorted_stats, key=key_function)
+
+    for (category_name, cache_name), single_group_stats in grouped_stats:
+        result.append(
+            CacheStat(
+                category_name=category_name,
+                cache_name=cache_name,
+                byte_length=sum(item.byte_length for item in single_group_stats),
+            )
+        )
+    return result
+
+
+class CounterStat(NamedTuple):
+    """A counter stat.
+
+    Properties
+    ----------
+    family_name : str
+        The name of the metric family (e.g. 'session_events_total').
+    value : int
+        The current count value.
+    labels : dict[str, str] | None
+        Labels to identify this specific counter (e.g. {"type": "connection"}).
+    unit : str
+        The unit of the metric (e.g. '' for unitless).
+    help : str
+        A description of the metric.
+    """
+
+    family_name: str
+    value: int
+    labels: dict[str, str] | None = None
+    unit: str = ""
+    help: str = ""
+
+    @property
+    def type(self) -> str:
+        return "counter"
+
+    def to_metric_str(self) -> str:
+        if self.labels:
+            labels_str = ",".join(f'{k}="{v}"' for k, v in sorted(self.labels.items()))
+            return f"{self.family_name}{{{labels_str}}} {self.value}"
+        return f"{self.family_name} {self.value}"
+
+    def marshall_metric_proto(self, metric: MetricProto) -> None:
+        """Fill an OpenMetrics `Metric` protobuf object."""
+        if self.labels:
+            for name, value in sorted(self.labels.items()):
+                label = metric.labels.add()
+                label.name = name
+                label.value = value
+
+        metric_point = metric.metric_points.add()
+        metric_point.counter_value.int_value = self.value
+
+
+class GaugeStat(NamedTuple):
+    """A gauge stat.
+
+    Properties
+    ----------
+    family_name : str
+        The name of the metric family (e.g. 'active_sessions').
+    value : int
+        The current gauge value.
+    labels : dict[str, str] | None
+        Optional labels to identify this specific gauge.
+    unit : str
+        The unit of the metric (e.g. '' for unitless).
+    help : str
+        A description of the metric.
+    """
+
+    family_name: str
+    value: int
+    labels: dict[str, str] | None = None
+    unit: str = ""
+    help: str = ""
+
+    @property
+    def type(self) -> str:
+        return "gauge"
+
+    def to_metric_str(self) -> str:
+        if self.labels:
+            labels_str = ",".join(f'{k}="{v}"' for k, v in sorted(self.labels.items()))
+            return f"{self.family_name}{{{labels_str}}} {self.value}"
+        return f"{self.family_name} {self.value}"
+
+    def marshall_metric_proto(self, metric: MetricProto) -> None:
+        """Fill an OpenMetrics `Metric` protobuf object."""
+        if self.labels:
+            for name, value in sorted(self.labels.items()):
+                label = metric.labels.add()
+                label.name = name
+                label.value = value
+
+        metric_point = metric.metric_points.add()
+        metric_point.gauge_value.int_value = self.value
+
+
+def metric_type_string_to_proto(type_string: str) -> MetricType.ValueType:
+    """Convert a metric type string to its corresponding proto enum value."""
+    from streamlit.proto.openmetrics_data_model_pb2 import (
+        COUNTER,
+        GAUGE,
+        GAUGE_HISTOGRAM,
+        HISTOGRAM,
+        INFO,
+        STATE_SET,
+        SUMMARY,
+        UNKNOWN,
+    )
+
+    type_map = {
+        "gauge": GAUGE,
+        "counter": COUNTER,
+        "state_set": STATE_SET,
+        "info": INFO,
+        "histogram": HISTOGRAM,
+        "gauge_histogram": GAUGE_HISTOGRAM,
+        "summary": SUMMARY,
+    }
+    return type_map.get(type_string, UNKNOWN)
+
+
+@runtime_checkable
+class StatsProvider(Protocol):
+    @property
+    def stats_families(self) -> Sequence[str]:
+        """The metric family names that this provider supports.
+
+        The StatsManager uses this property to determine which providers to call
+        when specific metric families are requested.
+        """
+
+    def get_stats(
+        self, family_names: Sequence[str] | None = None
+    ) -> Mapping[str, Sequence[Stat]]:
+        """Return stats for the specified metric families.
+
+        Parameters
+        ----------
+        family_names : Sequence[str] | None
+            If provided, only stats for these metric families should be computed
+            and returned. If None, stats for all families this provider supports
+            should be returned. Providers should check this parameter and skip
+            computing expensive stats for families that aren't requested.
+
+        Returns
+        -------
+        Mapping[str, Sequence[Stat]]
+            A mapping from metric family names to sequences of Stat objects.
+        """
+        raise NotImplementedError
+
+
+class StatsManager:
+    def __init__(self) -> None:
+        self._providers_by_family: dict[str, list[StatsProvider]] = {}
+
+    def register_provider(self, provider: StatsProvider) -> None:
+        """Register a StatsProvider with the manager.
+
+        This function is not thread-safe. Call it immediately after creation.
+
+        Parameters
+        ----------
+        provider : StatsProvider
+            The stats provider to register. The provider's `stats_families`
+            property determines which metric families it will be called for.
+        """
+        for family in provider.stats_families:
+            if family not in self._providers_by_family:
+                self._providers_by_family[family] = []
+            self._providers_by_family[family].append(provider)
+
+    def get_stats(
+        self, family_names: Sequence[str] | None = None
+    ) -> Mapping[str, Sequence[Stat]]:
+        """Return registered stats grouped by metric family name.
+
+        Parameters
+        ----------
+        family_names : Sequence[str] | None
+            If provided, only stats for these metric families will be returned.
+            If None, stats for all registered families are returned.
+
+        Returns
+        -------
+        Mapping[str, Sequence[Stat]]
+            A mapping from metric family names to sequences of Stat objects
+            from all providers.
+        """
+        result: dict[str, Sequence[Stat]] = {}
+
+        families_to_query = family_names or list(self._providers_by_family.keys())
+
+        # Track which providers we've already queried to avoid duplicates.
+        # The same provider may be registered for multiple families, and we call
+        # `provider.get_stats(family_names)` below to fetch all stat families for
+        # a given stats provider at once.
+        queried_providers: set[int] = set()
+
+        for family in families_to_query:
+            for provider in self._providers_by_family.get(family, []):
+                provider_id = id(provider)
+                if provider_id in queried_providers:
+                    continue
+                queried_providers.add(provider_id)
+
+                provider_stats = provider.get_stats(family_names)
+                for fname, stats in provider_stats.items():
+                    if fname not in result:
+                        result[fname] = []
+                    # Use list() to convert Sequence to list for concatenation.
+                    # This is needed for type covariance: providers return
+                    # Mapping[str, Sequence[Stat]] but we build a dict of lists.
+                    result[fname] = list(result[fname]) + list(stats)
+
+        return result

streamlit/runtime/theme_util.py

@@ -0,0 +1,148 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2026)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from streamlit.errors import StreamlitAPIException
+from streamlit.url_util import is_url
+
+if TYPE_CHECKING:
+    from streamlit.proto.NewSession_pb2 import CustomThemeConfig
+
+
+def _parse_font_config(
+    font_config: str | None,
+    property_name: str,
+) -> tuple[str, str | None]:
+    """Parse a single font configuration string.
+
+    Args:
+        font_config: The font configuration string (e.g., "Inter" or "Inter:https://...")
+        property_name: The property name for error messages ("font", "codeFont", "headingFont")
+
+    Returns
+    -------
+        A tuple of (font_name, source_url). source_url is None if not provided or not valid.
+    """
+    if not font_config:
+        return "", None
+
+    # Strip leading/trailing whitespace from the config
+    font_config = font_config.strip()
+
+    if ":" not in font_config:
+        # No colon found, treat the entire string as the font name
+        return font_config, None
+
+    # Note: it is possible there are multiple colons in the string, so we need to split on the first colon.
+    font_name, source_url = font_config.split(":", 1)
+    # Strip whitespace from both font name and source
+    font_name = font_name.strip()
+    source_url = source_url.strip()
+
+    # Check that the href does not contain multiple fonts, so we confirm that "family="
+    # only shows up once in the source string (structure applies to Google Fonts only)
+    family_occurrences = source_url.count("family=")
+    if family_occurrences > 1:
+        raise StreamlitAPIException(
+            f"The source URL specified in the {property_name} property of config.toml contains multiple fonts. "
+            "Please specify only one font in the source URL."
+        )
+
+    is_valid_url = is_url(source_url)
+
+    # If the source is a valid URL (http/https) but no font name is provided, throw an exception
+    if is_valid_url and not font_name:
+        raise StreamlitAPIException(
+            f"A font family name is required when specifying a source URL "
+            f"for the {property_name} property in config.toml."
+        )
+
+    if is_valid_url:
+        return font_name, source_url
+
+    return font_name, None
+
+
+def _get_font_source_config_name(property_name: str, section: str) -> str:
+    """Get the config name for font sources based on property and section. This is used on the FE
+    as the id for the font source link in the html head.
+    """
+    if section == "theme":
+        return property_name
+    return f"{property_name}-sidebar"
+
+
+def parse_fonts_with_source(
+    msg: CustomThemeConfig,
+    body_font_config: str | None,
+    code_font_config: str | None,
+    heading_font_config: str | None,
+    section: str,
+) -> CustomThemeConfig:
+    """Populate the CustomThemeConfig message with the font, codeFont, and headingFont fields set,
+    as well as the font_sources field to be added to the html head.
+
+    Args:
+        msg: CustomThemeConfig message to be populated.
+        body_font_config: A string with just the font name (e.g., "Inter") or in the format
+            "<font_family_name_here>:<source_url_here>".
+        code_font_config: A string with just the font name (e.g., "Roboto Mono") or in the format
+            "<code_font_family_name_here>:<source_url_here>".
+        heading_font_config: A string with just the font name (e.g., "Inter Bold") or in the format
+            "<heading_font_family_name_here>:<source_url_here>".
+        section: The section of the config.toml file to parse the fonts from.
+
+    Examples
+    --------
+    body_font_config: "Inter" (just font name)
+    code_font_config: "Tagesschrift:https://fonts.googleapis.com/css2?family=Tagesschrift&display=swap" (with source)
+    heading_font_config: "playwrite-cc-za:https://use.typekit.net/xxs7euo.css"
+
+    Returns
+    -------
+        Updated CustomThemeConfig message with the font, codeFont, and headingFont fields set.
+        Also sets sources in font_sources field to be added to the html (only when source URLs are provided).
+    """
+
+    # Parse body font config
+    body_font_name, body_font_source = _parse_font_config(body_font_config, "font")
+    if body_font_name:
+        msg.body_font = body_font_name
+    if body_font_source:
+        config_name = _get_font_source_config_name("font", section)
+        msg.font_sources.add(config_name=config_name, source_url=body_font_source)
+
+    # Parse code font config
+    code_font_name, code_font_source = _parse_font_config(code_font_config, "codeFont")
+    if code_font_name:
+        msg.code_font = code_font_name
+    if code_font_source:
+        config_name = _get_font_source_config_name("codeFont", section)
+        msg.font_sources.add(config_name=config_name, source_url=code_font_source)
+
+    # Parse heading font config
+    heading_font_name, heading_font_source = _parse_font_config(
+        heading_font_config, "headingFont"
+    )
+    if heading_font_name:
+        msg.heading_font = heading_font_name
+    if heading_font_source:
+        config_name = _get_font_source_config_name("headingFont", section)
+        msg.font_sources.add(config_name=config_name, source_url=heading_font_source)
+
+    return msg

streamlit/runtime/uploaded_file_manager.py

@@ -0,0 +1,152 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2026)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import io
+from abc import abstractmethod
+from typing import TYPE_CHECKING, NamedTuple, Protocol
+
+from streamlit import util
+from streamlit.runtime.stats import StatsProvider
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from streamlit.proto.Common_pb2 import FileURLs as FileURLsProto
+
+
+class UploadedFileRec(NamedTuple):
+    """Metadata and raw bytes for an uploaded file. Immutable."""
+
+    file_id: str
+    name: str
+    type: str
+    data: bytes
+
+
+class UploadFileUrlInfo(NamedTuple):
+    """Information we provide for single file in get_upload_urls."""
+
+    file_id: str
+    upload_url: str
+    delete_url: str
+
+
+class DeletedFile(NamedTuple):
+    """Represents a deleted file in deserialized values for st.file_uploader and
+    st.camera_input.
+
+    Return this from st.file_uploader and st.camera_input deserialize (so they can
+    be used in session_state), when widget value contains file record that is missing
+    from the storage.
+    DeleteFile instances filtered out before return final value to the user in script,
+    or before sending to frontend.
+    """
+
+    file_id: str
+
+
+class UploadedFile(io.BytesIO):
+    """A mutable uploaded file.
+
+    This class extends BytesIO, which has copy-on-write semantics when
+    initialized with `bytes`.
+    """
+
+    def __init__(self, record: UploadedFileRec, file_urls: FileURLsProto) -> None:
+        # BytesIO's copy-on-write semantics doesn't seem to be mentioned in
+        # the Python docs - possibly because it's a CPython-only optimization
+        # and not guaranteed to be in other Python runtimes. But it's detailed
+        # here: https://hg.python.org/cpython/rev/79a5fbe2c78f
+        super().__init__(record.data)
+        self.file_id = record.file_id
+        self.name = record.name
+        self.type = record.type
+        self.size = len(record.data)
+        self._file_urls = file_urls
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, UploadedFile):
+            return NotImplemented
+        return self.file_id == other.file_id
+
+    def __hash__(self) -> int:
+        return hash(self.file_id)
+
+    def __repr__(self) -> str:
+        return util.repr_(self)
+
+
+class UploadedFileManager(StatsProvider, Protocol):
+    """UploadedFileManager protocol, that should be implemented by the concrete
+    uploaded file managers.
+
+    It is responsible for:
+        - retrieving files by session_id and file_id for st.file_uploader and
+            st.camera_input
+        - cleaning up uploaded files associated with session on session end
+
+    It should be created during Runtime initialization.
+
+    Optionally UploadedFileManager could be responsible for issuing URLs which will be
+    used by frontend to upload files to.
+    """
+
+    @abstractmethod
+    def get_files(
+        self, session_id: str, file_ids: Sequence[str]
+    ) -> list[UploadedFileRec]:
+        """Return a  list of UploadedFileRec for a given sequence of file_ids.
+
+        Parameters
+        ----------
+        session_id
+            The ID of the session that owns the files.
+        file_ids
+            The sequence of ids associated with files to retrieve.
+
+        Returns
+        -------
+        List[UploadedFileRec]
+            A list of URL UploadedFileRec instances, each instance contains information
+            about uploaded file.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def remove_session_files(self, session_id: str) -> None:
+        """Remove all files associated with a given session."""
+        raise NotImplementedError
+
+    def get_upload_urls(
+        self, session_id: str, file_names: Sequence[str]
+    ) -> list[UploadFileUrlInfo]:
+        """Return a list of UploadFileUrlInfo for a given sequence of file_names.
+        Optional to implement, issuing of URLs could be done by other service.
+
+        Parameters
+        ----------
+        session_id
+            The ID of the session that request URLs.
+        file_names
+            The sequence of file names for which URLs are requested
+
+        Returns
+        -------
+        List[UploadFileUrlInfo]
+            A list of UploadFileUrlInfo instances, each instance contains information
+            about uploaded file URLs.
+        """
+        raise NotImplementedError