windmill-api 1.478.1__py3-none-any.whl → 1.479.1__py3-none-any.whl

windmill_api/models/extended_jobs_jobs_item_type_1_language.py

@@ -10,9 +10,11 @@ class ExtendedJobsJobsItemType1Language(str, Enum):
     DENO = "deno"
     GO = "go"
     GRAPHQL = "graphql"
+    JAVA = "java"
     MSSQL = "mssql"
     MYSQL = "mysql"
     NATIVETS = "nativets"
+    NU = "nu"
     ORACLEDB = "oracledb"
     PHP = "php"
     POSTGRESQL = "postgresql"

windmill_api/models/get_completed_job_response_200_language.py

@@ -10,9 +10,11 @@ class GetCompletedJobResponse200Language(str, Enum):
     DENO = "deno"
     GO = "go"
     GRAPHQL = "graphql"
+    JAVA = "java"
     MSSQL = "mssql"
     MYSQL = "mysql"
     NATIVETS = "nativets"
+    NU = "nu"
     ORACLEDB = "oracledb"
     PHP = "php"
     POSTGRESQL = "postgresql"

windmill_api/models/get_copilot_info_response_200.py

@@ -0,0 +1,111 @@
+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.get_copilot_info_response_200_code_completion_model import (
+        GetCopilotInfoResponse200CodeCompletionModel,
+    )
+    from ..models.get_copilot_info_response_200_default_model import GetCopilotInfoResponse200DefaultModel
+    from ..models.get_copilot_info_response_200_providers import GetCopilotInfoResponse200Providers
+
+
+T = TypeVar("T", bound="GetCopilotInfoResponse200")
+
+
+@_attrs_define
+class GetCopilotInfoResponse200:
+    """
+    Attributes:
+        providers (Union[Unset, GetCopilotInfoResponse200Providers]):
+        default_model (Union[Unset, GetCopilotInfoResponse200DefaultModel]):
+        code_completion_model (Union[Unset, GetCopilotInfoResponse200CodeCompletionModel]):
+    """
+
+    providers: Union[Unset, "GetCopilotInfoResponse200Providers"] = UNSET
+    default_model: Union[Unset, "GetCopilotInfoResponse200DefaultModel"] = UNSET
+    code_completion_model: Union[Unset, "GetCopilotInfoResponse200CodeCompletionModel"] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        providers: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.providers, Unset):
+            providers = self.providers.to_dict()
+
+        default_model: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.default_model, Unset):
+            default_model = self.default_model.to_dict()
+
+        code_completion_model: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.code_completion_model, Unset):
+            code_completion_model = self.code_completion_model.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if providers is not UNSET:
+            field_dict["providers"] = providers
+        if default_model is not UNSET:
+            field_dict["default_model"] = default_model
+        if code_completion_model is not UNSET:
+            field_dict["code_completion_model"] = code_completion_model
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.get_copilot_info_response_200_code_completion_model import (
+            GetCopilotInfoResponse200CodeCompletionModel,
+        )
+        from ..models.get_copilot_info_response_200_default_model import GetCopilotInfoResponse200DefaultModel
+        from ..models.get_copilot_info_response_200_providers import GetCopilotInfoResponse200Providers
+
+        d = src_dict.copy()
+        _providers = d.pop("providers", UNSET)
+        providers: Union[Unset, GetCopilotInfoResponse200Providers]
+        if isinstance(_providers, Unset):
+            providers = UNSET
+        else:
+            providers = GetCopilotInfoResponse200Providers.from_dict(_providers)
+
+        _default_model = d.pop("default_model", UNSET)
+        default_model: Union[Unset, GetCopilotInfoResponse200DefaultModel]
+        if isinstance(_default_model, Unset):
+            default_model = UNSET
+        else:
+            default_model = GetCopilotInfoResponse200DefaultModel.from_dict(_default_model)
+
+        _code_completion_model = d.pop("code_completion_model", UNSET)
+        code_completion_model: Union[Unset, GetCopilotInfoResponse200CodeCompletionModel]
+        if isinstance(_code_completion_model, Unset):
+            code_completion_model = UNSET
+        else:
+            code_completion_model = GetCopilotInfoResponse200CodeCompletionModel.from_dict(_code_completion_model)
+
+        get_copilot_info_response_200 = cls(
+            providers=providers,
+            default_model=default_model,
+            code_completion_model=code_completion_model,
+        )
+
+        get_copilot_info_response_200.additional_properties = d
+        return get_copilot_info_response_200
+
+    @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/get_copilot_info_response_200_code_completion_model.py

