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

streamlit/components/types/base_custom_component.py

@@ -0,0 +1,158 @@
+# 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 os
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from streamlit import util
+from streamlit.errors import StreamlitAPIException
+
+if TYPE_CHECKING:
+    from streamlit.runtime.state.common import WidgetCallback
+
+
+class MarshallComponentException(StreamlitAPIException):
+    """Class for exceptions generated during custom component marshalling."""
+
+
+class BaseCustomComponent(ABC):
+    """Interface for CustomComponents."""
+
+    def __init__(
+        self,
+        name: str,
+        path: str | None = None,
+        url: str | None = None,
+        module_name: str | None = None,
+    ) -> None:
+        if path is None and url is None:
+            raise StreamlitAPIException("Either 'path' or 'url' must be set.")
+
+        self._name = name
+        self._path = path
+        self._url = url
+        self._module_name = module_name
+
+    def __repr__(self) -> str:
+        return util.repr_(self)
+
+    def __call__(
+        self,
+        *args: Any,
+        default: Any = None,
+        key: str | None = None,
+        on_change: WidgetCallback | None = None,
+        tab_index: int | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """An alias for create_instance."""
+        return self.create_instance(
+            *args,
+            default=default,
+            key=key,
+            on_change=on_change,
+            tab_index=tab_index,
+            **kwargs,
+        )
+
+    @property
+    def abspath(self) -> str | None:
+        if self._path is None:
+            return None
+        return os.path.abspath(self._path)
+
+    @property
+    def module_name(self) -> str | None:
+        return self._module_name
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def path(self) -> str | None:
+        return self._path
+
+    @property
+    def url(self) -> str | None:
+        return self._url
+
+    def __str__(self) -> str:
+        return f"'{self.name}': {self.path if self.path is not None else self.url}"
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.path, self.url, self.module_name))
+
+    @abstractmethod
+    def __eq__(self, other: object) -> bool:
+        """Equality operator."""
+        return NotImplemented
+
+    @abstractmethod
+    def __ne__(self, other: object) -> bool:
+        """Inequality operator."""
+        return NotImplemented
+
+    @abstractmethod
+    def create_instance(
+        self,
+        *args: Any,
+        default: Any = None,
+        key: str | None = None,
+        on_change: WidgetCallback | None = None,
+        tab_index: int | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Create a new instance of the component.
+
+        Parameters
+        ----------
+        *args
+            Must be empty; all args must be named. (This parameter exists to
+            enforce correct use of the function.)
+        default: any or None
+            The default return value for the component. This is returned when
+            the component's frontend hasn't yet specified a value with
+            `setComponentValue`.
+        key: str or None
+            If not None, this is the user key we use to generate the
+            component's "widget ID".
+        on_change: WidgetCallback or None
+            An optional callback invoked when the widget's value changes. No arguments are passed to it.
+        tab_index: int or None
+            Specifies the tab order of the iframe containing the component.
+            Possible values are:
+            - ``None`` (default): Browser default behavior.
+            - ``-1``: Removes the iframe from the natural tab order, but it can still be focused programmatically.
+            - ``0`` or positive integer: Includes the iframe in the natural tab order.
+        **kwargs
+            Keyword args to pass to the component.
+
+        Raises
+        ------
+        MarshallComponentException
+            Raised when args is not empty or component cannot be marshalled.
+        StreamlitAPIException
+            Raised when PyArrow is not installed.
+
+        Returns
+        -------
+        any or None
+            The component's widget value.
+
+        """
+        raise NotImplementedError

streamlit/components/v1/__init__.py

@@ -0,0 +1,29 @@
+# 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.
+
+"""Contains the files and modules for the exposed API."""
+
+import streamlit
+from streamlit.components.v1.component_registry import declare_component
+
+# `html` and `iframe` are part of Custom Components, so they appear in this
+# `streamlit.components.v1` namespace.
+html = streamlit._main._html
+iframe = streamlit._main._iframe
+
+__all__ = [
+    "declare_component",
+    "html",
+    "iframe",
+]

streamlit/components/v1/component_arrow.py

@@ -0,0 +1,141 @@
+# 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.
+
+"""Data marshalling utilities for ArrowTable protobufs, which are used by
+CustomComponent for dataframe serialization.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from streamlit import dataframe_util
+from streamlit.elements.lib import pandas_styler_utils
+
+if TYPE_CHECKING:
+    from pandas import DataFrame, Index
+
+    from streamlit.proto.Components_pb2 import ArrowTable as ArrowTableProto
+
+
+def _maybe_tuple_to_list(item: Any) -> Any:
+    """Convert a tuple to a list. Leave as is if it's not a tuple."""
+    return list(item) if isinstance(item, tuple) else item
+
+
+def marshall(
+    proto: ArrowTableProto, data: Any, default_uuid: str | None = None
+) -> None:
+    """Marshall data into an ArrowTable proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowTable
+        Output. The protobuf for a Streamlit ArrowTable proto.
+
+    data : pandas.DataFrame, pandas.Styler, numpy.ndarray, Iterable, dict, or None
+        Something that is or can be converted to a dataframe.
+
+    """
+    if dataframe_util.is_pandas_styler(data):
+        pandas_styler_utils.marshall_styler(proto, data, default_uuid)  # type: ignore
+
+    df = dataframe_util.convert_anything_to_pandas_df(data)
+    _marshall_index(proto, df.index)
+    _marshall_columns(proto, df.columns)
+    _marshall_data(proto, df)
+
+
+def _marshall_index(proto: ArrowTableProto, index: Index[Any]) -> None:
+    """Marshall pandas.DataFrame index into an ArrowTable proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowTable
+        Output. The protobuf for a Streamlit ArrowTable proto.
+
+    index : pd.Index
+        Index to use for resulting frame.
+        Will default to RangeIndex (0, 1, 2, ..., n) if no index is provided.
+
+    """
+    import pandas as pd
+
+    index_values = list(map(_maybe_tuple_to_list, index.values))
+    index_df = pd.DataFrame(index_values)
+    proto.index = dataframe_util.convert_pandas_df_to_arrow_bytes(index_df)
+
+
+def _marshall_columns(proto: ArrowTableProto, columns: Index[Any]) -> None:
+    """Marshall pandas.DataFrame columns into an ArrowTable proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowTable
+        Output. The protobuf for a Streamlit ArrowTable proto.
+
+    columns : Index
+        Column labels to use for resulting frame.
+        Will default to RangeIndex (0, 1, 2, ..., n) if no column labels are provided.
+
+    """
+    import pandas as pd
+
+    column_values = list(map(_maybe_tuple_to_list, columns.values))
+    columns_df = pd.DataFrame(column_values)
+    proto.columns = dataframe_util.convert_pandas_df_to_arrow_bytes(columns_df)
+
+
+def _marshall_data(proto: ArrowTableProto, df: DataFrame) -> None:
+    """Marshall pandas.DataFrame data into an ArrowTable proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowTable
+        Output. The protobuf for a Streamlit ArrowTable proto.
+
+    df : pandas.DataFrame
+        A dataframe to marshall.
+
+    """
+    proto.data = dataframe_util.convert_pandas_df_to_arrow_bytes(df)
+
+
+def arrow_proto_to_dataframe(proto: ArrowTableProto) -> DataFrame:
+    """Convert ArrowTable proto to pandas.DataFrame.
+
+    Parameters
+    ----------
+    proto : proto.ArrowTable
+        Output. pandas.DataFrame
+
+    """
+
+    if dataframe_util.is_pyarrow_version_less_than("14.0.1"):
+        raise RuntimeError(
+            "The installed pyarrow version is not compatible with this component. "
+            "Please upgrade to 14.0.1 or higher: pip install -U pyarrow"
+        )
+
+    import pandas as pd
+
+    data = dataframe_util.convert_arrow_bytes_to_pandas_df(proto.data)
+    index = dataframe_util.convert_arrow_bytes_to_pandas_df(proto.index)
+    columns = dataframe_util.convert_arrow_bytes_to_pandas_df(proto.columns)
+
+    return pd.DataFrame(
+        data.to_numpy(),
+        index=index.to_numpy().T.tolist(),
+        columns=columns.to_numpy().T.tolist(),
+    )

streamlit/components/v1/component_registry.py

@@ -0,0 +1,147 @@
+# 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 inspect
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from streamlit import config
+from streamlit.components.v1.custom_component import CustomComponent
+from streamlit.runtime import get_instance
+from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
+
+if TYPE_CHECKING:
+    from types import FrameType
+
+    from streamlit.components.types.base_component_registry import BaseComponentRegistry
+
+
+def _get_module_name(caller_frame: FrameType) -> str:
+    # Get the caller's module name. `__name__` gives us the module's
+    # fully-qualified name, which includes its package.
+    module = inspect.getmodule(caller_frame)
+    if module is None:
+        raise RuntimeError("module is None. This should never happen.")
+    module_name = module.__name__
+
+    # If the caller was the main module that was executed (that is, if the
+    # user executed `python my_component.py`), then this name will be
+    # "__main__" instead of the actual package name. In this case, we use
+    # the main module's filename, sans `.py` extension, as the component name.
+    if module_name == "__main__":
+        file_path = inspect.getfile(caller_frame)
+        filename = os.path.basename(file_path)
+        module_name, _ = os.path.splitext(filename)
+
+    return module_name
+
+
+def declare_component(
+    name: str,
+    path: str | Path | None = None,
+    url: str | None = None,
+) -> CustomComponent:
+    """Create a custom component and register it if there is a ``ScriptRunContext``.
+
+    The component is not registered when there is no ``ScriptRunContext``.
+    This can happen when a ``CustomComponent`` is executed as standalone
+    command (e.g. for testing).
+
+    To use this function, import it from the ``streamlit.components.v1``
+    module.
+
+    .. warning::
+        Using ``st.components.v1.declare_component`` directly (instead of
+        importing its module) is deprecated and will be disallowed in a later
+        version.
+
+    Parameters
+    ----------
+    name : str
+        A short, descriptive name for the component, like "slider".
+
+    path: str, Path, or None
+        The path to serve the component's frontend files from. The path should
+        be absolute. If ``path`` is ``None`` (default), Streamlit will serve
+        the component from the location in ``url``. Either ``path`` or ``url``
+        must be specified. If both are specified, then ``url`` will take
+        precedence.
+
+    url: str or None
+        The URL that the component is served from. If ``url`` is ``None``
+        (default), Streamlit will serve the component from the location in
+        ``path``. Either ``path`` or ``url`` must be specified. If both are
+        specified, then ``url`` will take precedence.
+
+
+    Returns
+    -------
+    CustomComponent
+        A ``CustomComponent`` that can be called like a function.
+        Calling the component will create a new instance of the component
+        in the Streamlit app.
+
+    """
+    if path is not None and isinstance(path, Path):
+        path = str(path)
+
+    # Get our stack frame.
+    current_frame: FrameType | None = inspect.currentframe()
+    if current_frame is None:
+        raise RuntimeError("current_frame is None. This should never happen.")
+    # Get the stack frame of our calling function.
+    caller_frame = current_frame.f_back
+    if caller_frame is None:
+        raise RuntimeError("caller_frame is None. This should never happen.")
+
+    module_name = _get_module_name(caller_frame)
+
+    # Build the component name.
+    component_name = f"{module_name}.{name}"
+
+    # NOTE: We intentionally don't mention this behavior in this function's
+    # docstring as we're only using it internally for now (the config option
+    # is also hidden). This should be properly documented if/when we do decide
+    # to expose it more publicly.
+    if not url and (
+        component_base_path := config.get_option("server.customComponentBaseUrlPath")
+    ):
+        url = f"{component_base_path}/{component_name}/"  # ty: ignore[possibly-unresolved-reference]
+
+    # Create our component object, and register it.
+    component = CustomComponent(
+        name=component_name, path=path, url=url, module_name=module_name
+    )
+    # the ctx can be None if a custom component script is run outside of Streamlit, e.g. via 'python ...'
+    ctx = get_script_run_ctx()
+    if ctx is not None:
+        get_instance().component_registry.register_component(component)
+    return component
+
+
+# Keep for backwards-compatibility for now as we don't know whether existing custom
+# components use this method. We made significant refactors to the custom component
+# registry code in https://github.com/streamlit/streamlit/pull/8193 and after
+# that is out in the wild, we can follow-up with more refactorings, e.g. remove
+# the following class and method. When we do that, we should conduct some testing with
+# popular custom components.
+class ComponentRegistry:
+    @classmethod
+    def instance(cls) -> BaseComponentRegistry:
+        """Returns the ComponentRegistry of the runtime instance."""
+
+        return get_instance().component_registry

streamlit/components/v1/components.py

@@ -0,0 +1,38 @@
+# 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.
+
+# The components.py file exists because existing custom components have started
+# to rely on internals of the components package. For example, streamlit-option-menu accesses
+# [register_widget](https://github.com/victoryhb/streamlit-option-menu/blob/master/streamlit_option_menu/streamlit_callback.py#L28),
+# which is only a transitive import through `streamlit.components.v1.custom_component`.
+# Since we do not know what other internals are used out in the wild, let's try to
+# model the old behavior and not to break things.
+
+# This should be cleaned up in the future, e.g. as part of components v2.
+
+from streamlit.components.v1.component_registry import (
+    declare_component,
+)
+from streamlit.components.v1.custom_component import (
+    CustomComponent,
+    MarshallComponentException,
+)
+from streamlit.runtime.state import register_widget
+
+__all__ = [
+    "CustomComponent",
+    "MarshallComponentException",
+    "declare_component",
+    "register_widget",
+]