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

volcano_sdk/_generated/models/project_config_apply_result.py

@@ -0,0 +1,170 @@
+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_apply_result_entry import ProjectConfigApplyResultEntry
+  from ..models.project_config_apply_summary import ProjectConfigApplySummary
+  from ..models.project_config_missing_resource import ProjectConfigMissingResource
+  from ..models.project_config_skipped_resource import ProjectConfigSkippedResource
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigApplyResult")
+
+
+
+@_attrs_define
+class ProjectConfigApplyResult:
+    """ Per-resource report for a project config apply (or dry run).
+
+        Attributes:
+            results (list[ProjectConfigApplyResultEntry]):
+            skipped (list[ProjectConfigSkippedResource]): Manifest entries referencing functions, frontends, databases, or
+                buckets that do not exist. Their configuration was not applied;
+                deploy/create the resource first, then re-apply.
+            missing (list[ProjectConfigMissingResource]): Existing functions, frontends, databases, or buckets that have no
+                entry in the corresponding declared manifest section.
+            summary (ProjectConfigApplySummary):
+            dry_run (bool | Unset): True when the request was a dry run and no changes were made.
+     """
+
+    results: list[ProjectConfigApplyResultEntry]
+    skipped: list[ProjectConfigSkippedResource]
+    missing: list[ProjectConfigMissingResource]
+    summary: ProjectConfigApplySummary
+    dry_run: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_config_apply_result_entry import ProjectConfigApplyResultEntry
+        from ..models.project_config_apply_summary import ProjectConfigApplySummary
+        from ..models.project_config_missing_resource import ProjectConfigMissingResource
+        from ..models.project_config_skipped_resource import ProjectConfigSkippedResource
+        results = []
+        for results_item_data in self.results:
+            results_item = results_item_data.to_dict()
+            results.append(results_item)
+
+
+
+        skipped = []
+        for skipped_item_data in self.skipped:
+            skipped_item = skipped_item_data.to_dict()
+            skipped.append(skipped_item)
+
+
+
+        missing = []
+        for missing_item_data in self.missing:
+            missing_item = missing_item_data.to_dict()
+            missing.append(missing_item)
+
+
+
+        summary = self.summary.to_dict()
+
+        dry_run = self.dry_run
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "results": results,
+            "skipped": skipped,
+            "missing": missing,
+            "summary": summary,
+        })
+        if dry_run is not UNSET:
+            field_dict["dry_run"] = dry_run
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_config_apply_result_entry import ProjectConfigApplyResultEntry
+        from ..models.project_config_apply_summary import ProjectConfigApplySummary
+        from ..models.project_config_missing_resource import ProjectConfigMissingResource
+        from ..models.project_config_skipped_resource import ProjectConfigSkippedResource
+        d = dict(src_dict)
+        results = []
+        _results = d.pop("results")
+        for results_item_data in (_results):
+            results_item = ProjectConfigApplyResultEntry.from_dict(results_item_data)
+
+
+
+            results.append(results_item)
+
+
+        skipped = []
+        _skipped = d.pop("skipped")
+        for skipped_item_data in (_skipped):
+            skipped_item = ProjectConfigSkippedResource.from_dict(skipped_item_data)
+
+
+
+            skipped.append(skipped_item)
+
+
+        missing = []
+        _missing = d.pop("missing")
+        for missing_item_data in (_missing):
+            missing_item = ProjectConfigMissingResource.from_dict(missing_item_data)
+
+
+
+            missing.append(missing_item)
+
+
+        summary = ProjectConfigApplySummary.from_dict(d.pop("summary"))
+
+
+
+
+        dry_run = d.pop("dry_run", UNSET)
+
+        project_config_apply_result = cls(
+            results=results,
+            skipped=skipped,
+            missing=missing,
+            summary=summary,
+            dry_run=dry_run,
+        )
+
+
+        project_config_apply_result.additional_properties = d
+        return project_config_apply_result
+
+    @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_apply_result_entry.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 ..models.project_config_apply_result_entry_action import check_project_config_apply_result_entry_action
+from ..models.project_config_apply_result_entry_action import ProjectConfigApplyResultEntryAction
+from ..types import UNSET, Unset
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="ProjectConfigApplyResultEntry")
+
+
+
+@_attrs_define
+class ProjectConfigApplyResultEntry:
+    """ 
+        Attributes:
+            section (str): Manifest section the entry belongs to (e.g. variables, buckets, auth.providers.oauth).
+            action (ProjectConfigApplyResultEntryAction):
+            name (str | Unset): Resource name or key within the section. Empty for singleton sections.
+            error (str | Unset): Error detail when action is `error`.
+            notice (str | Unset): Optional operational note (e.g. disabling realtime drops active connections).
+     """
+
+    section: str
+    action: ProjectConfigApplyResultEntryAction
+    name: str | Unset = UNSET
+    error: str | Unset = UNSET
+    notice: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        section = self.section
+
+        action: str = self.action
+
+        name = self.name
+
+        error = self.error
+
+        notice = self.notice
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "section": section,
+            "action": action,
+        })
+        if name is not UNSET:
+            field_dict["name"] = name
+        if error is not UNSET:
+            field_dict["error"] = error
+        if notice is not UNSET:
+            field_dict["notice"] = notice
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        section = d.pop("section")
+
+        action = check_project_config_apply_result_entry_action(d.pop("action"))
+
+
+
+
+        name = d.pop("name", UNSET)
+
+        error = d.pop("error", UNSET)
+
+        notice = d.pop("notice", UNSET)
+
+        project_config_apply_result_entry = cls(
+            section=section,
+            action=action,
+            name=name,
+            error=error,
+            notice=notice,
+        )
+
+
+        project_config_apply_result_entry.additional_properties = d
+        return project_config_apply_result_entry
+
+    @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_apply_result_entry_action.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+ProjectConfigApplyResultEntryAction = Literal['created', 'deleted', 'error', 'unchanged', 'updated']
+
+PROJECT_CONFIG_APPLY_RESULT_ENTRY_ACTION_VALUES: set[ProjectConfigApplyResultEntryAction] = { 'created', 'deleted', 'error', 'unchanged', 'updated',  }
+
+def check_project_config_apply_result_entry_action(value: str) -> ProjectConfigApplyResultEntryAction:
+    if value in PROJECT_CONFIG_APPLY_RESULT_ENTRY_ACTION_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {PROJECT_CONFIG_APPLY_RESULT_ENTRY_ACTION_VALUES!r}")

