windmill-api 1.440.1__py3-none-any.whl → 1.450.1__py3-none-any.whl

windmill_api/models/script.py

@@ -59,6 +59,7 @@ class Script:
         delete_after_use (Union[Unset, bool]):
         visible_to_runner_only (Union[Unset, bool]):
         codebase (Union[Unset, str]):
+        on_behalf_of_email (Union[Unset, str]):
     """
 
     hash_: str
@@ -98,6 +99,7 @@ class Script:
     delete_after_use: Union[Unset, bool] = UNSET
     visible_to_runner_only: Union[Unset, bool] = UNSET
     codebase: Union[Unset, str] = UNSET
+    on_behalf_of_email: Union[Unset, str] = UNSET
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
@@ -151,6 +153,7 @@ class Script:
         delete_after_use = self.delete_after_use
         visible_to_runner_only = self.visible_to_runner_only
         codebase = self.codebase
+        on_behalf_of_email = self.on_behalf_of_email
 
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
@@ -216,6 +219,8 @@ class Script:
             field_dict["visible_to_runner_only"] = visible_to_runner_only
         if codebase is not UNSET:
             field_dict["codebase"] = codebase
+        if on_behalf_of_email is not UNSET:
+            field_dict["on_behalf_of_email"] = on_behalf_of_email
 
         return field_dict
 
@@ -304,6 +309,8 @@ class Script:
 
         codebase = d.pop("codebase", UNSET)
 
+        on_behalf_of_email = d.pop("on_behalf_of_email", UNSET)
+
         script = cls(
             hash_=hash_,
             path=path,
@@ -342,6 +349,7 @@ class Script:
             delete_after_use=delete_after_use,
             visible_to_runner_only=visible_to_runner_only,
             codebase=codebase,
+            on_behalf_of_email=on_behalf_of_email,
         )
 
         script.additional_properties = d

windmill_api/models/script_kind.py

@@ -5,6 +5,7 @@ class ScriptKind(str, Enum):
     APPROVAL = "approval"
     COMMAND = "command"
     FAILURE = "failure"
+    PREPROCESSOR = "preprocessor"
     SCRIPT = "script"
     TRIGGER = "trigger"
 

windmill_api/models/script_lang.py

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

windmill_api/models/script_language.py

@@ -13,6 +13,7 @@ class ScriptLanguage(str, Enum):
     MSSQL = "mssql"
     MYSQL = "mysql"
     NATIVETS = "nativets"
+    ORACLEDB = "oracledb"
     PHP = "php"
     POSTGRESQL = "postgresql"
     POWERSHELL = "powershell"

windmill_api/models/set_capture_config_json_body.py

@@ -0,0 +1,97 @@
+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 ..models.set_capture_config_json_body_trigger_kind import SetCaptureConfigJsonBodyTriggerKind
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.set_capture_config_json_body_trigger_config import SetCaptureConfigJsonBodyTriggerConfig
+
+
+T = TypeVar("T", bound="SetCaptureConfigJsonBody")
+
+
+@_attrs_define
+class SetCaptureConfigJsonBody:
+    """
+    Attributes:
+        trigger_kind (SetCaptureConfigJsonBodyTriggerKind):
+        path (str):
+        is_flow (bool):
+        trigger_config (Union[Unset, SetCaptureConfigJsonBodyTriggerConfig]):
+    """
+
+    trigger_kind: SetCaptureConfigJsonBodyTriggerKind
+    path: str
+    is_flow: bool
+    trigger_config: Union[Unset, "SetCaptureConfigJsonBodyTriggerConfig"] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        trigger_kind = self.trigger_kind.value
+
+        path = self.path
+        is_flow = self.is_flow
+        trigger_config: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.trigger_config, Unset):
+            trigger_config = self.trigger_config.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "trigger_kind": trigger_kind,
+                "path": path,
+                "is_flow": is_flow,
+            }
+        )
+        if trigger_config is not UNSET:
+            field_dict["trigger_config"] = trigger_config
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.set_capture_config_json_body_trigger_config import SetCaptureConfigJsonBodyTriggerConfig
+
+        d = src_dict.copy()
+        trigger_kind = SetCaptureConfigJsonBodyTriggerKind(d.pop("trigger_kind"))
+
+        path = d.pop("path")
+
+        is_flow = d.pop("is_flow")
+
+        _trigger_config = d.pop("trigger_config", UNSET)
+        trigger_config: Union[Unset, SetCaptureConfigJsonBodyTriggerConfig]
+        if isinstance(_trigger_config, Unset):
+            trigger_config = UNSET
+        else:
+            trigger_config = SetCaptureConfigJsonBodyTriggerConfig.from_dict(_trigger_config)
+
+        set_capture_config_json_body = cls(
+            trigger_kind=trigger_kind,
+            path=path,
+            is_flow=is_flow,
+            trigger_config=trigger_config,
+        )
+
+        set_capture_config_json_body.additional_properties = d
+        return set_capture_config_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/set_capture_config_json_body_trigger_config.py

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

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class SetCaptureConfigJsonBodyTriggerKind(str, Enum):
+    EMAIL = "email"
+    HTTP = "http"
+    KAFKA = "kafka"
+    NATS = "nats"
+    WEBHOOK = "webhook"
+    WEBSOCKET = "websocket"
+
+    def __str__(self) -> str:
+        return str(self.value)

windmill_api/models/set_nats_trigger_enabled_json_body.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="SetNatsTriggerEnabledJsonBody")
+
+
+@_attrs_define
+class SetNatsTriggerEnabledJsonBody:
+    """
+    Attributes:
+        enabled (bool):
+    """
+
+    enabled: bool
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        enabled = self.enabled
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "enabled": enabled,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        enabled = d.pop("enabled")
+
+        set_nats_trigger_enabled_json_body = cls(
+            enabled=enabled,
+        )
+
+        set_nats_trigger_enabled_json_body.additional_properties = d
+        return set_nats_trigger_enabled_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/set_postgres_trigger_enabled_json_body.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="SetPostgresTriggerEnabledJsonBody")
+
+
+@_attrs_define
+class SetPostgresTriggerEnabledJsonBody:
+    """
+    Attributes:
+        enabled (bool):
+    """
+
+    enabled: bool
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        enabled = self.enabled
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "enabled": enabled,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        enabled = d.pop("enabled")
+
+        set_postgres_trigger_enabled_json_body = cls(
+            enabled=enabled,
+        )
+
+        set_postgres_trigger_enabled_json_body.additional_properties = d
+        return set_postgres_trigger_enabled_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/set_threshold_alert_json_body.py

@@ -0,0 +1,58 @@
+from typing import 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
+
+T = TypeVar("T", bound="SetThresholdAlertJsonBody")
+
+
+@_attrs_define
+class SetThresholdAlertJsonBody:
+    """
+    Attributes:
+        threshold_alert_amount (Union[Unset, float]):
+    """
+
+    threshold_alert_amount: Union[Unset, float] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        threshold_alert_amount = self.threshold_alert_amount
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if threshold_alert_amount is not UNSET:
+            field_dict["threshold_alert_amount"] = threshold_alert_amount
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        threshold_alert_amount = d.pop("threshold_alert_amount", UNSET)
+
+        set_threshold_alert_json_body = cls(
+            threshold_alert_amount=threshold_alert_amount,
+        )
+
+        set_threshold_alert_json_body.additional_properties = d
+        return set_threshold_alert_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/slot.py

@@ -0,0 +1,58 @@
+from typing import 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
+
+T = TypeVar("T", bound="Slot")
+
+
+@_attrs_define
+class Slot:
+    """
+    Attributes:
+        name (Union[Unset, str]):
+    """
+
+    name: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        name = self.name
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        name = d.pop("name", UNSET)
+
+        slot = cls(
+            name=name,
+        )
+
+        slot.additional_properties = d
+        return slot
+
+    @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/slot_list.py

@@ -0,0 +1,66 @@
+from typing import 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
+
+T = TypeVar("T", bound="SlotList")
+
+
+@_attrs_define
+class SlotList:
+    """
+    Attributes:
+        slot_name (Union[Unset, str]):
+        active (Union[Unset, bool]):
+    """
+
+    slot_name: Union[Unset, str] = UNSET
+    active: Union[Unset, bool] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        slot_name = self.slot_name
+        active = self.active
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if slot_name is not UNSET:
+            field_dict["slot_name"] = slot_name
+        if active is not UNSET:
+            field_dict["active"] = active
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        slot_name = d.pop("slot_name", UNSET)
+
+        active = d.pop("active", UNSET)
+
+        slot_list = cls(
+            slot_name=slot_name,
+            active=active,
+        )
+
+        slot_list.additional_properties = d
+        return slot_list
+
+    @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/sync_teams_response_200_item.py

@@ -0,0 +1,87 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.sync_teams_response_200_item_channels_item import SyncTeamsResponse200ItemChannelsItem
+
+
+T = TypeVar("T", bound="SyncTeamsResponse200Item")
+
+
+@_attrs_define
+class SyncTeamsResponse200Item:
+    """
+    Attributes:
+        team_id (str): The unique identifier of the Microsoft Teams team Example: 19:abc123def456@thread.tacv2.
+        team_name (str): The display name of the Microsoft Teams team Example: Engineering Team.
+        channels (List['SyncTeamsResponse200ItemChannelsItem']): List of channels within the team
+    """
+
+    team_id: str
+    team_name: str
+    channels: List["SyncTeamsResponse200ItemChannelsItem"]
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        team_id = self.team_id
+        team_name = self.team_name
+        channels = []
+        for channels_item_data in self.channels:
+            channels_item = channels_item_data.to_dict()
+
+            channels.append(channels_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "team_id": team_id,
+                "team_name": team_name,
+                "channels": channels,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.sync_teams_response_200_item_channels_item import SyncTeamsResponse200ItemChannelsItem
+
+        d = src_dict.copy()
+        team_id = d.pop("team_id")
+
+        team_name = d.pop("team_name")
+
+        channels = []
+        _channels = d.pop("channels")
+        for channels_item_data in _channels:
+            channels_item = SyncTeamsResponse200ItemChannelsItem.from_dict(channels_item_data)
+
+            channels.append(channels_item)
+
+        sync_teams_response_200_item = cls(
+            team_id=team_id,
+            team_name=team_name,
+            channels=channels,
+        )
+
+        sync_teams_response_200_item.additional_properties = d
+        return sync_teams_response_200_item
+
+    @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