windmill-api 1.402.1__py3-none-any.whl → 1.403.0__py3-none-any.whl

windmill_api/models/list_queue_response_200_item_raw_flow_preprocessor_module.py

@@ -12,6 +12,9 @@ if TYPE_CHECKING:
     from ..models.list_queue_response_200_item_raw_flow_preprocessor_module_retry import (
         ListQueueResponse200ItemRawFlowPreprocessorModuleRetry,
     )
+    from ..models.list_queue_response_200_item_raw_flow_preprocessor_module_skip_if import (
+        ListQueueResponse200ItemRawFlowPreprocessorModuleSkipIf,
+    )
     from ..models.list_queue_response_200_item_raw_flow_preprocessor_module_sleep_type_0 import (
         ListQueueResponse200ItemRawFlowPreprocessorModuleSleepType0,
     )
@@ -40,6 +43,7 @@ class ListQueueResponse200ItemRawFlowPreprocessorModule:
         value (Any):
         stop_after_if (Union[Unset, ListQueueResponse200ItemRawFlowPreprocessorModuleStopAfterIf]):
         stop_after_all_iters_if (Union[Unset, ListQueueResponse200ItemRawFlowPreprocessorModuleStopAfterAllItersIf]):
+        skip_if (Union[Unset, ListQueueResponse200ItemRawFlowPreprocessorModuleSkipIf]):
         sleep (Union['ListQueueResponse200ItemRawFlowPreprocessorModuleSleepType0',
             'ListQueueResponse200ItemRawFlowPreprocessorModuleSleepType1', Unset]):
         cache_ttl (Union[Unset, float]):
@@ -59,6 +63,7 @@ class ListQueueResponse200ItemRawFlowPreprocessorModule:
     stop_after_all_iters_if: Union[
         Unset, "ListQueueResponse200ItemRawFlowPreprocessorModuleStopAfterAllItersIf"
     ] = UNSET
+    skip_if: Union[Unset, "ListQueueResponse200ItemRawFlowPreprocessorModuleSkipIf"] = UNSET
     sleep: Union[
         "ListQueueResponse200ItemRawFlowPreprocessorModuleSleepType0",
         "ListQueueResponse200ItemRawFlowPreprocessorModuleSleepType1",
@@ -90,6 +95,10 @@ class ListQueueResponse200ItemRawFlowPreprocessorModule:
         if not isinstance(self.stop_after_all_iters_if, Unset):
             stop_after_all_iters_if = self.stop_after_all_iters_if.to_dict()
 
+        skip_if: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.skip_if, Unset):
+            skip_if = self.skip_if.to_dict()
+
         sleep: Union[Dict[str, Any], Unset]
         if isinstance(self.sleep, Unset):
             sleep = UNSET
@@ -134,6 +143,8 @@ class ListQueueResponse200ItemRawFlowPreprocessorModule:
             field_dict["stop_after_if"] = stop_after_if
         if stop_after_all_iters_if is not UNSET:
             field_dict["stop_after_all_iters_if"] = stop_after_all_iters_if
+        if skip_if is not UNSET:
+            field_dict["skip_if"] = skip_if
         if sleep is not UNSET:
             field_dict["sleep"] = sleep
         if cache_ttl is not UNSET:
@@ -165,6 +176,9 @@ class ListQueueResponse200ItemRawFlowPreprocessorModule:
         from ..models.list_queue_response_200_item_raw_flow_preprocessor_module_retry import (
             ListQueueResponse200ItemRawFlowPreprocessorModuleRetry,
         )
+        from ..models.list_queue_response_200_item_raw_flow_preprocessor_module_skip_if import (
+            ListQueueResponse200ItemRawFlowPreprocessorModuleSkipIf,
+        )
         from ..models.list_queue_response_200_item_raw_flow_preprocessor_module_sleep_type_0 import (
             ListQueueResponse200ItemRawFlowPreprocessorModuleSleepType0,
         )
