agent-data-cli 0.1.0__py3-none-any.whl

agent_data_cli/dashboard/context.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from agent_data_cli.core.registry import SourceRegistry, build_default_registry
+from agent_data_cli.runtime_paths import resolve_runtime_paths
+from agent_data_cli.store.db import Store
+
+
+@dataclass(frozen=True, slots=True)
+class DashboardContext:
+    db_path: str
+    store: Store
+    registry: SourceRegistry
+
+
+def build_dashboard_context(
+    *,
+    db_path: str | None = None,
+    sources_dir: Path | None = None,
+) -> DashboardContext:
+    resolved_db_path = str(resolve_runtime_paths().db_path) if db_path is None else db_path
+    Path(resolved_db_path).parent.mkdir(parents=True, exist_ok=True)
+    store = Store(resolved_db_path)
+    store.init_schema()
+    registry = build_default_registry(store, sources_dir=sources_dir)
+    store.init_schema(storage_specs=registry.list_storage_specs())
+    return DashboardContext(db_path=resolved_db_path, store=store, registry=registry)

agent_data_cli/dashboard/index.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import streamlit as st
+
+from agent_data_cli.dashboard.runtime import get_dashboard_status
+from agent_data_cli.dashboard.widgets.common import render_object_details, running_in_streamlit
+
+
+def render_page() -> None:
+    st.set_page_config(page_title="Agent-Data-Cli Dashboard", layout="wide")
+    st.title("Agent-Data-Cli Dashboard")
+    st.caption("Streamlit Dashboard for Human to Understand the Projetc")
+
+    status = get_dashboard_status()
+    st.subheader("Runtime")
+    render_object_details(
+        {
+            "running": status.running,
+            "pid": status.pid,
+            "host": status.host,
+            "port": status.port,
+            "url": status.url,
+            "started_at": status.started_at,
+            "log_path": status.log_path,
+        }
+    )
+
+
+if running_in_streamlit():
+    render_page()

agent_data_cli/dashboard/pages/01_Source.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import streamlit as st
+
+from agent_data_cli.dashboard.adapters.source import check_source_config, check_source_health, list_sources
+from agent_data_cli.dashboard.context import build_dashboard_context
+from agent_data_cli.dashboard.state import ensure_page_result, get_page_state, save_page_result
+from agent_data_cli.dashboard.widgets.common import render_exception, render_object_details, running_in_streamlit
+from agent_data_cli.dashboard.widgets.forms import source_select
+from agent_data_cli.dashboard.widgets.tables import render_rows
+from agent_data_cli.utils.time import utc_now_iso
+
+
+def render_page() -> None:
+    ctx = build_dashboard_context()
+    page_state = ensure_page_result(
+        st.session_state,
+        "source_page_state",
+        loader=lambda: {"rows": list_sources(ctx.registry)},
+        updated_at=utc_now_iso(),
+    )
+    st.title("Source")
+
+    if st.button("Refresh Sources", key="source_refresh"):
+        rows = list_sources(ctx.registry)
+        save_page_result(st.session_state, "source_page_state", inputs={}, result={"rows": rows}, updated_at=utc_now_iso())
+        page_state = get_page_state(st.session_state, "source_page_state")
+    render_rows(None if page_state["result"] is None else page_state["result"]["rows"], empty_message="No source data yet.")
+
+    selected_source = source_select(ctx.registry, key="source_page_source")
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("Check Health", key="source_health") and selected_source is not None:
+            try:
+                result = check_source_health(ctx.registry, ctx.store, selected_source)
+                page_state["health_result"] = result
+                st.session_state["source_page_state"] = page_state
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+
+        if page_state.get("health_result") is not None:
+            render_object_details(page_state["health_result"], title="Health")
+
+    with col2:
+        if st.button("Config Check", key="source_config_check") and selected_source is not None:
+            try:
+                page_state["config_check_result"] = check_source_config(ctx.registry, selected_source)
+                st.session_state["source_page_state"] = page_state
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+
+        if page_state.get("config_check_result") is not None:
+            render_object_details(page_state["config_check_result"], title="Config Check")
+
+
+if running_in_streamlit():
+    render_page()

