streamlit-plugins 0.7.16__tar.gz → 0.7.19__tar.gz

streamlit_plugins-0.7.19/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include streamlit_plugins/components/navbar/v1/frontend/build *
+recursive-include streamlit_plugins/components/navbar/v2/frontend/build *
+include streamlit_plugins/components/navbar/pyproject.toml
+include streamlit_plugins/components/navbar/v2/pyproject.toml

{streamlit_plugins-0.7.16/streamlit_plugins.egg-info → streamlit_plugins-0.7.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-plugins
-Version: 0.7.16
+Version: 0.7.19
 Summary: Components and Frameworks to give new features to streamlit
 Home-page: https://github.com/quiradev/streamlit-plugins
 Author: Victor Quilon Ranera

{streamlit_plugins-0.7.16 → streamlit_plugins-0.7.19}/streamlit_plugins/components/document_blocks/__init__.py

@@ -64,7 +64,7 @@ __CSS = """
   flex: 1;
   max-width: 550px;
   background: #fff;
-  padding: 10px;
+  padding: 0;
   border-radius: 8px;
   box-shadow: 0 4px 12px rgba(0,0,0,0.1);
 }
@@ -952,8 +952,31 @@ def st_documents_blocks_info(
         tab_order: Optional[list[Literal["Blocks", "JSON", "HTML", "Markdown"] | str]] = None,
         custom_tabs: Optional[list[str]] = None,
         format_raw_code: bool = False,
+        set_state_on: Literal["hover", "click"] = "hover",
+        right_col_width: int | str = "100%",
 ) -> Generator[tuple[list[dict], list[TabContainer]], Any, None]:
-    main_container = st.container(horizontal=True)
+    st.write(
+        f"""
+        <style>
+        .st-key-documents_blocks_container {{
+            display: flex;
+            flex-direction: row;
+            flex-wrap: nowrap;
+        }}
+        .st-key-documents_blocks_container > div:first-child {{
+            flex: 0 0 fit-content;
+        }}
+        .st-key-documents_blocks_container > div:last-child {{
+            width: {right_col_width};
+            flex: 1 1 auto;
+            max-width: 100%;
+            overflow: auto;
+        }}
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+    main_container = st.container(horizontal=True, key="documents_blocks_container", gap="xxsmall")
     page_selected = 1
     if document.pages > 1:
         with st.container(horizontal_alignment="right"):
@@ -988,7 +1011,7 @@ def st_documents_blocks_info(
                 reading_order=reading_order,
                 custom_styles=custom_styles,
                 default_selected=dynamic_selected_block_id,
-                set_state_on="hover",
+                set_state_on=set_state_on,
                 width="content",
                 height=600,
                 key="document_blocks"
@@ -1135,22 +1158,21 @@ def st_documents_blocks_info(
         elif json_col and json_col.open:
             with json_col:
                 with st_dynamic_container(
-                        container_source_key="document_blocks",
-                        key="view-container", mimic_vertical=True, border=True
+                    container_source_key="document_blocks",
+                    key="view-container", border=True
                 ):
                     st.json(blocks_page)
 
         elif html_col and html_col.open:
             with html_col:
-                render_col, raw_col = st.tabs(
-                    ["Renderer", "Raw"],
-                    on_change=on_tab_change
-                )
                 with st_dynamic_container(
                         container_source_key="document_blocks",
-                        key="view-container", mimic_vertical=True, border=True
+                        key="view-container", border=True
                 ):
-
+                    render_col, raw_col = st.tabs(
+                        ["Renderer", "Raw"],
+                        on_change=on_tab_change
+                    )
                     html_content = _concat_content(blocks_normalized, content_type="html", parent_content_has_children=parent_content_has_children)
                     if not html_content:
                         st.warning("HTML content is empty. Please ensure that the blocks contain valid HTML content.")
@@ -1167,7 +1189,7 @@ def st_documents_blocks_info(
             with markdown_col:
                 with st_dynamic_container(
                     container_source_key="document_blocks",
-                    key="view-container", mimic_vertical=True, border=True
+                    key="view-container", border=True
                 ):
                     render_col, raw_col = st.tabs(
                         ["Renderer", "Raw"],

streamlit_plugins-0.7.19/streamlit_plugins/components/markdown_editor/__init__.py

@@ -0,0 +1,210 @@
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from streamlit.components.v2 import component as create_component
+from streamlit.elements.lib.layout_utils import Height
+
+_ASSET_DIR = Path(__file__).with_name("frontend") / "build"
+
+
+def _normalize_blocks(
+    blocks: Sequence[Mapping[str, Any]], *, for_review: bool = False
+) -> list[dict[str, str]]:
+    normalized: list[dict[str, str]] = []
+    seen_ids: set[str] = set()
+    for index, block in enumerate(blocks):
+        if not isinstance(block, Mapping):
+            raise TypeError(f"El bloque {index} debe ser un mapping")
+        markdown = block.get("markdown", block.get("text"))
+        if not isinstance(markdown, str):
+            raise TypeError(f"El bloque {index} debe incluir markdown de tipo str")
+        block_id = block.get("id") if for_review else block.get("id", f"block-{index}")
+        block_id = str(block_id) if block_id is not None or not for_review else None
+        if block_id is not None and block_id in seen_ids:
+            raise ValueError(f"ID de bloque duplicado: {block_id}")
+        item = {"markdown": markdown}
+        if block_id is not None:
+            seen_ids.add(block_id)
+            item["id"] = block_id
+        normalized.append(item)
+    if not normalized and not for_review:
+        normalized.append({"id": "block-0", "markdown": ""})
+    return normalized
+
+
+def _normalize_diff(diff: Mapping[str, Any] | None) -> dict[str, Any] | None:
+    if diff is None:
+        return None
+    if not isinstance(diff, Mapping):
+        raise TypeError("diff debe ser un mapping con before y after o sus bloques")
+    has_blocks = "before_blocks" in diff or "after_blocks" in diff
+    if has_blocks and not ("before_blocks" in diff and "after_blocks" in diff):
+        raise ValueError("diff debe incluir before_blocks y after_blocks juntos")
+    normalized: dict[str, Any] = {}
+    for version in ("before", "after"):
+        source = diff.get(version)
+        if has_blocks:
+            blocks = diff[f"{version}_blocks"]
+            if not isinstance(blocks, Sequence) or isinstance(blocks, (str, bytes)):
+                raise TypeError(f"{version}_blocks debe ser una secuencia de bloques")
+            blocks = _normalize_blocks(blocks, for_review=True)
+            normalized[f"{version}_blocks"] = blocks
+            markdown = "\n\n".join(block["markdown"] for block in blocks)
+            if source is None:
+                source = markdown
+            elif source != markdown:
+                raise ValueError(f"{version} debe coincidir con el Markdown de {version}_blocks")
+        if not isinstance(source, str):
+            raise ValueError("diff debe incluir before y after de tipo str o sus bloques")
+        normalized[version] = source
+    return normalized
+
+
+def _document_from_state(
+    state: Any,
+    initial_blocks: list[dict[str, str]],
+    *,
+    mode: str,
+    save_mode: str,
+) -> dict[str, Any]:
+    if state is None:
+        blocks = initial_blocks
+        return {
+            "blocks": blocks,
+            "markdown": "\n\n".join(block["markdown"] for block in blocks),
+            "mode": mode,
+            "save_mode": save_mode,
+        }
+    if not isinstance(state, Mapping):
+        raise TypeError("El estado devuelto por el editor debe ser un mapping")
+    state_blocks = state.get("blocks")
+    state_markdown = state.get("markdown")
+    if not isinstance(state_blocks, list) or not isinstance(state_markdown, str):
+        raise ValueError("El editor devolvió un estado incompleto")
+    state_mode = state.get("mode", mode)
+    if state_mode not in {"raw_visual", "visual"}:
+        raise ValueError("El editor devolvió un modo desconocido")
+    return {
+        "blocks": state_blocks,
+        "markdown": state_markdown,
+        "mode": state_mode,
+        "save_mode": save_mode,
+    }
+
+
+def st_markdown_block_editor(
+    initial_blocks: Sequence[Mapping[str, Any]],
+    *,
+    key: str,
+    revision: int = 0,
+    height: Height | None = "stretch",
+    mode: str = "raw_visual",
+    save_mode: str = "auto",
+    only_view: bool = False,
+    debug_blocks: bool = False,
+    diff: Mapping[str, Any] | None = None,
+    editor_modes: Sequence[str] = ("raw_visual", "visual"),
+    review_modes: Sequence[str] = ("visual", "markdown"),
+    review_layouts: Sequence[str] = ("before", "after", "split", "blocks"),
+    block_diff_style: str = "content",
+    placeholder: str = "Escribe aquí…",
+    show_copy_button: bool = True,
+    show_status_bar: bool = True,
+    toolbar_sections: Sequence[str] = ("view", "format", "block", "history", "changes"),
+) -> dict[str, Any]:
+    """Edit Markdown blocks or review visual, source and block-level changes.
+
+    With button saving, review compares the saved document with the local draft.
+    External diffs accept before/after strings or paired before_blocks/after_blocks.
+    Stable block IDs improve movement and content-change identification.
+    toolbar_sections controls header visibility, not editing permissions.
+    """
+    if not key:
+        raise ValueError("key no puede estar vacía")
+    if revision < 0:
+        raise ValueError("revision no puede ser negativa")
+    if height is not None and (isinstance(height, bool) or not isinstance(height, (int, str))):
+        raise TypeError("height debe ser un entero, 'stretch', 'content' o None")
+    if isinstance(height, int) and height < 240:
+        raise ValueError("height debe ser al menos 240 px")
+    if isinstance(height, str) and height not in {"stretch", "content"}:
+        raise ValueError("height debe ser 'stretch' o 'content'")
+    if mode not in {"raw_visual", "visual"}:
+        raise ValueError("mode debe ser 'raw_visual' o 'visual'")
+    if save_mode not in {"auto", "button"}:
+        raise ValueError("save_mode debe ser 'auto' o 'button'")
+    if not isinstance(only_view, bool):
+        raise TypeError("only_view debe ser bool")
+    if not isinstance(debug_blocks, bool):
+        raise TypeError("debug_blocks debe ser bool")
+    choices = {
+        "editor_modes": (editor_modes, {"raw_visual", "visual"}, True),
+        "review_modes": (review_modes, {"visual", "markdown"}, True),
+        "review_layouts": (review_layouts, {"before", "after", "split", "blocks"}, True),
+        "toolbar_sections": (toolbar_sections, {"view", "format", "block", "history", "changes"}, False),
+    }
+    for name, (values, allowed, required) in choices.items():
+        if not isinstance(values, Sequence) or isinstance(values, (str, bytes)):
+            raise TypeError(f"{name} debe ser una secuencia de opciones")
+        if (required and not values) or any(not isinstance(value, str) or value not in allowed for value in values):
+            raise ValueError(f"{name}: opciones válidas {sorted(allowed)}" + ("; elige al menos una" if required else ""))
+        if len(set(values)) != len(values):
+            raise ValueError(f"{name} no puede incluir opciones duplicadas")
+    if mode not in editor_modes:
+        raise ValueError("mode debe estar incluido en editor_modes")
+    if block_diff_style not in {"content", "inline"}:
+        raise ValueError("block_diff_style debe ser 'content' o 'inline'")
+    if not isinstance(placeholder, str):
+        raise TypeError("placeholder debe ser str")
+    if not isinstance(show_copy_button, bool):
+        raise TypeError("show_copy_button debe ser bool")
+    if not isinstance(show_status_bar, bool):
+        raise TypeError("show_status_bar debe ser bool")
+    normalized_diff = _normalize_diff(diff)
+
+    blocks = _normalize_blocks(initial_blocks)
+    renderer_bundle = _ASSET_DIR / "renderers.bundle.js"
+    if not renderer_bundle.is_file():
+        raise RuntimeError(
+            "Falta el bundle de renderizadores: ejecuta npm install y npm run build "
+            "en markdown_editor\\frontend"
+        )
+    editor = create_component(
+        name="markdown_block_editor",
+        html=(_ASSET_DIR / "editor.html").read_text(encoding="utf-8"),
+        css=(_ASSET_DIR / "editor.css").read_text(encoding="utf-8"),
+        js=(
+            renderer_bundle.read_text(encoding="utf-8")
+            + "\n"
+            + (_ASSET_DIR / "editor.js").read_text(encoding="utf-8")
+        ),
+        isolate_styles=False,
+    )
+    state = editor(
+        key=key,
+        data={
+            "blocks": blocks,
+            "revision": revision,
+            "mode": mode,
+            "save_mode": save_mode,
+            "only_view": only_view,
+            "debug_blocks": debug_blocks,
+            "height": height,
+            "diff": normalized_diff,
+            "editor_modes": list(editor_modes),
+            "review_modes": list(review_modes),
+            "review_layouts": list(review_layouts),
+            "block_diff_style": block_diff_style,
+            "placeholder": placeholder,
+            "show_copy_button": show_copy_button,
+            "show_status_bar": show_status_bar,
+            "toolbar_sections": list(toolbar_sections),
+        },
+        width="stretch",
+        height=height if height is not None else 760,
+    ).get("value")
+    return _document_from_state(state, blocks, mode=mode, save_mode=save_mode)
+
+
+__all__ = ["st_markdown_block_editor"]