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

acceldata/__init__.py

@@ -0,0 +1,7 @@
+"""Acceldata Python SDK package."""
+
+from acceldata.openapi_deserialization_patches import apply_openapi_deserialization_patches
+from acceldata.openapi_repr_patches import apply_openapi_repr_patches
+
+apply_openapi_repr_patches()
+apply_openapi_deserialization_patches()

acceldata/client/adoc_client.py

@@ -0,0 +1,666 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+
+from pydantic import JsonValue
+
+from acceldata.client.http_client import BaseHttpClient
+from acceldata.client.transient_retry import RetryConfig, effective_transient_retry
+from acceldata.constants import (
+    CONNECTION_TIMEOUT_MS,
+    READ_TIMEOUT_MS,
+)
+from acceldata.exceptions import InvalidPolicyTypeError
+from acceldata.models.api.catalog.assembly import Assembly
+from acceldata.models.api.catalog.asset import Asset
+from acceldata.models.api.catalog.asset_label_request import AssetLabelRequest
+from acceldata.models.api.catalog.asset_tag_info import AssetTagInfo
+from acceldata.models.api.catalog.asset_tag_request import AssetTagRequest
+from acceldata.models.api.catalog.asset_type import AssetType
+from acceldata.models.api.catalog.label import Label
+from acceldata.models.api.catalog.catalog_asset_meta_data import CatalogAssetMetaData
+from acceldata.models.api.catalog.crawler_action_response import CrawlerActionResponse
+from acceldata.models.api.catalog.data_cadence_rule_execution import DataCadenceRuleExecution
+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.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.profile_request import ProfileRequest
+from acceldata.models.api.catalog.quality_rule import QualityRule
+from acceldata.models.api.catalog.reconciliation_rule_execution import ReconciliationRuleExecution
+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.api.catalog.sample_data_api_response import SampleDataApiResponse
+from acceldata.models.api.pipeline.pipeline import Pipeline
+from acceldata.models.api.pipeline.pipeline_runs_response import PipelineRunsResponse
+from acceldata.models.api.pipeline.pipelines_listing_response import PipelinesListingResponse
+from acceldata.models.api.pipeline.span_event import SpanEvent
+from acceldata.models.api.pipeline.span_event_request import SpanEventRequest
+from acceldata.models.api.pipeline.spans_response import SpansResponse
+from acceldata.models.api.pipeline.tag import Tag
+from acceldata.models.sdk.catalog.asset_resource import AssetResource
+from acceldata.models.sdk.catalog.asset_source_type import AssetSourceType
+from acceldata.models.sdk.catalog.datasource_resource import DatasourceResource
+from acceldata.models.sdk.catalog.executor import (
+    POLICY_POLL_UNLIMITED_RETRIES,
+    Executor,
+    FailureStrategy,
+    get_result_callable_for_policy_polling,
+    policy_execution_result_via_poll,
+    policy_execution_status_via_result,
+)
+from acceldata.models.sdk.catalog.policy_execution_request import (
+    PolicyExecutionRequestInput,
+    policy_request_with_pipeline_run_id,
+)
+from acceldata.models.sdk.catalog.policy_filter import PolicyFilter, PolicyType, RuleExecutionStatus, RuleType
+from acceldata.models.sdk.catalog.policy_rule_resources import (
+    DataCadenceRuleResource,
+    DataQualityRuleResource,
+    ReconciliationRuleResource,
+)
+from acceldata.models.sdk.catalog.profile_request_resource import (
+    ProfileRequestResource,
+    ProfileResource,
+)
+from acceldata.models.sdk.catalog.profiling import AssetProfilingParams
+from acceldata.models.sdk.pipeline.create_pipeline_input_request import CreatePipelineInputRequest
+from acceldata.models.sdk.pipeline.pipeline_resource import PipelineResource
+from acceldata.models.sdk.pipeline.pipeline_run_resource import PipelineRunResource
+from acceldata.models.sdk.pipeline.span_resource import SpanResource, wrap_fetched_span
+from acceldata.services.asset_service import AssetService
+from acceldata.services.datasource_service import DataSourceService
+from acceldata.services.generic_service import GenericService
+from acceldata.services.pipeline_service import PipelineService
+from acceldata.services.rule_service import RuleService
+
+class AdocClient:
+    def __init__(
+            self,
+            url: str,
+            access_key: str,
+            secret_key: str,
+            connection_timeout_ms: int = CONNECTION_TIMEOUT_MS,
+            read_timeout_ms: int = READ_TIMEOUT_MS,
+            verify_ssl: bool | str = True,
+    ) -> None:
+        """Create a client and wire catalog, pipeline, and related services over HTTP.
+
+        ``url`` is normalized (trailing slashes removed) and combined with API path
+        prefixes inside :class:`~acceldata.client.http_client.BaseHttpClient`.
+        ``access_key`` and ``secret_key`` are sent on each request; empty credentials
+        raise ``ValueError`` from the HTTP client.
+
+        Args:
+            url: Base URL of your ADOC deployment (scheme and host; may include extra
+                path segments before API prefixes when applicable).
+            access_key: ADOC API access key.
+            secret_key: ADOC API secret key.
+            connection_timeout_ms: Time in milliseconds to wait while establishing
+                the TCP connection. Default ``5000`` (same as
+                :data:`~acceldata.constants.CONNECTION_TIMEOUT_MS`). ``None`` or ``0``
+                also resolves to that default.
+            read_timeout_ms: Time in milliseconds to wait for response data after the
+                connection is established. Default ``15000`` (same as
+                :data:`~acceldata.constants.READ_TIMEOUT_MS`). ``None`` or ``0`` also
+                resolves to that default.
+            verify_ssl: TLS certificate verification behavior passed to `requests`.
+                Use `True` (default) for standard certificate validation, `False` for
+                insecure mode, or a CA bundle path string for private CAs.
+        """
+        self._http_client: BaseHttpClient = BaseHttpClient(
+            url=url,
+            access_key=access_key,
+            secret_key=secret_key,
+            connection_timeout_ms=connection_timeout_ms,
+            read_timeout_ms=read_timeout_ms,
+            verify_ssl=verify_ssl,
+        )
+
+        self.asset_service: AssetService = AssetService(self._http_client)
+        self.pipeline_service: PipelineService = PipelineService(self._http_client)
+        self.datasource_service: DataSourceService = DataSourceService(self._http_client)
+        self.generic_service: GenericService = GenericService(self._http_client)
+        self.rule_service: RuleService = RuleService(self._http_client)
+
+    def create_pipeline(self, create_pipeline_input_request: Optional[CreatePipelineInputRequest]) -> PipelineResource:
+        """Create a pipeline (PUT ``/pipelines``).
+
+        Returns a :class:`~acceldata.models.sdk.pipeline.pipeline_resource.PipelineResource`
+        so you can chain operations (for example :meth:`PipelineResource.create_pipeline_run`,
+        which returns :class:`~acceldata.models.sdk.pipeline.pipeline_run_resource.PipelineRunResource`).
+        """
+        response = self.pipeline_service.create_pipeline(create_pipeline_input_request)
+        return PipelineResource.from_response(response, self.pipeline_service)
+
+    def get_pipeline(self, pipeline_identity: str) -> PipelineResource:
+        response = self.pipeline_service.get_pipeline(pipeline_identity)
+        return PipelineResource.from_response(response, self.pipeline_service)
+
+    def get_pipeline_res(self, pipeline_identity: str) -> PipelineResource:
+        """Backward-compatible alias for :meth:`get_pipeline`."""
+        return self.get_pipeline(pipeline_identity)
+
+    def delete_pipeline(self, pipeline_id: int):
+        response = self.pipeline_service.delete_pipeline(pipeline_id)
+        return response
+
+    def update_pipeline(self, pipeline: Pipeline) -> PipelineResource:
+        """PUT ``/pipelines`` with a full :class:`~acceldata.models.api.pipeline.pipeline.Pipeline` (include ``id``)."""
+        response = self.pipeline_service.update_pipeline(pipeline)
+        return PipelineResource.from_response(response, self.pipeline_service)
+
+    def replace_pipeline_tags(self, pipeline_identity: str | int, tags: list[Tag]) -> PipelineResource:
+        """GET pipeline by identity, replace ``tags``, PUT the full pipeline back."""
+        response = self.pipeline_service.replace_pipeline_tags(pipeline_identity, tags)
+        return PipelineResource.from_response(response, self.pipeline_service)
+
+    def pipeline_resource(self, pipeline: Pipeline) -> PipelineResource:
+        """Return a :class:`~acceldata.models.sdk.pipeline.pipeline_resource.PipelineResource` for API calls."""
+        return PipelineResource(pipeline, self.pipeline_service)
+
+    def get_pipelines(self) -> PipelinesListingResponse:
+        response = self.pipeline_service.get_pipelines()
+        return response
+
+    def get_pipeline_run(
+            self,
+            *,
+            pipeline_run_id: Optional[int] = None,
+            continuation_id: Optional[str] = None,
+            pipeline_id: Optional[int] = None,
+    ) -> PipelineRunResource:
+        """Load a pipeline run by id, or by ``continuation_id`` and ``pipeline_id`` together."""
+        run = self.pipeline_service.get_pipeline_run(
+            pipeline_run_id=pipeline_run_id,
+            continuation_id=continuation_id,
+            pipeline_id=pipeline_id,
+        )
+        return PipelineRunResource(run, self.pipeline_service)
+
+    def get_pipeline_runs(self, pipeline_id: int) -> PipelineRunsResponse:
+        """List runs for a pipeline."""
+        return self.pipeline_service.get_pipeline_runs(pipeline_id)
+
+    def get_root_span(self, pipeline_run_id: int) -> Optional[SpanResource]:
+        """Return a :class:`~acceldata.models.sdk.pipeline.span_resource.SpanResource` for the root span, or ``None``."""
+        return self.pipeline_service.get_root_span(pipeline_run_id)
+
+    def get_span(self, pipeline_run_id: int, span_identity: str) -> SpanResource:
+        """GET a span by uid for ``pipeline_run_id``; returns :class:`~acceldata.models.sdk.pipeline.span_resource.SpanResource`."""
+        s = self.pipeline_service.get_span(pipeline_run_id, span_identity=span_identity)
+        return wrap_fetched_span(self.pipeline_service, s)
+
+    def create_span(
+            self,
+            pipeline_run_id: int,
+            span: dict[str, JsonValue],
+    ) -> SpanResource:
+        """POST ``/pipelines/runs/{pipeline_run_id}/spans`` — create a span (root or child)."""
+        res = self.pipeline_service.create_span(pipeline_run_id, span)
+        return wrap_fetched_span(self.pipeline_service, res)
+
+    def get_child_spans(self, span_id: int) -> list[SpanResource]:
+        """GET ``/pipelines/spans/{span_id}/childSpans`` — list child spans as resources."""
+        spans = self.pipeline_service.get_child_spans(span_id)
+        return [wrap_fetched_span(self.pipeline_service, s) for s in spans]
+
+    def get_spans(self, pipeline_run_id: int) -> SpansResponse:
+        """List spans for a run."""
+        return self.pipeline_service.get_spans(pipeline_run_id)
+
+    def create_span_event(self, request: SpanEventRequest) -> SpanEvent:
+        """POST ``/pipelines/spans/{span_id}/events`` — append a span event; returns :class:`SpanEvent`."""
+        return self.pipeline_service.create_span_event(request)
+
+    def get_crawler_status(
+            self,
+            datasource_name: str,
+            *,
+            transient_retry: RetryConfig | None = None,
+    ):
+        return self.datasource_service.get_crawler_status(
+            datasource_name, transient_retry=transient_retry
+        )
+
+    def get_datasource(
+            self,
+            assembly_identifier: Any,
+            *,
+            properties: bool = False,
+    ) -> DatasourceResource:
+        """Load one datasource by name or numeric id; returns a :class:`~acceldata.models.sdk.catalog.datasource_resource.DatasourceResource`."""
+        return self.datasource_service.get_datasource(
+            assembly_identifier, properties=properties
+        )
+
+    def get_datasources(
+            self,
+            source_type: AssetSourceType | None = None,
+    ) -> list[DatasourceResource]:
+        """List datasources, optionally filtered by catalog source type."""
+        return self.datasource_service.get_datasources(source_type)
+
+    def get_datasource_by_id(self, id: int, *, properties: bool = False) -> DatasourceResource:
+        """Load one datasource by numeric id."""
+        return self.get_datasource(id, properties=properties)
+
+    def get_all_datasources(self) -> list[DatasourceResource]:
+        """List all datasources with no type filter."""
+        return self.get_datasources()
+
+    def datasource_resource(self, assembly: Assembly | DatasourceResource) -> DatasourceResource:
+        """Build a :class:`~acceldata.models.sdk.catalog.datasource_resource.DatasourceResource` for catalog calls."""
+        if isinstance(assembly, DatasourceResource):
+            if assembly.datasource_service is self.datasource_service:
+                return assembly
+            return DatasourceResource(
+                self.datasource_service, Assembly.model_validate(assembly.to_dict())
+            )
+        return DatasourceResource(self.datasource_service, assembly)
+
+    def get_datasource_resource(
+            self,
+            assembly_identifier: Any,
+            *,
+            properties: bool = False,
+    ) -> DatasourceResource:
+        """Alias for :meth:`get_datasource` (same return type)."""
+        return self.get_datasource(assembly_identifier, properties=properties)
+
+    def start_crawler(
+            self,
+            datasource_name: str,
+            *,
+            transient_retry: RetryConfig | None = None,
+    ) -> CrawlerActionResponse:
+        """POST to start a crawler.
+
+        Prefer :meth:`get_datasource` (or :meth:`datasource_resource`) and
+        :meth:`~acceldata.models.sdk.catalog.datasource_resource.DatasourceResource.start_crawler`
+        so the call goes through a datasource handle instead of passing a bare name string.
+        """
+        return self.datasource_service.start_crawler(datasource_name, transient_retry=transient_retry)
+
+    def get_asset(self, identifier: str | int) -> AssetResource:
+        """Resolve a catalog asset by numeric id or uid string."""
+        return self.asset_service.get_asset(identifier)
+
+    def get_asset_types(self) -> list[AssetType]:
+        """Return all asset types defined in the catalog."""
+        return self.generic_service.get_asset_types()
+
+    def get_all_asset_types(self) -> list[AssetType]:
+        """Alias for :meth:`get_asset_types`."""
+        return self.get_asset_types()
+
+    def get_asset_tags(self, asset_id: int) -> list[AssetTagInfo]:
+        """GET tags for one catalog asset."""
+        return self.asset_service.get_asset_tags(asset_id)
+
+    def add_asset_tag(self, asset_id: int, payload: AssetTagRequest) -> AssetTagInfo:
+        """POST a tag on a catalog asset."""
+        return self.asset_service.add_asset_tag(asset_id, payload)
+
+    def add_asset_labels(self, asset_id: int, payload: AssetLabelRequest) -> list[Label]:
+        """PUT labels on a catalog asset."""
+        return self.asset_service.add_asset_labels(asset_id, payload)
+
+    def get_asset_labels(self, asset_id: int) -> list[Label]:
+        """GET labels for one catalog asset."""
+        return self.asset_service.get_asset_labels(asset_id)
+
+    def get_asset_metadata(self, asset_id: int) -> CatalogAssetMetaData:
+        return self.asset_service.get_asset_metadata(asset_id)
+
+    def add_custom_metadata(
+            self, asset_id: int, custom_metadata: Mapping[str, str]
+    ) -> CatalogAssetMetaData:
+        return self.asset_service.add_custom_metadata(asset_id, custom_metadata)
+
+    def asset_resource(self, asset: Asset | AssetResource) -> AssetResource:
+        """Return an :class:`~acceldata.models.sdk.catalog.asset_resource.AssetResource` for catalog calls scoped to ``asset``."""
+        if isinstance(asset, AssetResource):
+            if asset.asset_service is self.asset_service:
+                return asset
+            return AssetResource(
+                self.asset_service, Asset.model_validate(asset.to_dict())
+            )
+        return AssetResource(self.asset_service, asset)
+
+    def profile_request_resource(
+            self, profile_request: ProfileRequest | ProfileRequestResource
+    ) -> ProfileRequestResource:
+        """Wrap a profile request (or an existing :class:`ProfileRequestResource`) for this client."""
+        if isinstance(profile_request, ProfileRequestResource):
+            if profile_request.asset_service is self.asset_service:
+                return profile_request
+            return ProfileRequestResource(
+                self.asset_service, ProfileRequest.model_validate(profile_request.to_dict())
+            )
+        return ProfileRequestResource(self.asset_service, profile_request)
+
+    def profile_resource(self, profile_request: ProfileRequest) -> ProfileResource:
+        """Alias of :meth:`profile_request_resource`; returns :class:`~acceldata.models.sdk.catalog.profile_request_resource.ProfileResource`."""
+        return self.profile_request_resource(profile_request)
+
+    def cancel_profile(self, profile_req_id: int):
+        return self.asset_service.cancel_profile(profile_req_id)
+
+    def get_profile_request_details(
+            self, asset_id: int, req_id: int
+    ) -> ProfileRequestResource:
+        pr = self.asset_service.get_profile_request_details(asset_id, req_id)
+        return ProfileRequestResource(self.asset_service, pr)
+
+    def get_profile_status(self, asset_id: int, req_id: int) -> ProfileRequestResource:
+        """Same as :meth:`get_profile_request_details`."""
+        return self.get_profile_request_details(asset_id, req_id)
+
+    def profile_asset(
+            self,
+            asset_id: int,
+            profiling_params: Optional[AssetProfilingParams] = None,
+            *,
+            sync: bool = False,
+            transient_retry: RetryConfig | None = None,
+    ) -> ProfileRequestResource:
+        """Start profiling for an asset.
+
+        ``sync=False`` (default) is fire-and-forget and returns the initial
+        request details. ``sync=True`` blocks and polls by request id until the
+        profiling request reaches a non-running status.
+        """
+        return self.asset_service.profile_asset(
+            asset_id,
+            profiling_params,
+            sync=sync,
+            transient_retry=transient_retry,
+        )
+
+    def get_latest_profile_status(self, asset_id: int):
+        return self.asset_service.get_latest_profile_status(asset_id)
+
+    def get_sample_data_result(self, request_id: str | SampleDataApiResponse | None) -> SampleDataApiResponse | None:
+        return self.asset_service.get_sample_data_result(request_id)
+
+    def sample_data(
+            self,
+            asset_id: int,
+            *,
+            sync: bool = True,
+    ) -> SampleDataApiResponse | None:
+        return self.asset_service.sample_data(asset_id, sync=sync)
+
+    def list_all_policies(
+            self,
+            policy_filter: PolicyFilter,
+            page: int = 0,
+            size: int = 25,
+            with_latest_execution: bool = True,
+            sort_by: str = "updatedAt:DESC",
+    ) -> RulesWithLatestExecutionResponse | None:
+        """List catalog rules (GET ``/rules``) with optional paging and latest execution payload."""
+        return self.rule_service.get_all_rules(
+            policy_filter,
+            page=page,
+            size=size,
+            with_latest_execution=with_latest_execution,
+            sort_by=sort_by,
+        )
+
+    def get_policy(
+            self,
+            type: PolicyType | None = None,
+            identifier: str | int | None = None,
+    ) -> (
+            QualityRule
+            | DataQualityRuleResponse
+            | ReconciliationRuleResponse
+            | DataCadenceRuleResponse
+    ):
+        """Fetch one catalog rule by id or name.
+
+        Without ``type``, calls GET ``/rules/{identifier}`` and returns a
+        :class:`~acceldata.models.api.catalog.quality_rule.QualityRule`.
+
+        With ``type``, calls the typed rule endpoint (data-quality, reconciliation, or data-cadence)
+        and returns :class:`~acceldata.models.api.catalog.data_quality_rule_response.DataQualityRuleResponse`,
+        :class:`~acceldata.models.api.catalog.reconciliation_rule_response.ReconciliationRuleResponse`
+        (catalog ``Reconciliation.RuleResponse``), or
+        :class:`~acceldata.models.api.catalog.data_cadence_rule_response.DataCadenceRuleResponse`
+        (catalog ``DataCadenceRule.RuleResponse``).
+
+        :param identifier: Rule id or name (required).
+        :param type: Optional policy kind; when set, selects the typed GET path.
+        """
+        if identifier is None:
+            raise ValueError("Parameter 'identifier' is mandatory.")
+
+        if type is None:
+            return self.rule_service.get_policy(identifier)
+
+        if type == PolicyType.DATA_QUALITY:
+            return self.rule_service.get_dq_rule(identifier)
+        if type == PolicyType.RECONCILIATION:
+            return self.rule_service.get_reconciliation_rule(identifier)
+        if type == PolicyType.DATA_CADENCE:
+            return self.rule_service.get_freshness_rule(identifier)
+        allowed = (PolicyType.DATA_QUALITY, PolicyType.RECONCILIATION, PolicyType.DATA_CADENCE)
+        names = ", ".join(p.name for p in allowed)
+        raise InvalidPolicyTypeError(
+            f"Invalid policy type {type!r}. Use one of: {names}, or omit ``type`` to call GET /rules/{{identifier}}.",
+            allowed_policy_types=tuple(p.name for p in allowed),
+        )
+
+    def get_data_quality_rule_resource(self, identifier: str | int) -> DataQualityRuleResource:
+        """Typed rule as :class:`~acceldata.models.sdk.catalog.policy_rule_resources.DataQualityRuleResource` (execute, status, executions)."""
+        m = self.rule_service.get_dq_rule(identifier)
+        return DataQualityRuleResource(self, m, identifier)
+
+    def get_reconciliation_rule_resource(self, identifier: str | int) -> ReconciliationRuleResource:
+        """Reconciliation rule resource (typed GET, executions, and helpers)."""
+        m = self.rule_service.get_reconciliation_rule(identifier)
+        return ReconciliationRuleResource(self, m, identifier)
+
+    def get_data_cadence_rule_resource(self, identifier: str | int) -> DataCadenceRuleResource:
+        """Data-cadence (freshness) rule resource."""
+        m = self.rule_service.get_freshness_rule(identifier)
+        return DataCadenceRuleResource(self, m, identifier)
+
+    def get_dq_policy_resource(self, identifier: str | int) -> DataQualityRuleResource:
+        """Alias for :meth:`get_data_quality_rule_resource` — typed DQ (data-quality) policy handle."""
+        return self.get_data_quality_rule_resource(identifier)
+
+    def get_recon_policy_resource(self, identifier: str | int) -> ReconciliationRuleResource:
+        """Alias for :meth:`get_reconciliation_rule_resource` — typed reconciliation policy handle."""
+        return self.get_reconciliation_rule_resource(identifier)
+
+    def get_cadence_policy_resource(self, identifier: str | int) -> DataCadenceRuleResource:
+        """Alias for :meth:`get_data_cadence_rule_resource` — typed data-cadence (freshness) policy handle."""
+        return self.get_data_cadence_rule_resource(identifier)
+
+    def policy_executions(
+            self,
+            identifier: str | int,
+            rule_type: RuleType,
+            page: int = 0,
+            size: int = 25,
+            sort_by: str = "finishedAt:DESC",
+    ) -> list[GenericExecution]:
+        """List past runs for a catalog rule.
+
+        Data-quality and reconciliation rules use ``GET /rules/{{kind}}/{{id}}/executions``.
+        All other kinds use ``GET /rules/executions`` with ``ruleId`` (and paging) as in the catalog API.
+
+        The API may return a flat ``executions`` list or a wrapped body (e.g.
+        ``DataQuality.ExecutionsResponse`` / ``Reconciliation.ExecutionsResponse``); both are handled.
+
+        Each list row is deserialized to the concrete execution wrapper for that ``rule_type``
+        (e.g. :class:`~acceldata.models.api.catalog.data_quality_execution.DataQualityExecution` for
+        data-quality), then wrapped in :class:`~acceldata.models.api.catalog.generic_execution.GenericExecution`.
+        Pass a numeric rule id, or a rule name (resolved via the typed rule GET, or ``GET /rules/{{name}}``
+        where applicable).
+        """
+        return self.rule_service.policy_executions(
+            identifier, rule_type, page=page, size=size, sort_by=sort_by
+        )
+
+    def get_reconciliation_rule_execution_details(
+            self, execution_id: str | int
+    ) -> ReconciliationRuleExecution:
+        """GET ``/rules/reconciliation/executions/{execution_id}`` (Reconciliation.Execution)."""
+        return self.rule_service.get_reconciliation_rule_execution_details(execution_id)
+
+    def get_dq_rule_execution_details(self, execution_id: str | int) -> DataQualityExecution:
+        """GET ``/rules/data-quality/executions/{execution_id}`` (DataQualityExecution)."""
+        return self.rule_service.get_dq_rule_execution_details(execution_id)
+
+    def get_reconciliation_rule_result(self, execution_id: str | int) -> ExecutionResult:
+        """GET ``/rules/reconciliation/executions/{execution_id}/result`` — :class:`~acceldata.models.api.catalog.execution_result.ExecutionResult`."""
+        return self.rule_service.get_reconciliation_rule_result(execution_id)
+
+    def execute_dq_rule(
+            self,
+            rule_id: str | int,
+            policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        """POST ``/rules/data-quality/{rule_id}/executions`` — start a DQ run; response is :class:`GenericExecution`."""
+        return self.rule_service.execute_dq_rule(
+            rule_id,
+            policy_execution_request,
+        )
+
+    def execute_reconciliation_rule(
+            self,
+            rule_id: str | int,
+            policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        """POST ``/rules/reconciliation/{rule_id}/executions`` — start a reconciliation run; :class:`GenericExecution`."""
+        return self.rule_service.execute_reconciliation_rule(
+            rule_id,
+            policy_execution_request,
+        )
+
+    def execute_freshness_rule(
+            self,
+            rule_id: str | int,
+            policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        """POST ``/rules/data-cadence/{rule_id}/executions`` — start a cadence/freshness run; :class:`GenericExecution`."""
+        return self.rule_service.execute_freshness_rule(
+            rule_id,
+            policy_execution_request,
+        )
+
+    def get_dq_rule_result(self, execution_id: str | int) -> ExecutionResult:
+        """GET ``/rules/data-quality/executions/{execution_id}/result`` — result for :meth:`execute_dq_rule`."""
+        return self.rule_service.get_dq_rule_result(execution_id)
+
+    def get_freshness_rule_result(self, execution_id: str | int) -> ExecutionResult:
+        """GET ``/rules/data-cadence/executions/{execution_id}/result`` — result for :meth:`execute_freshness_rule`."""
+        return self.rule_service.get_freshness_rule_result(execution_id)
+
+    def get_data_cadence_rule_execution_details(
+            self, execution_id: str | int
+    ) -> DataCadenceRuleExecution:
+        """GET ``/rules/data-cadence/executions/{execution_id}`` — :class:`DataCadenceRuleExecution` (parity with DQ/recon execution GET)."""
+        return self.rule_service.get_data_cadence_rule_execution_details(execution_id)
+
+    def get_policy_execution_status(
+            self,
+            rule_type: RuleType,
+            execution_id: str | int,
+            *,
+            transient_retry: RetryConfig | None = None,
+    ) -> RuleExecutionStatus:
+        """Return the current execution result status for ``execution_id``.
+
+        Uses the catalog ``GET .../executions/{{id}}/result`` contract, wired only for
+        data-quality, reconciliation (including equality), and data-cadence. Other rule
+        kinds should use :meth:`policy_executions`. Starting runs remains limited to
+        :meth:`execute_policy` / :class:`~acceldata.models.sdk.catalog.executor.Executor`.
+        """
+        result_call = get_result_callable_for_policy_polling(rule_type, self)
+        cfg = effective_transient_retry(None, transient_retry)
+        return policy_execution_status_via_result(result_call, execution_id, cfg)
+
+    def get_policy_execution_result(
+            self,
+            rule_type: RuleType,
+            execution_id: str | int,
+            *,
+            failure_strategy: FailureStrategy = FailureStrategy.DoNotFail,
+            transient_retry: RetryConfig | None = None,
+    ) -> ExecutionResult:
+        """Block until a terminal result for ``execution_id``; returns :class:`~acceldata.models.api.catalog.execution_result.ExecutionResult`.
+
+        Same rule-kind limits as :meth:`get_policy_execution_status`.
+        """
+        result_call = get_result_callable_for_policy_polling(rule_type, self)
+        cfg = effective_transient_retry(None, transient_retry)
+        return policy_execution_result_via_poll(
+            result_call,
+            execution_id,
+            sleep_interval=5.0,
+            failure_strategy=failure_strategy,
+            retry_cfg=cfg,
+            total_retries=POLICY_POLL_UNLIMITED_RETRIES,
+        )
+
+    def cancel_rule_execution(self, execution_id: str | int) -> ExecutionCancellationResponse:
+        """PUT ``/rules/execution/{execution_id}/cancel`` — cancel a running execution."""
+        return self.rule_service.cancel_rule_execution(execution_id)
+
+    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`."""
+        return self.rule_service.enable_rule(rule_id)
+
+    def disable_rule(self, rule_id: str | int) -> QualityRule:
+        """PUT ``/rules/{rule_id}/enable`` with ``EnableRuleRequest`` (``enable: false``); returns :class:`QualityRule`."""
+        return self.rule_service.disable_rule(rule_id)
+
+    def execute_policy(
+            self,
+            rule_type: RuleType,
+            rule_id: str | int,
+            policy_execution_request: PolicyExecutionRequestInput,
+            *,
+            sync: bool = True,
+            failure_strategy: FailureStrategy = FailureStrategy.DoNotFail,
+            sleep_interval: float = 5.0,
+            total_retries: int = POLICY_POLL_UNLIMITED_RETRIES,
+            transient_retry: RetryConfig | None = None,
+            pipeline_run_id: int | None = None,
+    ) -> Executor:
+        """Run a catalog rule via :class:`~acceldata.models.sdk.catalog.executor.Executor`.
+
+        Returns the same ``Executor`` instance used to start (and optionally block on) the run;
+        call :meth:`~acceldata.models.sdk.catalog.executor.Executor.get_result` or ``get_status`` on it.
+
+        ``pipeline_run_id`` — optional catalog pipeline run id; when set, it is sent on the execution
+        request (overriding ``pipelineRunId`` on ``policy_execution_request`` when both are present).
+
+        Default ``sync=True`` blocks until a terminal result (legacy ``TorchClient`` parity). Pass
+        ``sync=False`` to return after the run is accepted and poll later via the ``Executor``.
+
+        When ``sync=True``, ``sleep_interval`` and ``total_retries`` are passed to
+        :meth:`~acceldata.models.sdk.catalog.executor.Executor.get_execution_result` (``total_retries`` defaults to
+        ``POLICY_POLL_UNLIMITED_RETRIES`` / ``-1`` for no cap on RUNNING/WAITING poll rounds).
+        """
+        executor = Executor(rule_type, self, sync=sync, transient_retry=transient_retry)
+        effective_request = policy_request_with_pipeline_run_id(
+            policy_execution_request, pipeline_run_id
+        )
+        return executor.execute(
+            rule_id,
+            effective_request,
+            sleep_interval=sleep_interval,
+            total_retries=total_retries,
+            failure_strategy=failure_strategy,
+            transient_retry=transient_retry,
+        )