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

volcano_sdk/_generated/models/project_config_bucket.py

@@ -0,0 +1,118 @@
+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_bucket_policy import ProjectConfigBucketPolicy
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigBucket")
+
+
+
+@_attrs_define
+class ProjectConfigBucket:
+    """ Settings for an existing storage bucket. Buckets are never created or
+    deleted through the manifest. When `policies` is declared it is fully
+    synced (policies absent from the list are deleted; an empty list
+    deletes all); omitting `policies` leaves the bucket's policies
+    untouched.
+
+        Attributes:
+            name (str):
+            file_size_limit (int | Unset): Maximum file size in bytes
+            allowed_mime_types (list[str] | Unset):
+            policies (list[ProjectConfigBucketPolicy] | Unset):
+     """
+
+    name: str
+    file_size_limit: int | Unset = UNSET
+    allowed_mime_types: list[str] | Unset = UNSET
+    policies: list[ProjectConfigBucketPolicy] | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_config_bucket_policy import ProjectConfigBucketPolicy
+        name = self.name
+
+        file_size_limit = self.file_size_limit
+
+        allowed_mime_types: list[str] | Unset = UNSET
+        if not isinstance(self.allowed_mime_types, Unset):
+            allowed_mime_types = self.allowed_mime_types
+
+
+
+        policies: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.policies, Unset):
+            policies = []
+            for policies_item_data in self.policies:
+                policies_item = policies_item_data.to_dict()
+                policies.append(policies_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "name": name,
+        })
+        if file_size_limit is not UNSET:
+            field_dict["file_size_limit"] = file_size_limit
+        if allowed_mime_types is not UNSET:
+            field_dict["allowed_mime_types"] = allowed_mime_types
+        if policies is not UNSET:
+            field_dict["policies"] = policies
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_config_bucket_policy import ProjectConfigBucketPolicy
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        file_size_limit = d.pop("file_size_limit", UNSET)
+
+        allowed_mime_types = cast(list[str], d.pop("allowed_mime_types", UNSET))
+
+
+        _policies = d.pop("policies", UNSET)
+        policies: list[ProjectConfigBucketPolicy] | Unset = UNSET
+        if _policies is not UNSET:
+            policies = []
+            for policies_item_data in _policies:
+                policies_item = ProjectConfigBucketPolicy.from_dict(policies_item_data)
+
+
+
+                policies.append(policies_item)
+
+
+        project_config_bucket = cls(
+            name=name,
+            file_size_limit=file_size_limit,
+            allowed_mime_types=allowed_mime_types,
+            policies=policies,
+        )
+
+        return project_config_bucket
+

volcano_sdk/_generated/models/project_config_bucket_policy.py

@@ -0,0 +1,80 @@
+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_bucket_policy_operation import check_project_config_bucket_policy_operation
+from ..models.project_config_bucket_policy_operation import ProjectConfigBucketPolicyOperation
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigBucketPolicy")
+
+
+
+@_attrs_define
+class ProjectConfigBucketPolicy:
+    """ 
+        Attributes:
+            name (str):
+            operation (ProjectConfigBucketPolicyOperation):
+            definition (str): Policy expression
+     """
+
+    name: str
+    operation: ProjectConfigBucketPolicyOperation
+    definition: str
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        operation: str = self.operation
+
+        definition = self.definition
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "name": name,
+            "operation": operation,
+            "definition": definition,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        operation = check_project_config_bucket_policy_operation(d.pop("operation"))
+
+
+
+
+        definition = d.pop("definition")
+
+        project_config_bucket_policy = cls(
+            name=name,
+            operation=operation,
+            definition=definition,
+        )
+
+        return project_config_bucket_policy
+

volcano_sdk/_generated/models/project_config_bucket_policy_operation.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+ProjectConfigBucketPolicyOperation = Literal['DELETE', 'INSERT', 'SELECT', 'UPDATE']
+
+PROJECT_CONFIG_BUCKET_POLICY_OPERATION_VALUES: set[ProjectConfigBucketPolicyOperation] = { 'DELETE', 'INSERT', 'SELECT', 'UPDATE',  }
+
+def check_project_config_bucket_policy_operation(value: str) -> ProjectConfigBucketPolicyOperation:
+    if value in PROJECT_CONFIG_BUCKET_POLICY_OPERATION_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {PROJECT_CONFIG_BUCKET_POLICY_OPERATION_VALUES!r}")

volcano_sdk/_generated/models/project_config_custom_domain.py

