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

volcano_sdk/_generated/models/project_health_check.py

@@ -0,0 +1,140 @@
+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_health_category import check_project_health_category
+from ..models.project_health_category import ProjectHealthCategory
+from ..models.project_health_status import check_project_health_status
+from ..models.project_health_status import ProjectHealthStatus
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.project_health_evidence import ProjectHealthEvidence
+  from ..models.project_health_scope import ProjectHealthScope
+
+
+
+
+
+T = TypeVar("T", bound="ProjectHealthCheck")
+
+
+
+@_attrs_define
+class ProjectHealthCheck:
+    """ 
+        Attributes:
+            id (str):
+            category (ProjectHealthCategory):
+            status (ProjectHealthStatus):
+            reason_code (str):
+            scope (ProjectHealthScope):
+            evidence (ProjectHealthEvidence):
+     """
+
+    id: str
+    category: ProjectHealthCategory
+    status: ProjectHealthStatus
+    reason_code: str
+    scope: ProjectHealthScope
+    evidence: ProjectHealthEvidence
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_health_evidence import ProjectHealthEvidence
+        from ..models.project_health_scope import ProjectHealthScope
+        id = self.id
+
+        category: str = self.category
+
+        status: str = self.status
+
+        reason_code = self.reason_code
+
+        scope = self.scope.to_dict()
+
+        evidence = self.evidence.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "id": id,
+            "category": category,
+            "status": status,
+            "reason_code": reason_code,
+            "scope": scope,
+            "evidence": evidence,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_health_evidence import ProjectHealthEvidence
+        from ..models.project_health_scope import ProjectHealthScope
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        category = check_project_health_category(d.pop("category"))
+
+
+
+
+        status = check_project_health_status(d.pop("status"))
+
+
+
+
+        reason_code = d.pop("reason_code")
+
+        scope = ProjectHealthScope.from_dict(d.pop("scope"))
+
+
+
+
+        evidence = ProjectHealthEvidence.from_dict(d.pop("evidence"))
+
+
+
+
+        project_health_check = cls(
+            id=id,
+            category=category,
+            status=status,
+            reason_code=reason_code,
+            scope=scope,
+            evidence=evidence,
+        )
+
+
+        project_health_check.additional_properties = d
+        return project_health_check
+
+    @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_health_data_status.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+ProjectHealthDataStatus = Literal['complete', 'no_data', 'partial', 'stale']
+
+PROJECT_HEALTH_DATA_STATUS_VALUES: set[ProjectHealthDataStatus] = { 'complete', 'no_data', 'partial', 'stale',  }
+
+def check_project_health_data_status(value: str) -> ProjectHealthDataStatus:
+    if value in PROJECT_HEALTH_DATA_STATUS_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {PROJECT_HEALTH_DATA_STATUS_VALUES!r}")

volcano_sdk/_generated/models/project_health_evidence.py

@@ -0,0 +1,100 @@
+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="ProjectHealthEvidence")
+
+
+
+@_attrs_define
+class ProjectHealthEvidence:
+    """ 
+        Attributes:
+            metric (str):
+            value (float):
+            unit (str):
+            sample_count (int):
+     """
+
+    metric: str
+    value: float
+    unit: str
+    sample_count: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        metric = self.metric
+
+        value = self.value
+
+        unit = self.unit
+
+        sample_count = self.sample_count
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "metric": metric,
+            "value": value,
+            "unit": unit,
+            "sample_count": sample_count,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        metric = d.pop("metric")
+
+        value = d.pop("value")
+
+        unit = d.pop("unit")
+
+        sample_count = d.pop("sample_count")
+
+        project_health_evidence = cls(
+            metric=metric,
+            value=value,
+            unit=unit,
+            sample_count=sample_count,
+        )
+
+
+        project_health_evidence.additional_properties = d
+        return project_health_evidence
+
+    @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_health_resource.py

@@ -0,0 +1,102 @@
+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_health_resource_type import check_project_health_resource_type
+from ..models.project_health_resource_type import ProjectHealthResourceType
+from typing import cast
+from uuid import UUID
+
+
+
+
+
+
+T = TypeVar("T", bound="ProjectHealthResource")
+
+
+
+@_attrs_define
+class ProjectHealthResource:
+    """ 
+        Attributes:
+            type_ (ProjectHealthResourceType):
+            id (UUID):
+            name (str):
+     """
+
+    type_: ProjectHealthResourceType
+    id: UUID
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        type_: str = self.type_
+
+        id = str(self.id)
+
+        name = self.name
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "type": type_,
+            "id": id,
+            "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_health_resource_type(d.pop("type"))
+
+
+
+
+        id = UUID(d.pop("id"))
+
+
+
+
+        name = d.pop("name")
+
+        project_health_resource = cls(
+            type_=type_,
+            id=id,
+            name=name,
+        )
+
+
+        project_health_resource.additional_properties = d
+        return project_health_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_health_resource_type.py

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