agent_data_cli/dashboard/pages/02_Channel.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import streamlit as st
+
+from agent_data_cli.dashboard.adapters.channel import list_channel_options, list_channels, search_channels
+from agent_data_cli.dashboard.adapters.group import add_channel_to_group
+from agent_data_cli.dashboard.adapters.sub import add_subscription, remove_subscription
+from agent_data_cli.dashboard.context import build_dashboard_context
+from agent_data_cli.dashboard.state import get_page_state, invalidate_pages, save_page_result
+from agent_data_cli.dashboard.widgets.common import render_exception, running_in_streamlit
+from agent_data_cli.dashboard.widgets.forms import optional_channel_select, optional_group_select, source_select
+from agent_data_cli.dashboard.widgets.tables import render_rows
+from agent_data_cli.utils.time import utc_now_iso
+
+
+def render_page() -> None:
+    ctx = build_dashboard_context()
+    st.title("Channel")
+    form_row1 = st.columns(2)
+    with form_row1[0]:
+        source_name = source_select(ctx.registry, key="channel_source")
+    with form_row1[1]:
+        query = st.text_input("Query", key="channel_query")
+    form_row2 = st.columns(2)
+    with form_row2[0]:
+        limit = st.number_input("Limit", min_value=1, value=20, key="channel_limit")
+    page_state = get_page_state(st.session_state, "channel_page_state")
+
+    with form_row2[1]:
+        action_row = st.columns(2)
+        with action_row[0]:
+            list_clicked = st.button("List Channels", key="channel_list", width="stretch")
+        with action_row[1]:
+            search_clicked = st.button("Search Channels", key="channel_search", width="stretch")
+
+    if list_clicked and source_name is not None:
+        try:
+            rows = list_channels(ctx.registry, ctx.store, source_name)
+            save_page_result(
+                st.session_state,
+                "channel_page_state",
+                inputs={"source": source_name, "mode": "list"},
+                result={"rows": rows},
+                updated_at=utc_now_iso(),
+            )
+            page_state = get_page_state(st.session_state, "channel_page_state")
+        except Exception as exc:  # noqa: BLE001
+            render_exception(exc)
+    if search_clicked and source_name is not None:
+        try:
+            rows = search_channels(ctx.registry, ctx.store, source_name, query=query, limit=int(limit))
+            save_page_result(
+                st.session_state,
+                "channel_page_state",
+                inputs={"source": source_name, "query": query, "limit": int(limit)},
+                result={"rows": rows},
+                updated_at=utc_now_iso(),
+            )
+            page_state = get_page_state(st.session_state, "channel_page_state")
+        except Exception as exc:  # noqa: BLE001
+            render_exception(exc)
+
+    render_rows(None if page_state["result"] is None else page_state["result"]["rows"], empty_message="Search or list channels.")
+
+    action_inputs = st.columns(2)
+    with action_inputs[0]:
+        selected_channel = optional_channel_select(
+            [] if source_name is None else list_channel_options(ctx.registry, ctx.store, source_name),
+            key="channel_selected",
+            label="Selected Channel",
+        )
+    with action_inputs[1]:
+        selected_group = optional_group_select(ctx.store, key="channel_group")
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        if st.button("Subscribe", key="channel_sub") and source_name is not None and selected_channel:
+            try:
+                add_subscription(ctx.registry, source_name, selected_channel)
+                invalidate_pages(st.session_state, "sub_page_state", "channel_page_state", "content_update_page_state")
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+    with col2:
+        if st.button("Unsubscribe", key="channel_unsub") and source_name is not None and selected_channel:
+            try:
+                remove_subscription(ctx.registry, source_name, selected_channel)
+                invalidate_pages(st.session_state, "sub_page_state", "channel_page_state", "content_update_page_state")
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+    with col3:
+        if st.button("Add To Group", key="channel_group_add") and source_name is not None and selected_channel and selected_group:
+            try:
+                add_channel_to_group(ctx.store, selected_group, source_name, selected_channel)
+                invalidate_pages(st.session_state, "group_page_state", "content_update_page_state", "content_query_page_state")
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+
+
+if running_in_streamlit():
+    render_page()

