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

acceldata/models/api/catalog/relative_threshold_config.py

@@ -0,0 +1,111 @@
+# 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, Optional
+from acceldata.models.api.catalog.above_configs_success import AboveConfigsSuccess
+from acceldata.models.api.catalog.operational_config import OperationalConfig
+from acceldata.models.api.catalog.relative_config import RelativeConfig
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class RelativeThresholdConfig(BaseModel):
+    """
+    RelativeThresholdConfig
+    """ # noqa: E501
+    config: RelativeConfig
+    operational_config: OperationalConfig = Field(alias="operationalConfig")
+    success: Optional[AboveConfigsSuccess] = None
+    type: StrictStr = Field(description="Allowed values at generation time: ANOMALY, RELATIVE, TIME_BASED, ABSOLUTE.")
+    warning: Optional[AboveConfigsSuccess] = None
+    __properties: ClassVar[List[str]] = ["config", "operationalConfig", "success", "type", "warning"]
+
+    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 RelativeThresholdConfig 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 config
+        if self.config:
+            _dict['config'] = self.config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of operational_config
+        if self.operational_config:
+            _dict['operationalConfig'] = self.operational_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of success
+        if self.success:
+            _dict['success'] = self.success.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of warning
+        if self.warning:
+            _dict['warning'] = self.warning.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RelativeThresholdConfig from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "config": RelativeConfig.from_dict(obj["config"]) if obj.get("config") is not None else None,
+            "operationalConfig": OperationalConfig.from_dict(obj["operationalConfig"]) if obj.get("operationalConfig") is not None else None,
+            "success": AboveConfigsSuccess.from_dict(obj["success"]) if obj.get("success") is not None else None,
+            "type": obj.get("type"),
+            "warning": AboveConfigsSuccess.from_dict(obj["warning"]) if obj.get("warning") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/root_cause_analysis.py

@@ -0,0 +1,108 @@
+# 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
+from acceldata.models.api.catalog.above_configs_success import AboveConfigsSuccess
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class RootCauseAnalysis(BaseModel):
+    """
+    RootCauseAnalysis
+    """ # noqa: E501
+    bad: StrictInt
+    bad_fraction: AboveConfigsSuccess = Field(alias="badFraction")
+    good: StrictInt
+    good_fraction: AboveConfigsSuccess = Field(alias="goodFraction")
+    key: StrictStr
+    total_fraction: AboveConfigsSuccess = Field(alias="totalFraction")
+    __properties: ClassVar[List[str]] = ["bad", "badFraction", "good", "goodFraction", "key", "totalFraction"]
+
+    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 RootCauseAnalysis 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 bad_fraction
+        if self.bad_fraction:
+            _dict['badFraction'] = self.bad_fraction.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of good_fraction
+        if self.good_fraction:
+            _dict['goodFraction'] = self.good_fraction.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of total_fraction
+        if self.total_fraction:
+            _dict['totalFraction'] = self.total_fraction.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RootCauseAnalysis from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bad": obj.get("bad"),
+            "badFraction": AboveConfigsSuccess.from_dict(obj["badFraction"]) if obj.get("badFraction") is not None else None,
+            "good": obj.get("good"),
+            "goodFraction": AboveConfigsSuccess.from_dict(obj["goodFraction"]) if obj.get("goodFraction") is not None else None,
+            "key": obj.get("key"),
+            "totalFraction": AboveConfigsSuccess.from_dict(obj["totalFraction"]) if obj.get("totalFraction") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/rule_execution.py

