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

jvcli/client/lib/utils.py

@@ -1,312 +0,0 @@
-"""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_BASE_URL = os.environ.get("JIVAS_BASE_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_api(
-    endpoint: str,
-    method: str = "POST",
-    headers: Optional[Dict] = None,
-    json_data: Optional[Dict] = None,
-    files: Optional[List] = None,
-    data: Optional[Dict] = None,
-    timeout: int = 10,
-) -> Optional[requests.Response]:
-    """Generic function to call an API endpoint."""
-
-    if not endpoint.startswith("http"):
-        endpoint = f"{JIVAS_BASE_URL}/{endpoint}"
-
-    ctx = get_user_info()  # Assumes a function that fetches user info
-
-    if ctx.get("token"):
-        try:
-            headers = headers or {}
-            headers["Authorization"] = f"Bearer {ctx['token']}"
-
-            response = requests.request(
-                method=method,
-                url=endpoint,
-                headers=headers,
-                json=json_data,
-                files=files,
-                data=data,
-                timeout=timeout,
-            )
-
-            if response.status_code == 401:
-                st.session_state.EXPIRATION = ""
-                return None
-
-            return response
-
-        except Exception as e:
-            st.session_state.EXPIRATION = ""
-            st.write(e)
-
-    return None
-
-
-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."""
-
-    endpoint = f"{JIVAS_BASE_URL}/action/walker"
-
-    # Create form data
-    data = {"agent_id": agent_id, "module_root": module_root, "walker": walker}
-
-    if args:
-        data["args"] = json.dumps(args)
-
-    file_list = []
-
-    if files:
-        for file in files:
-            file_list.append(("attachments", (file[0], file[1], file[2])))
-
-    response = call_api(endpoint, headers=headers, data=data, files=file_list)
-
-    if response is not None and response.status_code == 200:
-        result = response.json()
-        return result if result else []
-
-    return []
-
-
-def call_healthcheck(agent_id: str, headers: Optional[Dict] = None) -> Optional[dict]:
-    """Call the API to check the health of an agent."""
-    endpoint = "walker/healthcheck"
-    json_data = {"agent_id": agent_id}
-    response = call_api(endpoint, headers=headers, json_data=json_data)
-
-    if response is not None and response.status_code in [200, 501, 503]:
-        result = response.json()
-        reports = result.get("reports", [])
-        return reports[0] if reports else {}
-
-    return {}
-
-
-def call_list_agents(headers: Optional[Dict] = None) -> list:
-    """Call the API to list agents."""
-    endpoint = "walker/list_agents"
-    json_data = {"reporting": True}
-    response = call_api(endpoint, headers=headers, json_data=json_data)
-
-    if response is not None and response.status_code == 200:
-        result = response.json()
-        reports = result.get("reports", [])
-        return [
-            {"id": agent.get("id", ""), "label": agent.get("name", "")}
-            for agent in reports
-        ]
-
-    return []
-
-
-def call_get_agent(agent_id: str, headers: Optional[Dict] = None) -> dict:
-    """Call the API to get details of a specific agent."""
-    endpoint = "walker/get_agent"
-    json_data = {"agent_id": agent_id}
-    response = call_api(endpoint, headers=headers, json_data=json_data)
-
-    if response is not None and response.status_code == 200:
-        result = response.json()
-        reports = result.get("reports", [])
-        return reports[0] if reports else {}
-
-    return {}
-
-
-def call_list_actions(agent_id: str, headers: Optional[Dict] = None) -> list:
-    """Call the API to list actions for a given agent."""
-    endpoint = "walker/list_actions"
-    json_data = {"agent_id": agent_id}
-    response = call_api(endpoint, headers=headers, json_data=json_data)
-
-    if response is not None and response.status_code == 200:
-        result = response.json()
-        reports = result.get("reports", [])
-        return reports[0] if reports else []
-
-    return []
-
-
-def call_get_action(
-    agent_id: str, action_id: str, headers: Optional[Dict] = None
-) -> dict:
-    """Call the API to get a specific action for a given agent."""
-    endpoint = "walker/get_action"
-    json_data = {"agent_id": agent_id, "action_id": action_id}
-    response = call_api(endpoint, headers=headers, json_data=json_data)
-
-    if response is not None and response.status_code == 200:
-        result = response.json()
-        reports = result.get("reports", [])
-        return reports[0] if reports else {}
-
-    return {}
-
-
-def call_update_action(
-    agent_id: str, action_id: str, action_data: dict, headers: Optional[Dict] = None
-) -> dict:
-    """Call the API to update a specific action for a given agent."""
-    endpoint = "walker/update_action"
-    json_data = {
-        "agent_id": agent_id,
-        "action_id": action_id,
-        "action_data": action_data,
-    }
-    response = call_api(endpoint, headers=headers, json_data=json_data)
-
-    if response is not None and response.status_code == 200:
-        result = response.json()
-        reports = result.get("reports", [])
-        return reports[0] if reports else {}
-
-    return {}
-
-
-def call_update_agent(
-    agent_id: str, agent_data: dict, headers: Optional[Dict] = None
-) -> dict:
-    """Call the API to update a specific agent."""
-    endpoint = "walker/update_agent"
-    json_data = {"agent_id": agent_id, "agent_data": agent_data}
-    response = call_api(endpoint, headers=headers, json_data=json_data)
-
-    if response is not None and response.status_code == 200:
-        result = response.json()
-        reports = result.get("reports", [])
-        return reports[0] if reports else {}
-
-    return {}
-
-
-def call_import_agent(descriptor: str, headers: Optional[Dict] = None) -> list:
-    """Call the API to import an agent."""
-    endpoint = "walker/import_agent"
-    json_data = {"descriptor": descriptor}
-    response = call_api(endpoint, headers=headers, json_data=json_data)
-
-    if response is not None and response.status_code == 200:
-        result = response.json()
-        reports = result.get("reports", [])
-        return reports[0] if reports else []
-
-    return []
-
-
-def get_user_info() -> dict:
-    """Get user information from the session state."""
-    return {
-        "root_id": st.session_state.get("ROOT_ID", ""),
-        "token": st.session_state.get("TOKEN", ""),
-        "expiration": st.session_state.get("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,
-    )

jvcli/client/lib/widgets.py

@@ -1,295 +0,0 @@
-"""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)
-
-    def update_action() -> None:
-        st.session_state[model_key]
-        call_update_action(
-            agent_id=agent_id,
-            action_id=action_id,
-            action_data=st.session_state[model_key],
-        )
-
-    current_state = st.session_state[model_key]["enabled"]
-    new_state = st.checkbox(
-        "Enabled",
-        key="enabled",
-        value=current_state,
-    )
-
-    if new_state != current_state:
-        st.session_state[model_key]["enabled"] = new_state
-        update_action()
-        st.rerun()
-
-    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,
-    hidden: Optional[list] = None,
-    masked: Optional[list] = None,
-) -> None:
-    """Render the app controls for a given agent and action."""
-    if hidden is None:
-        hidden = []
-    if masked is None:
-        masked = []
-
-    # Generate a dynamic key for the session state using the action_id
-    model_key = f"model_{agent_id}_{action_id}"
-
-    # Combine default masked keys with additional keys specified in 'masked'
-    default_masked_keys = [
-        "password",
-        "token",
-        "api_key",
-        "key",
-        "secret",
-        "secret_key",
-    ]
-    all_masked_keys = set(default_masked_keys + masked)
-
-    # Recursive function to handle nested dictionaries
-    def render_fields(item_key: str, value: Any, parent_key: str = "") -> None:
-        """Render fields based on their type."""
-
-        # Skip rendering if the field is in the hidden list
-        if item_key in hidden:
-            return
-
-        field_type = type(value)
-        label = snake_to_title(item_key)  # Convert item_key to Title Case
-
-        # Special case for masked fields to render as a password field
-        if item_key.lower() in all_masked_keys:
-            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, sort_keys=False),
-                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, sort_keys=False),
-                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:  # pragma: no cover, don't know how to test this yet 😅
-        """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:  # pragma: no cover, don't know how to test this yet 😅
-        """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

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