jvcli 2.0.30__py3-none-any.whl → 2.1.1__py3-none-any.whl

jvcli/client/pages/action_dashboard_page.py

@@ -1,120 +0,0 @@
-"""Render the action_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("action_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 action_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 = package.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)

jvcli/client/pages/analytics_page.py

@@ -1,245 +0,0 @@
-"""Renders the analytics page of the JVCLI client."""
-
-import calendar
-import datetime
-import os
-from typing import Optional
-
-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 call_healthcheck, get_user_info
-
-JIVAS_BASE_URL = os.environ.get("JIVAS_BASE_URL", "http://localhost:8000")
-
-
-def render(router: StreamlitRouter) -> None:
-    """Render the analytics page."""
-
-    selected_agent = st.session_state.get("selected_agent")
-
-    # Call the healthcheck endpoint and render the collapsible section
-    @st.cache_data(show_spinner=True)
-    def fetch_healthcheck(agent_id: str) -> Optional[dict]:
-        return call_healthcheck(agent_id)
-
-    health_data = None
-
-    if selected_agent:
-        # Clear the cache and fetch fresh data if the button is clicked
-        if st.session_state.get("recheck_health_clicked", False):
-            fetch_healthcheck.clear()
-            health_data = call_healthcheck(selected_agent["id"])
-            st.session_state["recheck_health_clicked"] = False
-        else:
-            # Use cached data
-            health_data = fetch_healthcheck(selected_agent["id"])
-
-        try:
-            if health_data:
-                trace = health_data.get("trace", {})
-                errors = [
-                    f"{key}: {value['message']}"
-                    for key, value in trace.items()
-                    if value.get("severity") == "error"
-                ]
-                warnings = [
-                    f"{key}: {value['message']}"
-                    for key, value in trace.items()
-                    if value.get("severity") == "warning"
-                ]
-
-                if errors:
-                    section_label = "Agent health needs ATTENTION!"
-                    section_color = "red"
-                    expanded = True
-                elif warnings:
-                    section_label = "Agent health is OK (with warnings)"
-                    section_color = "orange"
-                    expanded = True
-                else:
-                    section_label = "Agent health is OK"
-                    section_color = "green"
-                    expanded = False
-
-                with st.expander(
-                    f":{section_color}[{section_label}]", expanded=expanded
-                ):
-                    if errors:
-                        st.error("Errors")
-                        for error in errors:
-                            st.text(f"- {error}")
-                    if warnings:
-                        st.warning("Warnings")
-                        for warning in warnings:
-                            st.text(f"- {warning}")
-                    if st.button("Recheck Health", key="recheck_inside_expander"):
-                        st.session_state["recheck_health_clicked"] = True
-                        st.rerun()
-
-            else:
-                st.error("Failed to fetch healthcheck data.")
-        except Exception as e:
-            st.error("An error occurred while fetching healthcheck data.")
-            print(e)
-
-    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:
-        ctx = get_user_info()
-        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_BASE_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_BASE_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_BASE_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

@@ -1,150 +0,0 @@
-"""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_BASE_URL = os.environ.get("JIVAS_BASE_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_BASE_URL}/action/walker"
-
-    # Create form data
-    files = {"attachments": ("audio.wav", file, "audio/wav")}
-
-    data = {
-        "args": "{}",
-        "module_root": "jivas.agent.action",
-        "agent_id": agent_id,
-        "walker": "invoke_stt_action",
-    }
-
-    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_BASE_URL}/interact"
-    ctx = get_user_info()
-
-    st.header("Chat", divider=True)
-    tts_on = st.toggle("TTS")
-
-    message = ""
-    # Handle audio input first
-    audio_value = st.audio_input("Record a voice message")
-    # Get selected agent from query params
-    selected_agent = st.query_params.get("agent")
-
-    if selected_agent:
-        chat_messages = st.session_state.messages.get(selected_agent, [])
-
-        # Display chat messages from history on app rerun
-        for item in chat_messages:
-            role = item.get("role", "user")
-            content = item.get("content", "")
-            with st.chat_message(role):
-                st.markdown(content)
-                if payload := item.get("payload"):
-                    with st.expander("...", False):
-                        st.json(payload)
-
-    # Process audio input if available
-    if audio_value and selected_agent:
-        result = transcribe_audio(ctx["token"], selected_agent, audio_value)
-        if result and result.get("success", False):
-            message = result["transcript"]
-
-    # Otherwise handle text input
-    if input := st.chat_input("Type your message here"):
-        message = input
-
-    if message:
-        send_message(message, 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/graph_page.py

@@ -1,20 +0,0 @@
-"""Render the Jivas Studio page in an iframe."""
-
-import os
-
-import streamlit as st
-from streamlit_router import StreamlitRouter
-
-JIVAS_STUDIO_URL = os.environ.get("JIVAS_STUDIO_URL", "http://localhost:8989")
-
-
-def render(router: StreamlitRouter) -> None:
-    """
-    Render the Jivas Studio page in an iframe.
-
-    args:
-        router: StreamlitRouter
-            The StreamlitRouter instance
-    """
-
-    st.components.v1.iframe(JIVAS_STUDIO_URL, width=None, height=800, scrolling=False)

jvcli/commands/clean.py

@@ -1,29 +0,0 @@
-"""Runs the jac clean command"""
-
-import subprocess
-
-import click
-
-
-@click.command(
-    help="Clean the Jac files in the current directory and subdirectories. This command executes 'jac clean', which removes compiled Jac artifacts and temporary files. "
-    "Use this command to ensure a clean state before rebuilding your Jac project."
-)
-@click.pass_context
-def clean(ctx: click.Context) -> None:
-    """Clean the Jac files in directory."""
-    try:
-        click.echo("Running jac clean in actions directory...")
-        result = subprocess.run(["jac", "clean"], check=True)
-        if result.returncode == 0:
-            click.echo("Successfully cleaned directory.")
-
-        else:
-            click.secho("Failed to clean directory.", fg="red")
-            ctx.exit(1)
-    except subprocess.CalledProcessError as e:
-        click.secho(f"Error running jac clean: {e}", fg="red")
-        ctx.exit(1)
-    except Exception as e:
-        click.secho(f"Unexpected error: {e}", fg="red")
-        ctx.exit(1)