@@ -0,0 +1,69 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.get_copilot_info_response_200_code_completion_model_provider import (
+    GetCopilotInfoResponse200CodeCompletionModelProvider,
+)
+
+T = TypeVar("T", bound="GetCopilotInfoResponse200CodeCompletionModel")
+
+
+@_attrs_define
+class GetCopilotInfoResponse200CodeCompletionModel:
+    """
+    Attributes:
+        model (str):
+        provider (GetCopilotInfoResponse200CodeCompletionModelProvider):
+    """
+
+    model: str
+    provider: GetCopilotInfoResponse200CodeCompletionModelProvider
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        model = self.model
+        provider = self.provider.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+                "provider": provider,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        model = d.pop("model")
+
+        provider = GetCopilotInfoResponse200CodeCompletionModelProvider(d.pop("provider"))
+
+        get_copilot_info_response_200_code_completion_model = cls(
+            model=model,
+            provider=provider,
+        )
+
+        get_copilot_info_response_200_code_completion_model.additional_properties = d
+        return get_copilot_info_response_200_code_completion_model
+
+    @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/get_copilot_info_response_200_code_completion_model_provider.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class GetCopilotInfoResponse200CodeCompletionModelProvider(str, Enum):
+    ANTHROPIC = "anthropic"
+    CUSTOMAI = "customai"
+    DEEPSEEK = "deepseek"
+    GOOGLEAI = "googleai"
+    GROQ = "groq"
+    MISTRAL = "mistral"
+    OPENAI = "openai"
+    OPENROUTER = "openrouter"
+    TOGETHERAI = "togetherai"
+
+    def __str__(self) -> str:
+        return str(self.value)

windmill_api/models/get_copilot_info_response_200_default_model.py

@@ -0,0 +1,67 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.get_copilot_info_response_200_default_model_provider import GetCopilotInfoResponse200DefaultModelProvider
+
+T = TypeVar("T", bound="GetCopilotInfoResponse200DefaultModel")
+
+
+@_attrs_define
+class GetCopilotInfoResponse200DefaultModel:
+    """
+    Attributes:
+        model (str):
+        provider (GetCopilotInfoResponse200DefaultModelProvider):
+    """
+
+    model: str
+    provider: GetCopilotInfoResponse200DefaultModelProvider
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        model = self.model
+        provider = self.provider.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+                "provider": provider,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        model = d.pop("model")
+
+        provider = GetCopilotInfoResponse200DefaultModelProvider(d.pop("provider"))
+
+        get_copilot_info_response_200_default_model = cls(
+            model=model,
+            provider=provider,
+        )
+
+        get_copilot_info_response_200_default_model.additional_properties = d
+        return get_copilot_info_response_200_default_model
+
+    @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/get_copilot_info_response_200_default_model_provider.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class GetCopilotInfoResponse200DefaultModelProvider(str, Enum):
+    ANTHROPIC = "anthropic"
+    CUSTOMAI = "customai"
+    DEEPSEEK = "deepseek"
+    GOOGLEAI = "googleai"
+    GROQ = "groq"
+    MISTRAL = "mistral"
+    OPENAI = "openai"
+    OPENROUTER = "openrouter"
+    TOGETHERAI = "togetherai"
+
+    def __str__(self) -> str:
+        return str(self.value)

windmill_api/models/get_copilot_info_response_200_providers.py

@@ -0,0 +1,66 @@
+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.get_copilot_info_response_200_providers_additional_property import (
+        GetCopilotInfoResponse200ProvidersAdditionalProperty,
+    )
+
+
+T = TypeVar("T", bound="GetCopilotInfoResponse200Providers")
+
+
+@_attrs_define
+class GetCopilotInfoResponse200Providers:
+    """ """
+
+    additional_properties: Dict[str, "GetCopilotInfoResponse200ProvidersAdditionalProperty"] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> Dict[str, Any]:
+        pass
+
+        field_dict: Dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.get_copilot_info_response_200_providers_additional_property import (
+            GetCopilotInfoResponse200ProvidersAdditionalProperty,
+        )
+
+        d = src_dict.copy()
+        get_copilot_info_response_200_providers = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = GetCopilotInfoResponse200ProvidersAdditionalProperty.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        get_copilot_info_response_200_providers.additional_properties = additional_properties
+        return get_copilot_info_response_200_providers
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> "GetCopilotInfoResponse200ProvidersAdditionalProperty":
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: "GetCopilotInfoResponse200ProvidersAdditionalProperty") -> 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/get_copilot_info_response_200_providers_additional_property.py

