jvcli 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

jvcli/client/lib/widgets.py

@@ -0,0 +1,252 @@
+"""Streamlit widgets for JVCLI client app."""
+
+from typing import Any, Optional
+
+import streamlit as st
+import yaml
+
+from jvcli.client.lib.utils import call_get_action, call_update_action
+
+
+def app_header(agent_id: str, action_id: str, info: dict) -> tuple:
+    """Render the app header and return model key and module root."""
+
+    # Create a dynamic key for the session state using the action_id
+    model_key = f"model_{agent_id}_{action_id}"
+    module_root = info.get("config", {}).get("module_root")
+
+    # Initialize session state if not already
+    if model_key not in st.session_state:
+        # Copy original data to prevent modification of original_data
+        st.session_state[model_key] = call_get_action(
+            agent_id=agent_id, action_id=action_id
+        )
+
+    # add standard action app header
+    st.header(
+        st.session_state[model_key]
+        .get("_package", {})
+        .get("meta", {})
+        .get("title", "Action"),
+        divider=True,
+    )
+
+    # Display the description from the model
+    if description := st.session_state[model_key].get("description", False):
+        st.text(description)
+
+    # Manage the 'enabled' field
+    st.session_state[model_key]["enabled"] = st.checkbox(
+        "Enabled", key="enabled", value=st.session_state[model_key]["enabled"]
+    )
+
+    return model_key, module_root
+
+
+def snake_to_title(snake_str: str) -> str:
+    """Convert a snake_case string to Title Case."""
+    return snake_str.replace("_", " ").title()
+
+
+def app_controls(agent_id: str, action_id: str) -> None:
+    """Render the app controls for a given agent and action."""
+    # Generate a dynamic key for the session state using the action_id
+    model_key = f"model_{agent_id}_{action_id}"
+
+    # Recursive function to handle nested dictionaries
+    def render_fields(item_key: str, value: Any, parent_key: str = "") -> None:
+        """Render fields based on their type."""
+
+        field_type = type(value)
+        label = snake_to_title(item_key)  # Convert item_key to Title Case
+
+        if item_key not in st.session_state.get("model_key", {}).keys():
+            # Special case for 'api_key' to render as a password field
+            if item_key == "api_key":
+                st.session_state[model_key][item_key] = st.text_input(
+                    label, value=value, type="password", key=item_key
+                )
+
+            elif field_type == int:
+                st.session_state[model_key][item_key] = st.number_input(
+                    label, value=value, step=1, key=item_key
+                )
+
+            elif field_type == float:
+                st.session_state[model_key][item_key] = st.number_input(
+                    label, value=value, step=0.01, key=item_key
+                )
+
+            elif field_type == bool:
+                st.session_state[model_key][item_key] = st.checkbox(
+                    label, value=value, key=item_key
+                )
+
+            elif field_type == list:
+                yaml_str = st.text_area(
+                    label + " (YAML format)", value=yaml.dump(value), key=item_key
+                )
+                try:
+                    # Update the list with the user-defined YAML
+                    loaded_value = yaml.safe_load(yaml_str)
+                    if not isinstance(loaded_value, list):
+                        raise ValueError("The provided YAML does not produce a list.")
+                    st.session_state[model_key][item_key] = loaded_value
+                except (yaml.YAMLError, ValueError) as e:
+                    st.error(f"Error parsing YAML for {item_key}: {e}")
+
+            elif field_type == str:
+                if len(value) > 100:
+                    st.session_state[model_key][item_key] = st.text_area(
+                        label, value=value, key=item_key
+                    )
+                else:
+                    st.session_state[model_key][item_key] = st.text_input(
+                        label, value=value, key=item_key
+                    )
+
+            elif field_type == dict:
+                yaml_str = st.text_area(
+                    label + " (YAML format)", value=yaml.dump(value), key=item_key
+                )
+                try:
+                    # Update the dictionary with the user-defined YAML
+                    st.session_state[model_key][item_key] = (
+                        yaml.safe_load(yaml_str) or {}
+                    )
+                except yaml.YAMLError as e:
+                    st.error(f"Error parsing YAML for {item_key}: {e}")
+
+            else:
+                st.write(f"Unsupported type for {item_key}: {field_type}")
+
+    # Iterate over keys of context except specific keys
+    keys_to_iterate = [
+        key
+        for key in (st.session_state[model_key]).keys()
+        if key not in ["id", "version", "label", "description", "enabled", "_package"]
+    ]
+
+    for item_key in keys_to_iterate:
+        render_fields(item_key, st.session_state[model_key][item_key])
+
+
+def app_update_action(agent_id: str, action_id: str) -> None:
+    """Add a standard update button to apply changes."""
+
+    model_key = f"model_{agent_id}_{action_id}"
+
+    st.divider()
+
+    if st.button("Update"):
+        result = call_update_action(
+            agent_id=agent_id,
+            action_id=action_id,
+            action_data=st.session_state[model_key],
+        )
+        if result and result.get("id", "") == action_id:
+            st.success("Changes saved")
+        else:
+            st.error("Unable to save changes")
+
+
+def dynamic_form(
+    field_definitions: list,
+    initial_data: Optional[list] = None,
+    session_key: str = "dynamic_form",
+) -> list:
+    """
+    Create a dynamic form widget with add/remove functionality.
+
+    Parameters:
+    - field_definitions: A list of dictionaries where each dictionary defines a field
+                         with 'name', 'type', and any specific 'options' if needed.
+    - initial_data: A list of dictionaries to initialize the form with predefined values.
+    - session_key: A unique key to store and manage session state of the form.
+
+    Returns:
+    - list: The current value of the dynamic form.
+    """
+    if session_key not in st.session_state:
+        if initial_data is not None:
+            st.session_state[session_key] = []
+            for idx, row_data in enumerate(initial_data):
+                fields = {
+                    field["name"]: row_data.get(field["name"], "")
+                    for field in field_definitions
+                }
+                st.session_state[session_key].append({"id": idx, "fields": fields})
+        else:
+            st.session_state[session_key] = [
+                {"id": 0, "fields": {field["name"]: "" for field in field_definitions}}
+            ]
+
+    def add_row() -> None:
+        """Add a new row to the dynamic form."""
+        new_id = (
+            max((item["id"] for item in st.session_state[session_key]), default=-1) + 1
+        )
+        new_row = {
+            "id": new_id,
+            "fields": {field["name"]: "" for field in field_definitions},
+        }
+        st.session_state[session_key].append(new_row)
+
+    def remove_row(id_to_remove: int) -> None:
+        """Remove a row from the dynamic form."""
+        st.session_state[session_key] = [
+            item for item in st.session_state[session_key] if item["id"] != id_to_remove
+        ]
+
+    for item in st.session_state[session_key]:
+        # Display fields in a row
+        row_cols = st.columns(len(field_definitions))
+        for i, field in enumerate(field_definitions):
+            field_name = field["name"]
+            field_type = field.get("type", "text")
+            options = field.get("options", [])
+
+            if field_type == "text":
+                item["fields"][field_name] = row_cols[i].text_input(
+                    field_name,
+                    value=item["fields"][field_name],
+                    key=f"{session_key}_{item['id']}_{field_name}",
+                )
+            elif field_type == "number":
+                field_value = item["fields"][field_name]
+                if field_value == "":
+                    field_value = 0
+                item["fields"][field_name] = row_cols[i].number_input(
+                    field_name,
+                    value=int(field_value),
+                    key=f"{session_key}_{item['id']}_{field_name}",
+                )
+            elif field_type == "select":
+                item["fields"][field_name] = row_cols[i].selectbox(
+                    field_name,
+                    options,
+                    index=(
+                        options.index(item["fields"][field_name])
+                        if item["fields"][field_name] in options
+                        else 0
+                    ),
+                    key=f"{session_key}_{item['id']}_{field_name}",
+                )
+
+        # Add a remove button in a new row beneath the fields, aligned to the left
+        with st.container():
+            if st.button(
+                "Remove",
+                key=f"remove_{item['id']}",
+                on_click=lambda id=item["id"]: remove_row(id),
+            ):
+                pass
+
+    # Add a divider above the "Add Row" button
+    st.divider()
+
+    # Button to add a new row
+    st.button("Add Row", on_click=add_row)
+
+    # Return the current value of the dynamic form
+    return [item["fields"] for item in st.session_state[session_key]]