@@ -202,6 +216,13 @@ class ListQueueResponse200ItemRawFlowPreprocessorModule:
                 _stop_after_all_iters_if
             )
 
+        _skip_if = d.pop("skip_if", UNSET)
+        skip_if: Union[Unset, ListQueueResponse200ItemRawFlowPreprocessorModuleSkipIf]
+        if isinstance(_skip_if, Unset):
+            skip_if = UNSET
+        else:
+            skip_if = ListQueueResponse200ItemRawFlowPreprocessorModuleSkipIf.from_dict(_skip_if)
+
         def _parse_sleep(
             data: object,
         ) -> Union[
@@ -275,6 +296,7 @@ class ListQueueResponse200ItemRawFlowPreprocessorModule:
             value=value,
             stop_after_if=stop_after_if,
             stop_after_all_iters_if=stop_after_all_iters_if,
+            skip_if=skip_if,
             sleep=sleep,
             cache_ttl=cache_ttl,
             timeout=timeout,

windmill_api/models/list_queue_response_200_item_raw_flow_preprocessor_module_skip_if.py

@@ -0,0 +1,58 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ListQueueResponse200ItemRawFlowPreprocessorModuleSkipIf")
+
+
+@_attrs_define
+class ListQueueResponse200ItemRawFlowPreprocessorModuleSkipIf:
+    """
+    Attributes:
+        expr (str):
+    """
+
+    expr: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        expr = self.expr
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "expr": expr,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        expr = d.pop("expr")
+
+        list_queue_response_200_item_raw_flow_preprocessor_module_skip_if = cls(
+            expr=expr,
+        )
+
+        list_queue_response_200_item_raw_flow_preprocessor_module_skip_if.additional_properties = d
+        return list_queue_response_200_item_raw_flow_preprocessor_module_skip_if
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

windmill_api/models/open_flow_value_failure_module.py

@@ -8,6 +8,7 @@ from ..types import UNSET, Unset
 if TYPE_CHECKING:
     from ..models.open_flow_value_failure_module_mock import OpenFlowValueFailureModuleMock
     from ..models.open_flow_value_failure_module_retry import OpenFlowValueFailureModuleRetry
+    from ..models.open_flow_value_failure_module_skip_if import OpenFlowValueFailureModuleSkipIf
     from ..models.open_flow_value_failure_module_sleep_type_0 import OpenFlowValueFailureModuleSleepType0
     from ..models.open_flow_value_failure_module_sleep_type_1 import OpenFlowValueFailureModuleSleepType1
     from ..models.open_flow_value_failure_module_stop_after_all_iters_if import (
@@ -28,6 +29,7 @@ class OpenFlowValueFailureModule:
         value (Any):
         stop_after_if (Union[Unset, OpenFlowValueFailureModuleStopAfterIf]):
         stop_after_all_iters_if (Union[Unset, OpenFlowValueFailureModuleStopAfterAllItersIf]):
+        skip_if (Union[Unset, OpenFlowValueFailureModuleSkipIf]):
         sleep (Union['OpenFlowValueFailureModuleSleepType0', 'OpenFlowValueFailureModuleSleepType1', Unset]):
         cache_ttl (Union[Unset, float]):
         timeout (Union[Unset, float]):
@@ -44,6 +46,7 @@ class OpenFlowValueFailureModule:
     value: Any
     stop_after_if: Union[Unset, "OpenFlowValueFailureModuleStopAfterIf"] = UNSET
     stop_after_all_iters_if: Union[Unset, "OpenFlowValueFailureModuleStopAfterAllItersIf"] = UNSET
+    skip_if: Union[Unset, "OpenFlowValueFailureModuleSkipIf"] = UNSET
     sleep: Union["OpenFlowValueFailureModuleSleepType0", "OpenFlowValueFailureModuleSleepType1", Unset] = UNSET
     cache_ttl: Union[Unset, float] = UNSET
     timeout: Union[Unset, float] = UNSET
@@ -69,6 +72,10 @@ class OpenFlowValueFailureModule:
         if not isinstance(self.stop_after_all_iters_if, Unset):
             stop_after_all_iters_if = self.stop_after_all_iters_if.to_dict()
 
+        skip_if: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.skip_if, Unset):
+            skip_if = self.skip_if.to_dict()
+
         sleep: Union[Dict[str, Any], Unset]
         if isinstance(self.sleep, Unset):
             sleep = UNSET
@@ -113,6 +120,8 @@ class OpenFlowValueFailureModule:
             field_dict["stop_after_if"] = stop_after_if
         if stop_after_all_iters_if is not UNSET:
             field_dict["stop_after_all_iters_if"] = stop_after_all_iters_if
+        if skip_if is not UNSET:
+            field_dict["skip_if"] = skip_if
         if sleep is not UNSET:
             field_dict["sleep"] = sleep
         if cache_ttl is not UNSET:
@@ -140,6 +149,7 @@ class OpenFlowValueFailureModule:
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         from ..models.open_flow_value_failure_module_mock import OpenFlowValueFailureModuleMock
         from ..models.open_flow_value_failure_module_retry import OpenFlowValueFailureModuleRetry
+        from ..models.open_flow_value_failure_module_skip_if import OpenFlowValueFailureModuleSkipIf
         from ..models.open_flow_value_failure_module_sleep_type_0 import OpenFlowValueFailureModuleSleepType0
         from ..models.open_flow_value_failure_module_sleep_type_1 import OpenFlowValueFailureModuleSleepType1
         from ..models.open_flow_value_failure_module_stop_after_all_iters_if import (
@@ -167,6 +177,13 @@ class OpenFlowValueFailureModule:
         else:
             stop_after_all_iters_if = OpenFlowValueFailureModuleStopAfterAllItersIf.from_dict(_stop_after_all_iters_if)
 
+        _skip_if = d.pop("skip_if", UNSET)
+        skip_if: Union[Unset, OpenFlowValueFailureModuleSkipIf]
+        if isinstance(_skip_if, Unset):
+            skip_if = UNSET
+        else:
+            skip_if = OpenFlowValueFailureModuleSkipIf.from_dict(_skip_if)
+
         def _parse_sleep(
             data: object,
         ) -> Union["OpenFlowValueFailureModuleSleepType0", "OpenFlowValueFailureModuleSleepType1", Unset]:
@@ -236,6 +253,7 @@ class OpenFlowValueFailureModule:
             value=value,
             stop_after_if=stop_after_if,
             stop_after_all_iters_if=stop_after_all_iters_if,
+            skip_if=skip_if,
             sleep=sleep,
             cache_ttl=cache_ttl,
             timeout=timeout,

windmill_api/models/open_flow_value_failure_module_skip_if.py

@@ -0,0 +1,58 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OpenFlowValueFailureModuleSkipIf")
+
+
+@_attrs_define
+class OpenFlowValueFailureModuleSkipIf:
+    """
+    Attributes:
+        expr (str):
+    """
+
+    expr: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        expr = self.expr
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "expr": expr,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        expr = d.pop("expr")
+
+        open_flow_value_failure_module_skip_if = cls(
+            expr=expr,
+        )
+
+        open_flow_value_failure_module_skip_if.additional_properties = d
+        return open_flow_value_failure_module_skip_if
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

windmill_api/models/open_flow_value_modules_item.py

@@ -8,6 +8,7 @@ from ..types import UNSET, Unset
 if TYPE_CHECKING:
     from ..models.open_flow_value_modules_item_mock import OpenFlowValueModulesItemMock
     from ..models.open_flow_value_modules_item_retry import OpenFlowValueModulesItemRetry
+    from ..models.open_flow_value_modules_item_skip_if import OpenFlowValueModulesItemSkipIf
     from ..models.open_flow_value_modules_item_sleep_type_0 import OpenFlowValueModulesItemSleepType0
     from ..models.open_flow_value_modules_item_sleep_type_1 import OpenFlowValueModulesItemSleepType1
     from ..models.open_flow_value_modules_item_stop_after_all_iters_if import (
@@ -28,6 +29,7 @@ class OpenFlowValueModulesItem:
         value (Any):
         stop_after_if (Union[Unset, OpenFlowValueModulesItemStopAfterIf]):
         stop_after_all_iters_if (Union[Unset, OpenFlowValueModulesItemStopAfterAllItersIf]):
+        skip_if (Union[Unset, OpenFlowValueModulesItemSkipIf]):
         sleep (Union['OpenFlowValueModulesItemSleepType0', 'OpenFlowValueModulesItemSleepType1', Unset]):
         cache_ttl (Union[Unset, float]):
         timeout (Union[Unset, float]):
@@ -44,6 +46,7 @@ class OpenFlowValueModulesItem:
     value: Any
     stop_after_if: Union[Unset, "OpenFlowValueModulesItemStopAfterIf"] = UNSET
     stop_after_all_iters_if: Union[Unset, "OpenFlowValueModulesItemStopAfterAllItersIf"] = UNSET
+    skip_if: Union[Unset, "OpenFlowValueModulesItemSkipIf"] = UNSET
     sleep: Union["OpenFlowValueModulesItemSleepType0", "OpenFlowValueModulesItemSleepType1", Unset] = UNSET
     cache_ttl: Union[Unset, float] = UNSET
     timeout: Union[Unset, float] = UNSET
@@ -69,6 +72,10 @@ class OpenFlowValueModulesItem:
         if not isinstance(self.stop_after_all_iters_if, Unset):
             stop_after_all_iters_if = self.stop_after_all_iters_if.to_dict()
 
+        skip_if: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.skip_if, Unset):
+            skip_if = self.skip_if.to_dict()
+
         sleep: Union[Dict[str, Any], Unset]
         if isinstance(self.sleep, Unset):
             sleep = UNSET
@@ -113,6 +120,8 @@ class OpenFlowValueModulesItem:
             field_dict["stop_after_if"] = stop_after_if
         if stop_after_all_iters_if is not UNSET:
             field_dict["stop_after_all_iters_if"] = stop_after_all_iters_if
+        if skip_if is not UNSET:
+            field_dict["skip_if"] = skip_if
         if sleep is not UNSET:
             field_dict["sleep"] = sleep
         if cache_ttl is not UNSET:
@@ -140,6 +149,7 @@ class OpenFlowValueModulesItem:
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         from ..models.open_flow_value_modules_item_mock import OpenFlowValueModulesItemMock
         from ..models.open_flow_value_modules_item_retry import OpenFlowValueModulesItemRetry
+        from ..models.open_flow_value_modules_item_skip_if import OpenFlowValueModulesItemSkipIf
         from ..models.open_flow_value_modules_item_sleep_type_0 import OpenFlowValueModulesItemSleepType0
         from ..models.open_flow_value_modules_item_sleep_type_1 import OpenFlowValueModulesItemSleepType1
         from ..models.open_flow_value_modules_item_stop_after_all_iters_if import (
@@ -167,6 +177,13 @@ class OpenFlowValueModulesItem:
         else:
             stop_after_all_iters_if = OpenFlowValueModulesItemStopAfterAllItersIf.from_dict(_stop_after_all_iters_if)
 
+        _skip_if = d.pop("skip_if", UNSET)
+        skip_if: Union[Unset, OpenFlowValueModulesItemSkipIf]
+        if isinstance(_skip_if, Unset):
+            skip_if = UNSET
+        else:
+            skip_if = OpenFlowValueModulesItemSkipIf.from_dict(_skip_if)
+
         def _parse_sleep(
             data: object,
         ) -> Union["OpenFlowValueModulesItemSleepType0", "OpenFlowValueModulesItemSleepType1", Unset]:
@@ -236,6 +253,7 @@ class OpenFlowValueModulesItem:
             value=value,
             stop_after_if=stop_after_if,
             stop_after_all_iters_if=stop_after_all_iters_if,
+            skip_if=skip_if,
             sleep=sleep,
             cache_ttl=cache_ttl,
             timeout=timeout,

windmill_api/models/open_flow_value_modules_item_skip_if.py

@@ -0,0 +1,58 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OpenFlowValueModulesItemSkipIf")
+
+
+@_attrs_define
+class OpenFlowValueModulesItemSkipIf:
+    """
+    Attributes:
+        expr (str):
+    """
+
+    expr: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        expr = self.expr
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "expr": expr,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        expr = d.pop("expr")
+
+        open_flow_value_modules_item_skip_if = cls(
+            expr=expr,
+        )
+
+        open_flow_value_modules_item_skip_if.additional_properties = d
+        return open_flow_value_modules_item_skip_if
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

windmill_api/models/open_flow_value_preprocessor_module.py

@@ -8,6 +8,7 @@ from ..types import UNSET, Unset
 if TYPE_CHECKING:
     from ..models.open_flow_value_preprocessor_module_mock import OpenFlowValuePreprocessorModuleMock
     from ..models.open_flow_value_preprocessor_module_retry import OpenFlowValuePreprocessorModuleRetry
+    from ..models.open_flow_value_preprocessor_module_skip_if import OpenFlowValuePreprocessorModuleSkipIf
     from ..models.open_flow_value_preprocessor_module_sleep_type_0 import OpenFlowValuePreprocessorModuleSleepType0
     from ..models.open_flow_value_preprocessor_module_sleep_type_1 import OpenFlowValuePreprocessorModuleSleepType1
     from ..models.open_flow_value_preprocessor_module_stop_after_all_iters_if import (
@@ -28,6 +29,7 @@ class OpenFlowValuePreprocessorModule:
         value (Any):
         stop_after_if (Union[Unset, OpenFlowValuePreprocessorModuleStopAfterIf]):
         stop_after_all_iters_if (Union[Unset, OpenFlowValuePreprocessorModuleStopAfterAllItersIf]):
+        skip_if (Union[Unset, OpenFlowValuePreprocessorModuleSkipIf]):
         sleep (Union['OpenFlowValuePreprocessorModuleSleepType0', 'OpenFlowValuePreprocessorModuleSleepType1', Unset]):
         cache_ttl (Union[Unset, float]):
         timeout (Union[Unset, float]):
@@ -44,6 +46,7 @@ class OpenFlowValuePreprocessorModule:
     value: Any
     stop_after_if: Union[Unset, "OpenFlowValuePreprocessorModuleStopAfterIf"] = UNSET
     stop_after_all_iters_if: Union[Unset, "OpenFlowValuePreprocessorModuleStopAfterAllItersIf"] = UNSET
+    skip_if: Union[Unset, "OpenFlowValuePreprocessorModuleSkipIf"] = UNSET
     sleep: Union[
         "OpenFlowValuePreprocessorModuleSleepType0", "OpenFlowValuePreprocessorModuleSleepType1", Unset
     ] = UNSET
@@ -71,6 +74,10 @@ class OpenFlowValuePreprocessorModule:
         if not isinstance(self.stop_after_all_iters_if, Unset):
             stop_after_all_iters_if = self.stop_after_all_iters_if.to_dict()
 
+        skip_if: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.skip_if, Unset):
+            skip_if = self.skip_if.to_dict()
+
         sleep: Union[Dict[str, Any], Unset]
         if isinstance(self.sleep, Unset):
             sleep = UNSET
@@ -115,6 +122,8 @@ class OpenFlowValuePreprocessorModule:
             field_dict["stop_after_if"] = stop_after_if
         if stop_after_all_iters_if is not UNSET:
             field_dict["stop_after_all_iters_if"] = stop_after_all_iters_if
+        if skip_if is not UNSET:
+            field_dict["skip_if"] = skip_if
         if sleep is not UNSET:
             field_dict["sleep"] = sleep
         if cache_ttl is not UNSET:
@@ -142,6 +151,7 @@ class OpenFlowValuePreprocessorModule:
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         from ..models.open_flow_value_preprocessor_module_mock import OpenFlowValuePreprocessorModuleMock
         from ..models.open_flow_value_preprocessor_module_retry import OpenFlowValuePreprocessorModuleRetry
+        from ..models.open_flow_value_preprocessor_module_skip_if import OpenFlowValuePreprocessorModuleSkipIf
         from ..models.open_flow_value_preprocessor_module_sleep_type_0 import OpenFlowValuePreprocessorModuleSleepType0
         from ..models.open_flow_value_preprocessor_module_sleep_type_1 import OpenFlowValuePreprocessorModuleSleepType1
         from ..models.open_flow_value_preprocessor_module_stop_after_all_iters_if import (
@@ -173,6 +183,13 @@ class OpenFlowValuePreprocessorModule:
                 _stop_after_all_iters_if
             )
 
+        _skip_if = d.pop("skip_if", UNSET)
+        skip_if: Union[Unset, OpenFlowValuePreprocessorModuleSkipIf]
+        if isinstance(_skip_if, Unset):
+            skip_if = UNSET
+        else:
+            skip_if = OpenFlowValuePreprocessorModuleSkipIf.from_dict(_skip_if)
+
         def _parse_sleep(
             data: object,
         ) -> Union["OpenFlowValuePreprocessorModuleSleepType0", "OpenFlowValuePreprocessorModuleSleepType1", Unset]:
@@ -242,6 +259,7 @@ class OpenFlowValuePreprocessorModule:
             value=value,
             stop_after_if=stop_after_if,
             stop_after_all_iters_if=stop_after_all_iters_if,
+            skip_if=skip_if,
             sleep=sleep,
             cache_ttl=cache_ttl,
             timeout=timeout,

windmill_api/models/open_flow_value_preprocessor_module_skip_if.py

@@ -0,0 +1,58 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OpenFlowValuePreprocessorModuleSkipIf")
+
+
+@_attrs_define
+class OpenFlowValuePreprocessorModuleSkipIf:
+    """
+    Attributes:
+        expr (str):
+    """
+
+    expr: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        expr = self.expr
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "expr": expr,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        expr = d.pop("expr")
+
+        open_flow_value_preprocessor_module_skip_if = cls(
+            expr=expr,
+        )
+
+        open_flow_value_preprocessor_module_skip_if.additional_properties = d
+        return open_flow_value_preprocessor_module_skip_if
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

windmill_api/models/open_flow_w_path_value_failure_module.py

@@ -8,6 +8,7 @@ from ..types import UNSET, Unset
 if TYPE_CHECKING:
     from ..models.open_flow_w_path_value_failure_module_mock import OpenFlowWPathValueFailureModuleMock
     from ..models.open_flow_w_path_value_failure_module_retry import OpenFlowWPathValueFailureModuleRetry
+    from ..models.open_flow_w_path_value_failure_module_skip_if import OpenFlowWPathValueFailureModuleSkipIf
     from ..models.open_flow_w_path_value_failure_module_sleep_type_0 import OpenFlowWPathValueFailureModuleSleepType0
     from ..models.open_flow_w_path_value_failure_module_sleep_type_1 import OpenFlowWPathValueFailureModuleSleepType1
     from ..models.open_flow_w_path_value_failure_module_stop_after_all_iters_if import (
@@ -28,6 +29,7 @@ class OpenFlowWPathValueFailureModule:
         value (Any):
         stop_after_if (Union[Unset, OpenFlowWPathValueFailureModuleStopAfterIf]):
         stop_after_all_iters_if (Union[Unset, OpenFlowWPathValueFailureModuleStopAfterAllItersIf]):
+        skip_if (Union[Unset, OpenFlowWPathValueFailureModuleSkipIf]):
         sleep (Union['OpenFlowWPathValueFailureModuleSleepType0', 'OpenFlowWPathValueFailureModuleSleepType1', Unset]):
         cache_ttl (Union[Unset, float]):
         timeout (Union[Unset, float]):
@@ -44,6 +46,7 @@ class OpenFlowWPathValueFailureModule:
     value: Any
     stop_after_if: Union[Unset, "OpenFlowWPathValueFailureModuleStopAfterIf"] = UNSET
     stop_after_all_iters_if: Union[Unset, "OpenFlowWPathValueFailureModuleStopAfterAllItersIf"] = UNSET
+    skip_if: Union[Unset, "OpenFlowWPathValueFailureModuleSkipIf"] = UNSET
     sleep: Union[
         "OpenFlowWPathValueFailureModuleSleepType0", "OpenFlowWPathValueFailureModuleSleepType1", Unset
     ] = UNSET
@@ -73,6 +76,10 @@ class OpenFlowWPathValueFailureModule:
         if not isinstance(self.stop_after_all_iters_if, Unset):
             stop_after_all_iters_if = self.stop_after_all_iters_if.to_dict()
 
+        skip_if: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.skip_if, Unset):
+            skip_if = self.skip_if.to_dict()
+
         sleep: Union[Dict[str, Any], Unset]
         if isinstance(self.sleep, Unset):
             sleep = UNSET
@@ -117,6 +124,8 @@ class OpenFlowWPathValueFailureModule:
             field_dict["stop_after_if"] = stop_after_if
         if stop_after_all_iters_if is not UNSET:
             field_dict["stop_after_all_iters_if"] = stop_after_all_iters_if
+        if skip_if is not UNSET:
+            field_dict["skip_if"] = skip_if
         if sleep is not UNSET:
             field_dict["sleep"] = sleep
         if cache_ttl is not UNSET:
@@ -144,6 +153,7 @@ class OpenFlowWPathValueFailureModule:
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         from ..models.open_flow_w_path_value_failure_module_mock import OpenFlowWPathValueFailureModuleMock
         from ..models.open_flow_w_path_value_failure_module_retry import OpenFlowWPathValueFailureModuleRetry
+        from ..models.open_flow_w_path_value_failure_module_skip_if import OpenFlowWPathValueFailureModuleSkipIf
         from ..models.open_flow_w_path_value_failure_module_sleep_type_0 import (
             OpenFlowWPathValueFailureModuleSleepType0,
         )
@@ -179,6 +189,13 @@ class OpenFlowWPathValueFailureModule:
                 _stop_after_all_iters_if
             )
 
+        _skip_if = d.pop("skip_if", UNSET)
+        skip_if: Union[Unset, OpenFlowWPathValueFailureModuleSkipIf]
+        if isinstance(_skip_if, Unset):
+            skip_if = UNSET
+        else:
+            skip_if = OpenFlowWPathValueFailureModuleSkipIf.from_dict(_skip_if)
+
         def _parse_sleep(
             data: object,
         ) -> Union["OpenFlowWPathValueFailureModuleSleepType0", "OpenFlowWPathValueFailureModuleSleepType1", Unset]:
@@ -248,6 +265,7 @@ class OpenFlowWPathValueFailureModule:
             value=value,
             stop_after_if=stop_after_if,
             stop_after_all_iters_if=stop_after_all_iters_if,
+            skip_if=skip_if,
             sleep=sleep,
             cache_ttl=cache_ttl,
             timeout=timeout,

windmill_api/models/open_flow_w_path_value_failure_module_skip_if.py

@@ -0,0 +1,58 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="OpenFlowWPathValueFailureModuleSkipIf")
+
+
+@_attrs_define
+class OpenFlowWPathValueFailureModuleSkipIf:
+    """
+    Attributes:
+        expr (str):
+    """
+
+    expr: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        expr = self.expr
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "expr": expr,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        expr = d.pop("expr")
+
+        open_flow_w_path_value_failure_module_skip_if = cls(
+            expr=expr,
+        )
+
+        open_flow_w_path_value_failure_module_skip_if.additional_properties = d
+        return open_flow_w_path_value_failure_module_skip_if
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties