windmill-api 1.543.0__py3-none-any.whl → 1.544.1__py3-none-any.whl

windmill_api/models/run_dynamic_select_json_body.py

@@ -0,0 +1,118 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.run_dynamic_select_json_body_args import RunDynamicSelectJsonBodyArgs
+    from ..models.run_dynamic_select_json_body_runnable_ref_type_0 import RunDynamicSelectJsonBodyRunnableRefType0
+    from ..models.run_dynamic_select_json_body_runnable_ref_type_1 import RunDynamicSelectJsonBodyRunnableRefType1
+
+
+T = TypeVar("T", bound="RunDynamicSelectJsonBody")
+
+
+@_attrs_define
+class RunDynamicSelectJsonBody:
+    """
+    Attributes:
+        entrypoint_function (str): Name of the function to execute for dynamic select
+        runnable_ref (Union['RunDynamicSelectJsonBodyRunnableRefType0', 'RunDynamicSelectJsonBodyRunnableRefType1']):
+        args (Union[Unset, RunDynamicSelectJsonBodyArgs]): Arguments to pass to the function
+    """
+
+    entrypoint_function: str
+    runnable_ref: Union["RunDynamicSelectJsonBodyRunnableRefType0", "RunDynamicSelectJsonBodyRunnableRefType1"]
+    args: Union[Unset, "RunDynamicSelectJsonBodyArgs"] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.run_dynamic_select_json_body_runnable_ref_type_0 import RunDynamicSelectJsonBodyRunnableRefType0
+
+        entrypoint_function = self.entrypoint_function
+        runnable_ref: Dict[str, Any]
+
+        if isinstance(self.runnable_ref, RunDynamicSelectJsonBodyRunnableRefType0):
+            runnable_ref = self.runnable_ref.to_dict()
+
+        else:
+            runnable_ref = self.runnable_ref.to_dict()
+
+        args: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.args, Unset):
+            args = self.args.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entrypoint_function": entrypoint_function,
+                "runnable_ref": runnable_ref,
+            }
+        )
+        if args is not UNSET:
+            field_dict["args"] = args
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.run_dynamic_select_json_body_args import RunDynamicSelectJsonBodyArgs
+        from ..models.run_dynamic_select_json_body_runnable_ref_type_0 import RunDynamicSelectJsonBodyRunnableRefType0
+        from ..models.run_dynamic_select_json_body_runnable_ref_type_1 import RunDynamicSelectJsonBodyRunnableRefType1
+
+        d = src_dict.copy()
+        entrypoint_function = d.pop("entrypoint_function")
+
+        def _parse_runnable_ref(
+            data: object,
+        ) -> Union["RunDynamicSelectJsonBodyRunnableRefType0", "RunDynamicSelectJsonBodyRunnableRefType1"]:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                runnable_ref_type_0 = RunDynamicSelectJsonBodyRunnableRefType0.from_dict(data)
+
+                return runnable_ref_type_0
+            except:  # noqa: E722
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            runnable_ref_type_1 = RunDynamicSelectJsonBodyRunnableRefType1.from_dict(data)
+
+            return runnable_ref_type_1
+
+        runnable_ref = _parse_runnable_ref(d.pop("runnable_ref"))
+
+        _args = d.pop("args", UNSET)
+        args: Union[Unset, RunDynamicSelectJsonBodyArgs]
+        if isinstance(_args, Unset):
+            args = UNSET
+        else:
+            args = RunDynamicSelectJsonBodyArgs.from_dict(_args)
+
+        run_dynamic_select_json_body = cls(
+            entrypoint_function=entrypoint_function,
+            runnable_ref=runnable_ref,
+            args=args,
+        )
+
+        run_dynamic_select_json_body.additional_properties = d
+        return run_dynamic_select_json_body
+
+    @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/{openai_sync_script_by_path_json_body.py → run_dynamic_select_json_body_args.py}

@@ -3,12 +3,12 @@ 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="OpenaiSyncScriptByPathJsonBody")
+T = TypeVar("T", bound="RunDynamicSelectJsonBodyArgs")
 
 
 @_attrs_define
-class OpenaiSyncScriptByPathJsonBody:
-    """The arguments to pass to the script or flow"""
+class RunDynamicSelectJsonBodyArgs:
+    """Arguments to pass to the function"""
 
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -22,10 +22,10 @@ class OpenaiSyncScriptByPathJsonBody:
     @classmethod
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         d = src_dict.copy()
-        openai_sync_script_by_path_json_body = cls()
+        run_dynamic_select_json_body_args = cls()
 
-        openai_sync_script_by_path_json_body.additional_properties = d
-        return openai_sync_script_by_path_json_body
+        run_dynamic_select_json_body_args.additional_properties = d
+        return run_dynamic_select_json_body_args
 
     @property
     def additional_keys(self) -> List[str]:

windmill_api/models/run_dynamic_select_json_body_runnable_ref_type_0.py

