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

erdo/_generated/actions/utils.py

@@ -6,22 +6,34 @@ Provides type-safe action definitions for utils service.
 Actual execution happens in the Go backend after syncing.
 """
 
-from typing import Any, Dict, Optional, Union
+from typing import Any, List, Optional, Union
 
 from pydantic import BaseModel, Field
 
+from erdo._generated.types import Resource
 from erdo.template import TemplateString
-from erdo.types import StepMetadata
 
 
-class EchoParams(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 EchoParams(BaseActionParams):
     """Echo parameters back as output parameters"""
 
     name: str = "utils.echo"  # Action type for roundtrip compatibility
     data: Optional[Any] = None  # data parameter
 
 
-class ParseJsonParams(BaseModel):
+class ParseJsonParams(BaseActionParams):
     """Parse JSON string and validate required keys parameters"""
 
     model_config = {"populate_by_name": True}  # Allow both field names and aliases
@@ -33,7 +45,7 @@ class ParseJsonParams(BaseModel):
     required_keys: Optional[Any] = None  # required_keys parameter
 
 
-class ConcatParams(BaseModel):
+class ConcatParams(BaseActionParams):
     """Concatenate arrays or strings from specified keys parameters"""
 
     name: str = "utils.concat"  # Action type for roundtrip compatibility
@@ -41,7 +53,7 @@ class ConcatParams(BaseModel):
     data: Optional[Any] = None  # data parameter
 
 
-class CastParams(BaseModel):
+class CastParams(BaseActionParams):
     """Cast string values to different types (string, integer, float, bool) parameters"""
 
     model_config = {"populate_by_name": True}  # Allow both field names and aliases
@@ -53,7 +65,7 @@ class CastParams(BaseModel):
     )  # type parameter
 
 
-class RaiseParams(BaseModel):
+class RaiseParams(BaseActionParams):
     """Raise a status with message and parameters parameters"""
 
     name: str = "utils.raise"  # Action type for roundtrip compatibility
@@ -62,7 +74,7 @@ class RaiseParams(BaseModel):
     parameters: Optional[Any] = None  # parameters parameter
 
 
-class CaptureExceptionParams(BaseModel):
+class CaptureExceptionParams(BaseActionParams):
     """Capture an exception to Sentry and return an error result parameters"""
 
     name: str = "utils.capture_exception"  # Action type for roundtrip compatibility
@@ -71,7 +83,7 @@ class CaptureExceptionParams(BaseModel):
     error_type: Optional[Union[str, TemplateString]] = None  # error_type parameter
 
 
-class SendStatusParams(BaseModel):
+class SendStatusParams(BaseActionParams):
     """Send a status event to the client parameters"""
 
     name: str = "utils.send_status"  # Action type for roundtrip compatibility
@@ -80,7 +92,7 @@ class SendStatusParams(BaseModel):
     details: Optional[Any] = None  # details parameter
 
 
-class WriteParams(BaseModel):
+class WriteParams(BaseActionParams):
     """Write output message with specified content types parameters"""
 
     name: str = "utils.write"  # Action type for roundtrip compatibility
@@ -92,85 +104,146 @@ class WriteParams(BaseModel):
     ui_content_type: Optional[Union[str, TemplateString]] = (
         None  # ui_content_type parameter
     )
+    output_channels: Optional[Any] = None  # output_channels parameter
+
+
+class ProcessIntegrationQueriesParams(BaseActionParams):
+    """Process integration queries to create resource-specific search queries parameters"""
+
+    name: str = (
+        "utils.process_integration_queries"  # Action type for roundtrip compatibility
+    )
+    query: Optional[Union[str, TemplateString]] = None  # query parameter
+    resource: Optional[Any] = None  # resource parameter
+    queries: Optional[Any] = None  # queries parameter
+
+
+class PopulateResourceIdsParams(BaseActionParams):
+    """Assigns incremental IDs to new resources based on the maximum existing resource ID parameters"""
+
+    name: str = "utils.populate_resource_ids"  # Action type for roundtrip compatibility
+    all_resources: Optional[Any] = None  # all_resources parameter
+    new_resources: Optional[Any] = None  # new_resources parameter
 
 
 class EchoResult(BaseModel):
     """Echo parameters back as output result type
 
-    Result schema for utils.echo action.
+    Generic result schema for utils.echo 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 ParseJsonResult(BaseModel):
     """Parse JSON string and validate required keys result type
 
-    Result schema for utils.parse_json action.
+    Generic result schema for utils.parse_json 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 ConcatResult(BaseModel):
     """Concatenate arrays or strings from specified keys result type
 
-    Result schema for utils.concat action.
+    Generic result schema for utils.concat 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 CastResult(BaseModel):
     """Cast string values to different types (string, integer, float, bool) result type
 
-    Result schema for utils.cast action.
+    Generic result schema for utils.cast 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 RaiseResult(BaseModel):
     """Raise a status with message and parameters result type
 
