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

erdo/bot_permissions.py

@@ -0,0 +1,266 @@
+"""Bot permission management for the Erdo SDK."""
+
+import os
+from typing import Any, Dict, Optional
+
+import requests
+
+
+class BotPermissions:
+    """Manage RBAC permissions for bots."""
+
+    def __init__(self, base_url: Optional[str] = None):
+        """Initialize bot permissions manager.
+
+        Args:
+            base_url: Erdo server base URL. Defaults to ERDO_SERVER_URL env var or localhost:4000
+        """
+        self.base_url = base_url or os.getenv(
+            "ERDO_SERVER_URL", "http://localhost:4000"
+        )
+        self.session = requests.Session()
+
+        # Set auth token if available
+        token = os.getenv("ERDO_AUTH_TOKEN")
+        if token:
+            self.session.headers.update({"Authorization": f"Bearer {token}"})
+
+    def set_public_access(
+        self, bot_id: str, is_public: bool = True, permission_level: str = "view"
+    ) -> bool:
+        """Set public access for a bot.
+
+        Args:
+            bot_id: Bot ID
+            is_public: Whether to make the bot public
+            permission_level: Permission level for public access (view, comment, edit, admin)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            url = f"{self.base_url}/rbac/bot/{bot_id}/public"
+            data = {
+                "isPublic": is_public,
+                "level": permission_level if is_public else None,
+            }
+            response = self.session.put(url, json=data)
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Error setting public access: {e}")
+            return False
+
+    def set_user_permission(
+        self, bot_id: str, user_id: str, permission_level: str
+    ) -> bool:
+        """Set permissions for a specific user.
+
+        Args:
+            bot_id: Bot ID
+            user_id: User ID
+            permission_level: Permission level (view, comment, edit, admin, owner)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            url = f"{self.base_url}/rbac/bot/{bot_id}/user/{user_id}"
+            data = {"level": permission_level}
+            response = self.session.put(url, json=data)
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Error setting user permission: {e}")
+            return False
+
+    def set_org_permission(
+        self, bot_id: str, org_id: str, permission_level: str
+    ) -> bool:
+        """Set permissions for an organization.
+
+        Args:
+            bot_id: Bot ID
+            org_id: Organization ID
+            permission_level: Permission level (view, comment, edit, admin, owner)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            url = f"{self.base_url}/rbac/bot/{bot_id}/org/{org_id}"
+            data = {"level": permission_level}
+            response = self.session.put(url, json=data)
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Error setting org permission: {e}")
+            return False
+
+    def remove_user_permission(self, bot_id: str, user_id: str) -> bool:
+        """Remove permissions for a specific user.
+
+        Args:
+            bot_id: Bot ID
+            user_id: User ID
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            url = f"{self.base_url}/rbac/bot/{bot_id}/user/{user_id}"
+            response = self.session.delete(url)
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Error removing user permission: {e}")
+            return False
+
+    def remove_org_permission(self, bot_id: str, org_id: str) -> bool:
+        """Remove permissions for an organization.
+
+        Args:
+            bot_id: Bot ID
+            org_id: Organization ID
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            url = f"{self.base_url}/rbac/bot/{bot_id}/org/{org_id}"
+            response = self.session.delete(url)
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Error removing org permission: {e}")
+            return False
+
+    def get_permissions(self, bot_id: str) -> Optional[Dict[str, Any]]:
+        """Get all permissions for a bot.
+
+        Args:
+            bot_id: Bot ID
+
+        Returns:
+            Dictionary with permission details or None if error
+        """
+        try:
+            url = f"{self.base_url}/rbac/permissions/bot/{bot_id}"
+            response = self.session.get(url)
+            if response.status_code == 200:
+                return response.json()
+            return None
+        except Exception as e:
+            print(f"Error getting permissions: {e}")
+            return None
+
+    def check_access(self, bot_id: str, permission_level: str = "view") -> bool:
+        """Check if current user has access to a bot.
+
+        Args:
+            bot_id: Bot ID
+            permission_level: Required permission level
+
+        Returns:
+            True if user has access, False otherwise
+        """
+        try:
+            url = f"{self.base_url}/rbac/access/bot/{bot_id}/{permission_level}"
+            response = self.session.get(url)
+            if response.status_code == 200:
+                data = response.json()
+                return data.get("hasAccess", False)
+            return False
+        except Exception as e:
+            print(f"Error checking access: {e}")
+            return False
+
+    def invite_user(self, bot_id: str, email: str, permission_level: str) -> bool:
+        """Invite a user to access a bot.
+
+        Args:
+            bot_id: Bot ID
+            email: User's email address
+            permission_level: Permission level to grant
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            url = f"{self.base_url}/rbac/resource/bot/{bot_id}/invite"
+            data = {"email": email, "permissionLevel": permission_level}
+            response = self.session.post(url, json=data)
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Error inviting user: {e}")
+            return False
+
+
+# Convenience functions for direct use
+def set_bot_public(
+    bot_id: str, is_public: bool = True, permission_level: str = "view"
+) -> bool:
+    """Set public access for a bot.
+
+    Args:
+        bot_id: Bot ID
+        is_public: Whether to make the bot public
+        permission_level: Permission level for public access
+
+    Returns:
+        True if successful, False otherwise
+    """
+    permissions = BotPermissions()
+    return permissions.set_public_access(bot_id, is_public, permission_level)
+
+
+def set_bot_user_permission(bot_id: str, user_id: str, permission_level: str) -> bool:
+    """Set permissions for a user on a bot.
+
+    Args:
+        bot_id: Bot ID
+        user_id: User ID
+        permission_level: Permission level
+
+    Returns:
+        True if successful, False otherwise
+    """
+    permissions = BotPermissions()
+    return permissions.set_user_permission(bot_id, user_id, permission_level)
+
+
+def set_bot_org_permission(bot_id: str, org_id: str, permission_level: str) -> bool:
+    """Set permissions for an organization on a bot.
+
+    Args:
+        bot_id: Bot ID
+        org_id: Organization ID
+        permission_level: Permission level
+
+    Returns:
+        True if successful, False otherwise
+    """
+    permissions = BotPermissions()
+    return permissions.set_org_permission(bot_id, org_id, permission_level)
+
+
+def get_bot_permissions(bot_id: str) -> Optional[Dict[str, Any]]:
+    """Get all permissions for a bot.
+
+    Args:
+        bot_id: Bot ID
+
+    Returns:
+        Dictionary with permission details or None if error
+    """
+    permissions = BotPermissions()
+    return permissions.get_permissions(bot_id)
+
+
+def check_bot_access(bot_id: str, permission_level: str = "view") -> bool:
+    """Check if current user has access to a bot.
+
+    Args:
+        bot_id: Bot ID
+        permission_level: Required permission level
+
+    Returns:
+        True if user has access, False otherwise
+    """
+    permissions = BotPermissions()
+    return permissions.check_access(bot_id, permission_level)