@@ -0,0 +1,80 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.run_dynamic_select_json_body_runnable_ref_type_0_runnable_kind import (
+    RunDynamicSelectJsonBodyRunnableRefType0RunnableKind,
+)
+from ..models.run_dynamic_select_json_body_runnable_ref_type_0_source import (
+    RunDynamicSelectJsonBodyRunnableRefType0Source,
+)
+
+T = TypeVar("T", bound="RunDynamicSelectJsonBodyRunnableRefType0")
+
+
+@_attrs_define
+class RunDynamicSelectJsonBodyRunnableRefType0:
+    """
+    Attributes:
+        source (RunDynamicSelectJsonBodyRunnableRefType0Source):
+        path (str): Path to the deployed script or flow
+        runnable_kind (RunDynamicSelectJsonBodyRunnableRefType0RunnableKind):
+    """
+
+    source: RunDynamicSelectJsonBodyRunnableRefType0Source
+    path: str
+    runnable_kind: RunDynamicSelectJsonBodyRunnableRefType0RunnableKind
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        source = self.source.value
+
+        path = self.path
+        runnable_kind = self.runnable_kind.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "source": source,
+                "path": path,
+                "runnable_kind": runnable_kind,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        source = RunDynamicSelectJsonBodyRunnableRefType0Source(d.pop("source"))
+
+        path = d.pop("path")
+
+        runnable_kind = RunDynamicSelectJsonBodyRunnableRefType0RunnableKind(d.pop("runnable_kind"))
+
+        run_dynamic_select_json_body_runnable_ref_type_0 = cls(
+            source=source,
+            path=path,
+            runnable_kind=runnable_kind,
+        )
+
+        run_dynamic_select_json_body_runnable_ref_type_0.additional_properties = d
+        return run_dynamic_select_json_body_runnable_ref_type_0
+
+    @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/run_dynamic_select_json_body_runnable_ref_type_0_runnable_kind.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RunDynamicSelectJsonBodyRunnableRefType0RunnableKind(str, Enum):
+    FLOW = "flow"
+    SCRIPT = "script"
+
+    def __str__(self) -> str:
+        return str(self.value)

windmill_api/models/run_dynamic_select_json_body_runnable_ref_type_0_source.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class RunDynamicSelectJsonBodyRunnableRefType0Source(str, Enum):
+    DEPLOYED = "deployed"
+
+    def __str__(self) -> str:
+        return str(self.value)

windmill_api/models/run_dynamic_select_json_body_runnable_ref_type_1.py

@@ -0,0 +1,89 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.run_dynamic_select_json_body_runnable_ref_type_1_language import (
+    RunDynamicSelectJsonBodyRunnableRefType1Language,
+)
+from ..models.run_dynamic_select_json_body_runnable_ref_type_1_source import (
+    RunDynamicSelectJsonBodyRunnableRefType1Source,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RunDynamicSelectJsonBodyRunnableRefType1")
+
+
+@_attrs_define
+class RunDynamicSelectJsonBodyRunnableRefType1:
+    """
+    Attributes:
+        source (RunDynamicSelectJsonBodyRunnableRefType1Source):
+        code (str): Code content for inline execution
+        language (Union[Unset, RunDynamicSelectJsonBodyRunnableRefType1Language]):
+    """
+
+    source: RunDynamicSelectJsonBodyRunnableRefType1Source
+    code: str
+    language: Union[Unset, RunDynamicSelectJsonBodyRunnableRefType1Language] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        source = self.source.value
+
+        code = self.code
+        language: Union[Unset, str] = UNSET
+        if not isinstance(self.language, Unset):
+            language = self.language.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "source": source,
+                "code": code,
+            }
+        )
+        if language is not UNSET:
+            field_dict["language"] = language
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        source = RunDynamicSelectJsonBodyRunnableRefType1Source(d.pop("source"))
+
+        code = d.pop("code")
+
+        _language = d.pop("language", UNSET)
+        language: Union[Unset, RunDynamicSelectJsonBodyRunnableRefType1Language]
+        if isinstance(_language, Unset):
+            language = UNSET
+        else:
+            language = RunDynamicSelectJsonBodyRunnableRefType1Language(_language)
+
+        run_dynamic_select_json_body_runnable_ref_type_1 = cls(
+            source=source,
+            code=code,
+            language=language,
+        )
+
+        run_dynamic_select_json_body_runnable_ref_type_1.additional_properties = d
+        return run_dynamic_select_json_body_runnable_ref_type_1
+
+    @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/run_dynamic_select_json_body_runnable_ref_type_1_language.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+
+class RunDynamicSelectJsonBodyRunnableRefType1Language(str, Enum):
+    ANSIBLE = "ansible"
+    BASH = "bash"
+    BIGQUERY = "bigquery"
+    BUN = "bun"
+    CSHARP = "csharp"
+    DENO = "deno"
+    DUCKDB = "duckdb"
+    GO = "go"
+    GRAPHQL = "graphql"
+    JAVA = "java"
+    MSSQL = "mssql"
+    MYSQL = "mysql"
+    NATIVETS = "nativets"
+    NU = "nu"
+    ORACLEDB = "oracledb"
+    PHP = "php"
+    POSTGRESQL = "postgresql"
+    POWERSHELL = "powershell"
+    PYTHON3 = "python3"
+    RUBY = "ruby"
+    RUST = "rust"
+    SNOWFLAKE = "snowflake"
+
+    def __str__(self) -> str:
+        return str(self.value)

