erdo 0.1.4__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 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 (  # noqa: F401
+    checkpoint_attempt,
+    refresh_resource,
+)
+
+# Make all services available for import
+__all__ = [
+    "checkpoint_attempt",
+    "refresh_resource",
+    "analysis",
+    "bot",
+    "llm",
+    "resource_definitions",
+    "utils",
+    "codeexec",
+    "memory",
+    "webparser",
+    "websearch",
+]

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

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Post-install script to download Erdo CLI binary from GitHub releases."""
+
+import os
+import platform
+import shutil
+import urllib.request
+from pathlib import Path
+
+
+def get_platform_info():
+    """Get platform and architecture information."""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    # Normalize architecture names
+    if machine in ["x86_64", "amd64"]:
+        arch = "amd64"
+    elif machine in ["aarch64", "arm64"]:
+        arch = "arm64"
+    else:
+        raise RuntimeError(f"Unsupported architecture: {machine}")
+
+    # Map platform names
+    if system == "darwin":
+        platform_name = "darwin"
+    elif system == "linux":
+        platform_name = "linux"
+    elif system == "windows":
+        platform_name = "windows"
+    else:
+        raise RuntimeError(f"Unsupported platform: {system}")
+
+    return platform_name, arch
+
+
+def get_download_url(version="latest"):
+    """Get the download URL for the CLI binary."""
+    platform_name, arch = get_platform_info()
+
+    # Construct the binary name based on GoReleaser naming convention
+    if platform_name == "windows":
+        binary_name = f"erdo-cli_Windows_{arch}.zip"
+    else:
+        # For Unix-like systems, use tar.gz
+        if arch == "amd64":
+            arch_name = "x86_64"
+        else:
+            arch_name = arch
+
+        platform_title = platform_name.title()
+        binary_name = f"erdo-cli_{platform_title}_{arch_name}.tar.gz"
+
+    base_url = "https://github.com/erdoai/homebrew-tap/releases"
+    if version == "latest":
+        return f"{base_url}/latest/download/{binary_name}"
+    else:
+        return f"{base_url}/download/{version}/{binary_name}"
+
+
+def download_and_install_cli():
+    """Download and install the CLI binary."""
+    try:
+        # Get the installation directory
+        package_dir = Path(__file__).parent
+        bin_dir = package_dir / "bin"
+        bin_dir.mkdir(exist_ok=True)
+
+        platform_name, arch = get_platform_info()
+
+        # Determine the final binary name
+        if platform_name == "windows":
+            binary_name = "erdo.exe"
+        else:
+            binary_name = "erdo"
+
+        binary_path = bin_dir / binary_name
+
+        # Skip if binary already exists
+        if binary_path.exists():
+            print(f"Erdo CLI already installed at {binary_path}")
+            return
+
+        print("Downloading Erdo CLI...")
+        download_url = get_download_url()
+
+        # Download the archive
+        archive_path = bin_dir / "erdo-cli-archive"
+        urllib.request.urlretrieve(download_url, archive_path)
+
+        # Extract the binary
+        if platform_name == "windows":
+            import zipfile
+
+            with zipfile.ZipFile(archive_path, "r") as zip_ref:
+                # Extract erdo.exe from the zip
+                for file_info in zip_ref.filelist:
+                    if file_info.filename.endswith("erdo.exe"):
+                        with (
+                            zip_ref.open(file_info) as source,
+                            open(binary_path, "wb") as target,
+                        ):
+                            shutil.copyfileobj(source, target)
+                        break
+        else:
+            import tarfile
+
+            with tarfile.open(archive_path, "r:gz") as tar_ref:
+                # Extract erdo binary from the tar.gz
+                for member in tar_ref.getmembers():
+                    if member.name.endswith("/erdo") or member.name == "erdo":
+                        with (
+                            tar_ref.extractfile(member) as source,
+                            open(binary_path, "wb") as target,
+                        ):
+                            shutil.copyfileobj(source, target)
+                        break
+
+        # Make executable on Unix-like systems
+        if platform_name != "windows":
+            os.chmod(binary_path, 0o755)
+
+        # Clean up the archive
+        archive_path.unlink()
+
+        print(f"✓ Erdo CLI installed to {binary_path}")
+
+        # Add to PATH instructions
+        print("\nTo use the CLI globally, add the following to your PATH:")
+        print(f'export PATH="{bin_dir}:$PATH"')
+
+    except Exception as e:
+        print(f"Warning: Failed to download Erdo CLI: {e}")
+        print(
+            "You can manually download it from: https://github.com/erdoai/homebrew-tap/releases"
+        )
+
+
+if __name__ == "__main__":
+    download_and_install_cli()

erdo/integrations.py

@@ -0,0 +1,131 @@
+# Integration base classes for defining integration configurations in Python
+"""
+Integration configuration framework for defining integration configs alongside agents.
+
+This module provides base classes for defining integration configurations in Python,
+which can then be synced to the backend alongside agents.
+"""
+
+from typing import Any, Dict, Optional
+
+from ._generated.types import IntegrationConfig, IntegrationDefinition
+
+
+# Helper function to create integration configurations
+def create_integration_config(**kwargs) -> IntegrationConfig:
+    """Create an IntegrationConfig with the provided parameters."""
+    # Extract metadata
+    source = kwargs.pop("source", "python")
+    file_path = kwargs.pop("file_path", None)
+
+    # Create IntegrationDefinition with remaining parameters
+    definition = IntegrationDefinition(**kwargs)
+
+    return IntegrationConfig(definition=definition, source=source, file_path=file_path)
+
+
+# Base class that acts like IntegrationConfig but handles initialization better
+class IntegrationConfigClass:
+    """Base class for integration configurations using auto-generated types."""
+
+    def __init__(self, **kwargs):
+        """Initialize with integration definition parameters."""
+        # Extract metadata
+        self._source = kwargs.pop("source", "python")
+        self._file_path = kwargs.pop("file_path", None)
+
+        # Create the definition with remaining kwargs
+        self._definition = IntegrationDefinition(**kwargs)
+
+        # Create the actual IntegrationConfig instance
+        self._config = IntegrationConfig(
+            definition=self._definition, source=self._source, file_path=self._file_path
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for syncing to backend."""
+        return self._config.to_dict()
+
+    @property
+    def definition(self) -> IntegrationDefinition:
+        """Access the underlying definition."""
+        return self._definition
+
+    @property
+    def config(self) -> IntegrationConfig:
+        """Access the underlying IntegrationConfig."""
+        return self._config
+
+
+# Helper functions for common credential schemas
+def oauth_credential_schema() -> Dict[str, Any]:
+    """Helper to create standard OAuth credential schema"""
+    return {
+        "access_token": {
+            "type": "string",
+            "description": "OAuth access token",
+            "required": True,
+            "source": "integration_credentials",
+        },
+        "refresh_token": {
+            "type": "string",
+            "description": "OAuth refresh token",
+            "required": False,
+            "source": "integration_credentials",
+        },
+    }
+
+
+def database_credential_schema() -> Dict[str, Any]:
+    """Helper to create standard database credential schema"""
+    return {
+        "host": {
+            "type": "string",
+            "description": "Database host",
+            "required": True,
+            "source": "integration_credentials",
+        },
+        "port": {
+            "type": "string",
+            "description": "Database port",
+            "required": True,
+            "source": "integration_credentials",
+        },
+        "database": {
+            "type": "string",
+            "description": "Database name",
+            "required": True,
+            "source": "integration_credentials",
+        },
+        "username": {
+            "type": "string",
+            "description": "Database username",
+            "required": True,
+            "source": "integration_credentials",
+        },
+        "password": {
+            "type": "string",
+            "description": "Database password",
+            "required": True,
+            "source": "integration_credentials",
+        },
+    }
+
+
+def api_key_credential_schema(
+    key_name: str = "api_key", header_name: Optional[str] = None
+) -> Dict[str, Any]:
+    """Helper to create standard API key credential schema"""
+    schema = {
+        key_name: {
+            "type": "string",
+            "description": "API Key for authentication",
+            "required": True,
+            "source": "integration_credentials",
+        }
+    }
+
+    if header_name:
+        schema[key_name]["header"] = header_name
+
+    return schema

erdo/py.typed

@@ -0,0 +1 @@
+