volcano-sdk-python 0.6.7__py3-none-any.whl

volcano_sdk/_generated/models/project_config_frontend.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.project_config_custom_domain import ProjectConfigCustomDomain
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigFrontend")
+
+
+
+@_attrs_define
+class ProjectConfigFrontend:
+    """ Configuration for an existing (deployed) frontend. Frontends are never
+    created or deleted through the manifest. A declared frontend entry
+    without `custom_domain` deletes an existing custom domain.
+
+        Attributes:
+            name (str):
+            custom_domain (ProjectConfigCustomDomain | Unset): Custom domain with BYOC TLS (PRO plan). `tls` is required
+                when the
+                domain is first created and optional afterwards: providing new TLS
+                material for the same domain rotates the certificate in place (zero
+                downtime); omitting `tls` keeps the stored certificate. TLS material is
+                write-only and omitted from config export.
+     """
+
+    name: str
+    custom_domain: ProjectConfigCustomDomain | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_config_custom_domain import ProjectConfigCustomDomain
+        name = self.name
+
+        custom_domain: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.custom_domain, Unset):
+            custom_domain = self.custom_domain.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "name": name,
+        })
+        if custom_domain is not UNSET:
+            field_dict["custom_domain"] = custom_domain
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_config_custom_domain import ProjectConfigCustomDomain
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        _custom_domain = d.pop("custom_domain", UNSET)
+        custom_domain: ProjectConfigCustomDomain | Unset
+        if isinstance(_custom_domain,  Unset):
+            custom_domain = UNSET
+        else:
+            custom_domain = ProjectConfigCustomDomain.from_dict(_custom_domain)
+
+
+
+
+        project_config_frontend = cls(
+            name=name,
+            custom_domain=custom_domain,
+        )
+
+        return project_config_frontend
+

volcano_sdk/_generated/models/project_config_function.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.function_http_auth_mode import check_function_http_auth_mode
+from ..models.function_http_auth_mode import FunctionHTTPAuthMode
+from ..models.function_invocation_mode import check_function_invocation_mode
+from ..models.function_invocation_mode import FunctionInvocationMode
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.project_config_function_openapi_spec_type_0 import ProjectConfigFunctionOpenapiSpecType0
+  from ..models.project_config_scheduler import ProjectConfigScheduler
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigFunction")
+
+
+
+@_attrs_define
+class ProjectConfigFunction:
+    """ Configuration for an existing (deployed) function. Functions are never
+    created or deleted through the manifest. When `schedulers` is declared
+    it is fully synced (schedulers absent from the list are deleted);
+    omitting `schedulers` leaves the function's schedulers untouched.
+
+        Attributes:
+            name (str):
+            public (bool | Unset): Function visibility for anon-key invocation
+            invocation_mode (FunctionInvocationMode | Unset): Invocation contract. `rpc` preserves the existing POST
+                `{payload: ...}` contract;
+                `http` forwards HTTP request semantics to the function runtime.
+            http_auth_mode (FunctionHTTPAuthMode | Unset): Authentication applied by the HTTP ingress. `none` is valid only
+                for public
+                HTTP-mode functions and is intended for externally signed webhooks.
+            openapi_spec (None | ProjectConfigFunctionOpenapiSpecType0 | Unset): OpenAPI 3.0 or 3.1 metadata for an HTTP-
+                mode function
+            schedulers (list[ProjectConfigScheduler] | Unset):
+     """
+
+    name: str
+    public: bool | Unset = UNSET
+    invocation_mode: FunctionInvocationMode | Unset = UNSET
+    http_auth_mode: FunctionHTTPAuthMode | Unset = UNSET
+    openapi_spec: None | ProjectConfigFunctionOpenapiSpecType0 | Unset = UNSET
+    schedulers: list[ProjectConfigScheduler] | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_config_function_openapi_spec_type_0 import ProjectConfigFunctionOpenapiSpecType0
+        from ..models.project_config_scheduler import ProjectConfigScheduler
+        name = self.name
+
+        public = self.public
+
+        invocation_mode: str | Unset = UNSET
+        if not isinstance(self.invocation_mode, Unset):
+            invocation_mode = self.invocation_mode
+
+
+        http_auth_mode: str | Unset = UNSET
+        if not isinstance(self.http_auth_mode, Unset):
+            http_auth_mode = self.http_auth_mode
+
+
+        openapi_spec: dict[str, Any] | None | Unset
+        if isinstance(self.openapi_spec, Unset):
+            openapi_spec = UNSET
+        elif isinstance(self.openapi_spec, ProjectConfigFunctionOpenapiSpecType0):
+            openapi_spec = self.openapi_spec.to_dict()
+        else:
+            openapi_spec = self.openapi_spec
+
+        schedulers: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.schedulers, Unset):
+            schedulers = []
+            for schedulers_item_data in self.schedulers:
+                schedulers_item = schedulers_item_data.to_dict()
+                schedulers.append(schedulers_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "name": name,
+        })
+        if public is not UNSET:
+            field_dict["public"] = public
+        if invocation_mode is not UNSET:
+            field_dict["invocation_mode"] = invocation_mode
+        if http_auth_mode is not UNSET:
+            field_dict["http_auth_mode"] = http_auth_mode
+        if openapi_spec is not UNSET:
+            field_dict["openapi_spec"] = openapi_spec
+        if schedulers is not UNSET:
+            field_dict["schedulers"] = schedulers
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_config_function_openapi_spec_type_0 import ProjectConfigFunctionOpenapiSpecType0
+        from ..models.project_config_scheduler import ProjectConfigScheduler
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        public = d.pop("public", UNSET)
+
+        _invocation_mode = d.pop("invocation_mode", UNSET)
+        invocation_mode: FunctionInvocationMode | Unset
+        if isinstance(_invocation_mode,  Unset):
+            invocation_mode = UNSET
+        else:
+            invocation_mode = check_function_invocation_mode(_invocation_mode)
+
+
+
+
+        _http_auth_mode = d.pop("http_auth_mode", UNSET)
+        http_auth_mode: FunctionHTTPAuthMode | Unset
+        if isinstance(_http_auth_mode,  Unset):
+            http_auth_mode = UNSET
+        else:
+            http_auth_mode = check_function_http_auth_mode(_http_auth_mode)
+
+
+
+
+        def _parse_openapi_spec(data: object) -> None | ProjectConfigFunctionOpenapiSpecType0 | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                openapi_spec_type_0 = ProjectConfigFunctionOpenapiSpecType0.from_dict(data)
+
+
+
+                return openapi_spec_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | ProjectConfigFunctionOpenapiSpecType0 | Unset, data)
+
+        openapi_spec = _parse_openapi_spec(d.pop("openapi_spec", UNSET))
+
+
+        _schedulers = d.pop("schedulers", UNSET)
+        schedulers: list[ProjectConfigScheduler] | Unset = UNSET
+        if _schedulers is not UNSET:
+            schedulers = []
+            for schedulers_item_data in _schedulers:
+                schedulers_item = ProjectConfigScheduler.from_dict(schedulers_item_data)
+
+
+
+                schedulers.append(schedulers_item)
+
+
+        project_config_function = cls(
+            name=name,
+            public=public,
+            invocation_mode=invocation_mode,
+            http_auth_mode=http_auth_mode,
+            openapi_spec=openapi_spec,
+            schedulers=schedulers,
+        )
+
+        return project_config_function
+

