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

erdo/_generated/condition/__init__.py

@@ -133,19 +133,22 @@ class _BaseCondition:
         return _NotCondition(self)
 
 
-class IsNull(_BaseCondition):
-    def __init__(self, key: Any = None) -> None:
-        self.key = key
+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"] = "IsNull"
+        result["type"] = "TextEquals"
 
         # 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.text is not None:
+            leaf["text"] = self.text
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -153,28 +156,22 @@ class IsNull(_BaseCondition):
         return result
 
 
-class IsSuccess(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsSuccess", "leaf": {}}
-
-
-class AndCondition(_BaseCondition):
-    def __init__(self, conditions: Any = None) -> None:
-        self.conditions = conditions
+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"] = "AndCondition"
+        result["type"] = "TextStartsWith"
 
         # 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,22 +179,19 @@ class AndCondition(_BaseCondition):
         return result
 
 
-class EarlierThan(_BaseCondition):
-    def __init__(self, time: Any = None, value: Any = None) -> None:
-        self.time = time
-        self.value = value
+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"] = "EarlierThan"
+        result["type"] = "NotCondition"
 
         # 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.value is not None:
-            leaf["value"] = self.value
+        if self.condition is not None:
+            leaf["condition"] = self.condition
 
         if leaf:
             result["leaf"] = leaf
@@ -214,29 +208,43 @@ class FalseCondition(_BaseCondition):
         return {"type": "FalseCondition", "leaf": {}}
 
 
-class IsError(_BaseCondition):
-    def __init__(self) -> None:
-        pass
+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."""
-        return {"type": "IsError", "leaf": {}}
+        result: Dict[str, Any] = {}
+        result["type"] = "GreaterThan"
 
+        # 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.value is not None:
+            leaf["value"] = self.value
 
-class LessThan(_BaseCondition):
-    def __init__(self, number: Any = None, value: Any = None) -> None:
-        self.number = number
+        if leaf:
+            result["leaf"] = leaf
+
+        return result
+
+
+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"] = "LessThan"
+        result["type"] = "IsAny"
 
         # 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.key is not None:
+            leaf["key"] = self.key
         if self.value is not None:
             leaf["value"] = self.value
 
@@ -246,7 +254,25 @@ class LessThan(_BaseCondition):
         return result
 
 
-class TextEquals(_BaseCondition):
+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 IsErrorInternalError(_BaseCondition):
+    def __init__(self) -> None:
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsErrorInternalError", "leaf": {}}
+
+
+class TextContains(_BaseCondition):
     def __init__(self, text: Any = None, value: Any = None) -> None:
         self.text = text
         self.value = value
@@ -254,7 +280,7 @@ class TextEquals(_BaseCondition):
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "TextEquals"
+        result["type"] = "TextContains"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
@@ -269,7 +295,7 @@ class TextEquals(_BaseCondition):
         return result
 
 
-class TextStartsWith(_BaseCondition):
+class TextEndsWith(_BaseCondition):
     def __init__(self, text: Any = None, value: Any = None) -> None:
         self.text = text
         self.value = value
@@ -277,7 +303,7 @@ class TextStartsWith(_BaseCondition):
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "TextStartsWith"
+        result["type"] = "TextEndsWith"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
@@ -301,19 +327,22 @@ class TrueCondition(_BaseCondition):
         return {"type": "TrueCondition", "leaf": {}}
 
 
-class NotCondition(_BaseCondition):
-    def __init__(self, condition: Any = None) -> None:
-        self.condition = condition
+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"] = "NotCondition"
+        result["type"] = "EarlierThan"
 
         # 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.time is not None:
+            leaf["time"] = self.time
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -330,6 +359,15 @@ class IsErrorActionNotFound(_BaseCondition):
         return {"type": "IsErrorActionNotFound", "leaf": {}}
 
 
+class IsErrorInfoNeeded(_BaseCondition):
+    def __init__(self) -> None:
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsErrorInfoNeeded", "leaf": {}}
+
+
 class IsErrorTerminated(_BaseCondition):
     def __init__(self) -> None:
         pass
@@ -339,27 +377,22 @@ class IsErrorTerminated(_BaseCondition):
         return {"type": "IsErrorTerminated", "leaf": {}}
 
 
-class TextContains(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
-        self.value = value
+class IsErrorTimeout(_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"] = "TextContains"
+        return {"type": "IsErrorTimeout", "leaf": {}}
 
-        # 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
+class IsSuccess(_BaseCondition):
+    def __init__(self) -> None:
+        pass
 
-        return result
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsSuccess", "leaf": {}}
 
 
 class OrCondition(_BaseCondition):
@@ -382,22 +415,28 @@ class OrCondition(_BaseCondition):
         return result
 
 
-class GreaterThan(_BaseCondition):
-    def __init__(self, number: Any = None, value: Any = None) -> None:
-        self.number = number
-        self.value = value
+class IsFormattedError(_BaseCondition):
+    def __init__(self) -> None:
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsFormattedError", "leaf": {}}
+
+
+class IsNull(_BaseCondition):
+    def __init__(self, key: Any = None) -> None:
+        self.key = key
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "GreaterThan"
+        result["type"] = "IsNull"
 
         # 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.value is not None:
-            leaf["value"] = self.value
+        if self.key is not None:
+            leaf["key"] = self.key
 
         if leaf:
             result["leaf"] = leaf
@@ -405,20 +444,20 @@ class GreaterThan(_BaseCondition):
         return result
 
 
-class IsAny(_BaseCondition):
-    def __init__(self, key: Any = None, value: Any = None) -> None:
-        self.key = key
+class LessThan(_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"] = "IsAny"
+        result["type"] = "LessThan"
 
         # 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.number is not None:
+            leaf["number"] = self.number
         if self.value is not None:
             leaf["value"] = self.value
 
@@ -428,49 +467,19 @@ class IsAny(_BaseCondition):
         return result
 
 
-class IsErrorInfoNeeded(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsErrorInfoNeeded", "leaf": {}}
-
-
-class IsErrorInternalError(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsErrorInternalError", "leaf": {}}
-
-
-class IsFormattedError(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsFormattedError", "leaf": {}}
-
-
-class TextEndsWith(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
-        self.value = value
+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."""
         result: Dict[str, Any] = {}
-        result["type"] = "TextEndsWith"
+        result["type"] = "AndCondition"
 
         # 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.conditions is not None:
+            leaf["conditions"] = self.conditions
 
         if leaf:
             result["leaf"] = leaf
@@ -483,22 +492,23 @@ __all__ = [
     "And",
     "Or",
     "Not",
-    "LessThan",
-    "TextEquals",
-    "TextStartsWith",
-    "TrueCondition",
-    "IsErrorActionNotFound",
-    "IsErrorTerminated",
-    "TextContains",
+    "FalseCondition",
     "GreaterThan",
     "IsAny",
-    "IsErrorInfoNeeded",
+    "IsError",
     "IsErrorInternalError",
-    "IsFormattedError",
+    "TextContains",
     "TextEndsWith",
-    "IsNull",
-    "IsSuccess",
+    "TrueCondition",
     "EarlierThan",
-    "FalseCondition",
-    "IsError",
+    "IsErrorActionNotFound",
+    "IsErrorInfoNeeded",
+    "IsErrorTerminated",
+    "IsErrorTimeout",
+    "IsSuccess",
+    "IsFormattedError",
+    "IsNull",
+    "LessThan",
+    "TextEquals",
+    "TextStartsWith",
 ]