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

acceldata/models/sdk/catalog/executor.py

@@ -0,0 +1,524 @@
+from __future__ import annotations
+
+import logging
+from enum import IntEnum
+from time import sleep
+from typing import Callable
+
+from acceldata.client.transient_retry import (
+    RetryConfig,
+    effective_transient_retry,
+    transient_retry_call,
+)
+from acceldata.exceptions import (
+    APIError,
+    AcceldataSdkException,
+    ApiException,
+    InvalidRuleTypeError,
+    PolicyExecutionCompletedWithErrorResultError,
+    PolicyExecutionCompletedWithWarningError,
+)
+from acceldata.mappers.catalog_executions import (
+    execution_status_pair_from_result,
+    rule_execution_error_message_from_result,
+    rule_execution_id_from_generic_post_response,
+)
+from acceldata.utils.operation_ack import ack_failure, ack_success
+from acceldata.models.api.catalog.data_quality_execution import DataQualityExecution
+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.generic_rule_execution import GenericRuleExecution
+from acceldata.models.api.catalog.reconciliation_rule_execution import ReconciliationRuleExecution
+from acceldata.models.api.catalog.quality_rule import QualityRule
+from acceldata.models.api.catalog.rule_execution import RuleExecution
+from acceldata.models.api.catalog.rule_execution_result import RuleExecutionResult
+from acceldata.models.sdk.catalog.policy_execution_request import PolicyExecutionRequestInput
+from acceldata.models.sdk.catalog.policy_filter import RuleExecutionStatus, RuleType
+LOGGER = logging.getLogger("sdk.executor")
+
+
+def _execution_result_for_log(er: ExecutionResult) -> str:
+    """Compact log string for :class:`ExecutionResult` without full model serialization."""
+    try:
+        es, rs = execution_status_pair_from_result(er)
+        msg = rule_execution_error_message_from_result(er)
+        parts = [f"executionStatus={es}", f"resultStatus={rs}"]
+        if msg:
+            parts.append(f"executionError={msg}")
+        return ", ".join(parts)
+    except Exception:
+        LOGGER.debug("ExecutionResult compact formatting failed; using str()", exc_info=True)
+        return str(er)
+
+
+def _execution_progress_for_log(er: ExecutionResult) -> str | None:
+    """Compact progress summary from `ExecutionResult.items` for poll logs."""
+    items = getattr(er, "items", None)
+    if not items:
+        return None
+
+    terminal_item_statuses = {
+        RuleExecutionStatus.SUCCESSFUL.value,
+        RuleExecutionStatus.WARNING.value,
+        RuleExecutionStatus.ERRORED.value,
+        RuleExecutionStatus.ABORTED.value,
+        RuleExecutionStatus.SKIPPED.value,
+    }
+    status_counts: dict[str, int] = {}
+    completed = 0
+    result_percents: list[float] = []
+
+    for item in items:
+        st = getattr(item, "status", None) or "UNKNOWN"
+        status_counts[st] = status_counts.get(st, 0) + 1
+        if st in terminal_item_statuses:
+            completed += 1
+        rp = getattr(item, "result_percent", None)
+        if isinstance(rp, (int, float)):
+            result_percents.append(float(rp))
+
+    total = len(items)
+    percent_done = (completed / total) * 100.0 if total else 0.0
+    status_parts = ",".join(f"{k}:{status_counts[k]}" for k in sorted(status_counts))
+    msg = f"items={completed}/{total} ({percent_done:.1f}%), itemStatuses=[{status_parts}]"
+    if result_percents:
+        avg_percent = sum(result_percents) / len(result_percents)
+        msg = f"{msg}, avgItemResultPercent={avg_percent:.2f}"
+    return msg
+
+
+def _errored_execution_result(message: str) -> ExecutionResult:
+    es = RuleExecutionStatus.ERRORED.value
+    re = RuleExecution.model_construct(
+        execution_status=es,
+        result_status=es,
+        execution_error=message,
+    )
+    ge = GenericRuleExecution(re)
+    rer = RuleExecutionResult.model_construct(
+        rule_execution_type="DQ_RULE_TYPE_EXECUTION",
+        status=es,
+    )
+    return ExecutionResult.model_construct(execution=ge, items=[], meta={}, result=rer)
+
+
+class FailureStrategy(IntEnum):
+    DoNotFail = 0
+    FailOnWarning = 1
+    FailOnError = 2
+
+
+# Poll loops: ``total_retries == POLICY_POLL_UNLIMITED_RETRIES`` (-1) means no cap on RUNNING/WAITING rounds.
+POLICY_POLL_UNLIMITED_RETRIES: int = -1
+
+
+# ``Executor`` / ``execute_policy`` — catalog POST + poll helpers wired for these kinds only.
+_EXECUTOR_RULE_TYPES: tuple[RuleType, ...] = (
+    RuleType.DATA_QUALITY,
+    RuleType.RECONCILIATION,
+    RuleType.DATA_CADENCE,
+)
+
+
+def get_callables(rule_type: RuleType, adoc_client) -> tuple[Callable, Callable]:
+    if rule_type == RuleType.RECONCILIATION:
+        return adoc_client.execute_reconciliation_rule, adoc_client.get_reconciliation_rule_result
+    if rule_type == RuleType.DATA_QUALITY:
+        return adoc_client.execute_dq_rule, adoc_client.get_dq_rule_result
+    if rule_type == RuleType.DATA_CADENCE:
+        return adoc_client.execute_freshness_rule, adoc_client.get_freshness_rule_result
+    allowed_s = ", ".join(t.name for t in _EXECUTOR_RULE_TYPES)
+    raise InvalidRuleTypeError(
+        f"Rule type {rule_type!r} is not supported for execution. Use one of: {allowed_s}.",
+        allowed_rule_types=tuple(t.name for t in _EXECUTOR_RULE_TYPES),
+    )
+
+
+def get_result_callable_for_policy_polling(rule_type: RuleType, adoc_client) -> Callable[..., ExecutionResult]:
+    """GET ``.../executions/{{id}}/result`` for kinds that expose that contract (not used by :class:`Executor` alone)."""
+    if rule_type == RuleType.RECONCILIATION:
+        return adoc_client.get_reconciliation_rule_result
+    if rule_type == RuleType.DATA_QUALITY:
+        return adoc_client.get_dq_rule_result
+    if rule_type == RuleType.DATA_CADENCE:
+        return adoc_client.get_freshness_rule_result
+    allowed_poll = ("DATA_QUALITY", "RECONCILIATION", "DATA_CADENCE")
+    raise InvalidRuleTypeError(
+        f"policy execution status/result polling is not implemented for {rule_type.name}; "
+        f"supported kinds: {', '.join(allowed_poll)}. For other rule types use policy_executions().",
+        allowed_rule_types=allowed_poll,
+    )
+
+
+def policy_execution_status_via_result(
+    result_call: Callable[..., ExecutionResult],
+    execution_id: int | str,
+    retry_cfg: RetryConfig | None,
+) -> RuleExecutionStatus:
+    """One-shot status from the catalog execution result payload (same behavior as :meth:`Executor.get_execution_status`)."""
+    try:
+        details = transient_retry_call(
+            lambda: result_call(execution_id=execution_id),
+            retry_cfg,
+            logger=LOGGER,
+            operation_name="get_execution_status",
+        )
+        try:
+            _, rs = execution_status_pair_from_result(details)
+            return RuleExecutionStatus(rs)
+        except ValueError:
+            return RuleExecutionStatus.ERRORED
+    except APIError as e:
+        ack_failure(
+            LOGGER,
+            "get_execution_status",
+            "http_error",
+            status_code=e.status_code,
+            message=e.message,
+            execution_id=execution_id,
+        )
+        return RuleExecutionStatus.ERRORED
+    except ApiException as e:
+        ack_failure(
+            LOGGER,
+            "get_execution_status",
+            "transport_error",
+            reason=e.reason,
+            execution_id=execution_id,
+        )
+        return RuleExecutionStatus.ERRORED
+
+
+def policy_execution_result_via_poll(
+    result_call: Callable[..., ExecutionResult],
+    execution_id: int | str,
+    *,
+    sleep_interval: float,
+    failure_strategy: FailureStrategy,
+    retry_cfg: RetryConfig | None,
+    total_retries: int = POLICY_POLL_UNLIMITED_RETRIES,
+) -> ExecutionResult:
+    """Poll until terminal (same behavior as :meth:`Executor.get_execution_result`).
+
+    ``total_retries`` — max non-terminal (RUNNING/WAITING) poll rounds after which polling stops
+    with a synthetic ERRORED result. Default ``POLICY_POLL_UNLIMITED_RETRIES`` (``-1``) means no cap;
+    an integer ``>= 1`` sets that cap.
+    """
+    retry_count = 0
+    execution_details: ExecutionResult | None = None
+    try:
+        while True:
+            execution_details = transient_retry_call(
+                lambda: result_call(execution_id=execution_id),
+                retry_cfg,
+                logger=LOGGER,
+                operation_name="get_execution_result",
+            )
+            st, rs = execution_status_pair_from_result(execution_details)
+            progress = _execution_progress_for_log(execution_details)
+            if progress:
+                LOGGER.info(
+                    "Policy execution %s poll #%s: executionStatus=%s resultStatus=%s, %s",
+                    execution_id,
+                    retry_count + 1,
+                    st,
+                    rs,
+                    progress,
+                )
+            else:
+                LOGGER.info(
+                    "Policy execution %s poll #%s: executionStatus=%s resultStatus=%s",
+                    execution_id,
+                    retry_count + 1,
+                    st,
+                    rs,
+                )
+            if st in (
+                RuleExecutionStatus.RUNNING.value,
+                RuleExecutionStatus.WAITING.value,
+            ):
+                sleep(sleep_interval)
+                retry_count += 1
+                if total_retries == POLICY_POLL_UNLIMITED_RETRIES or retry_count < total_retries:
+                    continue
+                msg = f"Exiting after {total_retries} non-terminal poll rounds."
+                ack_failure(
+                    LOGGER,
+                    "get_execution_result",
+                    "poll_cap_exhausted",
+                    execution_id=execution_id,
+                    total_retries=total_retries,
+                )
+                execution_details = _errored_execution_result(msg)
+                break
+            ack_success(
+                LOGGER,
+                "get_execution_result",
+                execution_id=execution_id,
+                execution_status=st,
+                result_status=rs,
+            )
+            break
+    except (APIError, ApiException) as e:
+        kind = "http error" if isinstance(e, APIError) else "transport error"
+        ack_failure(
+            LOGGER,
+            "get_execution_result",
+            "transport_or_http_error",
+            kind=kind,
+            execution_id=execution_id,
+            error=str(e),
+        )
+        LOGGER.error("Rule execution failed (%s): %s", kind, e)
+        execution_details = _errored_execution_result(
+            f"Rule execution failed due to {kind}. Details:{e}"
+        )
+        if failure_strategy >= FailureStrategy.FailOnError:
+            em = rule_execution_error_message_from_result(execution_details)
+            raise AcceldataSdkException(em or str(e)) from e
+
+    assert execution_details is not None
+
+    _, rs = execution_status_pair_from_result(execution_details)
+    if rs == RuleExecutionStatus.SUCCESSFUL.value:
+        ack_success(
+            LOGGER,
+            "policy_execution_outcome",
+            execution_id=execution_id,
+            result_status=rs,
+        )
+    elif rs == RuleExecutionStatus.WARNING.value:
+        ack_success(
+            LOGGER,
+            "policy_execution_outcome",
+            execution_id=execution_id,
+            result_status=rs,
+            note="warning",
+        )
+        if failure_strategy == FailureStrategy.FailOnWarning:
+            raise PolicyExecutionCompletedWithWarningError(
+                f"Execution completed with warning. Details: {execution_details}",
+                details=execution_details,
+            )
+    else:
+        ack_failure(
+            LOGGER,
+            "policy_execution_outcome",
+            "terminal_error_result",
+            execution_id=execution_id,
+            result_status=rs,
+            detail=_execution_result_for_log(execution_details),
+        )
+        if failure_strategy >= FailureStrategy.FailOnError:
+            raise PolicyExecutionCompletedWithErrorResultError(
+                f"Rule execution completed with errors. Details: {execution_details}",
+                details=execution_details,
+            )
+    return execution_details
+
+
+class Executor:
+    def __init__(
+        self,
+        rule_type: RuleType,
+        adoc_client,
+        sync: bool = True,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ):
+        self.id: int | None = None
+        self.error_message: str | None = None
+        self.message: str | None = None
+        self.sync = sync
+        self.client = adoc_client
+        self._transient_retry = transient_retry
+        self._exec_call, self._result_call = get_callables(rule_type, adoc_client)
+
+    def _resolved_poll_retry(self, explicit: RetryConfig | None) -> RetryConfig | None:
+        """Per-call ``explicit`` overrides the executor-level default from ``Executor(..., transient_retry=...)``."""
+        return effective_transient_retry(explicit, self._transient_retry)
+
+    def get_status(self) -> RuleExecutionStatus:
+        if self.id is None:
+            raise ValueError(
+                "A valid execution id is required: run execute() first, or set executor.id to an existing execution id."
+            )
+        return self.get_execution_status(self.id)
+
+    def get_execution_status(
+        self,
+        execution_id: int | str,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> RuleExecutionStatus:
+        cfg = self._resolved_poll_retry(transient_retry)
+        status = policy_execution_status_via_result(self._result_call, execution_id, cfg)
+        self.message = (
+            f"Policy execution {execution_id} current status is {status.value}."
+        )
+        return status
+
+    def get_result(
+        self,
+        sleep_interval: float = 5.0,
+        total_retries: int = POLICY_POLL_UNLIMITED_RETRIES,
+        failure_strategy: FailureStrategy = FailureStrategy.DoNotFail,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> ExecutionResult:
+        """Poll until this executor's run is terminal; same as :meth:`get_execution_result` for ``execution_id=self.id``.
+
+        Call after :meth:`execute` or ``AdocClient.execute_policy`` (``sync=False``) once ``self.id`` is set.
+        When ``sync=True`` (the default), this is already invoked inside :meth:`execute`.
+
+        ``sleep_interval`` — seconds between polls while status is RUNNING or WAITING.
+
+        ``total_retries`` — max non-terminal poll rounds; default ``POLICY_POLL_UNLIMITED_RETRIES`` (``-1``) polls
+        until terminal or HTTP failure; an integer ``>= 1`` stops early with a synthetic ERRORED payload
+        (see :meth:`get_execution_result`).
+
+        ``failure_strategy`` — whether to raise when the finished run has WARNING or ERROR result status.
+
+        ``transient_retry`` — optional per-call :class:`~acceldata.client.transient_retry.RetryConfig` for
+        each GET; overrides ``Executor(..., transient_retry=...)``.
+        """
+        if self.id is None:
+            raise ValueError(
+                "A valid execution id is required: run execute() first, or set executor.id to an existing execution id."
+            )
+        return self.get_execution_result(
+            execution_id=self.id,
+            sleep_interval=sleep_interval,
+            total_retries=total_retries,
+            failure_strategy=failure_strategy,
+            transient_retry=transient_retry,
+        )
+
+    def get_execution_result(
+        self,
+        execution_id: int | str,
+        sleep_interval: float = 5.0,
+        total_retries: int = POLICY_POLL_UNLIMITED_RETRIES,
+        failure_strategy: FailureStrategy = FailureStrategy.DoNotFail,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> ExecutionResult:
+        """Wait until the execution leaves RUNNING/WAITING, then return :class:`~acceldata.models.api.catalog.execution_result.ExecutionResult`.
+
+        ``total_retries`` limits how many *RUNNING/WAITING* poll rounds apply before giving up; default
+        ``POLICY_POLL_UNLIMITED_RETRIES`` (``-1``) means no limit until terminal.
+        On HTTP or other errors while waiting, an ERRORED result is produced and ``failure_strategy`` may raise.
+
+        When ``transient_retry`` is set (or inherited from ``Executor(..., transient_retry=...)``),
+        each GET retries transient HTTP/transport failures before treating the request as failed.
+        """
+        cfg = self._resolved_poll_retry(transient_retry)
+        result = policy_execution_result_via_poll(
+            self._result_call,
+            execution_id,
+            sleep_interval=sleep_interval,
+            failure_strategy=failure_strategy,
+            retry_cfg=cfg,
+            total_retries=total_retries,
+        )
+        _, rs = execution_status_pair_from_result(result)
+        self.message = (
+            f"Policy execution {execution_id} completed with result status {rs}."
+        )
+        return result
+
+    def execute(
+        self,
+        rule_id: int | str,
+        policy_execution_request: PolicyExecutionRequestInput,
+        sleep_interval: float = 5.0,
+        total_retries: int = POLICY_POLL_UNLIMITED_RETRIES,
+        failure_strategy: FailureStrategy = FailureStrategy.DoNotFail,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> Executor:
+        """When ``transient_retry`` is set (or inherited from ``Executor(..., transient_retry=...)``),
+        the initial start request (POST) uses the same retry policy as result retrieval in ``sync=True`` mode.
+
+        ``total_retries`` is passed to :meth:`get_execution_result` when ``sync=True``; see that method and
+        ``POLICY_POLL_UNLIMITED_RETRIES`` for semantics.
+        """
+        cfg = self._resolved_poll_retry(transient_retry)
+        try:
+            execution_obj: GenericExecution = transient_retry_call(
+                lambda: self._exec_call(
+                    rule_id=rule_id,
+                    policy_execution_request=policy_execution_request,
+                ),
+                cfg,
+                logger=LOGGER,
+                operation_name="start_policy_execution",
+            )
+            self.id = rule_execution_id_from_generic_post_response(execution_obj)
+            if self.id is None:
+                raise ValueError(
+                    "The catalog response did not include an execution id after starting the rule. "
+                    "Try execute_*_rule directly and inspect the response."
+                )
+            ack_success(
+                LOGGER,
+                "start_policy_execution",
+                rule_id=rule_id,
+                execution_id=self.id,
+            )
+            if self.sync:
+                self.get_execution_result(
+                    self.id,
+                    sleep_interval=sleep_interval,
+                    total_retries=total_retries,
+                    failure_strategy=failure_strategy,
+                    transient_retry=transient_retry,
+                )
+                if self.message is None:
+                    self.message = (
+                        f"Policy execution {self.id} completed."
+                    )
+            else:
+                self.message = (
+                    f"Policy execution triggered successfully with execution id {self.id}."
+                )
+            return self
+        except (APIError, ApiException, ValueError) as e:
+            self.error_message = f"Rule execution failed: {e}"
+            self.message = self.error_message
+            LOGGER.warning(
+                "Executor.execute failed (rule_id=%r, sync=%s): %s",
+                rule_id,
+                self.sync,
+                e,
+                exc_info=LOGGER.isEnabledFor(logging.DEBUG),
+            )
+            if failure_strategy >= FailureStrategy.FailOnError:
+                raise
+            return self
+
+    def cancel(self) -> ExecutionCancellationResponse:
+        if self.id is None:
+            raise ValueError("A valid execution id is required before cancellation.")
+        out = self.client.cancel_rule_execution(self.id)
+        msg = getattr(getattr(out, "result", None), "message", None)
+        self.message = msg or f"Cancellation requested for policy execution {self.id}."
+        return out
+
+    def get_dq_rule_execution_details(self, execution_id: str | int) -> DataQualityExecution:
+        return self.client.get_dq_rule_execution_details(execution_id)
+
+    def get_reconciliation_rule_execution_details(
+        self, execution_id: str | int
+    ) -> ReconciliationRuleExecution:
+        return self.client.get_reconciliation_rule_execution_details(execution_id)
+
+    def cancel_rule_execution(self, execution_id: str | int) -> ExecutionCancellationResponse:
+        return self.client.cancel_rule_execution(execution_id)
+
+    def enable_rule(self, rule_id: str | int) -> QualityRule:
+        return self.client.enable_rule(rule_id)
+
+    def disable_rule(self, rule_id: str | int) -> QualityRule:
+        return self.client.disable_rule(rule_id)

acceldata/models/sdk/catalog/policy_execution_request.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from typing import Any, List, Optional, TypeAlias, Union
+
+from acceldata.models.api.catalog.column_variable import ColumnVariable
+from acceldata.models.api.catalog.policy_execution_marker_config import PolicyExecutionMarkerConfig
+from acceldata.models.api.catalog.policy_execution_request import (
+    PolicyExecutionRequest as CatalogPolicyExecutionRequest,
+)
+from acceldata.models.api.catalog.rule_spark_sql_dynamic_filter_variable_mapping import (
+    RuleSparkSQLDynamicFilterVariableMapping,
+)
+from acceldata.models.api.catalog.spark_resource_config import SparkResourceConfig
+from acceldata.models.sdk.catalog.policy_execution_type import (
+    PolicyExecutionType,
+    policy_execution_type_wire,
+)
+
+# Accept either the SDK convenience wrapper or the generated catalog request model.
+PolicyExecutionRequestInput: TypeAlias = Union["PolicyExecutionInput", CatalogPolicyExecutionRequest]
+
+# Catalog wire value for policy execution requests built from :class:`PolicyExecutionInput`.
+_SDK_POLICY_EXECUTION_RESOURCE_STRATEGY = "INVENTORY"
+
+
+def ensure_catalog_policy_execution_request(
+    req: PolicyExecutionRequestInput,
+) -> CatalogPolicyExecutionRequest:
+    """Normalize execution payloads to :class:`CatalogPolicyExecutionRequest`."""
+    if isinstance(req, CatalogPolicyExecutionRequest):
+        return req
+    if isinstance(req, PolicyExecutionInput):
+        return req.to_api()
+    raise TypeError(
+        "policy_execution_request must be PolicyExecutionInput (PolicyExecutionRequest) or "
+        f"acceldata.models.api.catalog.policy_execution_request.PolicyExecutionRequest, got {type(req)!r}"
+    )
+
+
+def policy_request_with_pipeline_run_id(
+    req: PolicyExecutionRequestInput,
+    pipeline_run_id: int | None,
+) -> PolicyExecutionRequestInput:
+    """Return ``req`` unchanged when ``pipeline_run_id`` is ``None``.
+
+    Otherwise return a :class:`CatalogPolicyExecutionRequest` copy with
+    ``pipeline_run_id`` set; an explicit value overrides any pipeline id already on ``req``.
+    """
+    if pipeline_run_id is None:
+        return req
+    api = ensure_catalog_policy_execution_request(req)
+    return api.model_copy(update={"pipeline_run_id": pipeline_run_id})
+
+
+class PolicyExecutionInput:
+    """Convenience wrapper over :class:`CatalogPolicyExecutionRequest`.
+
+    Uses **camelCase** parameter and attribute names matching the catalog execution JSON
+    (``executionType``, ``markerConfigs``, ``ruleItemSelections``, ``includeInQualityScore``,
+    ``pipelineRunId``, ``sparkSQLDynamicFilterVariableMapping``, ``sparkFilterSelectedColumns``,
+    ``sparkResourceConfig``).
+
+    The catalog request also requires **column variables** on the wire. This class defaults to
+    ``columnVariables=[]``. Resource strategy is fixed for SDK-originated runs; use
+    :class:`CatalogPolicyExecutionRequest` directly if you need full control of every field.
+    """
+
+    def __init__(
+        self,
+        executionType: PolicyExecutionType | str,
+        *,
+        markerConfigs: Optional[List[PolicyExecutionMarkerConfig]] = None,
+        ruleItemSelections: Optional[List[int]] = None,
+        includeInQualityScore: bool = True,
+        pipelineRunId: Optional[int] = None,
+        columnVariables: Optional[List[ColumnVariable]] = None,
+        sparkSQLDynamicFilterVariableMapping: Optional[
+            List[RuleSparkSQLDynamicFilterVariableMapping]
+        ] = None,
+        sparkFilterSelectedColumns: Optional[List[str]] = None,
+        sparkResourceConfig: Optional[SparkResourceConfig] = None,
+    ) -> None:
+        self.executionType = executionType
+        self.markerConfigs = markerConfigs
+        self.ruleItemSelections = ruleItemSelections
+        self.includeInQualityScore = includeInQualityScore
+        self.pipelineRunId = pipelineRunId
+        self.columnVariables = columnVariables
+        self.sparkSQLDynamicFilterVariableMapping = (
+            sparkSQLDynamicFilterVariableMapping
+            if sparkSQLDynamicFilterVariableMapping is not None
+            else []
+        )
+        self.sparkFilterSelectedColumns = sparkFilterSelectedColumns
+        self.sparkResourceConfig = sparkResourceConfig
+
+    def to_api(self) -> CatalogPolicyExecutionRequest:
+        exec_wire = policy_execution_type_wire(self.executionType)
+        mapping = self.sparkSQLDynamicFilterVariableMapping
+        cols = self.columnVariables if self.columnVariables is not None else []
+        data: dict[str, Any] = {
+            # Use wire aliases to support generated models that validate by alias only.
+            "executionType": exec_wire,
+            "markerConfigs": self.markerConfigs,
+            "ruleItemSelections": self.ruleItemSelections,
+            "includeInQualityScore": self.includeInQualityScore,
+            "pipelineRunId": self.pipelineRunId,
+            "columnVariables": cols,
+            "resourceStrategyType": _SDK_POLICY_EXECUTION_RESOURCE_STRATEGY,
+            "sparkSQLDynamicFilterVariableMapping": mapping if mapping else None,
+            "sparkFilterSelectedColumns": self.sparkFilterSelectedColumns,
+            "sparkResourceConfig": self.sparkResourceConfig,
+        }
+        return CatalogPolicyExecutionRequest.model_validate(data)

acceldata/models/sdk/catalog/policy_execution_type.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class PolicyExecutionType(str, Enum):
+    """Wire values for ``executionType`` on policy execution APIs (DQ, recon, freshness, etc.)."""
+
+    SELECTIVE = "SELECTIVE"
+    FULL = "FULL"
+    INCREMENTAL = "INCREMENTAL"
+
+
+def policy_execution_type_wire(value: PolicyExecutionType | str) -> str:
+    """Return the API string for ``executionType``."""
+    return value.value if isinstance(value, PolicyExecutionType) else value