erdo 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

erdo/invoke/invoke.py

@@ -0,0 +1,244 @@
+"""Main invoke functionality for running agents via the orchestrator."""
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+from .client import InvokeClient
+
+
+@dataclass
+class InvokeResult:
+    """Result from a bot invocation."""
+
+    success: bool
+    bot_id: Optional[str] = None
+    invocation_id: Optional[str] = None
+    result: Optional[Any] = None
+    error: Optional[str] = None
+    events: List[Dict[str, Any]] = field(default_factory=list)
+
+    def __str__(self) -> str:
+        if self.success:
+            return f"✅ Invocation successful (ID: {self.invocation_id})"
+        else:
+            return f"❌ Invocation failed: {self.error}"
+
+    def get_final_result(self) -> Optional[Any]:
+        """Get the final result from the invocation."""
+        return self.result
+
+    def get_all_events(self) -> List[Dict[str, Any]]:
+        """Get all events from the invocation."""
+        return self.events
+
+
+class Invoke:
+    """Main class for invoking agents."""
+
+    def __init__(
+        self,
+        agent: Optional[Any] = None,
+        parameters: Optional[Dict[str, Any]] = None,
+        dataset_ids: Optional[list] = None,
+        endpoint: Optional[str] = None,
+        auth_token: Optional[str] = None,
+        stream: bool = False,
+        print_events: bool = False,
+    ):
+        """Initialize and optionally invoke an agent immediately.
+
+        Args:
+            agent: Optional Agent instance to invoke immediately
+            parameters: Parameters to pass to the agent
+            dataset_ids: Dataset IDs to include
+            endpoint: API endpoint URL
+            auth_token: Authentication token
+            stream: Whether to stream events
+            print_events: Whether to print events as they arrive
+        """
+        self.client = InvokeClient(endpoint=endpoint, auth_token=auth_token)
+        self.print_events = print_events
+        self.result = None
+
+        # If an agent is provided, invoke it immediately
+        if agent:
+            bot_key = getattr(agent, "key", None)
+            if not bot_key:
+                raise ValueError("Agent must have a 'key' attribute for invocation")
+
+            self.result = self.invoke_by_key(
+                bot_key, parameters=parameters, dataset_ids=dataset_ids, stream=stream
+            )
+
+    def invoke_agent(
+        self,
+        agent: Any,
+        parameters: Optional[Dict[str, Any]] = None,
+        dataset_ids: Optional[list] = None,
+        stream: bool = False,
+    ) -> InvokeResult:
+        """Invoke an agent instance.
+
+        Args:
+            agent: Agent instance with a 'key' attribute
+            parameters: Parameters to pass to the agent
+            dataset_ids: Dataset IDs to include
+            stream: Whether to stream events
+
+        Returns:
+            InvokeResult with the outcome
+        """
+        bot_key = getattr(agent, "key", None)
+        if not bot_key:
+            raise ValueError("Agent must have a 'key' attribute for invocation")
+
+        return self.invoke_by_key(bot_key, parameters, dataset_ids, stream)
+
+    def invoke_by_key(
+        self,
+        bot_key: str,
+        parameters: Optional[Dict[str, Any]] = None,
+        dataset_ids: Optional[list] = None,
+        stream: bool = False,
+    ) -> InvokeResult:
+        """Invoke a bot by its key.
+
+        Args:
+            bot_key: Bot key (e.g., "erdo.data-analyzer")
+            parameters: Parameters to pass to the bot
+            dataset_ids: Dataset IDs to include
+            stream: Whether to stream events
+
+        Returns:
+            InvokeResult with the outcome
+        """
+        try:
+            response = self.client.invoke_bot(
+                bot_key, parameters=parameters, dataset_ids=dataset_ids, stream=stream
+            )
+
+            if stream:
+                # Process SSE events
+                events = []
+                final_result = None
+                invocation_id = None
+
+                # Type guard: response should be SSEClient when stream=True
+                if not isinstance(response, dict):
+                    for event in response.events():
+                        events.append(event)
+
+                        if self.print_events:
+                            self._print_event(event)
+
+                        # Extract invocation ID from events
+                        if "invocation_id" in event:
+                            invocation_id = event["invocation_id"]
+
+                        # Check for final result
+                        if event.get("type") == "invocation_completed":
+                            final_result = event.get("result")
+                        elif event.get("type") == "result":
+                            final_result = event.get("data")
+
+                return InvokeResult(
+                    success=True,
+                    bot_id=bot_key,
+                    invocation_id=invocation_id,
+                    result=final_result,
+                    events=events,
+                )
+            else:
+                # Non-streaming response - response is a dict
+                response_dict = response if isinstance(response, dict) else {}
+                return InvokeResult(
+                    success=True,
+                    bot_id=bot_key,
+                    result=response_dict,
+                    events=[response_dict],
+                )
+
+        except Exception as e:
+            return InvokeResult(success=False, bot_id=bot_key, error=str(e))
+
+    def _print_event(self, event: Dict[str, Any]):
+        """Print an event in a readable format."""
+        event_type = event.get("type", "unknown")
+
+        if event_type == "step_started":
+            step_name = event.get("step_name", "Unknown step")
+            print(f"🔄 Step started: {step_name}")
+        elif event_type == "step_completed":
+            step_name = event.get("step_name", "Unknown step")
+            print(f"✅ Step completed: {step_name}")
+        elif event_type == "llm_chunk":
+            content = event.get("content", "")
+            print(content, end="", flush=True)
+        elif event_type == "invocation_completed":
+            print("\n✨ Invocation completed")
+        elif event_type == "error":
+            error = event.get("error", "Unknown error")
+            print(f"❌ Error: {error}")
+        else:
+            # Generic event printing
+            print(f"📡 {event_type}: {json.dumps(event, indent=2)}")
+
+
+# Convenience functions
+def invoke_agent(
+    agent: Any,
+    parameters: Optional[Dict[str, Any]] = None,
+    dataset_ids: Optional[list] = None,
+    stream: bool = False,
+    print_events: bool = False,
+    **kwargs,
+) -> InvokeResult:
+    """Invoke an agent instance.
+
+    Args:
+        agent: Agent instance with a 'key' attribute
+        parameters: Parameters to pass to the agent
+        dataset_ids: Dataset IDs to include
+        stream: Whether to stream events
+        print_events: Whether to print events
+        **kwargs: Additional arguments (endpoint, auth_token)
+
+    Returns:
+        InvokeResult with the outcome
+    """
+    invoke = Invoke(
+        endpoint=kwargs.get("endpoint"),
+        auth_token=kwargs.get("auth_token"),
+        print_events=print_events,
+    )
+    return invoke.invoke_agent(agent, parameters, dataset_ids, stream)
+
+
+def invoke_by_key(
+    bot_key: str,
+    parameters: Optional[Dict[str, Any]] = None,
+    dataset_ids: Optional[list] = None,
+    stream: bool = False,
+    print_events: bool = False,
+    **kwargs,
+) -> InvokeResult:
+    """Invoke a bot by its key.
+
+    Args:
+        bot_key: Bot key (e.g., "erdo.data-analyzer")
+        parameters: Parameters to pass to the bot
+        dataset_ids: Dataset IDs to include
+        stream: Whether to stream events
+        print_events: Whether to print events
+        **kwargs: Additional arguments (endpoint, auth_token)
+
+    Returns:
+        InvokeResult with the outcome
+    """
+    invoke = Invoke(
+        endpoint=kwargs.get("endpoint"),
+        auth_token=kwargs.get("auth_token"),
+        print_events=print_events,
+    )
+    return invoke.invoke_by_key(bot_key, parameters, dataset_ids, stream)