jvcli/client/pages/__init__.py

@@ -0,0 +1 @@
+"""Streamlit pages for the JVCLI client module."""

jvcli/client/pages/analytics_page.py

@@ -0,0 +1,178 @@
+"""Renders the analytics page of the JVCLI client."""
+
+import calendar
+import datetime
+import os
+
+import pandas as pd
+import requests
+import streamlit as st
+from streamlit.delta_generator import DeltaGenerator
+from streamlit_javascript import st_javascript
+from streamlit_router import StreamlitRouter
+
+from jvcli.client.lib.utils import get_user_info
+
+JIVAS_URL = os.environ.get("JIVAS_URL", "http://localhost:8000")
+
+
+def render(router: StreamlitRouter) -> None:
+    """Render the analytics page."""
+    ctx = get_user_info()
+
+    st.header("Analytics", divider=True)
+    today = datetime.date.today()
+    last_day = calendar.monthrange(today.year, today.month)[1]
+
+    date_range = st.date_input(
+        "Period",
+        (
+            datetime.date(today.year, today.month, 1),
+            datetime.date(today.year, today.month, last_day),
+        ),
+    )
+
+    (start_date, end_date) = date_range
+
+    # rerender_metrics = render_metrics()
+    col1, col2, col3 = st.columns(3)
+    timezone = st_javascript(
+        """await (async () => {
+                const userTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+                console.log(userTimezone)
+                return userTimezone
+    })().then(returnValue => returnValue)"""
+    )
+
+    try:
+        selected_agent = st.session_state.get("selected_agent")
+        if selected_agent and end_date > start_date:
+            interactions_chart(
+                token=ctx["token"],
+                agent_id=selected_agent["id"],
+                start_date=start_date,
+                end_date=end_date,
+                metric_col=col1,
+                timezone=timezone,
+            )
+            users_chart(
+                token=ctx["token"],
+                agent_id=selected_agent["id"],
+                start_date=start_date,
+                end_date=end_date,
+                metric_col=col2,
+                timezone=timezone,
+            )
+            channels_chart(
+                token=ctx["token"],
+                agent_id=selected_agent["id"],
+                start_date=start_date,
+                end_date=end_date,
+                metric_col=col3,
+                timezone=timezone,
+            )
+        else:
+            st.text("Invalid date range")
+    except Exception as e:
+        st.text("Unable to render charts")
+        print(e)
+
+
+def interactions_chart(
+    start_date: datetime.date,
+    end_date: datetime.date,
+    agent_id: str,
+    token: str,
+    metric_col: DeltaGenerator,
+    timezone: str,
+) -> None:
+    """Render the interactions chart."""
+    url = f"{JIVAS_URL}/walker/get_interactions_by_date"
+
+    with st.container(border=True):
+        st.subheader("Interactions by Date")
+        response = requests.post(
+            url=url,
+            json={
+                "agent_id": agent_id,
+                "reporting": True,
+                "start_date": start_date.isoformat(),
+                "end_date": end_date.isoformat(),
+                "timezone": timezone,
+            },
+            headers={"Authorization": f"Bearer {token}"},
+        )
+        if response.status_code == 200:
+            if response_data := response.json():
+                chart_data = pd.DataFrame(
+                    data=response_data["reports"][0]["data"],
+                )
+                st.line_chart(chart_data, x="date", y="count")
+                total = response_data["reports"][0]["total"]
+                metric_col.metric("Interactions", total)
+
+
+def users_chart(
+    start_date: datetime.date,
+    end_date: datetime.date,
+    agent_id: str,
+    token: str,
+    metric_col: DeltaGenerator,
+    timezone: str,
+) -> None:
+    """Render the users chart."""
+    url = f"{JIVAS_URL}/walker/get_users_by_date"
+    with st.container(border=True):
+        st.subheader("Users by Date")
+        response = requests.post(
+            url=url,
+            json={
+                "agent_id": agent_id,
+                "reporting": True,
+                "start_date": start_date.isoformat(),
+                "end_date": end_date.isoformat(),
+                "timezone": timezone,
+            },
+            headers={"Authorization": f"Bearer {token}"},
+        )
+        if response.status_code == 200:
+            if response_data := response.json():
+                chart_data = pd.DataFrame(
+                    data=response_data["reports"][0]["data"],
+                )
+                st.line_chart(chart_data, x="date", y="count")
+                total = response_data["reports"][0]["total"]
+                metric_col.metric("Users", total)
+
+
+def channels_chart(
+    start_date: datetime.date,
+    end_date: datetime.date,
+    agent_id: str,
+    token: str,
+    metric_col: DeltaGenerator,
+    timezone: str,
+) -> None:
+    """Render the channels chart."""
+    url = f"{JIVAS_URL}/walker/get_channels_by_date"
+    with st.container(border=True):
+        st.subheader("Channels by Date")
+        response = requests.post(
+            url=url,
+            json={
+                "agent_id": agent_id,
+                "reporting": True,
+                "start_date": start_date.isoformat(),
+                "end_date": end_date.isoformat(),
+                "timezone": timezone,
+            },
+            headers={"Authorization": f"Bearer {token}"},
+        )
+        if response.status_code == 200:
+            if response_data := response.json():
+                chart_data = pd.DataFrame(
+                    data=response_data["reports"][0]["data"],
+                )
+                st.line_chart(chart_data, x="date", y="count")
+                total = response_data["reports"][0]["total"]
+                metric_col.metric("Channels", total)

