erdo 0.1.31__py3-none-any.whl

erdo/sync/sync.py

@@ -0,0 +1,327 @@
+"""Main sync functionality for syncing agents to the backend."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .client import SyncClient
+from .extractor import (
+    extract_agent_from_instance,
+    extract_agents_from_file,
+)
+
+
+@dataclass
+class SyncResult:
+    """Result of a sync operation."""
+
+    success: bool
+    bot_id: Optional[str] = None
+    bot_name: Optional[str] = None
+    error: Optional[str] = None
+
+    def __str__(self) -> str:
+        if self.success:
+            return f"✅ Successfully synced {self.bot_name} (ID: {self.bot_id})"
+        else:
+            return f"❌ Failed to sync {self.bot_name}: {self.error}"
+
+
+class Sync:
+    """Main sync class for syncing agents."""
+
+    def __init__(
+        self,
+        agent: Optional[Any] = None,
+        endpoint: Optional[str] = None,
+        auth_token: Optional[str] = None,
+    ):
+        """Initialize sync and optionally sync an agent immediately.
+
+        Args:
+            agent: Optional Agent instance to sync immediately
+            endpoint: API endpoint URL. If not provided, uses config.
+            auth_token: Authentication token. If not provided, uses config.
+        """
+        self.client = SyncClient(endpoint=endpoint, auth_token=auth_token)
+        self.result = None
+
+        # If an agent is provided, sync it immediately
+        if agent:
+            self.result = self.sync_agent(agent)
+
+    def sync_agent(
+        self, agent: Any, source_file_path: Optional[str] = None
+    ) -> SyncResult:
+        """Sync a single agent to the backend.
+
+        Args:
+            agent: Agent instance to sync
+            source_file_path: Optional path to the source file for better extraction
+
+        Returns:
+            SyncResult with the outcome of the sync operation
+        """
+        try:
+            # Extract agent data
+            agent_data = extract_agent_from_instance(agent, source_file_path)
+
+            # Convert to API format
+            bot_request = self._convert_to_api_format(agent_data)
+
+            # Send to backend
+            bot_id = self.client.upsert_bot(bot_request)
+
+            return SyncResult(success=True, bot_id=bot_id, bot_name=agent.name)
+
+        except Exception as e:
+            return SyncResult(
+                success=False, bot_name=getattr(agent, "name", "Unknown"), error=str(e)
+            )
+
+    @classmethod
+    def from_file(
+        cls,
+        file_path: str,
+        endpoint: Optional[str] = None,
+        auth_token: Optional[str] = None,
+    ) -> List[SyncResult]:
+        """Sync agents from a Python file.
+
+        Args:
+            file_path: Path to the Python file containing agents
+            endpoint: API endpoint URL. If not provided, uses config.
+            auth_token: Authentication token. If not provided, uses config.
+
+        Returns:
+            List of SyncResult objects for each agent found
+        """
+        sync = cls(endpoint=endpoint, auth_token=auth_token)
+
+        try:
+            # Extract agents from file
+            agent_data = extract_agents_from_file(file_path)
+
+            # Handle single agent or list of agents
+            if isinstance(agent_data, list):
+                results = []
+                for data in agent_data:
+                    result = sync._sync_agent_data(data)
+                    results.append(result)
+                return results
+            else:
+                result = sync._sync_agent_data(agent_data)
+                return [result]
+
+        except Exception as e:
+            return [
+                SyncResult(
+                    success=False, error=f"Failed to extract agents from file: {e}"
+                )
+            ]
+
+    @classmethod
+    def from_directory(
+        cls,
+        directory_path: str = ".",
+        endpoint: Optional[str] = None,
+        auth_token: Optional[str] = None,
+    ) -> List[SyncResult]:
+        """Sync all agents from a directory.
+
+        Args:
+            directory_path: Path to directory containing agent files (default: current directory)
+            endpoint: API endpoint URL. If not provided, uses config.
+            auth_token: Authentication token. If not provided, uses config.
+
+        Returns:
+            List of SyncResult objects for each agent found
+        """
+        results = []
+
+        directory = Path(directory_path)
+
+        # Check for __init__.py with agents first
+        init_file = directory / "__init__.py"
+        if init_file.exists():
+            try:
+                init_results = cls.from_file(
+                    str(init_file), endpoint=endpoint, auth_token=auth_token
+                )
+                if init_results:
+                    return init_results
+            except Exception:
+                pass  # Fall back to directory scan
+
+        # Scan directory for agent files
+        for py_file in directory.glob("**/*.py"):
+            # Skip common non-agent files
+            if any(
+                skip in str(py_file)
+                for skip in ["__pycache__", "test_", "_test.py", ".venv", "venv"]
+            ):
+                continue
+
+            try:
+                # Check if file has agents
+                with open(py_file, "r") as f:
+                    content = f.read()
+                    if "agents = [" not in content:
+                        continue
+
+                # Try to sync agents from this file
+                file_results = cls.from_file(
+                    str(py_file), endpoint=endpoint, auth_token=auth_token
+                )
+                results.extend(file_results)
+
+            except Exception as e:
+                results.append(
+                    SyncResult(success=False, error=f"Failed to process {py_file}: {e}")
+                )
+
+        return results
+
+    def _sync_agent_data(self, agent_data: Dict[str, Any]) -> SyncResult:
+        """Sync extracted agent data to the backend.
+
+        Args:
+            agent_data: Extracted agent data dictionary
+
+        Returns:
+            SyncResult with the outcome of the sync operation
+        """
+        try:
+            # Convert to API format
+            bot_request = self._convert_to_api_format(agent_data)
+
+            # Send to backend
+            bot_id = self.client.upsert_bot(bot_request)
+
+            return SyncResult(
+                success=True, bot_id=bot_id, bot_name=agent_data["bot"]["name"]
+            )
+
+        except Exception as e:
+            return SyncResult(
+                success=False,
+                bot_name=agent_data.get("bot", {}).get("name", "Unknown"),
+                error=str(e),
+            )
+
+    def _convert_to_api_format(self, agent_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert extracted agent data to API format.
+
+        Args:
+            agent_data: Extracted agent data
+
+        Returns:
+            Bot request in API format
+        """
+        # Override source to "user" as per Go implementation
+        bot_data = agent_data["bot"].copy()
+        bot_data["source"] = "user"
+
+        # Convert steps to API format
+        api_steps = []
+        for step_with_handlers in agent_data.get("steps", []):
+            api_step = self._convert_step_to_api(step_with_handlers)
+            api_steps.append(api_step)
+
+        # Build the API request
+        # Convert parameter_definitions to dicts if they're objects
+        param_defs = agent_data.get("parameter_definitions", [])
+        if param_defs and hasattr(param_defs[0], "to_dict"):
+            param_defs = [
+                pd.to_dict() if hasattr(pd, "to_dict") else pd for pd in param_defs
+            ]
+
+        bot_request = {
+            "bot": bot_data,
+            "steps": api_steps,
+            "source": "user",
+            "parameter_definitions": param_defs,
+        }
+
+        # Include action result schemas if present
+        if "action_result_schemas" in agent_data:
+            bot_request["action_result_schemas"] = agent_data["action_result_schemas"]
+
+        return bot_request
+
+    def _convert_step_to_api(
+        self, step_with_handlers: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Convert StepWithHandlers to API format.
+
+        Args:
+            step_with_handlers: Step with handlers dictionary
+
+        Returns:
+            Step in API format
+        """
+        # Ensure parameters is not None
+        step = step_with_handlers["step"].copy()
+        if step.get("parameters") is None:
+            step["parameters"] = {}
+
+        # Convert result handlers
+        api_handlers = []
+        for handler in step_with_handlers.get("result_handlers", []):
+            api_handler = handler.copy()
+
+            # Convert nested steps in handler
+            if "steps" in api_handler:
+                api_handler_steps = []
+                for nested_step in api_handler["steps"]:
+                    api_nested = self._convert_step_to_api(nested_step)
+                    api_handler_steps.append(api_nested)
+                api_handler["steps"] = api_handler_steps
+
+            api_handlers.append(api_handler)
+
+        return {"step": step, "result_handlers": api_handlers}
+
+
+# Convenience functions
+def sync_agent(
+    agent: Any, source_file_path: Optional[str] = None, **kwargs
+) -> SyncResult:
+    """Sync a single agent to the backend.
+
+    Args:
+        agent: Agent instance to sync
+        source_file_path: Optional path to the source file
+        **kwargs: Additional arguments (endpoint, auth_token)
+
+    Returns:
+        SyncResult with the outcome of the sync operation
+    """
+    sync = Sync(endpoint=kwargs.get("endpoint"), auth_token=kwargs.get("auth_token"))
+    return sync.sync_agent(agent, source_file_path)
+
+
+def sync_agents_from_file(file_path: str, **kwargs) -> List[SyncResult]:
+    """Sync agents from a Python file.
+
+    Args:
+        file_path: Path to the Python file containing agents
+        **kwargs: Additional arguments (endpoint, auth_token)
+
+    Returns:
+        List of SyncResult objects
+    """
+    return Sync.from_file(file_path, **kwargs)
+
+
+def sync_agents_from_directory(directory_path: str = ".", **kwargs) -> List[SyncResult]:
+    """Sync all agents from a directory.
+
+    Args:
+        directory_path: Path to directory containing agent files
+        **kwargs: Additional arguments (endpoint, auth_token)
+
+    Returns:
+        List of SyncResult objects
+    """
+    return Sync.from_directory(directory_path, **kwargs)

erdo/template.py

@@ -0,0 +1,136 @@
+"""
+Template string handling for export/import roundtrip compatibility.
+
+This module provides utilities for handling template strings during the
+export/import roundtrip process. Template strings are Go template expressions
+that can't be executed as Python, so they need special handling.
+"""
+
+from typing import TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from erdo.types import Prompt
+
+
+class TemplateString:
+    """
+    A wrapper class for template strings during export/import roundtrip.
+
+    This class represents a Go template string (like {{.Data.field}}) in a way
+    that can be executed as Python code and then converted back to the original
+    template string during import.
+
+    It implements various duck-typing methods to be compatible with Pydantic
+    validation while preserving the template content for later extraction.
+    """
+
+    template: str
+
+    def __init__(self, template: Union[str, "Prompt"]):
+        """
+        Initialize a TemplateString with the template content.
+
+        Args:
+            template: The template string content (e.g., "{{.Data.field}}") or a Prompt object
+        """
+        # Convert Prompt objects to strings, ensure template is always a string
+        if hasattr(template, "content"):
+            # This is a Prompt object
+            self.template = str(template)
+        else:
+            self.template = str(template)
+
+    def __str__(self) -> str:
+        """Return the template string for display purposes."""
+        return self.template
+
+    def __repr__(self) -> str:
+        """Return a representation of the TemplateString."""
+        return f"TemplateString({self.template!r})"
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality with another TemplateString."""
+        if isinstance(other, TemplateString):
+            return self.template == other.template
+        return False
+
+    def __hash__(self) -> int:
+        """Make TemplateString hashable."""
+        return hash(self.template)
+
+    # Duck typing methods to make it behave like a string for Pydantic validation
+    def __len__(self) -> int:
+        """Return length to behave like a string."""
+        return len(self.template)
+
+    def __contains__(self, item) -> bool:
+        """Support 'in' operator to behave like a string."""
+        return item in self.template
+
+    def __getitem__(self, key):
+        """Support indexing to behave like a string."""
+        return self.template[key]
+
+    def __iter__(self):
+        """Support iteration to behave like a string."""
+        return iter(self.template)
+
+    # List-like methods for cases where template strings represent arrays
+    def __getstate__(self):
+        """Support pickling."""
+        return {"template": self.template}
+
+    def __setstate__(self, state):
+        """Support unpickling."""
+        self.template = state["template"]
+
+    # Additional methods to help with Pydantic validation
+    @classmethod
+    def __get_validators__(cls):
+        """Pydantic v1 compatibility."""
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, v, *args, **kwargs):
+        """Validate that the value is a string, TemplateString, or basic type."""
+        if isinstance(v, cls):
+            return v
+        # Allow strings and basic types that can be converted to strings
+        if isinstance(v, (str, int, float, bool)):
+            return v
+        # Allow Prompt objects (they have __str__ method and content attribute)
+        if hasattr(v, "__str__") and hasattr(v, "content"):
+            # This is likely a Prompt object
+            return str(v)
+        # Reject functions, lambdas, and other complex types
+        if callable(v):
+            raise ValueError(
+                f"Template fields cannot accept callable objects like {type(v).__name__}"
+            )
+        # For other types, try to convert to string
+        try:
+            str(v)
+            return v
+        except Exception:
+            raise ValueError(
+                f"Template fields cannot accept objects of type {type(v).__name__}"
+            )
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type, handler):
+        """Pydantic v2 compatibility."""
+        from pydantic_core import core_schema
+
+        return core_schema.no_info_plain_validator_function(cls.validate)
+
+    def to_template_string(self) -> str:
+        """
+        Convert back to the original template string format.
+
+        This is used during the import process to convert the TemplateString
+        object back to the raw template string.
+
+        Returns:
+            The original template string
+        """
+        return self.template

erdo/test/__init__.py

@@ -0,0 +1,41 @@
+"""Test evaluation helpers for erdo agent testing.
+
+This module provides helper functions for writing clean assertions when testing agents.
+Use these in regular Python scripts - no pytest needed!
+
+Example:
+    >>> from erdo import invoke
+    >>> from erdo.test import text_contains, json_path_equals
+    >>>
+    >>> # Test in a regular Python script
+    >>> response = invoke("my_agent", messages=[...], mode="replay")
+    >>> assert text_contains(response.result, "expected text")
+    >>> assert json_path_equals(response.result, "status", "success")
+    >>>
+    >>> # Or use via CLI
+    >>> # ./erdo invoke my_agent --message "test" --mode replay
+"""
+
+from .evaluate import (
+    has_dataset,
+    json_path_equals,
+    json_path_exists,
+    text_contains,
+    text_equals,
+    text_matches,
+)
+from .runner import discover_tests
+from .runner import main as run_tests
+from .runner import run_tests_parallel
+
+__all__ = [
+    "text_contains",
+    "text_equals",
+    "text_matches",
+    "json_path_equals",
+    "json_path_exists",
+    "has_dataset",
+    "run_tests",
+    "run_tests_parallel",
+    "discover_tests",
+]