agent_data_cli/dashboard/pages/03_Content_Search.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import streamlit as st
+
+from agent_data_cli.dashboard.adapters.channel import list_channel_options
+from agent_data_cli.dashboard.adapters.content import search_content
+from agent_data_cli.dashboard.context import build_dashboard_context
+from agent_data_cli.dashboard.state import get_page_state, save_page_result
+from agent_data_cli.dashboard.widgets.common import render_exception, running_in_streamlit
+from agent_data_cli.dashboard.widgets.forms import optional_channel_select, source_select
+from agent_data_cli.dashboard.widgets.tables import render_rows
+from agent_data_cli.utils.time import utc_now_iso
+
+
+def render_page() -> None:
+    ctx = build_dashboard_context()
+    st.title("Content Search")
+    row1 = st.columns(2)
+    with row1[0]:
+        source_name = source_select(ctx.registry, key="content_search_source")
+    with row1[1]:
+        channel = optional_channel_select(
+            [] if source_name is None else list_channel_options(ctx.registry, ctx.store, source_name),
+            key="content_search_channel",
+        )
+    row2 = st.columns(2)
+    with row2[0]:
+        query = st.text_input("Query", key="content_search_query")
+    with row2[1]:
+        since = st.text_input("Since", key="content_search_since")
+    row3 = st.columns(2)
+    with row3[0]:
+        limit = st.number_input("Limit", min_value=1, value=20, key="content_search_limit")
+    page_state = get_page_state(st.session_state, "content_search_page_state")
+
+    with row3[1]:
+        run_clicked = st.button("Run Search", key="content_search_run", width="stretch")
+
+    if run_clicked and source_name is not None:
+        try:
+            rows = search_content(
+                ctx.registry,
+                source_name,
+                channel=channel or None,
+                query=query or None,
+                since=since or None,
+                limit=int(limit),
+            )
+            save_page_result(
+                st.session_state,
+                "content_search_page_state",
+                inputs={"source": source_name, "channel": channel, "query": query, "since": since, "limit": int(limit)},
+                result={"rows": rows},
+                updated_at=utc_now_iso(),
+            )
+            page_state = get_page_state(st.session_state, "content_search_page_state")
+        except Exception as exc:  # noqa: BLE001
+            render_exception(exc)
+
+    render_rows(None if page_state["result"] is None else page_state["result"]["rows"], empty_message="Run a remote content search.")
+
+
+if running_in_streamlit():
+    render_page()

