jvcli 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

jvcli/__init__.py

@@ -4,5 +4,5 @@ jvcli package initialization.
 This package provides the CLI tool for Jivas Package Repository.
 """
 
-__version__ = "2.0.1"
+__version__ = "2.0.3"
 __supported__jivas__versions__ = ["2.0.0"]

jvcli/cli.py

@@ -4,6 +4,7 @@ import click
 
 from jvcli import __version__
 from jvcli.commands.auth import login, logout, signup
+from jvcli.commands.client import client
 from jvcli.commands.create import create
 from jvcli.commands.download import download
 from jvcli.commands.info import info
@@ -26,6 +27,7 @@ jvcli.add_command(download)
 jvcli.add_command(publish)
 jvcli.add_command(info)
 jvcli.add_command(studio)
+jvcli.add_command(client)
 
 # Register standalone commands
 jvcli.add_command(signup)

jvcli/client/__init__.py

@@ -0,0 +1 @@
+"""This package contains the client-side code for the JVCLI client streamlit app."""

jvcli/client/app.py

@@ -0,0 +1,160 @@
+"""This module contains the main application logic for the JVCLI client."""
+
+import os
+
+import requests
+import streamlit as st
+from streamlit_router import StreamlitRouter
+
+from jvcli.client.lib.page import Page
+from jvcli.client.lib.utils import call_list_actions, call_list_agents, load_function
+from jvcli.client.pages import analytics_page, chat_page, dashboard_page, graph_page
+
+JIVAS_URL = os.environ.get("JIVAS_URL", "http://localhost:8000")
+
+JIVAS_STUDIO_URL = os.environ.get("JIVAS_STUDIO_URL", "http://localhost:8989")
+
+
+def handle_agent_selection() -> None:
+    """Handle the selection of an agent."""
+    if "selected_agent" in st.session_state:
+        st.query_params["agent"] = st.session_state.selected_agent["id"]
+        st.session_state.messages = {}
+
+
+def login_form() -> None:
+    """Render the login form and handle login logic."""
+    login_url = f"{JIVAS_URL}/user/login"
+
+    with st.container(border=True):
+        st.header("Login")
+
+        email = st.text_input("Email")
+        password = st.text_input("Password", type="password")
+
+        if st.button("Login"):
+            response = requests.post(
+                login_url, json={"email": email, "password": password}
+            )
+
+            if response.status_code == 200:
+                st.session_state.ROOT_ID = response.json()["user"]["root_id"]
+                st.session_state.TOKEN = response.json()["token"]
+                st.session_state.EXPIRATION = response.json()["user"]["expiration"]
+                st.rerun()
+
+
+def main() -> None:
+    """Main function to render the Streamlit app."""
+    hide_sidebar = st.query_params.get("hide_sidebar")
+    router = StreamlitRouter()
+
+    # Initialize session state
+    for key in [
+        "messages",
+        "session_id",
+        "EXPIRATION",
+        "agents",
+        "actions_data",
+        "TOKEN",
+        "ROOT_ID",
+        "EXPIRATION",
+    ]:
+        if key not in st.session_state:
+            if key == "messages":
+                st.session_state[key] = {}
+            else:
+                st.session_state[key] = [] if key in ["actions_data"] else ""
+
+    if hide_sidebar == "true":
+        st.markdown(
+            """
+        <style>
+            [data-testid="stSidebar"] {
+                display: none;
+            }
+            [data-testid="stSidebarCollapsedControl"] {
+                display: none;
+            }
+        </style>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    # Setup the sidebar
+    with st.sidebar:
+        st.title("✧ JIVAS Manager")
+        # retrieve agent list
+        agents = call_list_agents()
+
+        try:
+            selected_agent_id = st.query_params["agent"]
+        except KeyError:
+            st.query_params["agent"] = agents[0]["id"] if agents else None
+            selected_agent_id = st.query_params["agent"]
+
+        selected_agent_index = next(
+            (i for i, item in enumerate(agents) if item["id"] == selected_agent_id),
+            len(agents) - 1 if agents else None,
+        )
+
+        # Render the ComboBox using streamlit-elements
+        st.sidebar.selectbox(
+            "Agent",
+            agents,
+            index=selected_agent_index,
+            placeholder="Select agent...",
+            format_func=lambda x: x["label"] if "label" in x else x,
+            on_change=handle_agent_selection,
+            key="selected_agent",
+        )
+
+        # Expander for the menu
+        with st.expander("Menu", True):
+            Page(router).item(analytics_page.render, "Dashboard", "/").st_button()
+            Page(router).item(chat_page.render, "Chat", "/chat").st_button()
+            Page(router).item(dashboard_page.render, "Actions", "/actions").st_button()
+            Page(router).item(graph_page.render, "Graph", "/graph").st_button()
+            st.button(
+                "Logout", on_click=dashboard_page.logout, use_container_width=True
+            )
+
+        with st.expander("Action Apps", False):
+            if selected_agent_id and (
+                actions_data := call_list_actions(agent_id=selected_agent_id)
+            ):
+                st.session_state.actions_data = actions_data
+
+                for action in actions_data:
+                    package = action.get("_package", {})
+
+                    if package.get("config", {}).get("app", False):
+                        func = load_function(
+                            f"{package['config']['path']}/app/app.py",
+                            "render",
+                            router=router,
+                            agent_id=selected_agent_id,
+                            action_id=action["id"],
+                            info=package,
+                        )
+                        # register the route to the app
+                        Page(router).item(
+                            callback=func,
+                            label=package["meta"]["title"],
+                            path=f'/{Page.normalize_label(package["meta"]["title"])}',
+                        ).st_button()
+    router.serve()
+
+
+# Initialize Streamlit app config
+if __name__ == "__main__":
+    token_query = st.query_params.get("token")
+    if token_query:
+        st.session_state.TOKEN = token_query
+
+    if "TOKEN" not in st.session_state:
+        st.set_page_config(page_title="JIVAS Manager", page_icon="💠")
+        login_form()
+    else:
+        st.set_page_config(page_title="JIVAS Manager", page_icon="💠", layout="wide")
+        main()

