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

acceldata/services/rule_service.py

@@ -0,0 +1,620 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from pydantic import ValidationError
+
+from acceldata.client.http_client import BaseHttpClient
+from acceldata.mappers.catalog_executions import (
+    catalog_generic_execution_branch_typename,
+    catalog_generic_execution_payload,
+)
+from acceldata.models.api.catalog.data_cadence_rule_response import DataCadenceRuleResponse
+from acceldata.models.api.catalog.data_quality_execution import DataQualityExecution
+from acceldata.models.api.catalog.data_quality_rule_response import DataQualityRuleResponse
+from acceldata.models.api.catalog.enable_rule_request import EnableRuleRequest
+from acceldata.models.api.catalog.execution_cancellation_response import ExecutionCancellationResponse
+from acceldata.models.api.catalog.execution_result import ExecutionResult
+from acceldata.models.api.catalog.generic_execution import GenericExecution
+from acceldata.models.api.catalog.policy_execution_request import (
+    PolicyExecutionRequest as CatalogPolicyExecutionRequest,
+)
+from acceldata.models.api.catalog.data_cadence_rule_execution import DataCadenceRuleExecution
+from acceldata.models.api.catalog.data_drift_execution import DataDriftExecution
+from acceldata.models.api.catalog.reconciliation_rule_execution import ReconciliationRuleExecution
+from acceldata.models.api.catalog.schema_drift_rule_execution import SchemaDriftRuleExecution
+from acceldata.models.sdk.catalog.policy_execution_request import (
+    PolicyExecutionRequestInput,
+    ensure_catalog_policy_execution_request,
+)
+from acceldata.models.sdk.catalog.policy_execution_type import PolicyExecutionType
+from acceldata.models.api.catalog.quality_rule import QualityRule
+from acceldata.models.api.catalog.reconciliation_rule_response import ReconciliationRuleResponse
+from acceldata.models.api.catalog.rules_with_latest_execution_response import \
+    RulesWithLatestExecutionResponse
+from acceldata.models.sdk.catalog.policy_filter import PolicyFilter, RuleType
+from acceldata.utils.time_range_utils import TimeRangeCalculator
+
+logger = logging.getLogger("sdk")
+
+# POST …/rules/{kind}/{id}/executions — each endpoint’s body matches one ``GenericExecution`` branch.
+# Use concrete execution DTO types from ``acceldata.models.api.catalog`` that match the wire shape,
+# or ``GenericExecution(typed)`` validation fails.
+_EXECUTE_RESPONSE_MODEL = {
+    "execute_dq_rule": DataQualityExecution,
+    "execute_reconciliation_rule": ReconciliationRuleExecution,
+    "execute_freshness_rule": DataCadenceRuleExecution,
+}
+
+# GET ``.../rules/.../executions`` list rows match exactly one ``GenericExecution`` branch; avoid
+# ``GenericExecution.from_dict`` here — the oneOf deserializer can match several branches for the same JSON.
+_POLICY_EXECUTIONS_LIST_ROW_MODEL: dict[RuleType, type] = {
+    RuleType.DATA_QUALITY: DataQualityExecution,
+    RuleType.RECONCILIATION: ReconciliationRuleExecution,
+    RuleType.EQUALITY: ReconciliationRuleExecution,
+    RuleType.DATA_DRIFT: DataDriftExecution,
+    RuleType.SCHEMA_DRIFT: SchemaDriftRuleExecution,
+    RuleType.DATA_CADENCE: DataCadenceRuleExecution,
+}
+
+
+def _normalize_catalog_policy_execution_row(row: dict[str, Any]) -> dict[str, Any]:
+    """Catalog execution list rows may omit ``items`` or send ``null``; typed API DTOs expect a list."""
+    normalized = dict(row)
+    if normalized.get("items") is None:
+        normalized["items"] = []
+    return normalized
+
+
+def _generic_execution_from_policy_executions_row(row: dict[str, Any], rule_type: RuleType) -> GenericExecution:
+    model_cls = _POLICY_EXECUTIONS_LIST_ROW_MODEL.get(rule_type)
+    if model_cls is None:
+        raise ValueError(f"policy_executions: unsupported rule_type {rule_type!r}")
+    row = _normalize_catalog_policy_execution_row(row)
+    try:
+        typed = model_cls.from_dict(row)
+    except (ValidationError, ValueError, TypeError) as strict_exc:
+        # Newer / looser list rows: same outer shape may no longer match the exact typed
+        # wrapper, but the payload may still be a valid :class:`GenericExecution` oneOf. Mirrors
+        # the POST ``_parse_generic_execution_response`` fallback to ``GenericExecution.from_dict``.
+        try:
+            ge = GenericExecution.from_dict(row)
+        except (ValidationError, ValueError) as loose_exc:
+            raise TypeError(
+                f"policy_executions could not deserialize row as {model_cls.__name__} "
+                f"and GenericExecution oneOf also failed. Strict: {strict_exc}. OneOf: {loose_exc}"
+            ) from strict_exc
+        branch = catalog_generic_execution_payload(ge)
+        if branch is None:
+            raise TypeError(
+                f"policy_executions: GenericExecution fallback deserialised empty (expected for row keys "
+                f"{sorted(row.keys())!r})"
+            ) from strict_exc
+        logger.debug(
+            "policy_executions: row was not a strict %s; deserialized as GenericExecution (oneOf: %s)",
+            model_cls.__name__,
+            catalog_generic_execution_branch_typename(ge),
+        )
+        return ge
+    if typed is None:
+        raise TypeError(f"policy_executions: empty deserialization for {model_cls.__name__}")
+    if not isinstance(typed, model_cls):
+        # ``from_dict`` should return ``model_cls``; keep behavior resilient for mocked/stubbed returns.
+        try:
+            return GenericExecution(typed)
+        except (ValidationError, ValueError, TypeError):
+            logger.debug(
+                "policy_executions: using unvalidated GenericExecution wrapper for %s.from_dict return type %s",
+                model_cls.__name__,
+                type(typed).__name__,
+            )
+            return GenericExecution.model_construct(actual_instance=typed)
+    return GenericExecution(typed)
+
+
+def _describe_generic_execution_parse_failure(exc: BaseException) -> str:
+    """One-line classification for GenericExecution ``oneOf`` failures (avoid huge pydantic dumps in logs)."""
+    msg = str(exc)
+    if "Multiple matches found" in msg:
+        return (
+            "GenericExecution oneOf is ambiguous (several branches matched). "
+            "Common when the API omits nulls for nested item fields while the client model schema marks those "
+            "properties as required without defaults — fix the spec / annotations and regenerate the client."
+        )
+    if "No match found" in msg:
+        return "GenericExecution oneOf: no branch matched this JSON shape."
+    return f"{type(exc).__name__}: {msg[:200]}{'…' if len(msg) > 200 else ''}"
+
+
+# Path segment under ``GET /rules/{segment}/{ruleId}/executions`` (kebab-case).
+# Data-quality and reconciliation use these typed paths; all other kinds use
+# ``GET /rules/executions`` with ``ruleId``; see ``_uses_rules_executions_endpoint``.
+_RULE_TYPE_TO_EXECUTIONS_PATH_SEGMENT: dict[RuleType, str] = {
+    RuleType.DATA_QUALITY: "data-quality",
+    RuleType.RECONCILIATION: "reconciliation",
+}
+
+
+def _uses_rules_executions_endpoint(rule_type: RuleType) -> bool:
+    """Whether to call ``GET /rules/executions`` with ``ruleId`` (any kind except data-quality / reconciliation)."""
+    return rule_type not in (RuleType.DATA_QUALITY, RuleType.RECONCILIATION)
+
+
+class RuleService:
+    def __init__(self, http_client: BaseHttpClient) -> None:
+        self._client = http_client
+
+    def get_all_rules(
+            self,
+            filter: PolicyFilter,
+            page: int = 0,
+            size: int = 25,
+            with_latest_execution: bool = True,
+            sort_by: str = "updatedAt:DESC",
+    ) -> RulesWithLatestExecutionResponse:
+        params: dict[str, Any] = {
+            "page": page,
+            "size": size,
+            "withLatestExecution": with_latest_execution,
+            "sortBy": sort_by,
+        }
+        if filter.policy_type is not None:
+            params["ruleType"] = filter.policy_type.name
+            if filter.policy_type.name == RuleType.RECONCILIATION.name:
+                params["ruleType"] = params["ruleType"] + ",EQUALITY"
+        if filter.last_execution_result is not None:
+            params["resultStatus"] = filter.last_execution_result.name
+        if filter.enable is not None:
+            params["enabled"] = filter.enable
+        if filter.active is not None and filter.active is True:
+            params["ruleStatus"] = "ACTIVE"
+        else:
+            params["ruleStatus"] = "ALL"
+        if filter.assets is not None:
+            params["assetIds"] = ",".join([str(i.id) for i in filter.assets])
+        if filter.data_sources is not None:
+            params["assemblyIds"] = ",".join([str(i.id) for i in filter.data_sources])
+        if filter.period is not None:
+            finished_before_time, started_after_time = TimeRangeCalculator.calculate_time_range(filter)
+            if started_after_time is not None:
+                params["startedAfter"] = int(round(started_after_time.timestamp() * 1000))
+            params["finishedBefore"] = int(round(finished_before_time.timestamp() * 1000))
+
+        logger.debug(params)
+        url = self._client.catalog_urls.rules()
+        response = self._client._get(
+            url=url,
+            params=params,
+        )
+        logger.debug(f"Response: {response}")
+        return RulesWithLatestExecutionResponse.from_dict(response)
+
+    @staticmethod
+    def _require_object_response(response: object, operation: str) -> dict[str, Any]:
+        if not isinstance(response, dict):
+            raise TypeError(f"{operation} expected a JSON object response, got {type(response).__name__}")
+        return response
+
+    def get_policy(self, identifier: str | int) -> QualityRule:
+        """GET ``/rules/{identifier}`` — returns :class:`~acceldata.models.api.catalog.quality_rule.QualityRule`."""
+        url = self._client.catalog_urls.rule_by_identifier(identifier)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_policy")
+        parsed = QualityRule.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_policy received an empty QualityRule payload")
+        return parsed
+
+    def get_dq_rule(self, rule_id: str | int) -> DataQualityRuleResponse:
+        """GET ``/rules/data-quality/{rule_id}`` — Data quality :class:`~acceldata.models.api.catalog.rule_response.RuleResponse`."""
+        url = self._client.catalog_urls.data_quality_rule(rule_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_dq_rule")
+        logger.info(f"Raw dq rule: {raw} ")
+        parsed = DataQualityRuleResponse.from_dict(raw)
+        logger.debug(f"DataQualityRuleResponse: {parsed}")
+        if parsed is None:
+            raise TypeError("get_dq_rule received an empty RuleResponse payload")
+        return parsed
+
+    def get_reconciliation_rule(self, rule_id: str | int) -> ReconciliationRuleResponse:
+        """GET ``/rules/reconciliation/{rule_id}``."""
+        url = self._client.catalog_urls.reconciliation_rule(rule_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_reconciliation_rule")
+        parsed = ReconciliationRuleResponse.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_reconciliation_rule received an empty response payload")
+        return parsed
+
+    def get_freshness_rule(self, rule_id: str | int) -> DataCadenceRuleResponse:
+        """GET ``/rules/data-cadence/{rule_id}`` (freshness / cadence rule)."""
+        url = self._client.catalog_urls.data_cadence_rule(rule_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_freshness_rule")
+        parsed = DataCadenceRuleResponse.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_freshness_rule received an empty response payload")
+        return parsed
+
+    def get_reconciliation_rule_execution_details(
+            self, execution_id: str | int
+    ) -> ReconciliationRuleExecution:
+        """GET ``/rules/reconciliation/executions/{execution_id}`` — Reconciliation.Execution payload."""
+        url = self._client.catalog_urls.reconciliation_rule_execution(execution_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_reconciliation_rule_execution_details")
+        parsed = ReconciliationRuleExecution.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_reconciliation_rule_execution_details received an empty response payload")
+        return parsed
+
+    def get_reconciliation_rule_result(self, execution_id: str | int) -> ExecutionResult:
+        """GET ``/rules/reconciliation/executions/{execution_id}/result`` — :class:`ExecutionResult`."""
+        url = self._client.catalog_urls.reconciliation_rule_execution_result(execution_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_reconciliation_rule_result")
+        parsed = ExecutionResult.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_reconciliation_rule_result received an empty response payload")
+        return parsed
+
+    @staticmethod
+    def _identifier_is_numeric_rule_id(identifier: str | int) -> bool:
+        if isinstance(identifier, int):
+            return True
+        return TimeRangeCalculator.check_int(str(identifier))
+
+    def _resolve_rule_id_for_executions(self, identifier: str | int, rule_type: RuleType) -> str | int:
+        if self._identifier_is_numeric_rule_id(identifier):
+            return identifier
+        if rule_type == RuleType.DATA_QUALITY:
+            rule_res = self.get_dq_rule(identifier)
+            rid = rule_res.rule.id
+        elif rule_type in (RuleType.RECONCILIATION, RuleType.EQUALITY):
+            rule_res = self.get_reconciliation_rule(identifier)
+            rid = rule_res.rule.id
+        elif rule_type == RuleType.DATA_CADENCE:
+            rule_res = self.get_freshness_rule(identifier)
+            rid = rule_res.rule.id
+        elif _uses_rules_executions_endpoint(rule_type):
+            qr = self.get_policy(identifier)
+            rid = qr.id
+        else:
+            raise ValueError(
+                f"A numeric rule id is required for {rule_type.name}; "
+                "name-based lookup is not implemented for this rule kind."
+            )
+        if rid is None:
+            raise TypeError("Resolved rule has no id; cannot list executions.")
+        return rid
+
+    def _policy_executions_url(self, rule_type: RuleType, rule_id: str | int) -> str:
+        segment = _RULE_TYPE_TO_EXECUTIONS_PATH_SEGMENT.get(rule_type)
+        if segment is None:
+            raise ValueError(f"Unknown rule type for listing executions: {rule_type!r}")
+        base = self._client.catalog_urls.rules()
+        return f"{base}/{segment}/{rule_id}/executions"
+
+    @staticmethod
+    def _executions_rows_from_policy_list_response(raw: dict[str, Any]) -> list[Any]:
+        """Normalize list payloads from GET ``.../rules/{{kind}}/{{id}}/executions``.
+
+        The API may return either a flat ``ExecutionsResponse`` shape
+        (``executions`` + ``meta`` at the top level) or a Kotlin-style wrapper whose
+        sole meaningful key ends with ``ExecutionsResponse``, e.g.
+        ``DataQuality.ExecutionsResponse`` or ``Reconciliation.ExecutionsResponse``.
+
+        When the payload has no recognizable executions list (e.g. empty object or
+        only ``meta``), returns an empty list — the rule may never have been executed.
+        """
+        if not raw:
+            return []
+        if "executions" in raw:
+            top = raw["executions"]
+            if top is None:
+                return []
+            if isinstance(top, list):
+                return top
+            raise TypeError(
+                "policy_executions expected top-level 'executions' to be a list or null, "
+                f"got {type(top).__name__}"
+            )
+
+        for key, value in raw.items():
+            if not isinstance(value, dict):
+                continue
+            if not key.endswith("ExecutionsResponse"):
+                continue
+            nested = value.get("executions")
+            if nested is None:
+                return []
+            if isinstance(nested, list):
+                return nested
+            raise TypeError(
+                "policy_executions expected wrapped *ExecutionsResponse.executions to be a list, "
+                f"got {type(nested).__name__} (key {key!r})"
+            )
+
+        logger.debug(
+            "policy_executions: no executions list in response (keys=%s); treating as no runs",
+            sorted(raw.keys()),
+        )
+        return []
+
+    def policy_executions(
+            self,
+            identifier: str | int,
+            rule_type: RuleType,
+            page: int = 0,
+            size: int = 25,
+            sort_by: str = "finishedAt:DESC",
+    ) -> list[GenericExecution]:
+        """List rule executions.
+
+        Uses ``GET /rules/{{kind}}/{{rule_id}}/executions`` for data-quality and reconciliation
+        rules only. All other kinds use ``GET /rules/executions`` with query param ``ruleId``
+        (same contract as the catalog UI).
+
+        Accepts both flat ``ExecutionsResponse`` JSON and wrapped shapes such as
+        ``DataQuality.ExecutionsResponse`` / ``Reconciliation.ExecutionsResponse``.
+
+        Returns an empty list when the catalog has no executions yet (including a JSON
+        ``null`` body parsed as ``None``, an empty object ``{}``, or a payload with no
+        ``executions`` / ``*ExecutionsResponse`` list).
+
+        Each row is first parsed with the rule-kind–specific typed model (e.g. ``DataQualityExecution``).
+        If that fails, the same row is retried with :class:`GenericExecution` (``oneOf``), same strategy as
+        :meth:`execute_dq_rule` and :meth:`_parse_generic_execution_response` for execute responses.
+        """
+        rule_id = self._resolve_rule_id_for_executions(identifier, rule_type)
+        if _uses_rules_executions_endpoint(rule_type):
+            url = self._client.catalog_urls.rules_executions()
+            params: dict[str, Any] = {
+                "page": page,
+                "size": size,
+                "sortBy": sort_by,
+                "ruleId": rule_id,
+            }
+        else:
+            url = self._policy_executions_url(rule_type, rule_id)
+            params = {
+                "page": page,
+                "size": size,
+                "sortBy": sort_by,
+            }
+        response = self._client._get(url=url, params=params)
+        logger.debug(f"Rule executions response: {response}")
+        if response is None:
+            return []
+        raw = self._require_object_response(response, "policy_executions")
+        rows = self._executions_rows_from_policy_list_response(raw)
+        row_model = _POLICY_EXECUTIONS_LIST_ROW_MODEL.get(rule_type)
+        if row_model is None:
+            raise ValueError(f"policy_executions: unsupported rule_type {rule_type!r}")
+        logger.debug(
+            "policy_executions: parsing %d row(s) as %s (rule_type=%s)",
+            len(rows),
+            row_model.__name__,
+            rule_type.name,
+        )
+        parsed: list[GenericExecution] = []
+        for row in rows:
+            if not isinstance(row, dict):
+                raise TypeError(
+                    "policy_executions expected each row to be an object with an 'execution' field, "
+                    f"got {type(row).__name__}"
+                )
+            if "execution" not in row:
+                raise TypeError("policy_executions row is missing required 'execution' field")
+            execution_raw = row["execution"]
+            if execution_raw is None:
+                raise TypeError("policy_executions row['execution'] is null")
+            if not isinstance(execution_raw, dict):
+                raise TypeError(
+                    "policy_executions expected row['execution'] to be an object, "
+                    f"got {type(execution_raw).__name__}"
+                )
+            # List rows match ``DataQualityExecution`` / ``ReconciliationRuleExecution`` etc. (execution +
+            # items + policy fields), not bare ``RuleExecution`` / ``GenericRuleExecution`` payloads.
+            ge = _generic_execution_from_policy_executions_row(row, rule_type)
+            if ge is None:
+                raise TypeError("policy_executions received empty execution payload")
+            parsed.append(ge)
+        return parsed
+
+    def execute_dq_rule(
+        self,
+        rule_id: str | int,
+        policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        """POST ``/rules/data-quality/{rule_id}/executions`` — returns :class:`GenericExecution`."""
+        payload = self._payload_from_policy_execution_request(policy_execution_request)
+        response = self._client._post(
+            url=self._client.catalog_urls.data_quality_rule_executions(rule_id),
+            payload=payload,
+        )
+        logger.debug(f"execute_dq_rule response: {response}")
+        return self._parse_generic_execution_response(response, "execute_dq_rule")
+
+    def execute_reconciliation_rule(
+        self,
+        rule_id: str | int,
+        policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        """POST ``/rules/reconciliation/{rule_id}/executions`` — returns :class:`GenericExecution`."""
+        payload = self._payload_from_policy_execution_request(policy_execution_request)
+        response = self._client._post(
+            url=self._client.catalog_urls.reconciliation_rule_executions(rule_id),
+            payload=payload,
+        )
+        return self._parse_generic_execution_response(response, "execute_reconciliation_rule")
+
+    def execute_freshness_rule(
+        self,
+        rule_id: str | int,
+        policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        """POST ``/rules/data-cadence/{rule_id}/executions`` — returns :class:`GenericExecution`."""
+        payload = self._payload_from_policy_execution_request(policy_execution_request)
+        response = self._client._post(
+            url=self._client.catalog_urls.data_cadence_rule_executions(rule_id),
+            payload=payload,
+        )
+        return self._parse_generic_execution_response(response, "execute_freshness_rule")
+
+    @staticmethod
+    def _payload_from_policy_execution_request(req: PolicyExecutionRequestInput) -> dict[str, Any]:
+        api_req = ensure_catalog_policy_execution_request(req)
+        if (
+            api_req.execution_type == PolicyExecutionType.SELECTIVE.value
+            and not api_req.marker_configs
+        ):
+            raise ValueError("markerConfigs is mandatory when execution_type is SELECTIVE")
+        # Always use generated model ``to_dict()`` so oneOf wrappers (e.g. MarkerConfig) serialize
+        # as plain wire JSON accepted by catalog execution endpoints.
+        return api_req.to_dict()
+
+    @staticmethod
+    def _parse_generic_execution_response(response: object, operation_name: str) -> GenericExecution:
+        raw = RuleService._require_object_response(response, operation_name)
+        first_error: BaseException | None = None
+
+        model_cls = _EXECUTE_RESPONSE_MODEL.get(operation_name)
+        if model_cls is not None and isinstance(raw, dict):
+            try:
+                typed = model_cls.from_dict(raw)
+                if typed is not None:
+                    logger.debug("%s: parsed as %s", operation_name, model_cls.__name__)
+                    return GenericExecution(typed)
+            except (ValidationError, ValueError, TypeError) as e:
+                first_error = e
+                logger.debug(
+                    "%s: %s.from_dict failed; falling back to GenericExecution",
+                    operation_name,
+                    model_cls.__name__,
+                    exc_info=e,
+                )
+
+        try:
+            ge = GenericExecution.from_dict(raw)
+            logger.debug("%s: response deserialized as GenericExecution (oneOf)", operation_name)
+            return ge
+        except (ValueError, ValidationError) as e:
+            first_error = e
+            logger.debug("%s: %s", operation_name, _describe_generic_execution_parse_failure(e))
+            logger.debug("%s: GenericExecution.from_dict failure detail", operation_name, exc_info=e)
+
+        # Kotlin/Jackson may wrap under a key ending in ``.Execution``.
+        for key, value in raw.items():
+            if isinstance(value, dict) and key.endswith(".Execution"):
+                try:
+                    ge = GenericExecution.from_dict(value)
+                    logger.debug("%s: response deserialized from nested key %r", operation_name, key)
+                    return ge
+                except (ValueError, ValidationError):
+                    continue
+
+        hint = (
+            _describe_generic_execution_parse_failure(first_error)
+            if first_error is not None
+            else "could not classify parse failure"
+        )
+        raise TypeError(
+            f"{operation_name}: could not deserialize execution response. {hint} "
+            f"Top-level keys: {sorted(raw.keys())}."
+        ) from first_error
+
+    def get_dq_rule_result(self, execution_id: str | int) -> ExecutionResult:
+        """GET ``/rules/data-quality/executions/{execution_id}/result`` — :class:`ExecutionResult`."""
+        url = self._client.catalog_urls.data_quality_rule_execution_result(execution_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_dq_rule_result")
+        parsed = ExecutionResult.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_dq_rule_result received an empty response payload")
+        return parsed
+
+    def get_dq_rule_execution_details(self, execution_id: str | int) -> DataQualityExecution:
+        """GET ``/rules/data-quality/executions/{execution_id}`` — :class:`DataQualityExecution`."""
+        url = self._client.catalog_urls.data_quality_rule_execution(execution_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_dq_rule_execution_details")
+        parsed = DataQualityExecution.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_dq_rule_execution_details received an empty response payload")
+        return parsed
+
+    def get_freshness_rule_result(self, execution_id: str | int) -> ExecutionResult:
+        """GET ``/rules/data-cadence/executions/{execution_id}/result`` — :class:`ExecutionResult`."""
+        url = self._client.catalog_urls.data_cadence_rule_execution_result(execution_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_freshness_rule_result")
+        parsed = ExecutionResult.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_freshness_rule_result received an empty response payload")
+        return parsed
+
+    def get_data_cadence_rule_execution_details(
+        self, execution_id: str | int
+    ) -> DataCadenceRuleExecution:
+        """GET ``/rules/data-cadence/executions/{execution_id}`` — :class:`DataCadenceRuleExecution`."""
+        url = self._client.catalog_urls.data_cadence_rule_execution(execution_id)
+        response = self._client._get(url=url)
+        raw = self._require_object_response(response, "get_data_cadence_rule_execution_details")
+        parsed = DataCadenceRuleExecution.from_dict(raw)
+        if parsed is None:
+            raise TypeError("get_data_cadence_rule_execution_details received an empty response payload")
+        return parsed
+
+    def cancel_rule_execution(self, execution_id: str | int) -> ExecutionCancellationResponse:
+        """PUT ``/rules/execution/{execution_id}/cancel`` — returns :class:`ExecutionCancellationResponse`."""
+        response = self._client._put(
+            url=self._client.catalog_urls.cancel_rule_execution(execution_id),
+            payload={},
+        )
+        raw = self._require_object_response(response, "cancel_rule_execution")
+        parsed = ExecutionCancellationResponse.from_dict(raw)
+        if parsed is None:
+            raise TypeError("cancel_rule_execution received an empty response payload")
+        if parsed.result.message is None:
+            parsed.result.message = (
+                f"Cancellation requested for execution {execution_id} "
+                f"(status={parsed.result.status})."
+            )
+        if parsed.result.request_id is None:
+            parsed.result.request_id = str(execution_id)
+        return parsed
+
+    def enable_rule(self, rule_id: str | int) -> QualityRule:
+        """PUT ``/rules/{rule_id}/enable`` with :class:`~acceldata.models.api.catalog.enable_rule_request.EnableRuleRequest` (``enable: true``); returns :class:`QualityRule`."""
+        payload = EnableRuleRequest(enable=True).to_dict()
+        response = self._client._put(
+            url=self._client.catalog_urls.rule_enable(rule_id),
+            payload=payload,
+        )
+        raw = self._require_object_response(response, "enable_rule")
+        inner = raw.get("rule", raw)
+        if not isinstance(inner, dict):
+            raise TypeError(f"enable_rule expected rule object, got {type(inner).__name__}")
+        parsed = QualityRule.from_dict(inner)
+        if parsed is None:
+            raise TypeError("enable_rule received an empty QualityRule payload")
+        return parsed
+
+    def disable_rule(self, rule_id: str | int) -> QualityRule:
+        """PUT ``/rules/{rule_id}/enable`` with :class:`~acceldata.models.api.catalog.enable_rule_request.EnableRuleRequest` (``enable: false``); returns :class:`QualityRule`."""
+        payload = EnableRuleRequest(enable=False).to_dict()
+        response = self._client._put(
+            url=self._client.catalog_urls.rule_enable(rule_id),
+            payload=payload,
+        )
+        raw = self._require_object_response(response, "disable_rule")
+        inner = raw.get("rule", raw)
+        if not isinstance(inner, dict):
+            raise TypeError(f"disable_rule expected rule object, got {type(inner).__name__}")
+        parsed = QualityRule.from_dict(inner)
+        if parsed is None:
+            raise TypeError("disable_rule received an empty QualityRule payload")
+        return parsed

acceldata/urls/__init__.py

@@ -0,0 +1 @@
+from .catalog_urls import CatalogUrls