agent_data_cli/dashboard/pages/04_Content_Query.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import streamlit as st
+
+from agent_data_cli.dashboard.adapters.channel import list_channel_options
+from agent_data_cli.dashboard.adapters.content import query_content
+from agent_data_cli.dashboard.context import build_dashboard_context
+from agent_data_cli.dashboard.state import get_page_state, save_page_result
+from agent_data_cli.dashboard.widgets.common import render_exception, running_in_streamlit
+from agent_data_cli.dashboard.widgets.forms import optional_channel_select, optional_group_select, source_select
+from agent_data_cli.dashboard.widgets.tables import render_rows
+from agent_data_cli.utils.time import utc_now_iso
+
+
+def render_page() -> None:
+    ctx = build_dashboard_context()
+    st.title("Content Query")
+    mode = st.radio("Mode", ["source", "group"], horizontal=True, key="content_query_mode")
+    row1 = st.columns(2)
+    with row1[0]:
+        source_name = source_select(ctx.registry, key="content_query_source") if mode == "source" else None
+    with row1[1]:
+        group_name = optional_group_select(ctx.store, key="content_query_group") if mode == "group" else None
+    row2 = st.columns(2)
+    with row2[0]:
+        channel_key = (
+            optional_channel_select(
+                [] if source_name is None else list_channel_options(ctx.registry, ctx.store, source_name),
+                key="content_query_channel",
+            )
+            if mode == "source"
+            else None
+        )
+    with row2[1]:
+        keywords = st.text_input("Keywords", key="content_query_keywords")
+    row3 = st.columns(2)
+    with row3[0]:
+        since = st.text_input("Since", key="content_query_since")
+    with row3[1]:
+        limit = st.number_input("Limit", min_value=1, value=20, key="content_query_limit")
+    page_state = get_page_state(st.session_state, "content_query_page_state")
+
+    run_clicked = st.button("Run Query", key="content_query_run")
+    if run_clicked:
+        try:
+            result = query_content(
+                ctx.registry,
+                ctx.store,
+                source_name=source_name,
+                group_name=group_name,
+                channel_key=channel_key or None,
+                keywords=keywords or None,
+                since=since or None,
+                limit=int(limit),
+            )
+            save_page_result(
+                st.session_state,
+                "content_query_page_state",
+                inputs={
+                    "mode": mode,
+                    "source": source_name,
+                    "group": group_name,
+                    "channel": channel_key,
+                    "keywords": keywords,
+                    "since": since,
+                    "limit": int(limit),
+                },
+                result=result,
+                updated_at=utc_now_iso(),
+            )
+            page_state = get_page_state(st.session_state, "content_query_page_state")
+        except Exception as exc:  # noqa: BLE001
+            render_exception(exc)
+
+    render_rows(None if page_state["result"] is None else page_state["result"]["rows"], empty_message="Query the local database.")
+
+
+if running_in_streamlit():
+    render_page()

agent_data_cli/dashboard/pages/05_Content_Update.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import streamlit as st
+
+from agent_data_cli.dashboard.adapters.channel import list_subscribed_channel_options
+from agent_data_cli.dashboard.adapters.content import update_content
+from agent_data_cli.dashboard.context import build_dashboard_context
+from agent_data_cli.dashboard.state import get_page_state, invalidate_pages, save_page_result
+from agent_data_cli.dashboard.widgets.common import render_exception, render_object_details, running_in_streamlit
+from agent_data_cli.dashboard.widgets.forms import optional_channel_select, optional_group_select, source_select
+from agent_data_cli.dashboard.widgets.tables import render_rows
+from agent_data_cli.utils.time import utc_now_iso
+
+
+def build_result_overview(result: dict[str, object]) -> dict[str, object]:
+    overview: dict[str, object] = {}
+    for key in ("dry_run", "saved_count", "skipped_count"):
+        if key in result:
+            overview[key] = result[key]
+    return overview
+
+
+def render_page() -> None:
+    ctx = build_dashboard_context()
+    st.title("Content Update")
+    mode = st.radio("Mode", ["source", "group"], horizontal=True, key="content_update_mode")
+    row1 = st.columns(2)
+    with row1[0]:
+        source_name = source_select(ctx.registry, key="content_update_source") if mode == "source" else None
+    with row1[1]:
+        group_name = optional_group_select(ctx.store, key="content_update_group") if mode == "group" else None
+    row2 = st.columns(2)
+    with row2[0]:
+        channel_key = (
+            optional_channel_select(
+                [] if source_name is None else list_subscribed_channel_options(ctx.store, source_name),
+                key="content_update_channel",
+            )
+            if mode == "source"
+            else None
+        )
+    with row2[1]:
+        since = st.text_input("Since", key="content_update_since")
+    row3 = st.columns(2)
+    with row3[0]:
+        limit = st.number_input("Limit", min_value=1, value=20, key="content_update_limit")
+    with row3[1]:
+        checkbox_row = st.columns(2)
+        with checkbox_row[0]:
+            fetch_all = st.checkbox("All", key="content_update_all")
+        with checkbox_row[1]:
+            dry_run = st.checkbox("Dry Run", key="content_update_dry_run")
+    page_state = get_page_state(st.session_state, "content_update_page_state")
+
+    run_clicked = st.button("Run Update", key="content_update_run")
+    if run_clicked:
+        try:
+            result = update_content(
+                ctx.registry,
+                ctx.store,
+                source_name=source_name,
+                group_name=group_name,
+                channel_key=channel_key or None,
+                since=since or None,
+                limit=int(limit),
+                fetch_all=fetch_all,
+                dry_run=dry_run,
+            )
+            save_page_result(
+                st.session_state,
+                "content_update_page_state",
+                inputs={
+                    "mode": mode,
+                    "source": source_name,
+                    "group": group_name,
+                    "channel": channel_key,
+                    "since": since,
+                    "limit": int(limit),
+                    "all": fetch_all,
+                    "dry_run": dry_run,
+                },
+                result=result,
+                updated_at=utc_now_iso(),
+            )
+            invalidate_pages(st.session_state, "content_query_page_state", "source_page_state")
+            page_state = get_page_state(st.session_state, "content_update_page_state")
+        except Exception as exc:  # noqa: BLE001
+            render_exception(exc)
+
+    if page_state["result"] is not None:
+        overview = build_result_overview(page_state["result"])
+        if overview:
+            render_object_details(overview, title="Update Result")
+        if "summaries" in page_state["result"]:
+            render_rows(page_state["result"]["summaries"], empty_message="No updates.")
+        elif "targets" in page_state["result"]:
+            render_rows(page_state["result"]["targets"], empty_message="No targets.")
+    else:
+        st.info("Run an update against one source or one group.")
+
+
+if running_in_streamlit():
+    render_page()

