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

erdo/__init__.py

@@ -4,32 +4,35 @@
 
 # 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 first
+# Import all generated types automatically
 from ._generated.types import *  # noqa: F403,F401
-from ._generated.types import __all__ as generated_all
 
 # Import state object for template support
 from .state import state  # noqa: F401
 
-# Import all handwritten SDK classes last (override generated ones)
-from .types import *  # noqa: F403,F401  # type: ignore[assignment]
-from .types import __all__ as handwritten_all
+# Import all handwritten SDK classes automatically
+from .types import *  # noqa: F403,F401
 
 __version__ = "0.1.0"
 
 # Build __all__ dynamically by combining all available types
 __all__ = []
 
-# Add generated types first
+# Add handwritten SDK classes
+from .types import __all__ as handwritten_all
+
+__all__.extend(handwritten_all)
+
+# Add all generated types automatically
+from ._generated.types import __all__ as generated_all
+
 __all__.extend(generated_all)
 
-# Add all condition functions
-__all__.extend(condition_all)
+# Add all condition functions automatically
+from ._generated.condition import __all__ as condition_all
 
-# Add handwritten SDK classes (may override generated ones in __all__)
-__all__.extend(handwritten_all)
+__all__.extend(condition_all)
 
 # Add state to __all__ for explicit import
 __all__.append("state")

erdo/_generated/actions/__init__.py

@@ -16,17 +16,19 @@ 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
-from .analysis import *  # noqa: F403,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

@@ -11,10 +11,21 @@ from typing import Any, List, Optional, Union
 from pydantic import BaseModel
 
 from erdo.template import TemplateString
-from erdo.types import StepMetadata
 
 
-class CreateAnalysisParams(BaseModel):
+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
@@ -23,6 +34,28 @@ class CreateAnalysisParams(BaseModel):
     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
 
@@ -34,11 +67,32 @@ class CreateAnalysisResult(BaseModel):
     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_id: Optional[Union[str, TemplateString]] = None,
     resource_id: Optional[Union[str, TemplateString]] = None,
-    step_metadata: Optional[StepMetadata] = None,
     **params: Any,
 ) -> CreateAnalysisParams:
     """Create an analysis for a dataset, resource, or dataset-resource combination
@@ -59,9 +113,67 @@ def create_analysis(
     # 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
+
 
-    return CreateAnalysisParams(**param_dict)
+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

@@ -17,10 +17,38 @@ 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 InvokeParams(BaseModel):
     """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)
     )
@@ -51,6 +79,7 @@ class AskParams(BaseModel):
 
 
 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,
@@ -61,11 +90,12 @@ def invoke(
 ) -> InvokeParams:
     """Invoke a bot with specified parameters and return the result
 
-    The bot.invoke action expects bot_name (not bot_id) as the parameter.
-    The backend will look up the bot by name and convert to bot_id internally.
+    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_name: Name of the bot to invoke
+        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
@@ -75,6 +105,7 @@ def invoke(
         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,
@@ -122,3 +153,8 @@ def ask(
 
     # Use normal constructor for proper validation
     return AskParams(**params_dict)
+
+
+# Associate parameter classes with their result types
+InvokeParams._result = InvokeResult
+AskParams._result = AskResult

erdo/_generated/actions/codeexec.py

@@ -6,28 +6,43 @@ Provides type-safe action definitions for codeexec service.
 Actual execution happens in the Go backend after syncing.
 """
 
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
 from pydantic import BaseModel
 
 from erdo.template import TemplateString
