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

acceldata/models/api/catalog/quality_rule_execution_metrics.py

@@ -0,0 +1,114 @@
+# 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class QualityRuleExecutionMetrics(BaseModel):
+    """
+    QualityRuleExecutionMetrics
+    """ # noqa: E501
+    average_quality_score_over30_days: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="averageQualityScoreOver30Days")
+    execution_type: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: SELECTIVE, FULL, INCREMENTAL.", alias="executionType")
+    last_execution_duration: Optional[StrictInt] = Field(default=None, alias="lastExecutionDuration")
+    open_alert_ids: List[StrictInt] = Field(alias="openAlertIds")
+    open_alerts_count: Optional[StrictInt] = Field(default=None, alias="openAlertsCount")
+    quality_score: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="qualityScore")
+    result_status: Optional[StrictStr] = Field(default=None, description="Allowed values at generation time: STARTED, RUNNING, ERRORED, WARNING, SUCCESSFUL, ABORTED, SKIPPED, WAITING, ANOMALY_DETECTION, EXECUTION_RESULT.", alias="resultStatus")
+    total_executions_over30_days: Optional[StrictInt] = Field(default=None, alias="totalExecutionsOver30Days")
+    total_records_processed: Optional[StrictInt] = Field(default=None, alias="totalRecordsProcessed")
+    __properties: ClassVar[List[str]] = ["averageQualityScoreOver30Days", "executionType", "lastExecutionDuration", "openAlertIds", "openAlertsCount", "qualityScore", "resultStatus", "totalExecutionsOver30Days", "totalRecordsProcessed"]
+
+    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 QualityRuleExecutionMetrics 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,
+        )
+        # set to None if execution_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.execution_type is None and "execution_type" in self.model_fields_set:
+            _dict['executionType'] = None
+
+        # set to None if result_status (nullable) is None
+        # and model_fields_set contains the field
+        if self.result_status is None and "result_status" in self.model_fields_set:
+            _dict['resultStatus'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QualityRuleExecutionMetrics from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "averageQualityScoreOver30Days": obj.get("averageQualityScoreOver30Days"),
+            "executionType": obj.get("executionType"),
+            "lastExecutionDuration": obj.get("lastExecutionDuration"),
+            "openAlertIds": obj.get("openAlertIds"),
+            "openAlertsCount": obj.get("openAlertsCount"),
+            "qualityScore": obj.get("qualityScore"),
+            "resultStatus": obj.get("resultStatus"),
+            "totalExecutionsOver30Days": obj.get("totalExecutionsOver30Days"),
+            "totalRecordsProcessed": obj.get("totalRecordsProcessed")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/quality_rule_with_latest_execution.py

@@ -0,0 +1,115 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional
+from acceldata.models.api.catalog.quality_rule import QualityRule
+from acceldata.models.api.catalog.quality_rule_execution_metrics import QualityRuleExecutionMetrics
+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 QualityRuleWithLatestExecution(BaseModel):
+    """
+    QualityRuleWithLatestExecution
+    """ # noqa: E501
+    child_rules: List[QualityRuleWithLatestExecution] = Field(alias="childRules")
+    execution: Optional[RuleExecution] = None
+    execution_metrics: Optional[QualityRuleExecutionMetrics] = Field(default=None, alias="executionMetrics")
+    rule: QualityRule
+    __properties: ClassVar[List[str]] = ["childRules", "execution", "executionMetrics", "rule"]
+
+    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 QualityRuleWithLatestExecution 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 child_rules (list)
+        _items = []
+        if self.child_rules:
+            for _item_child_rules in self.child_rules:
+                if _item_child_rules:
+                    _items.append(_item_child_rules.to_dict())
+            _dict['childRules'] = _items
+        # 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 execution_metrics
+        if self.execution_metrics:
+            _dict['executionMetrics'] = self.execution_metrics.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of rule
+        if self.rule:
+            _dict['rule'] = self.rule.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QualityRuleWithLatestExecution from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "childRules": [QualityRuleWithLatestExecution.from_dict(_item) for _item in obj["childRules"]] if obj.get("childRules") is not None else None,
+            "execution": RuleExecution.from_dict(obj["execution"]) if obj.get("execution") is not None else None,
+            "executionMetrics": QualityRuleExecutionMetrics.from_dict(obj["executionMetrics"]) if obj.get("executionMetrics") is not None else None,
+            "rule": QualityRule.from_dict(obj["rule"]) if obj.get("rule") is not None else None
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+QualityRuleWithLatestExecution.model_rebuild(raise_errors=False)
+

acceldata/models/api/catalog/range_configs.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, Optional
+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 RangeConfigs(BaseModel):
+    """
+    RangeConfigs
+    """ # noqa: E501
+    direction: StrictStr = Field(description="Allowed values at generation time: ABOVE, BELOW, RANGE, CHANGES_BY, DECREASED_BY, INCREASED_BY.")
+    lower_success: AboveConfigsSuccess = Field(alias="lowerSuccess")
+    lower_warning: Optional[AboveConfigsSuccess] = Field(default=None, alias="lowerWarning")
+    upper_success: AboveConfigsSuccess = Field(alias="upperSuccess")
+    upper_warning: Optional[AboveConfigsSuccess] = Field(default=None, alias="upperWarning")
+    __properties: ClassVar[List[str]] = ["direction", "lowerSuccess", "lowerWarning", "upperSuccess", "upperWarning"]
+
+    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 RangeConfigs 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 lower_success
+        if self.lower_success:
+            _dict['lowerSuccess'] = self.lower_success.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of lower_warning
+        if self.lower_warning:
+            _dict['lowerWarning'] = self.lower_warning.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of upper_success
+        if self.upper_success:
+            _dict['upperSuccess'] = self.upper_success.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of upper_warning
+        if self.upper_warning:
+            _dict['upperWarning'] = self.upper_warning.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RangeConfigs from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "direction": obj.get("direction"),
+            "lowerSuccess": AboveConfigsSuccess.from_dict(obj["lowerSuccess"]) if obj.get("lowerSuccess") is not None else None,
+            "lowerWarning": AboveConfigsSuccess.from_dict(obj["lowerWarning"]) if obj.get("lowerWarning") is not None else None,
+            "upperSuccess": AboveConfigsSuccess.from_dict(obj["upperSuccess"]) if obj.get("upperSuccess") is not None else None,
+            "upperWarning": AboveConfigsSuccess.from_dict(obj["upperWarning"]) if obj.get("upperWarning") is not None else None
+        })
+        return _obj
+
+

