erdo 0.1.31__py3-none-any.whl

erdo/actions/__init__.py

@@ -0,0 +1,40 @@
+# DO NOT EDIT THIS FILE MANUALLY - it will be overwritten.
+# Generated by: erdo gen-client
+"""
+Actions module re-exports.
+
+This module provides clean access to all action services from the top level.
+Users can import like: from erdo.actions import llm, bot, memory
+"""
+
+# Import all services as modules
+from .._generated.actions import analysis  # noqa: F401
+from .._generated.actions import bot  # noqa: F401
+from .._generated.actions import codeexec  # noqa: F401
+from .._generated.actions import llm  # noqa: F401
+from .._generated.actions import memory  # noqa: F401
+from .._generated.actions import resource_definitions  # noqa: F401
+from .._generated.actions import sqlexec  # noqa: F401
+from .._generated.actions import utils  # noqa: F401
+from .._generated.actions import webparser  # noqa: F401
+from .._generated.actions import websearch  # noqa: F401
+
+# Import internal actions explicitly
+from .._generated.internal_actions import checkpoint_attempt  # noqa: F401
+from .._generated.internal_actions import refresh_resource  # noqa: F401
+
+# Make all services available for import
+__all__ = [
+    "analysis",
+    "bot",
+    "checkpoint_attempt",
+    "codeexec",
+    "llm",
+    "memory",
+    "refresh_resource",
+    "resource_definitions",
+    "sqlexec",
+    "utils",
+    "webparser",
+    "websearch",
+]

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/cli_entry.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""CLI entry point that executes the downloaded Erdo CLI binary."""
+
+import platform
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+def get_binary_path() -> Path:
+    """Get the path to the CLI binary."""
+    package_dir = Path(__file__).parent
+    bin_dir = package_dir / "bin"
+
+    # Determine binary name based on platform
+    if platform.system().lower() == "windows":
+        binary_name = "erdo.exe"
+    else:
+        binary_name = "erdo"
+
+    return bin_dir / binary_name
+
+
+def find_system_cli() -> Optional[str]:
+    """Find erdo CLI in system PATH, excluding pyenv shims."""
+    erdo_path = shutil.which("erdo")
+    if erdo_path and "pyenv/shims" not in erdo_path:
+        return erdo_path
+    return None
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    # First, check if erdo is available in system PATH
+    system_cli = find_system_cli()
+    if system_cli:
+        try:
+            result = subprocess.run([system_cli] + sys.argv[1:])
+            sys.exit(result.returncode)
+        except Exception as e:
+            print(f"Error executing system CLI: {e}")
+            # Fall through to try local binary
+
+    # Check for local binary
+    binary_path = get_binary_path()
+    if not binary_path.exists():
+        try:
+            from .install_cli import download_and_install_cli
+
+            download_and_install_cli()
+        except Exception as e:
+            print(f"Failed to download CLI: {e}")
+            print(
+                "Please manually download from: https://github.com/erdoai/homebrew-tap/releases"
+            )
+            sys.exit(1)
+
+    # Execute the local binary with all arguments
+    try:
+        result = subprocess.run([str(binary_path)] + sys.argv[1:])
+        sys.exit(result.returncode)
+    except FileNotFoundError:
+        print(f"Error: CLI binary not found at {binary_path}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error executing CLI: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

erdo/conditions/__init__.py

@@ -0,0 +1,11 @@
+# DO NOT EDIT THIS FILE MANUALLY - it will be overwritten.
+# Generated by: erdo gen-client
+"""
+Conditions module for clean imports.
+
+This module re-exports all condition classes from the generated condition module
+so users can import like: from erdo.conditions import IsSuccess, And
+"""
+
+# Re-export all condition classes from _generated
+from .._generated.condition import *  # noqa: F403,F401

erdo/config/__init__.py

@@ -0,0 +1,5 @@
+"""Configuration management for Erdo SDK."""
+
+from .config import Config, get_config, set_config
+
+__all__ = ["Config", "get_config", "set_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)