erdo 0.1.31__py3-none-any.whl

erdo/__init__.py

@@ -0,0 +1,35 @@
+# DO NOT EDIT THIS FILE MANUALLY - it will be overwritten.
+# Generated by: erdo gen-client
+"""Erdo Agent SDK - Build AI agents with Python."""
+
+# Import all condition functions from generated condition module
+from ._generated.condition import *  # noqa: F403,F401
+from ._generated.condition import __all__ as condition_all
+
+# Import all generated types automatically
+from ._generated.types import *  # noqa: F403,F401
+from ._generated.types import __all__ as generated_all
+
+# Import invoke functions
+from .invoke.invoke import invoke, invoke_agent, invoke_by_key  # noqa: F401
+
+# Import state object for template support
+from .state import state  # noqa: F401
+
+# Import all handwritten SDK classes automatically
+from .types import *  # noqa: F403,F401
+from .types import __all__ as handwritten_all
+
+__version__ = "0.1.0"
+
+# Build __all__ dynamically by combining all available types
+__all__ = []
+__all__.extend(handwritten_all)
+__all__.extend(generated_all)
+__all__.extend(condition_all)
+
+# Add state to __all__ for explicit import
+__all__.append("state")
+
+# Add invoke functions to __all__
+__all__.extend(["invoke", "invoke_agent", "invoke_by_key"])

erdo/_generated/__init__.py

@@ -0,0 +1,18 @@
+# DO NOT EDIT THIS FILE MANUALLY - it will be overwritten.
+# Generated by: erdo gen-client
+"""
+Re-exports for generated code.
+
+This module provides clean access to all generated types and actions.
+"""
+
+# Re-export actions module
+from . import actions  # noqa: F401
+
+# Re-export internal actions
+from .internal_actions import *  # noqa: F403,F401
+
+# Re-export all generated types
+from .parameters import *  # noqa: F403,F401
+from .secrets import *  # noqa: F403,F401
+from .types import *  # noqa: F403,F401

erdo/_generated/actions/__init__.py

@@ -0,0 +1,34 @@
+# DO NOT EDIT THIS FILE MANUALLY - it will be overwritten.
+# Generated by: erdo gen-client
+"""
+Action functions for type-safe parameter generation.
+
+Import individual functions or entire modules:
+- from erdo.actions import memory, codeexec
+- from erdo.actions.memory import search, store
+- from erdo.actions.codeexec import execute
+"""
+
+# Module-level imports for convenient access
+from . import analysis  # noqa: F401
+from . import bot  # noqa: F401
+from . import codeexec  # noqa: F401
+from . import llm  # noqa: F401
+from . import memory  # noqa: F401
+from . import resource_definitions  # noqa: F401
+from . import sqlexec  # noqa: F401
+from . import utils  # noqa: F401
+from . import webparser  # noqa: F401
+from . import websearch  # noqa: F401
+
+# Import all functions from service modules
+from .analysis import *  # noqa: F403,F401
+from .bot import *  # noqa: F403,F401
+from .codeexec import *  # noqa: F403,F401
+from .llm import *  # noqa: F403,F401
+from .memory import *  # noqa: F403,F401
+from .resource_definitions import *  # noqa: F403,F401
+from .sqlexec import *  # noqa: F403,F401
+from .utils import *  # noqa: F403,F401
+from .webparser import *  # noqa: F403,F401
+from .websearch import *  # noqa: F403,F401

erdo/_generated/actions/analysis.py