jvcli/client/pages/chat_page.py

@@ -0,0 +1,143 @@
+"""Renders the chat page for the JVCLI client."""
+
+import os
+from typing import Optional
+
+import requests
+import streamlit as st
+from streamlit_router import StreamlitRouter
+
+from jvcli.client.lib.utils import get_user_info
+
+JIVAS_URL = os.environ.get("JIVAS_URL", "http://localhost:8000")
+
+
+def transcribe_audio(token: str, agent_id: str, file: bytes) -> dict:
+    """Transcribe audio using the walker API."""
+    action_walker_url = f"{JIVAS_URL}/action/walker"
+
+    # Create form data
+    files = {"attachments": ("audio.wav", file, "audio/wav")}
+
+    data = {
+        "args": "{}",
+        "module_root": "actions.jivas.deepgram_stt_action",
+        "agent_id": agent_id,
+        "walker": "transcribe_audio",
+    }
+
+    headers = {"Authorization": f"Bearer {token}"}
+
+    # Make the POST request
+    response = requests.post(
+        f"{action_walker_url}", headers=headers, data=data, files=files
+    )
+
+    # Parse JSON response
+    result = response.json()
+
+    return result
+
+
+def render(router: StreamlitRouter) -> None:
+    """Render the chat page."""
+    url = f"{JIVAS_URL}/interact"
+    ctx = get_user_info()
+
+    st.header("Chat", divider=True)
+    tts_on = st.toggle("TTS")
+
+    audio_value = st.audio_input("Record a voice message")
+    if audio_value:
+        selected_agent = st.session_state.get("selected_agent")
+        result = transcribe_audio(ctx["token"], selected_agent, audio_value)
+        if result.get("success", False):
+            send_message(
+                result["transcript"], url, ctx["token"], selected_agent, tts_on
+            )
+
+    if selected_agent := st.query_params.get("agent"):
+        chat_messages = st.session_state.messages.get(selected_agent, [])
+
+        # Display chat messages from history on app rerun
+        for message in chat_messages:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+                if payload := message.get("payload"):
+                    with st.expander("...", False):
+                        st.json(payload)
+
+        # Accept user input
+        if prompt := st.chat_input("Type your message here"):
+            send_message(prompt, url, ctx["token"], selected_agent, tts_on)
+
+
+def send_message(
+    prompt: str,
+    url: str,
+    token: str,
+    selected_agent: Optional[str] = None,
+    tts_on: bool = False,
+) -> None:
+    """Send a message to the walker API and display the response."""
+    # Add user message to chat history
+    add_agent_message(selected_agent, {"role": "user", "content": prompt})
+
+    # Display user message in chat message container
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        # Call walker API
+        response = requests.post(
+            url=url,
+            json={
+                "utterance": prompt,
+                "session_id": st.session_state.session_id,
+                "agent_id": selected_agent,
+                "tts": tts_on,
+                "verbose": True,
+            },
+            headers={"Authorization": f"Bearer {token}"},
+        )
+        if response.status_code == 200:
+            if response_data := response.json():
+                st.markdown(
+                    response_data.get("response", {})
+                    .get("message", {})
+                    .get("content", "...")
+                )
+                if "audio_url" in response_data.get("response", {}) and tts_on:
+                    audio_url = response_data.get("response", {}).get(
+                        "audio_url", "..."
+                    )
+                    st.audio(audio_url, autoplay=True)
+                with st.expander("...", False):
+                    st.json(response_data)
+
+                # Add assistant response to chat history
+                add_agent_message(
+                    selected_agent,
+                    {
+                        "role": "assistant",
+                        "content": response_data.get("response", {})
+                        .get("message", {})
+                        .get("content", "..."),
+                        "payload": response_data,
+                    },
+                )
+            if "session_id" in response_data.get("response", {}):
+                st.session_state.session_id = response_data["response"]["session_id"]
+
+
+def add_agent_message(agent_id: Optional[str], message: dict) -> None:
+    """Add a message to the chat history for a specific agent."""
+    all_messages = st.session_state.messages
+    agent_messages = all_messages.get(agent_id, [])
+    agent_messages.append(message)
+    st.session_state.messages[agent_id] = agent_messages
+
+
+def clear_messages() -> None:
+    """Clear all chat messages."""
+    st.session_state.messages = {}

