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

erdo/_generated/condition/__init__.py

@@ -133,48 +133,49 @@ class _BaseCondition:
         return _NotCondition(self)
 
 
-class IsNull(_BaseCondition):
-    def __init__(self, key: Any = None) -> None:
-        self.key = key
+class IsErrorInfoNeeded(_BaseCondition):
+    def __init__(self) -> None:
+        pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        result: Dict[str, Any] = {}
-        result["type"] = "IsNull"
+        return {"type": "IsErrorInfoNeeded", "leaf": {}}
 
-        # Add field values to leaf object (backend expects leaf format)
-        leaf: Dict[str, Any] = {}
-        if self.key is not None:
-            leaf["key"] = self.key
 
-        if leaf:
-            result["leaf"] = leaf
+class IsErrorTerminated(_BaseCondition):
+    def __init__(self) -> None:
+        pass
 
-        return result
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsErrorTerminated", "leaf": {}}
 
 
-class IsSuccess(_BaseCondition):
+class IsFormattedError(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsSuccess", "leaf": {}}
+        return {"type": "IsFormattedError", "leaf": {}}
 
 
-class AndCondition(_BaseCondition):
-    def __init__(self, conditions: Any = None) -> None:
-        self.conditions = conditions
+class TextEndsWith(_BaseCondition):
+    def __init__(self, text: Any = None, value: Any = None) -> None:
+        self.text = text
+        self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "AndCondition"
+        result["type"] = "TextEndsWith"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.conditions is not None:
-            leaf["conditions"] = self.conditions
+        if self.text is not None:
+            leaf["text"] = self.text
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -182,20 +183,20 @@ class AndCondition(_BaseCondition):
         return result
 
 
-class EarlierThan(_BaseCondition):
-    def __init__(self, time: Any = None, value: Any = None) -> None:
-        self.time = time
+class IsAny(_BaseCondition):
+    def __init__(self, key: Any = None, value: Any = None) -> None:
+        self.key = key
         self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "EarlierThan"
+        result["type"] = "IsAny"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.time is not None:
-            leaf["time"] = self.time
+        if self.key is not None:
+            leaf["key"] = self.key
         if self.value is not None:
             leaf["value"] = self.value
 
@@ -205,22 +206,22 @@ class EarlierThan(_BaseCondition):
         return result
 
 
-class FalseCondition(_BaseCondition):
+class IsErrorActionNotFound(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "FalseCondition", "leaf": {}}
+        return {"type": "IsErrorActionNotFound", "leaf": {}}
 
 
-class IsError(_BaseCondition):
+class IsErrorInternalError(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsError", "leaf": {}}
+        return {"type": "IsErrorInternalError", "leaf": {}}
 
 
 class LessThan(_BaseCondition):
@@ -246,43 +247,20 @@ class LessThan(_BaseCondition):
         return result
 
 
-class TextEquals(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
-        self.value = value
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        result: Dict[str, Any] = {}
-        result["type"] = "TextEquals"
-
-        # Add field values to leaf object (backend expects leaf format)
-        leaf: Dict[str, Any] = {}
-        if self.text is not None:
-            leaf["text"] = self.text
-        if self.value is not None:
-            leaf["value"] = self.value
-
-        if leaf:
-            result["leaf"] = leaf
-
-        return result
-
-
-class TextStartsWith(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
+class EarlierThan(_BaseCondition):
+    def __init__(self, time: Any = None, value: Any = None) -> None:
+        self.time = time
         self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "TextStartsWith"
+        result["type"] = "EarlierThan"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.text is not None:
-            leaf["text"] = self.text
+        if self.time is not None:
+            leaf["time"] = self.time
         if self.value is not None:
             leaf["value"] = self.value
 
@@ -292,28 +270,31 @@ class TextStartsWith(_BaseCondition):
         return result
 
 
-class TrueCondition(_BaseCondition):
+class FalseCondition(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "TrueCondition", "leaf": {}}
+        return {"type": "FalseCondition", "leaf": {}}
 
 
-class NotCondition(_BaseCondition):
-    def __init__(self, condition: Any = None) -> None:
-        self.condition = condition
+class GreaterThan(_BaseCondition):
+    def __init__(self, number: Any = None, value: Any = None) -> None:
+        self.number = number
+        self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "NotCondition"
+        result["type"] = "GreaterThan"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.condition is not None:
-            leaf["condition"] = self.condition
+        if self.number is not None:
+            leaf["number"] = self.number
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -321,22 +302,13 @@ class NotCondition(_BaseCondition):
         return result
 
 
-class IsErrorActionNotFound(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsErrorActionNotFound", "leaf": {}}
-
-
-class IsErrorTerminated(_BaseCondition):
+class IsErrorTimeout(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsErrorTerminated", "leaf": {}}
+        return {"type": "IsErrorTimeout", "leaf": {}}
 
 
 class TextContains(_BaseCondition):
@@ -362,19 +334,22 @@ class TextContains(_BaseCondition):
         return result
 
 
-class OrCondition(_BaseCondition):
-    def __init__(self, conditions: Any = None) -> None:
-        self.conditions = conditions
+class TextEquals(_BaseCondition):
+    def __init__(self, text: Any = None, value: Any = None) -> None:
+        self.text = text
+        self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "OrCondition"
+        result["type"] = "TextEquals"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.conditions is not None:
-            leaf["conditions"] = self.conditions
+        if self.text is not None:
+            leaf["text"] = self.text
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -382,20 +357,20 @@ class OrCondition(_BaseCondition):
         return result
 
 
-class GreaterThan(_BaseCondition):
-    def __init__(self, number: Any = None, value: Any = None) -> None:
-        self.number = number
+class TextStartsWith(_BaseCondition):
+    def __init__(self, text: Any = None, value: Any = None) -> None:
+        self.text = text
         self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "GreaterThan"
+        result["type"] = "TextStartsWith"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.number is not None:
-            leaf["number"] = self.number
+        if self.text is not None:
+            leaf["text"] = self.text
         if self.value is not None:
             leaf["value"] = self.value
 
@@ -405,22 +380,37 @@ class GreaterThan(_BaseCondition):
         return result
 
 
-class IsAny(_BaseCondition):
-    def __init__(self, key: Any = None, value: Any = None) -> None:
+class TrueCondition(_BaseCondition):
+    def __init__(self) -> None:
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "TrueCondition", "leaf": {}}
+
+
+class IsError(_BaseCondition):
+    def __init__(self) -> None:
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsError", "leaf": {}}
+
+
+class IsNull(_BaseCondition):
+    def __init__(self, key: Any = None) -> None:
         self.key = key
-        self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "IsAny"
+        result["type"] = "IsNull"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
         if self.key is not None:
             leaf["key"] = self.key
-        if self.value is not None:
-            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -428,49 +418,68 @@ class IsAny(_BaseCondition):
         return result
 
 
-class IsErrorInfoNeeded(_BaseCondition):
+class IsSuccess(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsErrorInfoNeeded", "leaf": {}}
+        return {"type": "IsSuccess", "leaf": {}}
 
 
-class IsErrorInternalError(_BaseCondition):
-    def __init__(self) -> None:
-        pass
+class AndCondition(_BaseCondition):
+    def __init__(self, conditions: Any = None) -> None:
+        self.conditions = conditions
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsErrorInternalError", "leaf": {}}
+        result: Dict[str, Any] = {}
+        result["type"] = "AndCondition"
+
+        # Add field values to leaf object (backend expects leaf format)
+        leaf: Dict[str, Any] = {}
+        if self.conditions is not None:
+            leaf["conditions"] = self.conditions
 
+        if leaf:
+            result["leaf"] = leaf
+
+        return result
 
-class IsFormattedError(_BaseCondition):
-    def __init__(self) -> None:
-        pass
+
+class OrCondition(_BaseCondition):
+    def __init__(self, conditions: Any = None) -> None:
+        self.conditions = conditions
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsFormattedError", "leaf": {}}
+        result: Dict[str, Any] = {}
+        result["type"] = "OrCondition"
 
+        # Add field values to leaf object (backend expects leaf format)
+        leaf: Dict[str, Any] = {}
+        if self.conditions is not None:
+            leaf["conditions"] = self.conditions
 
-class TextEndsWith(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
-        self.value = value
+        if leaf:
+            result["leaf"] = leaf
+
+        return result
+
+
+class NotCondition(_BaseCondition):
+    def __init__(self, condition: Any = None) -> None:
+        self.condition = condition
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "TextEndsWith"
+        result["type"] = "NotCondition"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.text is not None:
-            leaf["text"] = self.text
-        if self.value is not None:
-            leaf["value"] = self.value
+        if self.condition is not None:
+            leaf["condition"] = self.condition
 
         if leaf:
             result["leaf"] = leaf
@@ -483,22 +492,23 @@ __all__ = [
     "And",
     "Or",
     "Not",
-    "LessThan",
+    "EarlierThan",
+    "FalseCondition",
+    "GreaterThan",
+    "IsErrorTimeout",
+    "TextContains",
     "TextEquals",
     "TextStartsWith",
     "TrueCondition",
-    "IsErrorActionNotFound",
-    "IsErrorTerminated",
-    "TextContains",
-    "GreaterThan",
-    "IsAny",
+    "IsError",
+    "IsNull",
+    "IsSuccess",
     "IsErrorInfoNeeded",
-    "IsErrorInternalError",
+    "IsErrorTerminated",
     "IsFormattedError",
     "TextEndsWith",
-    "IsNull",
-    "IsSuccess",
-    "EarlierThan",
-    "FalseCondition",
-    "IsError",
+    "IsAny",
+    "IsErrorActionNotFound",
+    "IsErrorInternalError",
+    "LessThan",
 ]

erdo/_generated/internal_actions.py

@@ -14,7 +14,19 @@ from pydantic import BaseModel
 from erdo.template import TemplateString
 
 
-class CheckpointAttemptParams(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 CheckpointAttemptParams(BaseActionParams):
     """checkpoint_attempt parameters"""
 
     name: str = "checkpoint_attempt"  # Action type for roundtrip compatibility
@@ -22,7 +34,7 @@ class CheckpointAttemptParams(BaseModel):
     loops: Optional[Union[Any, TemplateString]] = None  # Loop data
 
 
-class RefreshResourceParams(BaseModel):
+class RefreshResourceParams(BaseActionParams):
     """refresh_resource parameters"""
 
     name: str = "refresh_resource"  # Action type for roundtrip compatibility