acceldata/models/api/catalog/reconciliation_item.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, 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 ReconciliationItem(BaseModel):
+    """
+    ReconciliationItem
+    """ # noqa: E501
+    execution_order: StrictInt = Field(alias="executionOrder")
+    id: Optional[StrictInt] = None
+    measurement_type: StrictStr = Field(description="Allowed values at generation time: EQUALITY, COUNT, PROFILE_EQUALITY, HASHED_EQUALITY, TIMELINESS, CUSTOM, ROW_COUNT_EQUALITY.", alias="measurementType")
+    rule_id: Optional[StrictInt] = Field(default=None, alias="ruleId")
+    threshold_config: Optional[RuleThresholdConfiguration] = Field(default=None, alias="thresholdConfig")
+    version: StrictInt
+    __properties: ClassVar[List[str]] = ["executionOrder", "id", "measurementType", "ruleId", "thresholdConfig", "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 ReconciliationItem 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 ReconciliationItem 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"),
+            "measurementType": obj.get("measurementType"),
+            "ruleId": obj.get("ruleId"),
+            "thresholdConfig": RuleThresholdConfiguration.from_dict(obj["thresholdConfig"]) if obj.get("thresholdConfig") is not None else None,
+            "version": obj.get("version")
+        })
+        return _obj
+
+

acceldata/models/api/catalog/reconciliation_item_execution.py