windmill_api/models/run_dynamic_select_json_body_runnable_ref_type_1_source.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class RunDynamicSelectJsonBodyRunnableRefType1Source(str, Enum):
+    INLINE = "inline"
+
+    def __str__(self) -> str:
+        return str(self.value)

windmill_api/models/s3_permission_rule.py

@@ -0,0 +1,65 @@
+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="S3PermissionRule")
+
+
+@_attrs_define
+class S3PermissionRule:
+    """
+    Attributes:
+        pattern (str):
+        allow (str):
+    """
+
+    pattern: str
+    allow: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        pattern = self.pattern
+        allow = self.allow
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "pattern": pattern,
+                "allow": allow,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        pattern = d.pop("pattern")
+
+        allow = d.pop("allow")
+
+        s3_permission_rule = cls(
+            pattern=pattern,
+            allow=allow,
+        )
+
+        s3_permission_rule.additional_properties = d
+        return s3_permission_rule
+
+    @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/update_gcp_trigger_json_body.py

@@ -33,6 +33,8 @@ class UpdateGcpTriggerJsonBody:
         delivery_config (Union[Unset, UpdateGcpTriggerJsonBodyDeliveryConfig]):
         enabled (Union[Unset, bool]):
         auto_acknowledge_msg (Union[Unset, bool]):
+        ack_deadline (Union[Unset, int]): Time in seconds within which the message must be acknowledged. If not
+            provided, defaults to the subscription's acknowledgment deadline (600 seconds).
         error_handler_path (Union[Unset, str]):
         error_handler_args (Union[Unset, UpdateGcpTriggerJsonBodyErrorHandlerArgs]): The arguments to pass to the script
             or flow
@@ -51,6 +53,7 @@ class UpdateGcpTriggerJsonBody:
     delivery_config: Union[Unset, "UpdateGcpTriggerJsonBodyDeliveryConfig"] = UNSET
     enabled: Union[Unset, bool] = UNSET
     auto_acknowledge_msg: Union[Unset, bool] = UNSET
+    ack_deadline: Union[Unset, int] = UNSET
     error_handler_path: Union[Unset, str] = UNSET
     error_handler_args: Union[Unset, "UpdateGcpTriggerJsonBodyErrorHandlerArgs"] = UNSET
     retry: Union[Unset, "UpdateGcpTriggerJsonBodyRetry"] = UNSET
@@ -76,6 +79,7 @@ class UpdateGcpTriggerJsonBody:
 
         enabled = self.enabled
         auto_acknowledge_msg = self.auto_acknowledge_msg
+        ack_deadline = self.ack_deadline
         error_handler_path = self.error_handler_path
         error_handler_args: Union[Unset, Dict[str, Any]] = UNSET
         if not isinstance(self.error_handler_args, Unset):
@@ -109,6 +113,8 @@ class UpdateGcpTriggerJsonBody:
             field_dict["enabled"] = enabled
         if auto_acknowledge_msg is not UNSET:
             field_dict["auto_acknowledge_msg"] = auto_acknowledge_msg
+        if ack_deadline is not UNSET:
+            field_dict["ack_deadline"] = ack_deadline
         if error_handler_path is not UNSET:
             field_dict["error_handler_path"] = error_handler_path
         if error_handler_args is not UNSET:
@@ -159,6 +165,8 @@ class UpdateGcpTriggerJsonBody:
 
         auto_acknowledge_msg = d.pop("auto_acknowledge_msg", UNSET)
 
+        ack_deadline = d.pop("ack_deadline", UNSET)
+
         error_handler_path = d.pop("error_handler_path", UNSET)
 
         _error_handler_args = d.pop("error_handler_args", UNSET)
@@ -188,6 +196,7 @@ class UpdateGcpTriggerJsonBody:
             delivery_config=delivery_config,
             enabled=enabled,
             auto_acknowledge_msg=auto_acknowledge_msg,
+            ack_deadline=ack_deadline,
             error_handler_path=error_handler_path,
             error_handler_args=error_handler_args,
             retry=retry,

{windmill_api-1.543.0.dist-info → windmill_api-1.544.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: windmill-api
-Version: 1.543.0
+Version: 1.544.1
 Summary: A client library for accessing Windmill API
 License: Apache-2.0
 Author: Ruben Fiszel