erdo/config/__init__.py

@@ -0,0 +1,5 @@
+"""Configuration management for Erdo SDK."""
+
+from .config import Config, get_config
+
+__all__ = ["Config", "get_config"]

erdo/config/config.py

@@ -0,0 +1,140 @@
+"""Configuration management for Erdo SDK."""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+
+class Config:
+    """Configuration manager for Erdo SDK."""
+
+    def __init__(
+        self, endpoint: Optional[str] = None, auth_token: Optional[str] = None
+    ):
+        """Initialize configuration.
+
+        Args:
+            endpoint: API endpoint URL. If not provided, will try environment variable or config file.
+            auth_token: Authentication token. If not provided, will try environment variable or config file.
+        """
+        self._endpoint = endpoint
+        self._auth_token = auth_token
+        self._config_yaml = Path.home() / ".erdo" / "config.yaml"
+        self._config_json = Path.home() / ".erdo" / "config.json"
+
+    @property
+    def endpoint(self) -> str:
+        """Get the API endpoint."""
+        if self._endpoint:
+            return self._endpoint
+
+        # Try environment variable
+        env_endpoint = os.environ.get("ERDO_ENDPOINT")
+        if env_endpoint:
+            return env_endpoint
+
+        # Try config file
+        config = self._load_config_file()
+        if config and "endpoint" in config:
+            return config["endpoint"]
+
+        raise ValueError(
+            "No endpoint configured. Set ERDO_ENDPOINT environment variable or run 'erdo configure'"
+        )
+
+    @property
+    def auth_token(self) -> str:
+        """Get the authentication token."""
+        if self._auth_token:
+            return self._auth_token
+
+        # Try environment variable
+        env_token = os.environ.get("ERDO_AUTH_TOKEN")
+        if env_token:
+            return env_token
+
+        # Try config file
+        config = self._load_config_file()
+        if config and "auth_token" in config:
+            return config["auth_token"]
+
+        raise ValueError(
+            "No auth token configured. Set ERDO_AUTH_TOKEN environment variable or run 'erdo login'"
+        )
+
+    def _load_config_file(self) -> Optional[dict]:
+        """Load configuration from file (supports both YAML and JSON)."""
+        # Try YAML first (CLI default format)
+        if self._config_yaml.exists():
+            try:
+                import yaml
+
+                with open(self._config_yaml, "r") as f:
+                    return yaml.safe_load(f)
+            except Exception:
+                try:
+                    # Fallback to simple parsing if yaml not available
+                    with open(self._config_yaml, "r") as f:
+                        config = {}
+                        for line in f:
+                            if ": " in line:
+                                key, value = line.strip().split(": ", 1)
+                                config[key] = value
+                        return config
+                except Exception:
+                    pass
+
+        # Try JSON as fallback
+        if self._config_json.exists():
+            try:
+                with open(self._config_json, "r") as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError):
+                pass
+
+        return None
+
+    def save(self):
+        """Save configuration to file (as JSON)."""
+        self._config_json.parent.mkdir(parents=True, exist_ok=True)
+
+        config = {}
+        if self._endpoint:
+            config["endpoint"] = self._endpoint
+        if self._auth_token:
+            config["auth_token"] = self._auth_token
+
+        with open(self._config_json, "w") as f:
+            json.dump(config, f, indent=2)
+
+    def set_endpoint(self, endpoint: str):
+        """Set the API endpoint."""
+        self._endpoint = endpoint
+
+    def set_auth_token(self, auth_token: str):
+        """Set the authentication token."""
+        self._auth_token = auth_token
+
+
+# Global config instance
+_config: Optional[Config] = None
+
+
+def get_config() -> Config:
+    """Get the global configuration instance."""
+    global _config
+    if _config is None:
+        _config = Config()
+    return _config
+
+
+def set_config(endpoint: Optional[str] = None, auth_token: Optional[str] = None):
+    """Set the global configuration.
+
+    Args:
+        endpoint: API endpoint URL
+        auth_token: Authentication token
+    """
+    global _config
+    _config = Config(endpoint=endpoint, auth_token=auth_token)