volcano_sdk/_generated/models/project_health_response.py

@@ -0,0 +1,176 @@
+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_health_data_status import check_project_health_data_status
+from ..models.project_health_data_status import ProjectHealthDataStatus
+from ..models.project_health_status import check_project_health_status
+from ..models.project_health_status import ProjectHealthStatus
+from typing import cast
+from uuid import UUID
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.project_health_check import ProjectHealthCheck
+
+
+
+
+
+T = TypeVar("T", bound="ProjectHealthResponse")
+
+
+
+@_attrs_define
+class ProjectHealthResponse:
+    """ 
+        Attributes:
+            project_id (UUID):
+            status (ProjectHealthStatus):
+            observed_at (datetime.datetime):
+            fresh_through (datetime.datetime):
+            data_status (ProjectHealthDataStatus):
+            checks (list[ProjectHealthCheck]):
+            findings (list[ProjectHealthCheck]): Top findings ordered by severity, then stable check ID.
+     """
+
+    project_id: UUID
+    status: ProjectHealthStatus
+    observed_at: datetime.datetime
+    fresh_through: datetime.datetime
+    data_status: ProjectHealthDataStatus
+    checks: list[ProjectHealthCheck]
+    findings: list[ProjectHealthCheck]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_health_check import ProjectHealthCheck
+        project_id = str(self.project_id)
+
+        status: str = self.status
+
+        observed_at = self.observed_at.isoformat()
+
+        fresh_through = self.fresh_through.isoformat()
+
+        data_status: str = self.data_status
+
+        checks = []
+        for checks_item_data in self.checks:
+            checks_item = checks_item_data.to_dict()
+            checks.append(checks_item)
+
+
+
+        findings = []
+        for findings_item_data in self.findings:
+            findings_item = findings_item_data.to_dict()
+            findings.append(findings_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "project_id": project_id,
+            "status": status,
+            "observed_at": observed_at,
+            "fresh_through": fresh_through,
+            "data_status": data_status,
+            "checks": checks,
+            "findings": findings,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_health_check import ProjectHealthCheck
+        d = dict(src_dict)
+        project_id = UUID(d.pop("project_id"))
+
+
+
+
+        status = check_project_health_status(d.pop("status"))
+
+
+
+
+        observed_at = datetime.datetime.fromisoformat(d.pop("observed_at"))
+
+
+
+
+        fresh_through = datetime.datetime.fromisoformat(d.pop("fresh_through"))
+
+
+
+
+        data_status = check_project_health_data_status(d.pop("data_status"))
+
+
+
+
+        checks = []
+        _checks = d.pop("checks")
+        for checks_item_data in (_checks):
+            checks_item = ProjectHealthCheck.from_dict(checks_item_data)
+
+
+
+            checks.append(checks_item)
+
+
+        findings = []
+        _findings = d.pop("findings")
+        for findings_item_data in (_findings):
+            findings_item = ProjectHealthCheck.from_dict(findings_item_data)
+
+
+
+            findings.append(findings_item)
+
+
+        project_health_response = cls(
+            project_id=project_id,
+            status=status,
+            observed_at=observed_at,
+            fresh_through=fresh_through,
+            data_status=data_status,
+            checks=checks,
+            findings=findings,
+        )
+
+
+        project_health_response.additional_properties = d
+        return project_health_response
+
+    @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_health_scope.py

@@ -0,0 +1,84 @@
+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 typing import cast
+
+if TYPE_CHECKING:
+  from ..models.project_health_resource import ProjectHealthResource
+
+
+
+
+
+T = TypeVar("T", bound="ProjectHealthScope")
+
+
+
+@_attrs_define
+class ProjectHealthScope:
+    """ 
+        Attributes:
+            resource (ProjectHealthResource):
+     """
+
+    resource: ProjectHealthResource
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.project_health_resource import ProjectHealthResource
+        resource = self.resource.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "resource": resource,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.project_health_resource import ProjectHealthResource
+        d = dict(src_dict)
+        resource = ProjectHealthResource.from_dict(d.pop("resource"))
+
+
+
+
+        project_health_scope = cls(
+            resource=resource,
+        )
+
+
+        project_health_scope.additional_properties = d
+        return project_health_scope
+
+    @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_health_status.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+ProjectHealthStatus = Literal['critical', 'degraded', 'healthy', 'unknown']
+
+PROJECT_HEALTH_STATUS_VALUES: set[ProjectHealthStatus] = { 'critical', 'degraded', 'healthy', 'unknown',  }
+
+def check_project_health_status(value: str) -> ProjectHealthStatus:
+    if value in PROJECT_HEALTH_STATUS_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {PROJECT_HEALTH_STATUS_VALUES!r}")