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

acceldata/models/api/catalog/data_cadence_rule.py

@@ -0,0 +1,236 @@
+# 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.backing_asset import BackingAsset
+from acceldata.models.api.catalog.job_schedule import JobSchedule
+from acceldata.models.api.catalog.notification_payload import NotificationPayload
+from acceldata.models.api.catalog.policy_group import PolicyGroup
+from acceldata.models.api.catalog.rule_tag import RuleTag
+from acceldata.models.api.catalog.rule_threshold_configuration import RuleThresholdConfiguration
+from acceldata.models.api.catalog.spark_resource_config import SparkResourceConfig
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class DataCadenceRule(BaseModel):
+    """
+    DataCadenceRule
+    """ # noqa: E501
+    anomaly_strength_threshold: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: HIGH, MEDIUM, LOW.", alias="anomalyStrengthThreshold")
+    archival_reason: Optional[StrictStr] = Field(default=None, alias="archivalReason")
+    archived: StrictBool
+    auto_created: Optional[StrictBool] = Field(default=None, alias="autoCreated")
+    auto_retry_enabled: Optional[StrictBool] = Field(default=None, alias="autoRetryEnabled")
+    backing_asset: BackingAsset = Field(alias="backingAsset")
+    created_at: datetime = Field(alias="createdAt")
+    created_by: Optional[StrictStr] = Field(default=None, alias="createdBy")
+    description: Optional[StrictStr] = None
+    enabled: StrictBool
+    id: Optional[StrictInt] = None
+    include_in_quality_score: StrictBool = Field(alias="includeInQualityScore")
+    job_schedule: Optional[JobSchedule] = Field(default=None, alias="jobSchedule")
+    last_updated_by: Optional[StrictStr] = Field(default=None, alias="lastUpdatedBy")
+    name: StrictStr
+    notification_channels: Optional[NotificationPayload] = Field(default=None, alias="notificationChannels")
+    policy_groups: Optional[List[PolicyGroup]] = Field(default=None, alias="policyGroups")
+    resource_strategy_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: INVENTORY, CUSTOM.", alias="resourceStrategyType")
+    schedule: Optional[StrictStr] = None
+    scheduled: StrictBool
+    selected_resource_inventory: Optional[StrictStr] = Field(default=None, alias="selectedResourceInventory")
+    spark_resource_config: Optional[SparkResourceConfig] = Field(default=None, alias="sparkResourceConfig")
+    tags: Optional[List[RuleTag]] = None
+    tenant_id: Optional[StrictStr] = Field(default=None, alias="tenantId")
+    threshold_level: RuleThresholdConfiguration = Field(alias="thresholdLevel")
+    time_zone: StrictStr = Field(alias="timeZone")
+    type: StrictStr = Field(description="Allowed values at generation time: DATA_QUALITY, RECONCILIATION, EQUALITY, DATA_DRIFT, SCHEMA_DRIFT, DATA_CADENCE, PROFILE_ANOMALY, AUTO_ANOMALY.")
+    updated_at: datetime = Field(alias="updatedAt")
+    version: StrictInt
+    __properties: ClassVar[List[str]] = ["anomalyStrengthThreshold", "archivalReason", "archived", "autoCreated", "autoRetryEnabled", "backingAsset", "createdAt", "createdBy", "description", "enabled", "id", "includeInQualityScore", "jobSchedule", "lastUpdatedBy", "name", "notificationChannels", "policyGroups", "resourceStrategyType", "schedule", "scheduled", "selectedResourceInventory", "sparkResourceConfig", "tags", "tenantId", "thresholdLevel", "timeZone", "type", "updatedAt", "version"]
+
+    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 DataCadenceRule 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 backing_asset
+        if self.backing_asset:
+            _dict['backingAsset'] = self.backing_asset.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of job_schedule
+        if self.job_schedule:
+            _dict['jobSchedule'] = self.job_schedule.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of notification_channels
+        if self.notification_channels:
+            _dict['notificationChannels'] = self.notification_channels.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in policy_groups (list)
+        _items = []
+        if self.policy_groups:
+            for _item_policy_groups in self.policy_groups:
+                if _item_policy_groups:
+                    _items.append(_item_policy_groups.to_dict())
+            _dict['policyGroups'] = _items
+        # override the default output from pydantic by calling `to_dict()` of spark_resource_config
+        if self.spark_resource_config:
+            _dict['sparkResourceConfig'] = self.spark_resource_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in tags (list)
+        _items = []
+        if self.tags:
+            for _item_tags in self.tags:
+                if _item_tags:
+                    _items.append(_item_tags.to_dict())
+            _dict['tags'] = _items
+        # override the default output from pydantic by calling `to_dict()` of threshold_level
+        if self.threshold_level:
+            _dict['thresholdLevel'] = self.threshold_level.to_dict()
+        # set to None if anomaly_strength_threshold (nullable) is None
+        # and model_fields_set contains the field
+        if self.anomaly_strength_threshold is None and "anomaly_strength_threshold" in self.model_fields_set:
+            _dict['anomalyStrengthThreshold'] = None
+
+        # set to None if archival_reason (nullable) is None
+        # and model_fields_set contains the field
+        if self.archival_reason is None and "archival_reason" in self.model_fields_set:
+            _dict['archivalReason'] = None
+
+        # set to None if created_by (nullable) is None
+        # and model_fields_set contains the field
+        if self.created_by is None and "created_by" in self.model_fields_set:
+            _dict['createdBy'] = None
+
+        # set to None if description (nullable) is None
+        # and model_fields_set contains the field
+        if self.description is None and "description" in self.model_fields_set:
+            _dict['description'] = None
+
+        # set to None if last_updated_by (nullable) is None
+        # and model_fields_set contains the field
+        if self.last_updated_by is None and "last_updated_by" in self.model_fields_set:
+            _dict['lastUpdatedBy'] = None
+
+        # set to None if policy_groups (nullable) is None
+        # and model_fields_set contains the field
+        if self.policy_groups is None and "policy_groups" in self.model_fields_set:
+            _dict['policyGroups'] = None
+
+        # set to None if resource_strategy_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.resource_strategy_type is None and "resource_strategy_type" in self.model_fields_set:
+            _dict['resourceStrategyType'] = None
+
+        # set to None if schedule (nullable) is None
+        # and model_fields_set contains the field
+        if self.schedule is None and "schedule" in self.model_fields_set:
+            _dict['schedule'] = None
+
+        # set to None if selected_resource_inventory (nullable) is None
+        # and model_fields_set contains the field
+        if self.selected_resource_inventory is None and "selected_resource_inventory" in self.model_fields_set:
+            _dict['selectedResourceInventory'] = None
+
+        # set to None if tags (nullable) is None
+        # and model_fields_set contains the field
+        if self.tags is None and "tags" in self.model_fields_set:
+            _dict['tags'] = None
+
+        # set to None if tenant_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.tenant_id is None and "tenant_id" in self.model_fields_set:
+            _dict['tenantId'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataCadenceRule from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "anomalyStrengthThreshold": obj.get("anomalyStrengthThreshold"),
+            "archivalReason": obj.get("archivalReason"),
+            "archived": obj.get("archived"),
+            "autoCreated": obj.get("autoCreated"),
+            "autoRetryEnabled": obj.get("autoRetryEnabled"),
+            "backingAsset": BackingAsset.from_dict(obj["backingAsset"]) if obj.get("backingAsset") is not None else None,
+            "createdAt": obj.get("createdAt"),
+            "createdBy": obj.get("createdBy"),
+            "description": obj.get("description"),
+            "enabled": obj.get("enabled"),
+            "id": obj.get("id"),
+            "includeInQualityScore": obj.get("includeInQualityScore"),
+            "jobSchedule": JobSchedule.from_dict(obj["jobSchedule"]) if obj.get("jobSchedule") is not None else None,
+            "lastUpdatedBy": obj.get("lastUpdatedBy"),
+            "name": obj.get("name"),
+            "notificationChannels": NotificationPayload.from_dict(obj["notificationChannels"]) if obj.get("notificationChannels") is not None else None,
+            "policyGroups": [PolicyGroup.from_dict(_item) for _item in obj["policyGroups"]] if obj.get("policyGroups") is not None else None,
+            "resourceStrategyType": obj.get("resourceStrategyType"),
+            "schedule": obj.get("schedule"),
+            "scheduled": obj.get("scheduled"),
+            "selectedResourceInventory": obj.get("selectedResourceInventory"),
+            "sparkResourceConfig": SparkResourceConfig.from_dict(obj["sparkResourceConfig"]) if obj.get("sparkResourceConfig") is not None else None,
+            "tags": [RuleTag.from_dict(_item) for _item in obj["tags"]] if obj.get("tags") is not None else None,
+            "tenantId": obj.get("tenantId"),
+            "thresholdLevel": RuleThresholdConfiguration.from_dict(obj["thresholdLevel"]) if obj.get("thresholdLevel") is not None else None,
+            "timeZone": obj.get("timeZone"),
+            "type": obj.get("type"),
+            "updatedAt": obj.get("updatedAt"),
+            "version": obj.get("version")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/data_cadence_rule_details.py

@@ -0,0 +1,125 @@
+# 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, StrictBool, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.data_cadence_rule_item import DataCadenceRuleItem
+from acceldata.models.api.catalog.short_segment import ShortSegment
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class DataCadenceRuleDetails(BaseModel):
+    """
+    DataCadenceRuleDetails
+    """ # noqa: E501
+    backing_asset_id: StrictInt = Field(alias="backingAssetId")
+    continue_execution_on_failure: StrictBool = Field(alias="continueExecutionOnFailure")
+    id: Optional[StrictInt] = None
+    is_composite_rule: StrictBool = Field(alias="isCompositeRule")
+    is_segmented: StrictBool = Field(alias="isSegmented")
+    items: List[DataCadenceRuleItem]
+    rule_id: StrictInt = Field(alias="ruleId")
+    segments: Optional[List[ShortSegment]] = None
+    version: StrictInt
+    __properties: ClassVar[List[str]] = ["backingAssetId", "continueExecutionOnFailure", "id", "isCompositeRule", "isSegmented", "items", "ruleId", "segments", "version"]
+
+    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 DataCadenceRuleDetails 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 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
+        # override the default output from pydantic by calling `to_dict()` of each item in segments (list)
+        _items = []
+        if self.segments:
+            for _item_segments in self.segments:
+                if _item_segments:
+                    _items.append(_item_segments.to_dict())
+            _dict['segments'] = _items
+        # set to None if segments (nullable) is None
+        # and model_fields_set contains the field
+        if self.segments is None and "segments" in self.model_fields_set:
+            _dict['segments'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataCadenceRuleDetails from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "backingAssetId": obj.get("backingAssetId"),
+            "continueExecutionOnFailure": obj.get("continueExecutionOnFailure"),
+            "id": obj.get("id"),
+            "isCompositeRule": obj.get("isCompositeRule"),
+            "isSegmented": obj.get("isSegmented"),
+            "items": [DataCadenceRuleItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
+            "ruleId": obj.get("ruleId"),
+            "segments": [ShortSegment.from_dict(_item) for _item in obj["segments"]] if obj.get("segments") is not None else None,
+            "version": obj.get("version")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/data_cadence_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.data_cadence_rule_item_execution import DataCadenceRuleItemExecution
+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 DataCadenceRuleExecution(BaseModel):
+    """
+    DataCadenceRuleExecution
+    """ # noqa: E501
+    execution: RuleExecution
+    items: List[DataCadenceRuleItemExecution]
+    __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 DataCadenceRuleExecution 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 DataCadenceRuleExecution 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": [DataCadenceRuleItemExecution.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/data_cadence_rule_item.py

@@ -0,0 +1,104 @@
+# 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 DataCadenceRuleItem(BaseModel):
+    """
+    DataCadenceRuleItem
+    """ # noqa: E501
+    display_name: StrictStr = Field(alias="displayName")
+    execution_order: StrictInt = Field(alias="executionOrder")
+    id: Optional[StrictInt] = None
+    measurement_type: StrictStr = Field(description="Allowed values at generation time: DATA_FRESHNESS, RECORD_COUNT_TOTAL, RECORD_COUNT_DRIFT, DATA_VOLUME_TOTAL, DATA_VOLUME_DRIFT, FILE_COUNT_TOTAL, FILE_COUNT_DRIFT, CHANGE_IN_FILE_SIZE, ABSOLUTE_FILE_SIZE, RAW_ABSOLUTE_SIZE, RAW_DATA_FRESHNESS, MESSAGES_COUNT_TOTAL, MESSAGES_COUNT_DRIFT, CHANGE_IN_TOPIC_SIZE, ABSOLUTE_TOPIC_SIZE.", alias="measurementType")
+    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]] = ["displayName", "executionOrder", "id", "measurementType", "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 DataCadenceRuleItem 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()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DataCadenceRuleItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "displayName": obj.get("displayName"),
+            "executionOrder": obj.get("executionOrder"),
+            "id": obj.get("id"),
+            "measurementType": obj.get("measurementType"),
+            "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
+
+