jvcli/client/lib/__init__.py

@@ -0,0 +1 @@
+"""jvcli client library functions."""

jvcli/client/lib/page.py

@@ -0,0 +1,68 @@
+"""This module contains the Page class used for managing pages in the JVCLI client."""
+
+from typing import Callable, Dict, Optional
+
+import streamlit as st
+from streamlit_router import StreamlitRouter
+
+
+class Page:
+    """Class to manage pages in the JVCLI client."""
+
+    def __init__(self, router: StreamlitRouter) -> None:
+        """Initialize the Page with a router."""
+        self._router: StreamlitRouter = router
+        self._callback: Optional[Callable] = None
+        self._label: Optional[str] = None
+        self._path: Optional[str] = None
+        self._key: Optional[str] = None
+        self._args: Optional[Dict] = None
+
+    def item(
+        self, callback: Callable, label: str, path: str, args: Optional[Dict] = None
+    ) -> "Page":
+        """
+        Register the page callable on the given route.
+
+        Args:
+            callback (Callable): The function to call for the page.
+            label (str): The label for the page.
+            path (str): The path for the page.
+            args (Optional[Dict], optional): Additional arguments for the page. Defaults to None.
+
+        Returns:
+            Page: The current Page instance.
+        """
+        if args is None:
+            args = {}
+        self._callback = callback
+        self._label = label
+        self._path = path
+        self._args = args
+        self._key = f"{Page.normalize_label(label)}"
+        self._router.register(func=self._callback, path=self._path, endpoint=self._key)
+        return self
+
+    def st_button(self) -> None:
+        """Add the Streamlit link for this page wherever it is called."""
+        if st.button(self._label, key=self._key, use_container_width=True):
+            self._router.redirect(*self._router.build(self._key, self._args))
+
+    @staticmethod
+    def normalize_label(label: str) -> str:
+        """
+        Normalize the label to be used as a key.
+
+        Args:
+            label (str): The label to normalize.
+
+        Returns:
+            str: The normalized label.
+        """
+        return (
+            "".join(char.lower() for char in label if char.isascii())
+            .strip()
+            .replace(" ", "-")
+            .replace("/", "-")
+            .replace(":", "-")
+        )

jvcli/client/lib/utils.py