@@ -0,0 +1,327 @@
+# 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.dataplane_job import DataplaneJob
+from acceldata.models.api.catalog.marker import Marker
+from acceldata.models.api.catalog.marker_config import MarkerConfig
+from acceldata.models.api.catalog.rule_spark_sql_dynamic_filter_variable_mapping import RuleSparkSQLDynamicFilterVariableMapping
+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 RuleExecution(BaseModel):
+    """
+    RuleExecution
+    """ # noqa: E501
+    allow_rerun: StrictBool = Field(alias="allowRerun")
+    analysis_job: Optional[DataplaneJob] = Field(default=None, alias="analysisJob")
+    analytics_pipeline_id: Optional[StrictInt] = Field(default=None, alias="analyticsPipelineId")
+    auto_retries: Optional[StrictInt] = Field(default=None, alias="autoRetries")
+    auto_retry_enabled: StrictBool = Field(alias="autoRetryEnabled")
+    data_persistence_enabled: StrictBool = Field(alias="dataPersistenceEnabled")
+    driver_pod_name: Optional[StrictStr] = Field(default=None, alias="driverPodName")
+    engine_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: SPARK, JDBC_SQL, POD.", alias="engineType")
+    executed_by: Optional[StrictStr] = Field(default=None, alias="executedBy")
+    execution_error: Optional[StrictStr] = Field(default=None, alias="executionError")
+    execution_mode: StrictStr = Field(description="Allowed values at generation time: SCHEDULED, MANUAL, WEBHOOK, API.", alias="executionMode")
+    execution_rank: Optional[StrictInt] = Field(default=None, alias="executionRank")
+    execution_status: StrictStr = Field(description="Allowed values at generation time: STARTED, RUNNING, ERRORED, WARNING, SUCCESSFUL, ABORTED, SKIPPED, WAITING, ANOMALY_DETECTION, EXECUTION_RESULT.", alias="executionStatus")
+    execution_type: StrictStr = Field(description="Allowed values at generation time: SELECTIVE, FULL, INCREMENTAL.", alias="executionType")
+    filter: Optional[StrictStr] = None
+    finished_at: Optional[datetime] = Field(default=None, alias="finishedAt")
+    id: Optional[StrictInt] = None
+    include_in_quality_score: StrictBool = Field(alias="includeInQualityScore")
+    is_protected_resource: StrictBool = Field(alias="isProtectedResource")
+    is_resource_requested_at_run_time: StrictBool = Field(alias="isResourceRequestedAtRunTime")
+    job_state: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: ACKNOWLEDGED, SUBMITTED, QUEUED, SKIPPED, RUNNING, READ_DATA, REFERENCE_DATA, PROFILE_STAGE_1, PROFILE_STAGE_2, PROFILE_STAGE_3, PROFILE_STAGE_4, DQ_BATCH_RULES, DQ_ROW_RULES, DQ_CUSTOM_RULES, DQ_SEGMENT, DQ_GOOD_RESULT_STORE, DQ_BAD_RESULT_STORE, VALIDATE, PROCESSING, PREPARE_RESULT, SEND_RESULT, SEND_RESULT_FAILED, SUCCESSFUL, FAILED, ABORTED, WAITING, METRICS_REQUEST_SENT, PARTIAL_RESPONSE_PUBLISHED, COMPLETE_RESPONSE_PUBLISHED, METRICS_RESPONSE_RECEIVED, ANOMALY_DETECTION_INITIATED, PARTIAL_ANOMALY_RESULT_RECEIVED, COMPLETE_ANOMALY_RESULT_RECEIVED, POLICY_EXECUTION_SUCCESSFUL, POLICY_EXECUTION_FAILURE, EXECUTION_RESULT.", alias="jobState")
+    last_health_update_at: Optional[datetime] = Field(default=None, alias="lastHealthUpdateAt")
+    last_marker: Optional[Marker] = Field(default=None, alias="lastMarker")
+    left_last_marker: Optional[Marker] = Field(default=None, alias="leftLastMarker")
+    left_marker_config: Optional[MarkerConfig] = Field(default=None, alias="leftMarkerConfig")
+    marker_config: Optional[MarkerConfig] = Field(default=None, alias="markerConfig")
+    parent_id: Optional[StrictInt] = Field(default=None, alias="parentId")
+    participating_columns: List[StrictStr] = Field(alias="participatingColumns")
+    persistence_path: Optional[StrictStr] = Field(default=None, alias="persistencePath")
+    pipeline_additional_configuration: Optional[Dict[str, StrictStr]] = Field(default=None, alias="pipelineAdditionalConfiguration")
+    policy_result_status_strategy: StrictStr = Field(description="Allowed values at generation time: CUSTOM, WEIGHTAGE, RULES.", alias="policyResultStatusStrategy")
+    request_id: Optional[StrictStr] = Field(default=None, alias="requestId")
+    reset_point: Optional[StrictInt] = Field(default=None, alias="resetPoint")
+    resource_strategy_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: INVENTORY, CUSTOM.", alias="resourceStrategyType")
+    result_persistence_path: Optional[Dict[str, StrictStr]] = Field(default=None, alias="resultPersistencePath")
+    result_status: StrictStr = Field(description="Allowed values at generation time: STARTED, RUNNING, ERRORED, WARNING, SUCCESSFUL, ABORTED, SKIPPED, WAITING, ANOMALY_DETECTION, EXECUTION_RESULT.", alias="resultStatus")
+    right_engine_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: SPARK, JDBC_SQL, POD.", alias="rightEngineType")
+    right_filter: Optional[StrictStr] = Field(default=None, alias="rightFilter")
+    right_last_marker: Optional[Marker] = Field(default=None, alias="rightLastMarker")
+    right_marker_config: Optional[MarkerConfig] = Field(default=None, alias="rightMarkerConfig")
+    right_spark_filter_selected_columns: Optional[List[StrictStr]] = Field(default=None, alias="rightSparkFilterSelectedColumns")
+    right_spark_sql_dynamic_filter_variable_mapping: Optional[RuleSparkSQLDynamicFilterVariableMapping] = Field(default=None, alias="rightSparkSQLDynamicFilterVariableMapping")
+    right_spark_sql_filter_type: StrictStr = Field(description="Allowed values at generation time: STATIC, DYNAMIC.", alias="rightSparkSQLFilterType")
+    rule_id: StrictInt = Field(alias="ruleId")
+    rule_name: Optional[StrictStr] = Field(default=None, alias="ruleName")
+    rule_selection_enabled: StrictBool = Field(alias="ruleSelectionEnabled")
+    rule_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: DATA_QUALITY, RECONCILIATION, EQUALITY, DATA_DRIFT, SCHEMA_DRIFT, DATA_CADENCE, PROFILE_ANOMALY, AUTO_ANOMALY.", alias="ruleType")
+    rule_version: StrictInt = Field(alias="ruleVersion")
+    schedule_instance_id: Optional[StrictStr] = Field(default=None, alias="scheduleInstanceId")
+    selected_resource_inventory: Optional[StrictStr] = Field(default=None, alias="selectedResourceInventory")
+    source_execution_id: Optional[StrictInt] = Field(default=None, alias="sourceExecutionId")
+    spark_filter_selected_columns: Optional[List[StrictStr]] = Field(default=None, alias="sparkFilterSelectedColumns")
+    spark_resource_config: Optional[SparkResourceConfig] = Field(default=None, alias="sparkResourceConfig")
+    spark_sql_dynamic_filter_variable_mapping: Optional[RuleSparkSQLDynamicFilterVariableMapping] = Field(default=None, alias="sparkSQLDynamicFilterVariableMapping")
+    spark_sql_filter_type: StrictStr = Field(description="Allowed values at generation time: STATIC, DYNAMIC.", alias="sparkSQLFilterType")
+    started_at: datetime = Field(alias="startedAt")
+    threshold_level: RuleThresholdConfiguration = Field(alias="thresholdLevel")
+    treat_zero_rows_as_success: Optional[StrictBool] = Field(default=None, alias="treatZeroRowsAsSuccess")
+    __properties: ClassVar[List[str]] = ["allowRerun", "analysisJob", "analyticsPipelineId", "autoRetries", "autoRetryEnabled", "dataPersistenceEnabled", "driverPodName", "engineType", "executedBy", "executionError", "executionMode", "executionRank", "executionStatus", "executionType", "filter", "finishedAt", "id", "includeInQualityScore", "isProtectedResource", "isResourceRequestedAtRunTime", "jobState", "lastHealthUpdateAt", "lastMarker", "leftLastMarker", "leftMarkerConfig", "markerConfig", "parentId", "participatingColumns", "persistencePath", "pipelineAdditionalConfiguration", "policyResultStatusStrategy", "requestId", "resetPoint", "resourceStrategyType", "resultPersistencePath", "resultStatus", "rightEngineType", "rightFilter", "rightLastMarker", "rightMarkerConfig", "rightSparkFilterSelectedColumns", "rightSparkSQLDynamicFilterVariableMapping", "rightSparkSQLFilterType", "ruleId", "ruleName", "ruleSelectionEnabled", "ruleType", "ruleVersion", "scheduleInstanceId", "selectedResourceInventory", "sourceExecutionId", "sparkFilterSelectedColumns", "sparkResourceConfig", "sparkSQLDynamicFilterVariableMapping", "sparkSQLFilterType", "startedAt", "thresholdLevel", "treatZeroRowsAsSuccess"]
+
+    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 RuleExecution 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 analysis_job
+        if self.analysis_job:
+            _dict['analysisJob'] = self.analysis_job.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of last_marker
+        if self.last_marker:
+            _dict['lastMarker'] = self.last_marker.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of left_last_marker
+        if self.left_last_marker:
+            _dict['leftLastMarker'] = self.left_last_marker.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of left_marker_config
+        if self.left_marker_config:
+            _dict['leftMarkerConfig'] = self.left_marker_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of marker_config
+        if self.marker_config:
+            _dict['markerConfig'] = self.marker_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of right_last_marker
+        if self.right_last_marker:
+            _dict['rightLastMarker'] = self.right_last_marker.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of right_marker_config
+        if self.right_marker_config:
+            _dict['rightMarkerConfig'] = self.right_marker_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of right_spark_sql_dynamic_filter_variable_mapping
+        if self.right_spark_sql_dynamic_filter_variable_mapping:
+            _dict['rightSparkSQLDynamicFilterVariableMapping'] = self.right_spark_sql_dynamic_filter_variable_mapping.to_dict()
+        # 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 spark_sql_dynamic_filter_variable_mapping
+        if self.spark_sql_dynamic_filter_variable_mapping:
+            _dict['sparkSQLDynamicFilterVariableMapping'] = self.spark_sql_dynamic_filter_variable_mapping.to_dict()
+        # 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 driver_pod_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.driver_pod_name is None and "driver_pod_name" in self.model_fields_set:
+            _dict['driverPodName'] = None
+
+        # set to None if engine_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.engine_type is None and "engine_type" in self.model_fields_set:
+            _dict['engineType'] = None
+
+        # set to None if executed_by (nullable) is None
+        # and model_fields_set contains the field
+        if self.executed_by is None and "executed_by" in self.model_fields_set:
+            _dict['executedBy'] = None
+
+        # set to None if execution_error (nullable) is None
+        # and model_fields_set contains the field
+        if self.execution_error is None and "execution_error" in self.model_fields_set:
+            _dict['executionError'] = None
+
+        # set to None if filter (nullable) is None
+        # and model_fields_set contains the field
+        if self.filter is None and "filter" in self.model_fields_set:
+            _dict['filter'] = None
+
+        # set to None if job_state (nullable) is None
+        # and model_fields_set contains the field
+        if self.job_state is None and "job_state" in self.model_fields_set:
+            _dict['jobState'] = None
+
+        # set to None if persistence_path (nullable) is None
+        # and model_fields_set contains the field
+        if self.persistence_path is None and "persistence_path" in self.model_fields_set:
+            _dict['persistencePath'] = None
+
+        # set to None if request_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.request_id is None and "request_id" in self.model_fields_set:
+            _dict['requestId'] = 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 right_engine_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.right_engine_type is None and "right_engine_type" in self.model_fields_set:
+            _dict['rightEngineType'] = None
+
+        # set to None if right_filter (nullable) is None
+        # and model_fields_set contains the field
+        if self.right_filter is None and "right_filter" in self.model_fields_set:
+            _dict['rightFilter'] = None
+
+        # set to None if right_spark_filter_selected_columns (nullable) is None
+        # and model_fields_set contains the field
+        if self.right_spark_filter_selected_columns is None and "right_spark_filter_selected_columns" in self.model_fields_set:
+            _dict['rightSparkFilterSelectedColumns'] = None
+
+        # set to None if rule_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.rule_name is None and "rule_name" in self.model_fields_set:
+            _dict['ruleName'] = None
+
+        # set to None if rule_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.rule_type is None and "rule_type" in self.model_fields_set:
+            _dict['ruleType'] = None
+
+        # set to None if schedule_instance_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.schedule_instance_id is None and "schedule_instance_id" in self.model_fields_set:
+            _dict['scheduleInstanceId'] = 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 spark_filter_selected_columns (nullable) is None
+        # and model_fields_set contains the field
+        if self.spark_filter_selected_columns is None and "spark_filter_selected_columns" in self.model_fields_set:
+            _dict['sparkFilterSelectedColumns'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RuleExecution from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "allowRerun": obj.get("allowRerun"),
+            "analysisJob": DataplaneJob.from_dict(obj["analysisJob"]) if obj.get("analysisJob") is not None else None,
+            "analyticsPipelineId": obj.get("analyticsPipelineId"),
+            "autoRetries": obj.get("autoRetries"),
+            "autoRetryEnabled": obj.get("autoRetryEnabled"),
+            "dataPersistenceEnabled": obj.get("dataPersistenceEnabled"),
+            "driverPodName": obj.get("driverPodName"),
+            "engineType": obj.get("engineType"),
+            "executedBy": obj.get("executedBy"),
+            "executionError": obj.get("executionError"),
+            "executionMode": obj.get("executionMode"),
+            "executionRank": obj.get("executionRank"),
+            "executionStatus": obj.get("executionStatus"),
+            "executionType": obj.get("executionType"),
+            "filter": obj.get("filter"),
+            "finishedAt": obj.get("finishedAt"),
+            "id": obj.get("id"),
+            "includeInQualityScore": obj.get("includeInQualityScore"),
+            "isProtectedResource": obj.get("isProtectedResource"),
+            "isResourceRequestedAtRunTime": obj.get("isResourceRequestedAtRunTime"),
+            "jobState": obj.get("jobState"),
+            "lastHealthUpdateAt": obj.get("lastHealthUpdateAt"),
+            "lastMarker": Marker.from_dict(obj["lastMarker"]) if obj.get("lastMarker") is not None else None,
+            "leftLastMarker": Marker.from_dict(obj["leftLastMarker"]) if obj.get("leftLastMarker") is not None else None,
+            "leftMarkerConfig": MarkerConfig.from_dict(obj["leftMarkerConfig"]) if obj.get("leftMarkerConfig") is not None else None,
+            "markerConfig": MarkerConfig.from_dict(obj["markerConfig"]) if obj.get("markerConfig") is not None else None,
+            "parentId": obj.get("parentId"),
+            "participatingColumns": obj.get("participatingColumns"),
+            "persistencePath": obj.get("persistencePath"),
+            "pipelineAdditionalConfiguration": obj.get("pipelineAdditionalConfiguration"),
+            "policyResultStatusStrategy": obj.get("policyResultStatusStrategy"),
+            "requestId": obj.get("requestId"),
+            "resetPoint": obj.get("resetPoint"),
+            "resourceStrategyType": obj.get("resourceStrategyType"),
+            "resultPersistencePath": obj.get("resultPersistencePath"),
+            "resultStatus": obj.get("resultStatus"),
+            "rightEngineType": obj.get("rightEngineType"),
+            "rightFilter": obj.get("rightFilter"),
+            "rightLastMarker": Marker.from_dict(obj["rightLastMarker"]) if obj.get("rightLastMarker") is not None else None,
+            "rightMarkerConfig": MarkerConfig.from_dict(obj["rightMarkerConfig"]) if obj.get("rightMarkerConfig") is not None else None,
+            "rightSparkFilterSelectedColumns": obj.get("rightSparkFilterSelectedColumns"),
+            "rightSparkSQLDynamicFilterVariableMapping": RuleSparkSQLDynamicFilterVariableMapping.from_dict(obj["rightSparkSQLDynamicFilterVariableMapping"]) if obj.get("rightSparkSQLDynamicFilterVariableMapping") is not None else None,
+            "rightSparkSQLFilterType": obj.get("rightSparkSQLFilterType"),
+            "ruleId": obj.get("ruleId"),
+            "ruleName": obj.get("ruleName"),
+            "ruleSelectionEnabled": obj.get("ruleSelectionEnabled"),
+            "ruleType": obj.get("ruleType"),
+            "ruleVersion": obj.get("ruleVersion"),
+            "scheduleInstanceId": obj.get("scheduleInstanceId"),
+            "selectedResourceInventory": obj.get("selectedResourceInventory"),
+            "sourceExecutionId": obj.get("sourceExecutionId"),
+            "sparkFilterSelectedColumns": obj.get("sparkFilterSelectedColumns"),
+            "sparkResourceConfig": SparkResourceConfig.from_dict(obj["sparkResourceConfig"]) if obj.get("sparkResourceConfig") is not None else None,
+            "sparkSQLDynamicFilterVariableMapping": RuleSparkSQLDynamicFilterVariableMapping.from_dict(obj["sparkSQLDynamicFilterVariableMapping"]) if obj.get("sparkSQLDynamicFilterVariableMapping") is not None else None,
+            "sparkSQLFilterType": obj.get("sparkSQLFilterType"),
+            "startedAt": obj.get("startedAt"),
+            "thresholdLevel": RuleThresholdConfiguration.from_dict(obj["thresholdLevel"]) if obj.get("thresholdLevel") is not None else None,
+            "treatZeroRowsAsSuccess": obj.get("treatZeroRowsAsSuccess")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/rule_execution_result.py

@@ -0,0 +1,90 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class RuleExecutionResult(BaseModel):
+    """
+    RuleExecutionResult
+    """ # noqa: E501
+    rule_execution_type: StrictStr = Field(description="Allowed values at generation time: RECONCILIATION_RULE_TYPE_EXECUTION, DQ_RULE_TYPE_EXECUTION, DATA_DRIFT_EXECUTION, SCHEMA_DRIFT_EXECUTION, DATA_CADENCE_TYPE_EXECUTION, PROFILE_ANOMALY_TYPE_EXECUTION, AUTO_ANOMALY_TYPE_EXECUTION.", alias="ruleExecutionType")
+    status: StrictStr = Field(description="Allowed values at generation time: STARTED, RUNNING, ERRORED, WARNING, SUCCESSFUL, ABORTED, SKIPPED, WAITING, ANOMALY_DETECTION, EXECUTION_RESULT.")
+    __properties: ClassVar[List[str]] = ["ruleExecutionType", "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 RuleExecutionResult 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 RuleExecutionResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "ruleExecutionType": obj.get("ruleExecutionType"),
+            "status": obj.get("status")
+        })
+        return _obj
+
+