@@ -0,0 +1,88 @@
+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.frontend_custom_domain_tls_config import FrontendCustomDomainTLSConfig
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigCustomDomain")
+
+
+
+@_attrs_define
+class ProjectConfigCustomDomain:
+    """ 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.
+
+        Attributes:
+            domain (str): Fully-qualified domain name (hostname only, no scheme/path)
+            tls (FrontendCustomDomainTLSConfig | Unset):
+     """
+
+    domain: str
+    tls: FrontendCustomDomainTLSConfig | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.frontend_custom_domain_tls_config import FrontendCustomDomainTLSConfig
+        domain = self.domain
+
+        tls: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.tls, Unset):
+            tls = self.tls.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "domain": domain,
+        })
+        if tls is not UNSET:
+            field_dict["tls"] = tls
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.frontend_custom_domain_tls_config import FrontendCustomDomainTLSConfig
+        d = dict(src_dict)
+        domain = d.pop("domain")
+
+        _tls = d.pop("tls", UNSET)
+        tls: FrontendCustomDomainTLSConfig | Unset
+        if isinstance(_tls,  Unset):
+            tls = UNSET
+        else:
+            tls = FrontendCustomDomainTLSConfig.from_dict(_tls)
+
+
+
+
+        project_config_custom_domain = cls(
+            domain=domain,
+            tls=tls,
+        )
+
+        return project_config_custom_domain
+

volcano_sdk/_generated/models/project_config_database.py

@@ -0,0 +1,109 @@
+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_database_database_type import check_project_config_database_database_type
+from ..models.project_config_database_database_type import ProjectConfigDatabaseDatabaseType
+from ..models.project_config_database_pg_version import check_project_config_database_pg_version
+from ..models.project_config_database_pg_version import ProjectConfigDatabasePgVersion
+from ..types import UNSET, Unset
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigDatabase")
+
+
+
+@_attrs_define
+class ProjectConfigDatabase:
+    """ Assertion-only entry for an existing database. No database property is
+    mutable through the manifest; declared values are compared against the
+    deployed database and any mismatch fails validation. Databases are
+    never created or deleted here.
+
+        Attributes:
+            name (str):
+            region (str): Deployed region ID (e.g. aws-us-east-1). Asserted, never written.
+            pg_version (ProjectConfigDatabasePgVersion): PostgreSQL major version. Asserted, never written.
+            database_type (ProjectConfigDatabaseDatabaseType | Unset): Compute tier. Asserted, never written - tier changes
+                are not
+                supported via the manifest; use the databases API/CLI/GUI instead.
+     """
+
+    name: str
+    region: str
+    pg_version: ProjectConfigDatabasePgVersion
+    database_type: ProjectConfigDatabaseDatabaseType | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        region = self.region
+
+        pg_version: str = self.pg_version
+
+        database_type: str | Unset = UNSET
+        if not isinstance(self.database_type, Unset):
+            database_type = self.database_type
+
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "name": name,
+            "region": region,
+            "pg_version": pg_version,
+        })
+        if database_type is not UNSET:
+            field_dict["database_type"] = database_type
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        region = d.pop("region")
+
+        pg_version = check_project_config_database_pg_version(d.pop("pg_version"))
+
+
+
+
+        _database_type = d.pop("database_type", UNSET)
+        database_type: ProjectConfigDatabaseDatabaseType | Unset
+        if isinstance(_database_type,  Unset):
+            database_type = UNSET
+        else:
+            database_type = check_project_config_database_database_type(_database_type)
+
+
+
+
+        project_config_database = cls(
+            name=name,
+            region=region,
+            pg_version=pg_version,
+            database_type=database_type,
+        )
+
+        return project_config_database
+

volcano_sdk/_generated/models/project_config_database_database_type.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+ProjectConfigDatabaseDatabaseType = Literal['volcano-db-2xl', 'volcano-db-l', 'volcano-db-m', 'volcano-db-s', 'volcano-db-xl', 'volcano-db-xs']
+
+PROJECT_CONFIG_DATABASE_DATABASE_TYPE_VALUES: set[ProjectConfigDatabaseDatabaseType] = { 'volcano-db-2xl', 'volcano-db-l', 'volcano-db-m', 'volcano-db-s', 'volcano-db-xl', 'volcano-db-xs',  }
+
+def check_project_config_database_database_type(value: str) -> ProjectConfigDatabaseDatabaseType:
+    if value in PROJECT_CONFIG_DATABASE_DATABASE_TYPE_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {PROJECT_CONFIG_DATABASE_DATABASE_TYPE_VALUES!r}")

volcano_sdk/_generated/models/project_config_database_pg_version.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+ProjectConfigDatabasePgVersion = Literal['15', '16']
+
+PROJECT_CONFIG_DATABASE_PG_VERSION_VALUES: set[ProjectConfigDatabasePgVersion] = { '15', '16',  }
+
+def check_project_config_database_pg_version(value: str) -> ProjectConfigDatabasePgVersion:
+    if value in PROJECT_CONFIG_DATABASE_PG_VERSION_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {PROJECT_CONFIG_DATABASE_PG_VERSION_VALUES!r}")