@@ -0,0 +1,157 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ReconciliationItemExecution(BaseModel):
+    """
+    ReconciliationItemExecution
+    """ # noqa: E501
+    delayed_left_analysis_job_id: Optional[StrictInt] = Field(default=None, alias="delayedLeftAnalysisJobId")
+    delayed_right_analysis_job_id: Optional[StrictInt] = Field(default=None, alias="delayedRightAnalysisJobId")
+    execution_id: StrictInt = Field(alias="executionId")
+    finished_at: Optional[datetime] = Field(default=None, alias="finishedAt")
+    id: Optional[StrictInt] = None
+    is_error: StrictBool = Field(alias="isError")
+    left_analytics_pipeline_name: StrictStr = Field(alias="leftAnalyticsPipelineName")
+    left_error: Optional[StrictStr] = Field(default=None, alias="leftError")
+    left_result: Optional[StrictStr] = Field(default=None, alias="leftResult")
+    left_rows_failed: Optional[StrictInt] = Field(default=None, alias="leftRowsFailed")
+    left_rows_scanned: Optional[StrictInt] = Field(default=None, alias="leftRowsScanned")
+    match_result: Optional[StrictStr] = Field(default=None, alias="matchResult")
+    measures_selection: Optional[List[StrictInt]] = Field(default=None, alias="measuresSelection")
+    right_analytics_pipeline_name: StrictStr = Field(alias="rightAnalyticsPipelineName")
+    right_error: Optional[StrictStr] = Field(default=None, alias="rightError")
+    right_result: Optional[StrictStr] = Field(default=None, alias="rightResult")
+    right_rows_failed: Optional[StrictInt] = Field(default=None, alias="rightRowsFailed")
+    right_rows_scanned: Optional[StrictInt] = Field(default=None, alias="rightRowsScanned")
+    rule_item_id: StrictInt = Field(alias="ruleItemId")
+    started_at: datetime = Field(alias="startedAt")
+    __properties: ClassVar[List[str]] = ["delayedLeftAnalysisJobId", "delayedRightAnalysisJobId", "executionId", "finishedAt", "id", "isError", "leftAnalyticsPipelineName", "leftError", "leftResult", "leftRowsFailed", "leftRowsScanned", "matchResult", "measuresSelection", "rightAnalyticsPipelineName", "rightError", "rightResult", "rightRowsFailed", "rightRowsScanned", "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 ReconciliationItemExecution 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,
+        )
+        # set to None if left_error (nullable) is None
+        # and model_fields_set contains the field
+        if self.left_error is None and "left_error" in self.model_fields_set:
+            _dict['leftError'] = None
+
+        # set to None if left_result (nullable) is None
+        # and model_fields_set contains the field
+        if self.left_result is None and "left_result" in self.model_fields_set:
+            _dict['leftResult'] = None
+
+        # set to None if match_result (nullable) is None
+        # and model_fields_set contains the field
+        if self.match_result is None and "match_result" in self.model_fields_set:
+            _dict['matchResult'] = None
+
+        # set to None if measures_selection (nullable) is None
+        # and model_fields_set contains the field
+        if self.measures_selection is None and "measures_selection" in self.model_fields_set:
+            _dict['measuresSelection'] = None
+
+        # set to None if right_error (nullable) is None
+        # and model_fields_set contains the field
+        if self.right_error is None and "right_error" in self.model_fields_set:
+            _dict['rightError'] = None
+
+        # set to None if right_result (nullable) is None
+        # and model_fields_set contains the field
+        if self.right_result is None and "right_result" in self.model_fields_set:
+            _dict['rightResult'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReconciliationItemExecution from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "delayedLeftAnalysisJobId": obj.get("delayedLeftAnalysisJobId"),
+            "delayedRightAnalysisJobId": obj.get("delayedRightAnalysisJobId"),
+            "executionId": obj.get("executionId"),
+            "finishedAt": obj.get("finishedAt"),
+            "id": obj.get("id"),
+            "isError": obj.get("isError"),
+            "leftAnalyticsPipelineName": obj.get("leftAnalyticsPipelineName"),
+            "leftError": obj.get("leftError"),
+            "leftResult": obj.get("leftResult"),
+            "leftRowsFailed": obj.get("leftRowsFailed"),
+            "leftRowsScanned": obj.get("leftRowsScanned"),
+            "matchResult": obj.get("matchResult"),
+            "measuresSelection": obj.get("measuresSelection"),
+            "rightAnalyticsPipelineName": obj.get("rightAnalyticsPipelineName"),
+            "rightError": obj.get("rightError"),
+            "rightResult": obj.get("rightResult"),
+            "rightRowsFailed": obj.get("rightRowsFailed"),
+            "rightRowsScanned": obj.get("rightRowsScanned"),
+            "ruleItemId": obj.get("ruleItemId"),
+            "startedAt": obj.get("startedAt")
+        })
+        return _obj
+
+