jvcli/client/pages/dashboard_page.py

@@ -0,0 +1,119 @@
+"""Render the dashboard page of the jvclient with actions data."""
+
+import streamlit as st
+from streamlit_elements import dashboard, elements, mui
+from streamlit_router import StreamlitRouter
+
+from jvcli.client.lib.page import Page
+
+
+def render(router: StreamlitRouter) -> None:
+    """Render the dashboard page."""
+    if actions_data := st.session_state.get("actions_data"):
+        with elements("dashboard"):
+            columns = 4
+            layout = []
+
+            # Compute the position of each card component in the layout
+            for idx, _ in enumerate(actions_data):
+                x = (idx % columns) * 3
+                y = (idx // columns) * 2
+                width = 3
+                height = 2
+                # Add an item to the dashboard manually without using `with` if it's not a context manager
+                layout.append(
+                    dashboard.Item(
+                        f"card_{idx}",
+                        x,
+                        y,
+                        width,
+                        height,
+                        isDraggable=False,
+                        isResizable=False,
+                    )
+                )
+
+            # now populate the actual cards with content
+            with dashboard.Grid(layout):
+                for idx, action in enumerate(actions_data):
+                    package = action.get("_package", {})
+                    title = package.get("meta", {}).get("title", action.get("label"))
+                    description = action.get("description", "")
+                    version = action.get("version", "0.0.0")
+                    action_type = package.get("meta", {}).get("type", "action")
+                    key = Page.normalize_label(title)
+                    enabled_color = "red"
+                    enabled_text = "(disabled)"
+                    avatar_text = "A"
+
+                    if action_type == "interact_action":
+                        avatar_text = "I"
+
+                    if action.get("enabled", False):
+                        enabled_color = "green"
+                        enabled_text = ""
+
+                    # create the card
+                    with mui.Card(
+                        key=f"card_{idx}",
+                        sx={
+                            "display": "flex",
+                            "flexDirection": "column",
+                            "borderRadius": 2,
+                            "overflow": "scroll",
+                        },
+                        elevation=2,
+                    ):
+                        # Card header with title
+                        mui.CardHeader(
+                            title=f"{title} {enabled_text}",
+                            subheader=f"{version}",
+                            avatar=mui.Avatar(
+                                avatar_text, sx={"bgcolor": enabled_color}
+                            ),
+                            action=mui.IconButton(mui.icon.MoreVert),
+                        )
+
+                        # Card body
+                        with mui.CardContent(sx={"flex": 1}):
+                            mui.Typography(description, variant="body2")
+
+                        # Card footer with action buttons
+                        with mui.CardActions(disableSpacing=True):
+                            query = st.query_params.to_dict()
+                            query_str = ""
+                            for k, v in query.items():
+                                if k != "request":
+                                    query_str += f"{k}={v}&"
+
+                            if package.get("config", {}).get("app", False):
+                                with mui.Stack(
+                                    direction="row",
+                                    spacing=2,
+                                    alignItems="center",
+                                    sx={"padding": "10px"},
+                                ):
+                                    mui.Button(
+                                        "Configure",
+                                        variant="outlined",
+                                        href=(
+                                            (
+                                                f"/?request=GET:/{key}&${query_str.rstrip('&')}"
+                                                if query_str
+                                                else f"/?request=GET:/{key}"
+                                            )
+                                            + f"&token={st.session_state.TOKEN}"
+                                        ),
+                                        target="_blank",
+                                    )
+
+
+def logout() -> None:
+    """Logout the user by clearing the session token."""
+    del st.session_state["TOKEN"]
+    token_query = st.query_params.get("token")
+
+    if token_query:
+        query_params = st.query_params.to_dict()
+        del query_params["token"]
+        st.query_params.from_dict(query_params)