volcano_sdk/_generated/models/project_config_email_template.py

@@ -0,0 +1,78 @@
+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="ProjectConfigEmailTemplate")
+
+
+
+@_attrs_define
+class ProjectConfigEmailTemplate:
+    """ 
+        Attributes:
+            subject (str | Unset):
+            html_body (str | Unset): HTML body. Max 256 KiB. PRO plan required for custom bodies.
+            text_body (str | Unset): Plain-text body. Max 256 KiB. PRO plan required for custom bodies.
+     """
+
+    subject: str | Unset = UNSET
+    html_body: str | Unset = UNSET
+    text_body: str | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        subject = self.subject
+
+        html_body = self.html_body
+
+        text_body = self.text_body
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if subject is not UNSET:
+            field_dict["subject"] = subject
+        if html_body is not UNSET:
+            field_dict["html_body"] = html_body
+        if text_body is not UNSET:
+            field_dict["text_body"] = text_body
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        subject = d.pop("subject", UNSET)
+
+        html_body = d.pop("html_body", UNSET)
+
+        text_body = d.pop("text_body", UNSET)
+
+        project_config_email_template = cls(
+            subject=subject,
+            html_body=html_body,
+            text_body=text_body,
+        )
+
+        return project_config_email_template
+

volcano_sdk/_generated/models/project_config_email_templates.py

@@ -0,0 +1,136 @@
+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_email_template import ProjectConfigEmailTemplate
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigEmailTemplates")
+
+
+
+@_attrs_define
+class ProjectConfigEmailTemplates:
+    """ Email templates keyed by type. Fully synced when declared - template
+    types absent from a declared map revert to server defaults (custom
+    bodies deleted, subject overrides cleared). Custom template bodies
+    require the PRO plan; subject-only changes are available on FREE.
+
+        Attributes:
+            confirmation (ProjectConfigEmailTemplate | Unset):
+            password_reset (ProjectConfigEmailTemplate | Unset):
+            password_changed (ProjectConfigEmailTemplate | Unset):
+            welcome (ProjectConfigEmailTemplate | Unset):
+     """
+
+    confirmation: ProjectConfigEmailTemplate | Unset = UNSET
+    password_reset: ProjectConfigEmailTemplate | Unset = UNSET
+    password_changed: ProjectConfigEmailTemplate | Unset = UNSET
+    welcome: ProjectConfigEmailTemplate | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_config_email_template import ProjectConfigEmailTemplate
+        confirmation: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.confirmation, Unset):
+            confirmation = self.confirmation.to_dict()
+
+        password_reset: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.password_reset, Unset):
+            password_reset = self.password_reset.to_dict()
+
+        password_changed: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.password_changed, Unset):
+            password_changed = self.password_changed.to_dict()
+
+        welcome: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.welcome, Unset):
+            welcome = self.welcome.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if confirmation is not UNSET:
+            field_dict["confirmation"] = confirmation
+        if password_reset is not UNSET:
+            field_dict["password_reset"] = password_reset
+        if password_changed is not UNSET:
+            field_dict["password_changed"] = password_changed
+        if welcome is not UNSET:
+            field_dict["welcome"] = welcome
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_config_email_template import ProjectConfigEmailTemplate
+        d = dict(src_dict)
+        _confirmation = d.pop("confirmation", UNSET)
+        confirmation: ProjectConfigEmailTemplate | Unset
+        if isinstance(_confirmation,  Unset):
+            confirmation = UNSET
+        else:
+            confirmation = ProjectConfigEmailTemplate.from_dict(_confirmation)
+
+
+
+
+        _password_reset = d.pop("password_reset", UNSET)
+        password_reset: ProjectConfigEmailTemplate | Unset
+        if isinstance(_password_reset,  Unset):
+            password_reset = UNSET
+        else:
+            password_reset = ProjectConfigEmailTemplate.from_dict(_password_reset)
+
+
+
+
+        _password_changed = d.pop("password_changed", UNSET)
+        password_changed: ProjectConfigEmailTemplate | Unset
+        if isinstance(_password_changed,  Unset):
+            password_changed = UNSET
+        else:
+            password_changed = ProjectConfigEmailTemplate.from_dict(_password_changed)
+
+
+
+
+        _welcome = d.pop("welcome", UNSET)
+        welcome: ProjectConfigEmailTemplate | Unset
+        if isinstance(_welcome,  Unset):
+            welcome = UNSET
+        else:
+            welcome = ProjectConfigEmailTemplate.from_dict(_welcome)
+
+
+
+
+        project_config_email_templates = cls(
+            confirmation=confirmation,
+            password_reset=password_reset,
+            password_changed=password_changed,
+            welcome=welcome,
+        )
+
+        return project_config_email_templates
+