erdo/invoke/__init__.py

@@ -0,0 +1,10 @@
+"""Invoke module for running agents via the Erdo orchestrator."""
+
+from .invoke import Invoke, InvokeResult, invoke_agent, invoke_by_key
+
+__all__ = [
+    "Invoke",
+    "InvokeResult",
+    "invoke_agent",
+    "invoke_by_key",
+]

erdo/invoke/client.py

@@ -0,0 +1,213 @@
+"""API client for invoking bots via the backend orchestrator."""
+
+import json
+from typing import Any, Dict, Generator, Optional, Union
+
+import requests
+
+from ..config import get_config
+
+
+class SSEClient:
+    """Client for Server-Sent Events streaming."""
+
+    def __init__(self, response: requests.Response):
+        """Initialize SSE client with a response object."""
+        self.response = response
+        self.response.encoding = "utf-8"
+
+    def events(self) -> Generator[Dict[str, Any], None, None]:
+        """Yield events from the SSE stream."""
+        for line in self.response.iter_lines():
+            if line:
+                line = line.decode("utf-8") if isinstance(line, bytes) else line
+                if line.startswith("data: "):
+                    data = line[6:]  # Remove 'data: ' prefix
+                    if data.strip():
+                        try:
+                            yield json.loads(data)
+                        except json.JSONDecodeError:
+                            # Some events might not be JSON
+                            yield {"raw": data}
+
+
+class InvokeClient:
+    """Client for invoking bots via the Erdo backend."""
+
+    def __init__(
+        self, endpoint: Optional[str] = None, auth_token: Optional[str] = None
+    ):
+        """Initialize the invoke 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 invoke_bot(
+        self,
+        bot_identifier: str,
+        parameters: Optional[Dict[str, Any]] = None,
+        dataset_ids: Optional[list] = None,
+        stream: bool = False,
+    ) -> Union[SSEClient, Dict[str, Any]]:
+        """Invoke a bot via the backend orchestrator.
+
+        Args:
+            bot_identifier: Bot ID or key (e.g., "erdo.data-analyzer")
+            parameters: Parameters to pass to the bot
+            dataset_ids: Optional dataset IDs to include
+            stream: Whether to return SSE client for streaming (default: False)
+
+        Returns:
+            SSEClient for streaming or final result dict for non-streaming
+
+        Raises:
+            requests.RequestException: If the API request fails.
+        """
+        url = f"{self.endpoint}/bots/{bot_identifier}/invoke"
+        headers = {
+            "Authorization": f"Bearer {self.auth_token}",
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",  # Endpoint always returns SSE
+        }
+
+        # Build invoke parameters
+        invoke_params: Dict[str, Any] = {
+            "parameters": parameters or {},
+        }
+
+        if dataset_ids:
+            invoke_params["dataset_ids"] = dataset_ids
+
+        # Make the request - always stream to handle SSE
+        response = requests.post(url, json=invoke_params, headers=headers, stream=True)
+
+        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)
+
+        sse_client = SSEClient(response)
+
+        if stream:
+            # Return SSE client for streaming
+            return sse_client
+        else:
+            # Consume all events and return final result
+            events: list[Dict[str, Any]] = []
+            final_result: Dict[str, Any] = {}
+
+            for event in sse_client.events():
+                events.append(event)
+
+                # Look for completion or result events
+                if "payload" in event:
+                    payload = event["payload"]
+                    if isinstance(payload, dict):
+                        if "result" in payload:
+                            final_result = payload["result"]
+                        elif "invocation_id" in payload:
+                            final_result["invocation_id"] = payload["invocation_id"]
+                        elif "bot_name" in payload:
+                            final_result["bot_name"] = payload["bot_name"]
+
+                # Check for invocation completed
+                if event.get("type") == "invocation_completed":
+                    if "result" in event:
+                        final_result = event["result"]
+                    break
+
+            # Return collected data
+            return {
+                "events": events,
+                "result": final_result,
+                "event_count": len(events),
+            }
+
+    def invoke_bot_from_thread(
+        self,
+        bot_identifier: str,
+        thread_id: str,
+        message: str,
+        parameters: Optional[Dict[str, Any]] = None,
+        stream: bool = False,
+    ) -> Union[SSEClient, Dict[str, Any]]:
+        """Invoke a bot from within a thread context.
+
+        Args:
+            bot_identifier: Bot ID or key
+            thread_id: Thread ID to invoke from
+            message: User message
+            parameters: Additional parameters
+            stream: Whether to return SSE client for streaming (default: False)
+
+        Returns:
+            SSEClient for streaming or final result dict
+        """
+        url = f"{self.endpoint}/bots/{bot_identifier}/invoke-from-thread"
+        headers = {
+            "Authorization": f"Bearer {self.auth_token}",
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",  # Endpoint always returns SSE
+        }
+
+        invoke_params = {
+            "thread_id": thread_id,
+            "message": message,
+            "parameters": parameters or {},
+        }
+
+        # Make the request - always stream to handle SSE
+        response = requests.post(url, json=invoke_params, headers=headers, stream=True)
+
+        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)
+
+        sse_client = SSEClient(response)
+
+        if stream:
+            # Return SSE client for streaming
+            return sse_client
+        else:
+            # Consume all events and return final result
+            events: list[Dict[str, Any]] = []
+            final_result: Dict[str, Any] = {}
+
+            for event in sse_client.events():
+                events.append(event)
+
+                # Look for completion or result events
+                if "payload" in event:
+                    payload = event["payload"]
+                    if isinstance(payload, dict):
+                        if "result" in payload:
+                            final_result = payload["result"]
+                        elif "invocation_id" in payload:
+                            final_result["invocation_id"] = payload["invocation_id"]
+
+                # Check for invocation completed
+                if event.get("type") == "invocation_completed":
+                    if "result" in event:
+                        final_result = event["result"]
+                    break
+
+            # Return collected data
+            return {
+                "events": events,
+                "result": final_result,
+                "event_count": len(events),
+            }