volcano_sdk/_generated/models/project_config_function_openapi_spec_type_0.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigFunctionOpenapiSpecType0")
+
+
+
+@_attrs_define
+class ProjectConfigFunctionOpenapiSpecType0:
+    """ OpenAPI 3.0 or 3.1 metadata for an HTTP-mode function
+
+     """
+
+    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)
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        project_config_function_openapi_spec_type_0 = cls(
+        )
+
+
+        project_config_function_openapi_spec_type_0.additional_properties = d
+        return project_config_function_openapi_spec_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

volcano_sdk/_generated/models/project_config_hosted_page.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigHostedPage")
+
+
+
+@_attrs_define
+class ProjectConfigHostedPage:
+    """ 
+        Attributes:
+            html (str): Raw HTML markup for the page. Max 256 KiB.
+            css (str | Unset): Optional CSS injected at render time. Max 256 KiB.
+     """
+
+    html: str
+    css: str | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        html = self.html
+
+        css = self.css
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "html": html,
+        })
+        if css is not UNSET:
+            field_dict["css"] = css
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        html = d.pop("html")
+
+        css = d.pop("css", UNSET)
+
+        project_config_hosted_page = cls(
+            html=html,
+            css=css,
+        )
+
+        return project_config_hosted_page
+

volcano_sdk/_generated/models/project_config_hosted_pages.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.project_config_hosted_page import ProjectConfigHostedPage
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigHostedPages")
+
+
+
+@_attrs_define
+class ProjectConfigHostedPages:
+    """ Hosted auth pages keyed by page type (PRO plan). Upsert-only: omitted
+    pages are left untouched (there is no delete for hosted pages).
+
+        Attributes:
+            login (ProjectConfigHostedPage | Unset):
+            reset_password (ProjectConfigHostedPage | Unset):
+            signup (ProjectConfigHostedPage | Unset):
+            forgot_password (ProjectConfigHostedPage | Unset):
+            device (ProjectConfigHostedPage | Unset):
+            verify_email (ProjectConfigHostedPage | Unset):
+     """
+
+    login: ProjectConfigHostedPage | Unset = UNSET
+    reset_password: ProjectConfigHostedPage | Unset = UNSET
+    signup: ProjectConfigHostedPage | Unset = UNSET
+    forgot_password: ProjectConfigHostedPage | Unset = UNSET
+    device: ProjectConfigHostedPage | Unset = UNSET
+    verify_email: ProjectConfigHostedPage | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_config_hosted_page import ProjectConfigHostedPage
+        login: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.login, Unset):
+            login = self.login.to_dict()
+
+        reset_password: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.reset_password, Unset):
+            reset_password = self.reset_password.to_dict()
+
+        signup: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.signup, Unset):
+            signup = self.signup.to_dict()
+
+        forgot_password: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.forgot_password, Unset):
+            forgot_password = self.forgot_password.to_dict()
+
+        device: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.device, Unset):
+            device = self.device.to_dict()
+
+        verify_email: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.verify_email, Unset):
+            verify_email = self.verify_email.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if login is not UNSET:
+            field_dict["login"] = login
+        if reset_password is not UNSET:
+            field_dict["reset_password"] = reset_password
+        if signup is not UNSET:
+            field_dict["signup"] = signup
+        if forgot_password is not UNSET:
+            field_dict["forgot_password"] = forgot_password
+        if device is not UNSET:
+            field_dict["device"] = device
+        if verify_email is not UNSET:
+            field_dict["verify_email"] = verify_email
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_config_hosted_page import ProjectConfigHostedPage
+        d = dict(src_dict)
+        _login = d.pop("login", UNSET)
+        login: ProjectConfigHostedPage | Unset
+        if isinstance(_login,  Unset):
+            login = UNSET
+        else:
+            login = ProjectConfigHostedPage.from_dict(_login)
+
+
+
+
+        _reset_password = d.pop("reset_password", UNSET)
+        reset_password: ProjectConfigHostedPage | Unset
+        if isinstance(_reset_password,  Unset):
+            reset_password = UNSET
+        else:
+            reset_password = ProjectConfigHostedPage.from_dict(_reset_password)
+
+
+
+
+        _signup = d.pop("signup", UNSET)
+        signup: ProjectConfigHostedPage | Unset
+        if isinstance(_signup,  Unset):
+            signup = UNSET
+        else:
+            signup = ProjectConfigHostedPage.from_dict(_signup)
+
+
+
+
+        _forgot_password = d.pop("forgot_password", UNSET)
+        forgot_password: ProjectConfigHostedPage | Unset
+        if isinstance(_forgot_password,  Unset):
+            forgot_password = UNSET
+        else:
+            forgot_password = ProjectConfigHostedPage.from_dict(_forgot_password)
+
+
+
+
+        _device = d.pop("device", UNSET)
+        device: ProjectConfigHostedPage | Unset
+        if isinstance(_device,  Unset):
+            device = UNSET
+        else:
+            device = ProjectConfigHostedPage.from_dict(_device)
+
+
+
+
+        _verify_email = d.pop("verify_email", UNSET)
+        verify_email: ProjectConfigHostedPage | Unset
+        if isinstance(_verify_email,  Unset):
+            verify_email = UNSET
+        else:
+            verify_email = ProjectConfigHostedPage.from_dict(_verify_email)
+
+
+
+
+        project_config_hosted_pages = cls(
+            login=login,
+            reset_password=reset_password,
+            signup=signup,
+            forgot_password=forgot_password,
+            device=device,
+            verify_email=verify_email,
+        )
+
+        return project_config_hosted_pages
+