@@ -0,0 +1,65 @@
+from typing import Any, Dict, List, Type, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="GetCopilotInfoResponse200ProvidersAdditionalProperty")
+
+
+@_attrs_define
+class GetCopilotInfoResponse200ProvidersAdditionalProperty:
+    """
+    Attributes:
+        resource_path (str):
+        models (List[str]):
+    """
+
+    resource_path: str
+    models: List[str]
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        resource_path = self.resource_path
+        models = self.models
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "resource_path": resource_path,
+                "models": models,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        resource_path = d.pop("resource_path")
+
+        models = cast(List[str], d.pop("models"))
+
+        get_copilot_info_response_200_providers_additional_property = cls(
+            resource_path=resource_path,
+            models=models,
+        )
+
+        get_copilot_info_response_200_providers_additional_property.additional_properties = d
+        return get_copilot_info_response_200_providers_additional_property
+
+    @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/get_github_app_token_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="GetGithubAppTokenJsonBody")
+
+
+@_attrs_define
+class GetGithubAppTokenJsonBody:
+    """
+    Attributes:
+        job_token (str):
+    """
+
+    job_token: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        job_token = self.job_token
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "job_token": job_token,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        job_token = d.pop("job_token")
+
+        get_github_app_token_json_body = cls(
+            job_token=job_token,
+        )
+
+        get_github_app_token_json_body.additional_properties = d
+        return get_github_app_token_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/get_github_app_token_response_200.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="GetGithubAppTokenResponse200")
+
+
+@_attrs_define
+class GetGithubAppTokenResponse200:
+    """
+    Attributes:
+        token (str):
+    """
+
+    token: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        token = self.token
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "token": token,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        token = d.pop("token")
+
+        get_github_app_token_response_200 = cls(
+            token=token,
+        )
+
+        get_github_app_token_response_200.additional_properties = d
+        return get_github_app_token_response_200
+
+    @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/get_global_connected_repositories_response_200_item.py

@@ -0,0 +1,104 @@
+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.get_global_connected_repositories_response_200_item_repositories_item import (
+        GetGlobalConnectedRepositoriesResponse200ItemRepositoriesItem,
+    )
+
+
+T = TypeVar("T", bound="GetGlobalConnectedRepositoriesResponse200Item")
+
+
+@_attrs_define
+class GetGlobalConnectedRepositoriesResponse200Item:
+    """
+    Attributes:
+        installation_id (float):
+        account_id (str):
+        repositories (List['GetGlobalConnectedRepositoriesResponse200ItemRepositoriesItem']):
+        workspace_id (Union[Unset, str]):
+    """
+
+    installation_id: float
+    account_id: str
+    repositories: List["GetGlobalConnectedRepositoriesResponse200ItemRepositoriesItem"]
+    workspace_id: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        installation_id = self.installation_id
+        account_id = self.account_id
+        repositories = []
+        for repositories_item_data in self.repositories:
+            repositories_item = repositories_item_data.to_dict()
+
+            repositories.append(repositories_item)
+
+        workspace_id = self.workspace_id
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "installation_id": installation_id,
+                "account_id": account_id,
+                "repositories": repositories,
+            }
+        )
+        if workspace_id is not UNSET:
+            field_dict["workspace_id"] = workspace_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.get_global_connected_repositories_response_200_item_repositories_item import (
+            GetGlobalConnectedRepositoriesResponse200ItemRepositoriesItem,
+        )
+
+        d = src_dict.copy()
+        installation_id = d.pop("installation_id")
+
+        account_id = d.pop("account_id")
+
+        repositories = []
+        _repositories = d.pop("repositories")
+        for repositories_item_data in _repositories:
+            repositories_item = GetGlobalConnectedRepositoriesResponse200ItemRepositoriesItem.from_dict(
+                repositories_item_data
+            )
+
+            repositories.append(repositories_item)
+
+        workspace_id = d.pop("workspace_id", UNSET)
+
+        get_global_connected_repositories_response_200_item = cls(
+            installation_id=installation_id,
+            account_id=account_id,
+            repositories=repositories,
+            workspace_id=workspace_id,
+        )
+
+        get_global_connected_repositories_response_200_item.additional_properties = d
+        return get_global_connected_repositories_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