acceldata-sdk-python 26.7.0__py3-none-any.whl

acceldata/models/api/catalog/process_metrics.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProcessMetrics(BaseModel):
+    """
+    ProcessMetrics
+    """ # noqa: E501
+    reporting_time: datetime = Field(alias="reportingTime")
+    status: StrictStr
+    __properties: ClassVar[List[str]] = ["reportingTime", "status"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProcessMetrics from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProcessMetrics from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "reportingTime": obj.get("reportingTime"),
+            "status": obj.get("status")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/profile_anomaly_details_response.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from acceldata.models.api.catalog.column_metric_with_anomaly_details import ColumnMetricWithAnomalyDetails
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProfileAnomalyDetailsResponse(BaseModel):
+    """
+    ProfileAnomalyDetailsResponse
+    """ # noqa: E501
+    column_metric_with_anomaly_details: Dict[str, List[ColumnMetricWithAnomalyDetails]] = Field(alias="columnMetricWithAnomalyDetails")
+    message: StrictStr
+    status: StrictStr
+    __properties: ClassVar[List[str]] = ["columnMetricWithAnomalyDetails", "message", "status"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProfileAnomalyDetailsResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each value in column_metric_with_anomaly_details (dict of array)
+        _field_dict_of_array = {}
+        if self.column_metric_with_anomaly_details:
+            for _key_column_metric_with_anomaly_details in self.column_metric_with_anomaly_details:
+                if self.column_metric_with_anomaly_details[_key_column_metric_with_anomaly_details] is not None:
+                    _field_dict_of_array[_key_column_metric_with_anomaly_details] = [
+                        _item.to_dict() for _item in self.column_metric_with_anomaly_details[_key_column_metric_with_anomaly_details]
+                    ]
+            _dict['columnMetricWithAnomalyDetails'] = _field_dict_of_array
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProfileAnomalyDetailsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "columnMetricWithAnomalyDetails": dict(
+                (_k,
+                        [ColumnMetricWithAnomalyDetails.from_dict(_item) for _item in _v]
+                        if _v is not None
+                        else None
+                )
+                for _k, _v in obj.get("columnMetricWithAnomalyDetails", {}).items()
+            ),
+            "message": obj.get("message"),
+            "status": obj.get("status")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/profile_anomaly_item_execution.py

@@ -0,0 +1,127 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.profile_anomaly_details_response import ProfileAnomalyDetailsResponse
+from acceldata.models.api.catalog.profile_anomaly_rule_item import ProfileAnomalyRuleItem
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProfileAnomalyItemExecution(BaseModel):
+    """
+    ProfileAnomalyItemExecution
+    """ # noqa: E501
+    anomaly_details: Optional[ProfileAnomalyDetailsResponse] = Field(default=None, alias="anomalyDetails")
+    anomaly_detected: StrictBool = Field(alias="anomalyDetected")
+    error: Optional[StrictStr] = None
+    execution_id: StrictInt = Field(alias="executionId")
+    finished_at: Optional[datetime] = Field(default=None, alias="finishedAt")
+    id: Optional[StrictInt] = None
+    item: ProfileAnomalyRuleItem
+    profile_id: StrictInt = Field(alias="profileId")
+    result: Optional[StrictStr] = None
+    rule_item_id: StrictInt = Field(alias="ruleItemId")
+    started_at: datetime = Field(alias="startedAt")
+    __properties: ClassVar[List[str]] = ["anomalyDetails", "anomalyDetected", "error", "executionId", "finishedAt", "id", "item", "profileId", "result", "ruleItemId", "startedAt"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProfileAnomalyItemExecution from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of anomaly_details
+        if self.anomaly_details:
+            _dict['anomalyDetails'] = self.anomaly_details.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of item
+        if self.item:
+            _dict['item'] = self.item.to_dict()
+        # set to None if error (nullable) is None
+        # and model_fields_set contains the field
+        if self.error is None and "error" in self.model_fields_set:
+            _dict['error'] = None
+
+        # set to None if result (nullable) is None
+        # and model_fields_set contains the field
+        if self.result is None and "result" in self.model_fields_set:
+            _dict['result'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProfileAnomalyItemExecution from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "anomalyDetails": ProfileAnomalyDetailsResponse.from_dict(obj["anomalyDetails"]) if obj.get("anomalyDetails") is not None else None,
+            "anomalyDetected": obj.get("anomalyDetected"),
+            "error": obj.get("error"),
+            "executionId": obj.get("executionId"),
+            "finishedAt": obj.get("finishedAt"),
+            "id": obj.get("id"),
+            "item": ProfileAnomalyRuleItem.from_dict(obj["item"]) if obj.get("item") is not None else None,
+            "profileId": obj.get("profileId"),
+            "result": obj.get("result"),
+            "ruleItemId": obj.get("ruleItemId"),
+            "startedAt": obj.get("startedAt")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/profile_anomaly_rule_execution.py

@@ -0,0 +1,102 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from acceldata.models.api.catalog.profile_anomaly_item_execution import ProfileAnomalyItemExecution
+from acceldata.models.api.catalog.rule_execution import RuleExecution
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProfileAnomalyRuleExecution(BaseModel):
+    """
+    ProfileAnomalyRuleExecution
+    """ # noqa: E501
+    execution: RuleExecution
+    items: List[ProfileAnomalyItemExecution]
+    __properties: ClassVar[List[str]] = ["execution", "items"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProfileAnomalyRuleExecution from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of execution
+        if self.execution:
+            _dict['execution'] = self.execution.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
+        _items = []
+        if self.items:
+            for _item_items in self.items:
+                if _item_items:
+                    _items.append(_item_items.to_dict())
+            _dict['items'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProfileAnomalyRuleExecution from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "execution": RuleExecution.from_dict(obj["execution"]) if obj.get("execution") is not None else None,
+            "items": [ProfileAnomalyItemExecution.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/profile_anomaly_rule_item.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.rule_threshold_configuration import RuleThresholdConfiguration
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProfileAnomalyRuleItem(BaseModel):
+    """
+    ProfileAnomalyRuleItem
+    """ # noqa: E501
+    execution_order: StrictInt = Field(alias="executionOrder")
+    id: Optional[StrictInt] = None
+    monitor_columns: Optional[List[StrictStr]] = Field(default=None, alias="monitorColumns")
+    name: StrictStr
+    rule_id: Optional[StrictInt] = Field(default=None, alias="ruleId")
+    rule_version: StrictInt = Field(alias="ruleVersion")
+    threshold_config: Optional[RuleThresholdConfiguration] = Field(default=None, alias="thresholdConfig")
+    __properties: ClassVar[List[str]] = ["executionOrder", "id", "monitorColumns", "name", "ruleId", "ruleVersion", "thresholdConfig"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProfileAnomalyRuleItem from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of threshold_config
+        if self.threshold_config:
+            _dict['thresholdConfig'] = self.threshold_config.to_dict()
+        # set to None if monitor_columns (nullable) is None
+        # and model_fields_set contains the field
+        if self.monitor_columns is None and "monitor_columns" in self.model_fields_set:
+            _dict['monitorColumns'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProfileAnomalyRuleItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "executionOrder": obj.get("executionOrder"),
+            "id": obj.get("id"),
+            "monitorColumns": obj.get("monitorColumns"),
+            "name": obj.get("name"),
+            "ruleId": obj.get("ruleId"),
+            "ruleVersion": obj.get("ruleVersion"),
+            "thresholdConfig": RuleThresholdConfiguration.from_dict(obj["thresholdConfig"]) if obj.get("thresholdConfig") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/profile_cancellation_response.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    Catalog Control Plane API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from acceldata.models.api.catalog.connection_test_result import ConnectionTestResult
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProfileCancellationResponse(BaseModel):
+    """
+    ProfileCancellationResponse
+    """ # noqa: E501
+    result: ConnectionTestResult
+    __properties: ClassVar[List[str]] = ["result"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProfileCancellationResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of result
+        if self.result:
+            _dict['result'] = self.result.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProfileCancellationResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "result": ConnectionTestResult.from_dict(obj["result"]) if obj.get("result") is not None else None
+        })
+        return _obj
+
+