volcano_sdk/_generated/models/project_config_missing_resource.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.project_config_missing_resource_type import check_project_config_missing_resource_type
+from ..models.project_config_missing_resource_type import ProjectConfigMissingResourceType
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigMissingResource")
+
+
+
+@_attrs_define
+class ProjectConfigMissingResource:
+    """ 
+        Attributes:
+            type_ (ProjectConfigMissingResourceType):
+            name (str):
+     """
+
+    type_: ProjectConfigMissingResourceType
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        type_: str = self.type_
+
+        name = self.name
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "type": type_,
+            "name": name,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = check_project_config_missing_resource_type(d.pop("type"))
+
+
+
+
+        name = d.pop("name")
+
+        project_config_missing_resource = cls(
+            type_=type_,
+            name=name,
+        )
+
+
+        project_config_missing_resource.additional_properties = d
+        return project_config_missing_resource
+
+    @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

volcano_sdk/_generated/models/project_config_missing_resource_type.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+ProjectConfigMissingResourceType = Literal['bucket', 'database', 'frontend', 'function']
+
+PROJECT_CONFIG_MISSING_RESOURCE_TYPE_VALUES: set[ProjectConfigMissingResourceType] = { 'bucket', 'database', 'frontend', 'function',  }
+
+def check_project_config_missing_resource_type(value: str) -> ProjectConfigMissingResourceType:
+    if value in PROJECT_CONFIG_MISSING_RESOURCE_TYPE_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {PROJECT_CONFIG_MISSING_RESOURCE_TYPE_VALUES!r}")