agent_data_cli/dashboard/pages/06_Sub.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import streamlit as st
+
+from agent_data_cli.dashboard.adapters.sub import list_subscriptions, remove_subscription
+from agent_data_cli.dashboard.context import build_dashboard_context
+from agent_data_cli.dashboard.state import get_page_state, invalidate_pages, save_page_result
+from agent_data_cli.dashboard.widgets.common import render_exception, running_in_streamlit
+from agent_data_cli.dashboard.widgets.forms import source_select
+from agent_data_cli.dashboard.widgets.tables import render_rows
+from agent_data_cli.utils.time import utc_now_iso
+
+
+def render_page() -> None:
+    ctx = build_dashboard_context()
+    st.title("Subscriptions")
+    selected_source = st.checkbox("Filter by source", key="sub_filter_enabled")
+    source_name = source_select(ctx.registry, key="sub_source") if selected_source else None
+    page_state = get_page_state(st.session_state, "sub_page_state")
+
+    if st.button("Refresh Subscriptions", key="sub_refresh"):
+        rows = list_subscriptions(ctx.store, source_name=source_name)
+        save_page_result(
+            st.session_state,
+            "sub_page_state",
+            inputs={"source": source_name},
+            result={"rows": rows},
+            updated_at=utc_now_iso(),
+        )
+        page_state = get_page_state(st.session_state, "sub_page_state")
+
+    render_rows(None if page_state["result"] is None else page_state["result"]["rows"], empty_message="No subscriptions yet.")
+
+    channel_key = st.text_input("Channel To Remove", key="sub_remove_channel")
+    if st.button("Remove Subscription", key="sub_remove") and source_name is not None and channel_key:
+        try:
+            rows = remove_subscription(ctx.registry, source_name, channel_key)
+            save_page_result(
+                st.session_state,
+                "sub_page_state",
+                inputs={"source": source_name},
+                result={"rows": rows},
+                updated_at=utc_now_iso(),
+            )
+            invalidate_pages(st.session_state, "channel_page_state", "content_update_page_state")
+        except Exception as exc:  # noqa: BLE001
+            render_exception(exc)
+
+
+if running_in_streamlit():
+    render_page()