erdo/sync/__init__.py

@@ -0,0 +1,17 @@
+"""Sync module for Erdo SDK - sync agents to the backend."""
+
+from .sync import (
+    Sync,
+    SyncResult,
+    sync_agent,
+    sync_agents_from_directory,
+    sync_agents_from_file,
+)
+
+__all__ = [
+    "Sync",
+    "SyncResult",
+    "sync_agent",
+    "sync_agents_from_file",
+    "sync_agents_from_directory",
+]

erdo/sync/client.py

@@ -0,0 +1,95 @@
+"""API client for syncing agents to the backend."""
+
+import json
+from typing import Any, Dict, Optional
+
+import requests
+
+from ..config import get_config
+from .extractor import TemplateStringEncoder
+
+
+class SyncClient:
+    """Client for syncing agents to the Erdo backend."""
+
+    def __init__(
+        self, endpoint: Optional[str] = None, auth_token: Optional[str] = None
+    ):
+        """Initialize the sync client.
+
+        Args:
+            endpoint: API endpoint URL. If not provided, uses config.
+            auth_token: Authentication token. If not provided, uses config.
+        """
+        config = get_config()
+        self.endpoint = endpoint or config.endpoint
+        self.auth_token = auth_token or config.auth_token
+
+    def upsert_bot(self, bot_request: Dict[str, Any]) -> str:
+        """Upsert a bot to the backend.
+
+        Args:
+            bot_request: The bot request data containing bot info, steps, etc.
+
+        Returns:
+            The bot ID of the upserted bot.
+
+        Raises:
+            requests.RequestException: If the API request fails.
+            ValueError: If the response is invalid.
+        """
+        url = f"{self.endpoint}/bot/upsert"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.auth_token}",
+        }
+
+        # Use custom encoder to handle special types
+        json_data = json.dumps(bot_request, cls=TemplateStringEncoder)
+        response = requests.post(url, data=json_data, headers=headers)
+
+        if response.status_code != 200:
+            error_msg = f"API request failed with status {response.status_code}"
+            try:
+                error_details = response.text
+                error_msg = f"{error_msg}: {error_details}"
+            except Exception:
+                pass
+            raise requests.RequestException(error_msg)
+
+        try:
+            result = response.json()
+            return result.get("bot_id", "")
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Failed to decode response: {e}")
+
+    def sync_test(self, test_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Sync a test to the backend.
+
+        Args:
+            test_data: The test data to sync.
+
+        Returns:
+            The response from the API.
+
+        Raises:
+            requests.RequestException: If the API request fails.
+        """
+        url = f"{self.endpoint}/test/sync"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.auth_token}",
+        }
+
+        response = requests.post(url, json=test_data, headers=headers)
+
+        if response.status_code != 200:
+            error_msg = f"API request failed with status {response.status_code}"
+            try:
+                error_details = response.text
+                error_msg = f"{error_msg}: {error_details}"
+            except Exception:
+                pass
+            raise requests.RequestException(error_msg)
+
+        return response.json()