@@ -0,0 +1,179 @@
+"""
+Analysis actions for creating and managing data analysis service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for analysis service.
+Actual execution happens in the Go backend after syncing.
+"""
+
+from typing import Any, List, Optional, Union
+
+from pydantic import BaseModel
+
+from erdo.template import TemplateString
+
+
+class BaseActionParams(BaseModel):
+    """Base class for all action parameter classes.
+
+    Provides common fields that all actions support:
+    - name: The action type identifier
+    - step_metadata: Optional configuration for the step created from this action
+    """
+
+    name: str
+    step_metadata: Optional[Any] = None
+
+
+class CreateAnalysisParams(BaseActionParams):
+    """Create an analysis for a dataset, resource, or dataset-resource combination parameters"""
+
+    name: str = "analysis.create_analysis"  # Action type for roundtrip compatibility
+    analysis: Optional[Any] = None  # analysis parameter
+    dataset_slug: Optional[Union[str, TemplateString]] = None  # dataset_slug parameter
+    resource_id: Optional[Union[str, TemplateString]] = None  # resource_id parameter
+
+
+class AnalyzeCsvParams(BaseActionParams):
+    """Analyze CSV file using Go-based CSV analyzer (fast, no Python needed) parameters"""
+
+    name: str = "analysis.analyze_csv"  # Action type for roundtrip compatibility
+    file: Optional[Any] = None  # file parameter
+    columns: Optional[Any] = None  # columns parameter
+    rows: Optional[Any] = None  # rows parameter
+    encryption_key: Optional[Union[str, TemplateString]] = (
+        None  # encryption_key parameter
+    )
+
+
+class AnalyzeExcelParams(BaseActionParams):
+    """Analyze Excel file using Go-based Excel analyzer (fast, no Python needed) parameters"""
+
+    name: str = "analysis.analyze_excel"  # Action type for roundtrip compatibility
+    file: Optional[Any] = None  # file parameter
+    encryption_key: Optional[Union[str, TemplateString]] = (
+        None  # encryption_key parameter
+    )
+
+
+class CreateAnalysisResult(BaseModel):
+    """Create an analysis for a dataset, resource, or dataset-resource combination result type
+
+    Result schema for analysis.create_analysis action.
+    """
+
+    analysis: Any
+    insights: Optional[List[str]]
+    recommendations: Optional[List[str]]
+
+
+class AnalyzeCsvResult(BaseModel):
+    """Analyze CSV file using Go-based CSV analyzer (fast, no Python needed) result type
+
+    Result schema for analysis.analyze_csv action.
+    """
+
+    summary: str
+    details: Any
+    dataset_file_name: str
+
+
+class AnalyzeExcelResult(BaseModel):
+    """Analyze Excel file using Go-based Excel analyzer (fast, no Python needed) result type
+
+    Result schema for analysis.analyze_excel action.
+    """
+
+    summary: str
+    details: Any
+    dataset_file_name: str
+
+
+def create_analysis(
+    analysis: Optional[Any] = None,
+    dataset_slug: Optional[Union[str, TemplateString]] = None,
+    resource_id: Optional[Union[str, TemplateString]] = None,
+    **params: Any,
+) -> CreateAnalysisParams:
+    """Create an analysis for a dataset, resource, or dataset-resource combination
+
+    Args:
+        analysis: analysis parameter
+        dataset_slug: dataset_slug parameter
+        resource_id: resource_id parameter
+
+    Returns:
+        CreateAnalysisParams: Type-safe parameter object
+    """
+    param_dict = {
+        "analysis": analysis,
+        "dataset_slug": dataset_slug,
+        "resource_id": resource_id,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+    params_obj = CreateAnalysisParams(**param_dict)
+    return params_obj
+
+
+def analyze_csv(
+    file: Optional[Any] = None,
+    columns: Optional[Any] = None,
+    rows: Optional[Any] = None,
+    encryption_key: Optional[Union[str, TemplateString]] = None,
+    **params: Any,
+) -> AnalyzeCsvParams:
+    """Analyze CSV file using Go-based CSV analyzer (fast, no Python needed)
+
+    Args:
+        file: file parameter
+        columns: columns parameter
+        rows: rows parameter
+        encryption_key: encryption_key parameter
+
+    Returns:
+        AnalyzeCsvParams: Type-safe parameter object
+    """
+    param_dict = {
+        "file": file,
+        "columns": columns,
+        "rows": rows,
+        "encryption_key": encryption_key,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+    params_obj = AnalyzeCsvParams(**param_dict)
+    return params_obj
+
+
+def analyze_excel(
+    file: Optional[Any] = None,
+    encryption_key: Optional[Union[str, TemplateString]] = None,
+    **params: Any,
+) -> AnalyzeExcelParams:
+    """Analyze Excel file using Go-based Excel analyzer (fast, no Python needed)
+
+    Args:
+        file: file parameter
+        encryption_key: encryption_key parameter
+
+    Returns:
+        AnalyzeExcelParams: Type-safe parameter object
+    """
+    param_dict = {
+        "file": file,
+        "encryption_key": encryption_key,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+    params_obj = AnalyzeExcelParams(**param_dict)
+    return params_obj
+
+
+# Associate parameter classes with their result types
+CreateAnalysisParams._result = CreateAnalysisResult
+AnalyzeCsvParams._result = AnalyzeCsvResult
+AnalyzeExcelParams._result = AnalyzeExcelResult

erdo/_generated/actions/bot.py

@@ -0,0 +1,186 @@
+"""
+Bot service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for Bot service with correct parameter names.
+Actual execution happens in the Go backend after syncing.
+
+NOTE: This module is hardcoded because bot.invoke requires bot_name parameter
+but the Go struct uses bot_id. The backend converts bot_name -> bot_id internally.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel
+
+from erdo.template import TemplateString
+from erdo.types import StepMetadata
+
+
+class InvokeResult(BaseModel):
+    """Bot invoke result type
+
+    Result schema for bot.invoke action.
+    """
+
+    result: Any  # The bot invocation result
+    messages: list  # Messages from the bot invocation
+    resources: list  # Resources created/used during invocation
+    final_state: Any  # Final state after invocation
+
+
+class AskResult(BaseModel):
+    """Bot ask result type
+
+    Result schema for bot.ask action.
+    """
+
+    success: bool  # Whether the question was successfully processed
+    response: Optional[str] = None  # The bot's response to the question
+    bot_id: Optional[str] = None  # ID of the bot that answered
+    invocation_id: Optional[str] = None  # ID of the invocation
+    error: Optional[str] = None  # Error message if ask failed
+
+
+class BaseActionParams(BaseModel):
+    """Base class for all action parameter classes.
+
+    Provides common fields that all actions support:
+    - name: The action type identifier
+    - step_metadata: Optional configuration for the step created from this action
+    """
+
+    name: str
+    step_metadata: Optional[Any] = None
+
+
+class InvokeParams(BaseActionParams):
+    """Invoke a bot with specified parameters and return the result parameters"""
+
+    name: str = "bot.invoke"  # Action type for roundtrip compatibility
+    bot_key: Optional[Union[str, TemplateString]] = (
+        None  # bot_key parameter (unique bot identifier like "erdo.security-checker")
+    )
+    bot_name: Optional[Union[str, TemplateString]] = (
+        None  # bot_name parameter (backend expects this, not bot_id)
+    )
+    parameters: Optional[Union[Dict[str, Any], TemplateString]] = (
+        None  # parameters parameter
+    )
+    bot_output_visibility_behaviour: Optional[Union[str, TemplateString]] = (
+        None  # Output visibility behaviour
+    )
+    transparent: Optional[Union[bool, TemplateString]] = (
+        None  # Whether the invocation is transparent
+    )
+    disable_tools: Optional[Union[bool, TemplateString]] = (
+        None  # Whether to disable tools for this invocation
+    )
+
+
+class AskParams(BaseActionParams):
+    """Ask a bot a question and get a response parameters"""
+
+    name: str = "bot.ask"  # Action type for roundtrip compatibility
+    query: Optional[Union[str, TemplateString]] = None  # query parameter
+    bot_name: Optional[Union[str, TemplateString]] = None  # bot_name parameter
+    bot_id: Optional[Union[str, TemplateString]] = None  # bot_id parameter
+    invocation_id: Optional[Union[str, TemplateString]] = (
+        None  # invocation_id parameter
+    )
+
+
+def invoke(
+    bot_key: Optional[Union[str, TemplateString]] = None,
+    bot_name: Optional[Union[str, TemplateString]] = None,
+    parameters: Optional[Union[Dict[str, Any], TemplateString]] = None,
+    bot_output_visibility_behaviour: Optional[Union[str, TemplateString]] = None,
+    transparent: Optional[Union[bool, TemplateString]] = None,
+    disable_tools: Optional[Union[bool, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> InvokeParams:
+    """Invoke a bot with specified parameters and return the result
+
+    The bot.invoke action expects bot_key or bot_name as the parameter.
+    The backend will look up the bot and convert to bot_id internally.
+
+    Args:
+        bot_key: Unique key of the bot to invoke (e.g., "erdo.security-checker")
+        bot_name: Name of the bot to invoke (alternative to bot_key)
+        parameters: Parameters to pass to the bot
+        bot_output_visibility_behaviour: Output visibility behaviour
+        transparent: Whether the invocation is transparent
+        disable_tools: Whether to disable tools for this invocation
+
+    Returns:
+        InvokeParams: Type-safe parameter object
+    """
+    params_dict = {
+        "bot_key": bot_key,
+        "bot_name": bot_name,
+        "parameters": parameters,
+        "bot_output_visibility_behaviour": bot_output_visibility_behaviour,
+        "transparent": transparent,
+        "disable_tools": disable_tools,
+    }
+
+    # Remove None values for optional parameters
+    params_dict = {k: v for k, v in params_dict.items() if v is not None}
+    params_dict.update(params)
+
+    # Include step_metadata in params_dict since it's a field on BaseActionParams
+    if step_metadata is not None:
+        params_dict["step_metadata"] = step_metadata
+
+    # Use normal constructor for proper validation
+    return InvokeParams(**params_dict)
+
+
+def ask(
+    query: Optional[Union[str, TemplateString]] = None,
+    bot_name: Optional[Union[str, TemplateString]] = None,
+    bot_id: Optional[Union[str, TemplateString]] = None,
+    invocation_id: Optional[Union[str, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> AskParams:
+    """Ask a bot a question and get a response
+
+    Args:
+        query: Question to ask the bot
+        bot_name: Name of the bot to ask
+        bot_id: ID of the bot to ask (alternative to bot_name)
+        invocation_id: Invocation ID for tracking
+
+    Returns:
+        AskParams: Type-safe parameter object
+    """
+    params_dict = {
+        "query": query,
+        "bot_name": bot_name,
+        "bot_id": bot_id,
+        "invocation_id": invocation_id,
+    }
+
+    # Remove None values for optional parameters
+    params_dict = {k: v for k, v in params_dict.items() if v is not None}
+    params_dict.update(params)
+
+    # Include step_metadata in params_dict since it's a field on BaseActionParams
+    if step_metadata is not None:
+        params_dict["step_metadata"] = step_metadata
+
+    # Use normal constructor for proper validation
+    return AskParams(**params_dict)
+
+
+# Rebuild models to resolve forward references (needed for Python 3.10+)
+InvokeParams.model_rebuild()
+AskParams.model_rebuild()
+
+# Associate parameter classes with their result types
+InvokeParams._result = InvokeResult
+AskParams._result = AskResult

erdo/_generated/actions/codeexec.py

@@ -0,0 +1,199 @@
+"""
+Code execution actions for running and processing code in sandboxed environments service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for codeexec service.
+Actual execution happens in the Go backend after syncing.
+"""
+
+from typing import Any, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from erdo.template import TemplateString
+
+
+class BaseActionParams(BaseModel):
+    """Base class for all action parameter classes.
+
+    Provides common fields that all actions support:
+    - name: The action type identifier
+    - step_metadata: Optional configuration for the step created from this action
+    """
+
+    name: str
+    step_metadata: Optional[Any] = None
+
+
+class ExecuteParams(BaseActionParams):
+    """Execute code in a sandboxed environment and return the results parameters"""
+
+    name: str = "codeexec.execute"  # Action type for roundtrip compatibility
+    entrypoint: Optional[Union[str, TemplateString]] = None  # entrypoint parameter
+    code_files: Optional[Any] = None  # code_files parameter
+    resources: Optional[Union[str, TemplateString]] = None  # resources parameter
+    parameters: Optional[Union[str, TemplateString]] = None  # parameters parameter
+    encryption_key: Optional[Union[str, TemplateString]] = (
+        None  # encryption_key parameter
+    )
+    timeout_seconds: Optional[Union[int, TemplateString]] = (
+        None  # timeout_seconds parameter
+    )
+    storage_config: Optional[Any] = None  # storage_config parameter
+
+
+class ParseFileAsBotResourceParams(BaseActionParams):
+    """Parse a file from code execution results into a bot resource with dataset and analysis parameters"""
+
+    name: str = (
+        "codeexec.parse_file_as_bot_resource"  # Action type for roundtrip compatibility
+    )
+    file: Optional[Any] = None  # file parameter
+    files_analysis: Optional[Any] = None  # files_analysis parameter
+    files_metadata: Optional[Any] = None  # files_metadata parameter
+    encryption_key: Optional[Union[str, TemplateString]] = (
+        None  # encryption_key parameter
+    )
+
+
+class ParseFileAsJsonParams(BaseActionParams):
+    """Parse a file from code execution results as JSON data parameters"""
+
+    name: str = "codeexec.parse_file_as_json"  # Action type for roundtrip compatibility
+    file: Optional[Any] = None  # file parameter
+    thread_id: Optional[Any] = None  # thread_id parameter
+
+
+class ExecuteResult(BaseModel):
+    """Execute code in a sandboxed environment and return the results result type
+
+    Result schema for codeexec.execute action.
+    """
+
+    output: str
+    error: Optional[str]
+    exit_code: Optional[float]
+    files: Optional[Any]
+
+
+class ParseFileAsBotResourceResult(BaseModel):
+    """Parse a file from code execution results into a bot resource with dataset and analysis result type
+
+    Generic result schema for codeexec.parse_file_as_bot_resource action.
+    """
+
+    success: bool = True  # Whether the action was successful
+
+    class Config:
+        extra = "allow"  # Allow additional fields dynamically
+
+
+class ParseFileAsJsonResult(BaseModel):
+    """Parse a file from code execution results as JSON data result type
+
+    Result schema for codeexec.parse_file_as_json action.
+    """
+
+    model_config = {"populate_by_name": True}  # Allow both field names and aliases
+
+    json_data: Any = Field(alias="json")
+
+
+def execute(
+    entrypoint: Optional[Union[str, TemplateString]] = None,
+    code_files: Optional[Any] = None,
+    resources: Optional[Union[str, TemplateString]] = None,
+    parameters: Optional[Union[str, TemplateString]] = None,
+    encryption_key: Optional[Union[str, TemplateString]] = None,
+    timeout_seconds: Optional[Union[int, TemplateString]] = None,
+    storage_config: Optional[Any] = None,
+    **params: Any,
+) -> ExecuteParams:
+    """Execute code in a sandboxed environment and return the results
+
+    Args:
+        entrypoint: entrypoint parameter
+        code_files: code_files parameter
+        resources: resources parameter
+        parameters: parameters parameter
+        encryption_key: encryption_key parameter
+        timeout_seconds: timeout_seconds parameter
+        storage_config: storage_config parameter
+
+    Returns:
+        ExecuteParams: Type-safe parameter object
+    """
+    param_dict = {
+        "entrypoint": entrypoint,
+        "code_files": code_files,
+        "resources": resources,
+        "parameters": parameters,
+        "encryption_key": encryption_key,
+        "timeout_seconds": timeout_seconds,
+        "storage_config": storage_config,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+    params_obj = ExecuteParams(**param_dict)
+    return params_obj
+
+
+def parse_file_as_bot_resource(
+    file: Optional[Any] = None,
+    files_analysis: Optional[Any] = None,
+    files_metadata: Optional[Any] = None,
+    encryption_key: Optional[Union[str, TemplateString]] = None,
+    **params: Any,
+) -> ParseFileAsBotResourceParams:
+    """Parse a file from code execution results into a bot resource with dataset and analysis
+
+    Args:
+        file: file parameter
+        files_analysis: files_analysis parameter
+        files_metadata: files_metadata parameter
+        encryption_key: encryption_key parameter
+
+    Returns:
+        ParseFileAsBotResourceParams: Type-safe parameter object
+    """
+    param_dict = {
+        "file": file,
+        "files_analysis": files_analysis,
+        "files_metadata": files_metadata,
+        "encryption_key": encryption_key,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+    params_obj = ParseFileAsBotResourceParams(**param_dict)
+    return params_obj
+
+
+def parse_file_as_json(
+    file: Optional[Any] = None, thread_id: Optional[Any] = None, **params: Any
+) -> ParseFileAsJsonParams:
+    """Parse a file from code execution results as JSON data
+
+    Args:
+        file: file parameter
+        thread_id: thread_id parameter
+
+    Returns:
+        ParseFileAsJsonParams: Type-safe parameter object
+    """
+    param_dict = {
+        "file": file,
+        "thread_id": thread_id,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+    params_obj = ParseFileAsJsonParams(**param_dict)
+    return params_obj
+
+
+# Associate parameter classes with their result types
+ExecuteParams._result = ExecuteResult
+ParseFileAsBotResourceParams._result = ParseFileAsBotResourceResult
+ParseFileAsJsonParams._result = ParseFileAsJsonResult