agent_data_cli/dashboard/pages/07_Group.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import streamlit as st
+
+from agent_data_cli.dashboard.adapters.group import (
+    add_channel_to_group,
+    add_source_to_group,
+    create_group,
+    delete_group,
+    list_group_members,
+    list_groups,
+    remove_channel_from_group,
+    remove_source_from_group,
+)
+from agent_data_cli.dashboard.context import build_dashboard_context
+from agent_data_cli.dashboard.state import get_page_state, invalidate_pages, save_page_result
+from agent_data_cli.dashboard.widgets.common import render_exception, running_in_streamlit
+from agent_data_cli.dashboard.widgets.forms import optional_group_select, source_select
+from agent_data_cli.dashboard.widgets.tables import render_rows
+from agent_data_cli.utils.time import utc_now_iso
+
+
+def render_page() -> None:
+    ctx = build_dashboard_context()
+    st.title("Group")
+    page_state = get_page_state(st.session_state, "group_page_state")
+
+    if st.button("Refresh Groups", key="group_refresh"):
+        rows = list_groups(ctx.store)
+        save_page_result(st.session_state, "group_page_state", inputs={}, result={"rows": rows}, updated_at=utc_now_iso())
+        page_state = get_page_state(st.session_state, "group_page_state")
+
+    render_rows(None if page_state["result"] is None else page_state["result"]["rows"], empty_message="No groups yet.")
+
+    input_row1 = st.columns(2)
+    with input_row1[0]:
+        group_name = st.text_input("Group Name", key="group_name")
+    with input_row1[1]:
+        selected_group = optional_group_select(ctx.store, key="group_selected")
+    input_row2 = st.columns(2)
+    with input_row2[0]:
+        source_name = source_select(ctx.registry, key="group_source")
+    with input_row2[1]:
+        channel_key = st.text_input("Channel", key="group_channel")
+
+    row1 = st.columns(2)
+    with row1[0]:
+        if st.button("Create Group", key="group_create") and group_name:
+            try:
+                rows = create_group(ctx.store, group_name)
+                save_page_result(
+                    st.session_state,
+                    "group_page_state",
+                    inputs={},
+                    result={"rows": rows},
+                    updated_at=utc_now_iso(),
+                )
+                invalidate_pages(st.session_state, "content_update_page_state", "content_query_page_state")
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+    with row1[1]:
+        if st.button("Delete Group", key="group_delete") and selected_group:
+            try:
+                rows = delete_group(ctx.store, selected_group)
+                save_page_result(
+                    st.session_state,
+                    "group_page_state",
+                    inputs={},
+                    result={"rows": rows},
+                    updated_at=utc_now_iso(),
+                )
+                invalidate_pages(st.session_state, "content_update_page_state", "content_query_page_state")
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+
+    row2 = st.columns(2)
+    with row2[0]:
+        if st.button("Show Members", key="group_members_show") and selected_group:
+            try:
+                st.write(list_group_members(ctx.store, selected_group))
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+    with row2[1]:
+        if st.button("Add Source", key="group_add_source") and selected_group and source_name:
+            try:
+                st.write(add_source_to_group(ctx.store, selected_group, source_name))
+                invalidate_pages(st.session_state, "content_update_page_state", "content_query_page_state")
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+
+    row3 = st.columns(2)
+    with row3[0]:
+        if st.button("Add Channel", key="group_add_channel") and selected_group and source_name and channel_key:
+            try:
+                st.write(add_channel_to_group(ctx.store, selected_group, source_name, channel_key))
+                invalidate_pages(st.session_state, "content_update_page_state", "content_query_page_state")
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+    with row3[1]:
+        if st.button("Remove Source", key="group_remove_source") and selected_group and source_name:
+            try:
+                st.write(remove_source_from_group(ctx.store, selected_group, source_name))
+                invalidate_pages(st.session_state, "content_update_page_state", "content_query_page_state")
+            except Exception as exc:  # noqa: BLE001
+                render_exception(exc)
+
+    if st.button("Remove Channel", key="group_remove_channel") and selected_group and source_name and channel_key:
+        try:
+            st.write(remove_channel_from_group(ctx.store, selected_group, source_name, channel_key))
+            invalidate_pages(st.session_state, "content_update_page_state", "content_query_page_state")
+        except Exception as exc:  # noqa: BLE001
+            render_exception(exc)
+
+
+if running_in_streamlit():
+    render_page()