-from erdo.types import StepMetadata
 
 
-class ExecuteParams(BaseModel):
+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[Any] = None  # resources parameter
-    encrypted_secrets: Optional[Union[str, TemplateString]] = (
-        None  # encrypted_secrets 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(BaseModel):
+class ParseFileAsBotResourceParams(BaseActionParams):
     """Parse a file from code execution results into a bot resource with dataset and analysis parameters"""
 
     name: str = (
@@ -36,9 +51,12 @@ class ParseFileAsBotResourceParams(BaseModel):
     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(BaseModel):
+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
@@ -61,10 +79,13 @@ class ExecuteResult(BaseModel):
 class ParseFileAsBotResourceResult(BaseModel):
     """Parse a file from code execution results into a bot resource with dataset and analysis result type
 
-    Result schema for codeexec.parse_file_as_bot_resource action.
+    Generic result schema for codeexec.parse_file_as_bot_resource action.
     """
 
-    data: Optional[Dict[str, Any]]  # Action result data
+    success: bool = True  # Whether the action was successful
+
+    class Config:
+        extra = "allow"  # Allow additional fields dynamically
 
 
 class ParseFileAsJsonResult(BaseModel):
@@ -73,16 +94,17 @@ class ParseFileAsJsonResult(BaseModel):
     Result schema for codeexec.parse_file_as_json action.
     """
 
-    data: Any
+    json: Any
 
 
 def execute(
     entrypoint: Optional[Union[str, TemplateString]] = None,
     code_files: Optional[Any] = None,
-    resources: Optional[Any] = None,
-    encrypted_secrets: Optional[Union[str, TemplateString]] = None,
+    resources: Optional[Union[str, TemplateString]] = None,
     parameters: Optional[Union[str, TemplateString]] = None,
-    step_metadata: Optional[StepMetadata] = 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
@@ -91,8 +113,10 @@ def execute(
         entrypoint: entrypoint parameter
         code_files: code_files parameter
         resources: resources parameter
-        encrypted_secrets: encrypted_secrets 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
@@ -101,21 +125,23 @@ def execute(
         "entrypoint": entrypoint,
         "code_files": code_files,
         "resources": resources,
-        "encrypted_secrets": encrypted_secrets,
         "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)
-
-    return ExecuteParams(**param_dict)
+    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,
-    step_metadata: Optional[StepMetadata] = 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
@@ -124,6 +150,7 @@ def parse_file_as_bot_resource(
         file: file parameter
         files_analysis: files_analysis parameter
         files_metadata: files_metadata parameter
+        encryption_key: encryption_key parameter
 
     Returns:
         ParseFileAsBotResourceParams: Type-safe parameter object
@@ -132,19 +159,17 @@ def parse_file_as_bot_resource(
         "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)
-
-    return ParseFileAsBotResourceParams(**param_dict)
+    params_obj = ParseFileAsBotResourceParams(**param_dict)
+    return params_obj
 
 
 def parse_file_as_json(
-    file: Optional[Any] = None,
-    thread_id: Optional[Any] = None,
-    step_metadata: Optional[StepMetadata] = None,
-    **params: Any,
+    file: Optional[Any] = None, thread_id: Optional[Any] = None, **params: Any
 ) -> ParseFileAsJsonParams:
     """Parse a file from code execution results as JSON data
 
@@ -162,8 +187,8 @@ def parse_file_as_json(
     # 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)
-
-    return ParseFileAsJsonParams(**param_dict)
+    params_obj = ParseFileAsJsonParams(**param_dict)
+    return params_obj
 
 
 # Associate parameter classes with their result types

erdo/_generated/actions/llm.py

@@ -13,10 +13,21 @@ from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
+from erdo._generated.types import Tool
 from erdo.template import TemplateString
 from erdo.types import StepMetadata
 
-from ..types import Tool
+
+class MessageResult(BaseModel):
+    """LLM message result type
+
+    Result schema for llm.message action.
+    """
+
+    content: str  # The generated response content
+    tool_calls: Optional[List[Any]] = None  # Tool calls made by the LLM
+    usage: Optional[Any] = None  # Token usage information
+    finish_reason: Optional[str] = None  # Reason the generation finished
 
 
 class MessageParams(BaseModel):
@@ -49,6 +60,9 @@ class MessageParams(BaseModel):
     disable_tools: Optional[Union[bool, TemplateString]] = (
         None  # Whether to disable tools for this message
     )
+    reasoning: Optional[Union[Dict[str, Any], TemplateString]] = (
+        None  # Reasoning configuration for extended thinking
+    )
 
 
 def message(
@@ -62,6 +76,7 @@ def message(
     max_tokens: Optional[Union[int, TemplateString]] = None,
     metadata: Optional[Union[Dict[str, Any], TemplateString]] = None,
     disable_tools: Optional[Union[bool, TemplateString]] = None,
+    reasoning: Optional[Union[Dict[str, Any], TemplateString]] = None,
     step_metadata: Optional[StepMetadata] = None,
 ) -> MessageParams:
     """Generate LLM message with bot-compatible parameters
@@ -80,6 +95,7 @@ def message(
         max_tokens: Maximum tokens in response
         metadata: Additional metadata
         disable_tools: Whether to disable tools for this message
+        reasoning: Reasoning configuration for extended thinking
 
     Returns:
         MessageParams: Type-safe parameter object
@@ -95,6 +111,7 @@ def message(
         "max_tokens": max_tokens,
         "metadata": metadata,
         "disable_tools": disable_tools,
+        "reasoning": reasoning,
     }
 
     # Remove None values for optional parameters
@@ -102,3 +119,7 @@ def message(
 
     # Use normal constructor for proper validation
     return MessageParams(**params)
+
+
+# Associate parameter classes with their result types
+MessageParams._result = MessageResult