-    Result schema for utils.raise action.
+    Generic result schema for utils.raise 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 CaptureExceptionResult(BaseModel):
     """Capture an exception to Sentry and return an error result result type
 
-    Result schema for utils.capture_exception action.
+    Generic result schema for utils.capture_exception 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 SendStatusResult(BaseModel):
     """Send a status event to the client result type
 
-    Result schema for utils.send_status action.
+    Generic result schema for utils.send_status 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 WriteResult(BaseModel):
     """Write output message with specified content types result type
 
-    Result schema for utils.write action.
+    Generic result schema for utils.write 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
 
-def echo(
-    data: Optional[Any] = None,
-    step_metadata: Optional[StepMetadata] = None,
-    **params: Any,
-) -> EchoParams:
+
+class ProcessIntegrationQueriesResult(BaseModel):
+    """Process integration queries to create resource-specific search queries result type
+
+    Generic result schema for utils.process_integration_queries action.
+    """
+
+    success: bool = True  # Whether the action was successful
+
+    class Config:
+        extra = "allow"  # Allow additional fields dynamically
+
+
+class PopulateResourceIdsResult(BaseModel):
+    """Assigns incremental IDs to new resources based on the maximum existing resource ID result type
+
+    Result schema for utils.populate_resource_ids action.
+    """
+
+    new_resources: List[Resource]
+
+
+def echo(data: Optional[Any] = None, **params: Any) -> EchoParams:
     """Echo parameters back as output
 
     Args:
@@ -185,14 +258,13 @@ def echo(
     # 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 EchoParams(**param_dict)
+    params_obj = EchoParams(**param_dict)
+    return params_obj
 
 
 def parse_json(
     json_data: Optional[Union[str, TemplateString]] = None,
     required_keys: Optional[Any] = None,
-    step_metadata: Optional[StepMetadata] = None,
     **params: Any,
 ) -> ParseJsonParams:
     """Parse JSON string and validate required keys
@@ -211,15 +283,12 @@ def parse_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 ParseJsonParams(**param_dict)
+    params_obj = ParseJsonParams(**param_dict)
+    return params_obj
 
 
 def concat(
-    concat: Optional[Any] = None,
-    data: Optional[Any] = None,
-    step_metadata: Optional[StepMetadata] = None,
-    **params: Any,
+    concat: Optional[Any] = None, data: Optional[Any] = None, **params: Any
 ) -> ConcatParams:
     """Concatenate arrays or strings from specified keys
 
@@ -237,14 +306,13 @@ def concat(
     # 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 ConcatParams(**param_dict)
+    params_obj = ConcatParams(**param_dict)
+    return params_obj
 
 
 def cast(
     value: Optional[Union[str, TemplateString]] = None,
     type_name: Optional[Union[str, TemplateString]] = None,
-    step_metadata: Optional[StepMetadata] = None,
     **params: Any,
 ) -> CastParams:
     """Cast string values to different types (string, integer, float, bool)
@@ -263,15 +331,14 @@ def cast(
     # 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 CastParams(**param_dict)
+    params_obj = CastParams(**param_dict)
+    return params_obj
 
 
 def raise_error(
     status: Optional[Union[str, TemplateString]] = None,
     message: Optional[Union[str, TemplateString]] = None,
     parameters: Optional[Any] = None,
-    step_metadata: Optional[StepMetadata] = None,
     **params: Any,
 ) -> RaiseParams:
     """Raise a status with message and parameters
@@ -292,15 +359,14 @@ def raise_error(
     # 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 RaiseParams(**param_dict)
+    params_obj = RaiseParams(**param_dict)
+    return params_obj
 
 
 def capture_exception(
     exception: Optional[Union[str, TemplateString]] = None,
     message: Optional[Union[str, TemplateString]] = None,
     error_type: Optional[Union[str, TemplateString]] = None,
-    step_metadata: Optional[StepMetadata] = None,
     **params: Any,
 ) -> CaptureExceptionParams:
     """Capture an exception to Sentry and return an error result
@@ -321,15 +387,14 @@ def capture_exception(
     # 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 CaptureExceptionParams(**param_dict)
+    params_obj = CaptureExceptionParams(**param_dict)
+    return params_obj
 
 
 def send_status(
     status: Optional[Union[str, TemplateString]] = None,
     message: Optional[Union[str, TemplateString]] = None,
     details: Optional[Any] = None,
-    step_metadata: Optional[StepMetadata] = None,
     **params: Any,
 ) -> SendStatusParams:
     """Send a status event to the client
@@ -350,8 +415,8 @@ def send_status(
     # 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 SendStatusParams(**param_dict)
+    params_obj = SendStatusParams(**param_dict)
+    return params_obj
 
 
 def write(
@@ -359,7 +424,7 @@ def write(
     content_type: Optional[Union[str, TemplateString]] = None,
     history_content_type: Optional[Union[str, TemplateString]] = None,
     ui_content_type: Optional[Union[str, TemplateString]] = None,
-    step_metadata: Optional[StepMetadata] = None,
+    output_channels: Optional[Any] = None,
     **params: Any,
 ) -> WriteParams:
     """Write output message with specified content types
@@ -369,6 +434,7 @@ def write(
         content_type: content_type parameter
         history_content_type: history_content_type parameter
         ui_content_type: ui_content_type parameter
+        output_channels: output_channels parameter
 
     Returns:
         WriteParams: Type-safe parameter object
@@ -378,12 +444,66 @@ def write(
         "content_type": content_type,
         "history_content_type": history_content_type,
         "ui_content_type": ui_content_type,
+        "output_channels": output_channels,
+    }
+    # 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 = WriteParams(**param_dict)
+    return params_obj
+
+
+def process_integration_queries(
+    query: Optional[Union[str, TemplateString]] = None,
+    resource: Optional[Any] = None,
+    queries: Optional[Any] = None,
+    **params: Any,
+) -> ProcessIntegrationQueriesParams:
+    """Process integration queries to create resource-specific search queries
+
+    Args:
+        query: query parameter
+        resource: resource parameter
+        queries: queries parameter
+
+    Returns:
+        ProcessIntegrationQueriesParams: Type-safe parameter object
+    """
+    param_dict = {
+        "query": query,
+        "resource": resource,
+        "queries": queries,
     }
     # 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 = ProcessIntegrationQueriesParams(**param_dict)
+    return params_obj
+
+
+def populate_resource_ids(
+    all_resources: Optional[Any] = None,
+    new_resources: Optional[Any] = None,
+    **params: Any,
+) -> PopulateResourceIdsParams:
+    """Assigns incremental IDs to new resources based on the maximum existing resource ID
+
+    Args:
+        all_resources: all_resources parameter
+        new_resources: new_resources parameter
 
-    return WriteParams(**param_dict)
+    Returns:
+        PopulateResourceIdsParams: Type-safe parameter object
+    """
+    param_dict = {
+        "all_resources": all_resources,
+        "new_resources": new_resources,
+    }
+    # 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 = PopulateResourceIdsParams(**param_dict)
+    return params_obj
 
 
 # Associate parameter classes with their result types
@@ -395,3 +515,5 @@ RaiseParams._result = RaiseResult
 CaptureExceptionParams._result = CaptureExceptionResult
 SendStatusParams._result = SendStatusResult
 WriteParams._result = WriteResult
+ProcessIntegrationQueriesParams._result = ProcessIntegrationQueriesResult
+PopulateResourceIdsParams._result = PopulateResourceIdsResult

erdo/_generated/actions/webparser.py

@@ -11,10 +11,21 @@ from typing import Any, Optional, Union
 from pydantic import BaseModel
 
 from erdo.template import TemplateString
-from erdo.types import StepMetadata
 
 
-class ParseParams(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 ParseParams(BaseActionParams):
     """Parse website content using Jina's reader API to extract text, images, and links parameters"""
 
     name: str = "webparser.parse"  # Action type for roundtrip compatibility
@@ -66,7 +77,6 @@ def parse(
     return_format: Optional[Union[str, TemplateString]] = None,
     timeout: Optional[Union[int, TemplateString]] = None,
     no_cache: Optional[Union[bool, TemplateString]] = None,
-    step_metadata: Optional[StepMetadata] = None,
     **params: Any,
 ) -> ParseParams:
     """Parse website content using Jina's reader API to extract text, images, and links
@@ -101,8 +111,8 @@ def parse(
     # 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 ParseParams(**param_dict)
+    params_obj = ParseParams(**param_dict)
+    return params_obj
 
 
 # Associate parameter classes with their result types

erdo/_generated/actions/websearch.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 SearchParams(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 SearchParams(BaseActionParams):
     """Search the web using Jina's search API and return relevant results parameters"""
 
     name: str = "websearch.search"  # Action type for roundtrip compatibility
@@ -42,7 +53,6 @@ def search(
     country: Optional[Union[str, TemplateString]] = None,
     location: Optional[Union[str, TemplateString]] = None,
     num_results: Optional[Union[int, TemplateString]] = None,
-    step_metadata: Optional[StepMetadata] = None,
     **params: Any,
 ) -> SearchParams:
     """Search the web using Jina's search API and return relevant results
@@ -67,8 +77,8 @@ def search(
     # 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 SearchParams(**param_dict)
+    params_obj = SearchParams(**param_dict)
+    return params_obj
 
 
 # Associate parameter classes with their result types