volcano_sdk/_generated/models/project_config_apply_summary.py

@@ -0,0 +1,124 @@
+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="ProjectConfigApplySummary")
+
+
+
+@_attrs_define
+class ProjectConfigApplySummary:
+    """ 
+        Attributes:
+            created (int):
+            updated (int):
+            deleted (int):
+            unchanged (int):
+            errors (int):
+            skipped (int):
+            missing (int):
+     """
+
+    created: int
+    updated: int
+    deleted: int
+    unchanged: int
+    errors: int
+    skipped: int
+    missing: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        created = self.created
+
+        updated = self.updated
+
+        deleted = self.deleted
+
+        unchanged = self.unchanged
+
+        errors = self.errors
+
+        skipped = self.skipped
+
+        missing = self.missing
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "created": created,
+            "updated": updated,
+            "deleted": deleted,
+            "unchanged": unchanged,
+            "errors": errors,
+            "skipped": skipped,
+            "missing": missing,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        created = d.pop("created")
+
+        updated = d.pop("updated")
+
+        deleted = d.pop("deleted")
+
+        unchanged = d.pop("unchanged")
+
+        errors = d.pop("errors")
+
+        skipped = d.pop("skipped")
+
+        missing = d.pop("missing")
+
+        project_config_apply_summary = cls(
+            created=created,
+            updated=updated,
+            deleted=deleted,
+            unchanged=unchanged,
+            errors=errors,
+            skipped=skipped,
+            missing=missing,
+        )
+
+
+        project_config_apply_summary.additional_properties = d
+        return project_config_apply_summary
+
+    @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