@@ -0,0 +1,334 @@
+"""This module contains utility functions for the JVCLI client."""
+
+import base64
+import json
+import os
+from importlib.util import module_from_spec, spec_from_file_location
+from io import BytesIO
+from typing import Any, Callable, Dict, List, Optional
+
+import requests
+import streamlit as st
+import yaml
+from PIL import Image
+
+JIVAS_URL = os.environ.get("JIVAS_URL", "http://localhost:8000")
+
+
+def load_function(file_path: str, function_name: str, **kwargs: Any) -> Callable:
+    """Dynamically loads and returns a function from a Python file, with optional keyword arguments."""
+
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"No file found at {file_path}")
+
+    # Get the module name from the file name
+    module_name = os.path.splitext(os.path.basename(file_path))[0]
+
+    # Load the module specification
+    spec = spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Could not load specification for module {module_name}")
+
+    # Create the module
+    module = module_from_spec(spec)
+    if spec.loader is None:
+        raise ImportError(f"Could not load module {module_name}")
+
+    # Execute the module
+    spec.loader.exec_module(module)
+
+    # Get the function
+    if not hasattr(module, function_name):
+        raise AttributeError(f"Function '{function_name}' not found in {file_path}")
+
+    func = getattr(module, function_name)
+
+    # Ensure the returned callable can accept any kwargs passed to it
+    def wrapped_func(*args: Any, **func_kwargs: Any) -> Any:
+        return func(*args, **{**kwargs, **func_kwargs})
+
+    return wrapped_func
+
+
+def call_list_agents() -> list:
+    """Call the API to list agents."""
+
+    ctx = get_user_info()
+
+    endpoint = f"{JIVAS_URL}/walker/list_agents"
+
+    if ctx["token"]:
+        try:
+            headers = {"Authorization": "Bearer " + ctx["token"]}
+            json = {"reporting": True}
+
+            # call interact
+            response = requests.post(endpoint, json=json, headers=headers)
+
+            if response.status_code == 200:
+                result = response.json().get("reports", [])
+                if len(result) > 0:
+                    return [
+                        {"id": agent["id"], "label": agent["name"]} for agent in result
+                    ]
+
+            if response.status_code == 401:
+                st.session_state.EXPIRATION = ""
+                return []
+
+        except Exception as e:
+            st.session_state.EXPIRATION = ""
+            print("Exception occurred: ", e)
+
+    return []
+
+
+def call_list_actions(agent_id: str) -> list:
+    """Call the API to list actions for a given agent."""
+
+    ctx = get_user_info()
+
+    endpoint = f"{JIVAS_URL}/walker/list_actions"
+
+    if ctx["token"]:
+        try:
+            headers = {"Authorization": "Bearer " + ctx["token"]}
+            json = {"agent_id": agent_id}
+
+            # call interact
+            response = requests.post(endpoint, json=json, headers=headers)
+
+            if response.status_code == 200:
+                result = (response.json()).get("reports", [])
+                if len(result) > 0:
+                    return result[0]
+                else:
+                    return []
+
+            if response.status_code == 401:
+                st.session_state.EXPIRATION = ""
+                return []
+
+        except Exception as e:
+            st.session_state.EXPIRATION = ""
+            print("Exception occurred: ", e)
+
+    return []
+
+
+def call_get_action(agent_id: str, action_id: str) -> list:
+    """Call the API to get a specific action for a given agent."""
+
+    ctx = get_user_info()
+
+    endpoint = f"{JIVAS_URL}/walker/get_action"
+
+    if ctx["token"]:
+        try:
+            headers = {"Authorization": "Bearer " + ctx["token"]}
+            json = {"agent_id": agent_id, "action_id": action_id}
+
+            # call interact
+            response = requests.post(endpoint, json=json, headers=headers)
+
+            if response.status_code == 200:
+                result = (response.json()).get("reports", [])
+                if len(result) > 0:
+                    return result[0]
+                else:
+                    return []
+
+            if response.status_code == 401:
+                st.session_state.EXPIRATION = ""
+                return []
+
+        except Exception as e:
+            st.session_state.EXPIRATION = ""
+            print("Exception occurred: ", e)
+
+    return []
+
+
+def call_update_action(agent_id: str, action_id: str, action_data: dict) -> dict:
+    """Call the API to update a specific action for a given agent."""
+
+    ctx = get_user_info()
+
+    endpoint = f"{JIVAS_URL}/walker/update_action"
+
+    if ctx["token"]:
+        try:
+            headers = {"Authorization": "Bearer " + ctx["token"]}
+            json = {
+                "agent_id": agent_id,
+                "action_id": action_id,
+                "action_data": action_data,
+            }
+
+            # call interact
+            response = requests.post(endpoint, json=json, headers=headers)
+
+            if response.status_code == 200:
+                result = (response.json()).get("reports", [])
+                if len(result) > 0:
+                    return result[0]
+                else:
+                    return {}
+
+            if response.status_code == 401:
+                st.session_state.EXPIRATION = ""
+                return {}
+
+        except Exception as e:
+            st.session_state.EXPIRATION = ""
+            print("Exception occurred: ", e)
+
+    return {}
+
+
+def call_action_walker_exec(
+    agent_id: str,
+    module_root: str,
+    walker: str,
+    args: Optional[Dict] = None,
+    files: Optional[List] = None,
+    headers: Optional[Dict] = None,
+) -> list:
+    """Call the API to execute a walker action for a given agent."""
+
+    ctx = get_user_info()
+
+    endpoint = f"{JIVAS_URL}/walker/action/walker"
+
+    if ctx.get("token"):
+        try:
+            headers = headers if headers else {}
+            headers["Authorization"] = "Bearer " + ctx["token"]
+
+            # Create form data
+            data = {"agent_id": agent_id, "module_root": module_root, "walker": walker}
+
+            if args:
+                data["args"] = json.dumps(args)
+
+            if files:
+                file_list = []
+
+                for file in files:
+                    file_list.append(("attachments", (file[0], file[1], file[2])))
+
+            # Dispatch request
+            response = requests.post(
+                url=endpoint, headers=headers, data=data, files=file_list
+            )
+
+            if response.status_code == 200:
+                result = response.json()
+                return result if result else []
+
+            if response.status_code == 401:
+                st.session_state.EXPIRATION = ""
+                return []
+
+        except Exception as e:
+            st.session_state.EXPIRATION = ""
+            st.write(e)
+
+    return []
+
+
+def call_import_agent(
+    descriptor: str,
+    headers: Optional[Dict] = None,
+) -> list:
+    """Call the API to import an agent."""
+
+    ctx = get_user_info()
+
+    endpoint = f"{JIVAS_URL}/walker/import_agent"
+
+    if ctx.get("token"):
+        try:
+            headers = headers if headers else {}
+            headers["Authorization"] = "Bearer " + ctx["token"]
+            headers["Content-Type"] = "application/json"
+            headers["Accept"] = "application/json"
+
+            data = {"descriptor": descriptor}
+
+            # Dispatch request
+            response = requests.post(endpoint, headers=headers, json=data)
+
+            if response.status_code == 200:
+                result = response.json()
+                return result if result else []
+
+            if response.status_code == 401:
+                st.session_state.EXPIRATION = ""
+                return []
+
+        except Exception as e:
+            st.session_state.EXPIRATION = ""
+            st.write(e)
+
+    return []
+
+
+def get_user_info() -> dict:
+    """Get user information from the session state."""
+    return {
+        "root_id": st.session_state.ROOT_ID,
+        "token": st.session_state.TOKEN,
+        "expiration": st.session_state.EXPIRATION,
+    }
+
+
+def decode_base64_image(base64_string: str) -> Image:
+    """Decode a base64 string into an image."""
+    # Decode the base64 string
+    image_data = base64.b64decode(base64_string)
+
+    # Create a bytes buffer from the decoded bytes
+    image_buffer = BytesIO(image_data)
+
+    # Open the image using PIL
+    return Image.open(image_buffer)
+
+
+class LongStringDumper(yaml.SafeDumper):
+    """Custom YAML dumper to handle long strings."""
+
+    def represent_scalar(
+        self, tag: str, value: str, style: Optional[str] = None
+    ) -> yaml.ScalarNode:
+        """Represent scalar values, using block style for long strings."""
+        # Replace any escape sequences to format the output as desired
+        if (
+            len(value) > 150 or "\n" in value
+        ):  # Adjust the threshold for long strings as needed
+            style = "|"
+            # converts all newline escapes to actual representations
+            value = "\n".join([line.rstrip() for line in value.split("\n")])
+        else:
+            # converts all newline escapes to actual representations
+            value = "\n".join([line.rstrip() for line in value.split("\n")]).rstrip()
+
+        return super().represent_scalar(tag, value, style)
+
+
+def jac_yaml_dumper(
+    data: Any,
+    indent: int = 2,
+    default_flow_style: bool = False,
+    allow_unicode: bool = True,
+    sort_keys: bool = False,
+) -> str:
+    """Dumps YAML data using LongStringDumper with customizable options."""
+    return yaml.dump(
+        data,
+        Dumper=LongStringDumper,
+        indent=indent,
+        default_flow_style=default_flow_style,
+        allow_unicode=allow_unicode,
+        sort_keys=sort_keys,
+    )