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

acceldata/models/sdk/catalog/policy_filter.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from acceldata.models.api.catalog.asset import Asset
+    from acceldata.models.api.catalog.assembly import Assembly
+
+
+class ExecutionPeriod(Enum):
+    """Time window for filtering rules by last execution time."""
+
+    Last15minutes = auto()
+    Last30minutes = auto()
+    Last1hour = auto()
+    Last3hours = auto()
+    Last6hours = auto()
+    Last12hours = auto()
+    Last24hours = auto()
+    Today = auto()
+    Yesterday = auto()
+    Last7days = auto()
+    Thismonth = auto()
+    Last1month = auto()
+    Last3month = auto()
+
+
+class RuleType(Enum):
+    """Catalog rule kind; query params use the enum member name (e.g. ``DATA_QUALITY``)."""
+
+    DATA_QUALITY = auto()
+    RECONCILIATION = auto()
+    EQUALITY = auto()
+    DATA_DRIFT = auto()
+    SCHEMA_DRIFT = auto()
+    DATA_CADENCE = auto()
+
+
+class PolicyType(Enum):
+    """Policy kind for :meth:`~acceldata.client.adoc_client.AdocClient.get_policy` routing."""
+
+    DATA_QUALITY = "DATA-QUALITY"
+    RECONCILIATION = "RECONCILIATION"
+    DATA_CADENCE = "DATA_CADENCE"
+
+
+class RuleResultStatus(Enum):
+    """Filter by last execution outcome."""
+
+    STARTED = auto()
+    RUNNING = auto()
+    ERRORED = auto()
+    WARNING = auto()
+    SUCCESSFUL = auto()
+    ABORTED = auto()
+    WAITING = auto()
+
+
+class RuleExecutionStatus(str, Enum):
+    """Status strings on :class:`~acceldata.models.api.catalog.generic_rule_execution.GenericRuleExecution` (API responses)."""
+
+    STARTED = "STARTED"
+    RUNNING = "RUNNING"
+    ERRORED = "ERRORED"
+    WARNING = "WARNING"
+    SUCCESSFUL = "SUCCESSFUL"
+    ABORTED = "ABORTED"
+    SKIPPED = "SKIPPED"
+    WAITING = "WAITING"
+    ANOMALY_DETECTION = "ANOMALY_DETECTION"
+    EXECUTION_RESULT = "EXECUTION_RESULT"
+
+
+@dataclass
+class PolicyFilter:
+    """
+    Filter for listing catalog rules (``GET /rules``).
+
+    Uses :class:`~acceldata.models.api.catalog.asset.Asset` and
+    :class:`~acceldata.models.api.catalog.assembly.Assembly` for asset / datasource scoping.
+
+    Constructor arguments use the field names below (snake_case), e.g. ``policy_type``, not ``policyType``.
+    """
+
+    period: ExecutionPeriod | None = None
+    tags: str | None = None
+    last_execution_result: RuleResultStatus | None = None
+    assets: list[Asset] | None = None
+    policy_type: RuleType | None = None
+    enable: bool | None = None
+    active: bool | None = None
+    data_sources: list[Assembly] | None = None

acceldata/models/sdk/catalog/policy_rule_resources.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from acceldata.client.transient_retry import RetryConfig
+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.executions_response import ExecutionsResponse
+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.reconciliation_rule_execution import ReconciliationRuleExecution
+from acceldata.models.sdk.catalog.policy_execution_request import PolicyExecutionRequestInput
+from acceldata.models.api.catalog.quality_rule import QualityRule
+from acceldata.models.api.catalog.reconciliation_rule_response import ReconciliationRuleResponse
+from acceldata.models.sdk.catalog.executor import (
+    POLICY_POLL_UNLIMITED_RETRIES,
+    Executor,
+    FailureStrategy,
+)
+from acceldata.models.sdk.catalog.policy_filter import RuleExecutionStatus, RuleType
+
+
+class DataQualityRuleResource:
+    """Typed handle for a data quality (DQ) policy rule: GET, executions, enable/disable, and :class:`~acceldata.models.sdk.catalog.executor.Executor` helpers."""
+
+    def __init__(
+        self,
+        client: Any,
+        model: DataQualityRuleResponse,
+        identifier: str | int | None = None,
+    ) -> None:
+        self._client = client
+        self._model = model
+        self._identifier = identifier
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self._model.to_dict()
+
+    @property
+    def rule_response(self) -> DataQualityRuleResponse:
+        return self._model
+
+    def __repr__(self) -> str:
+        return f"DataQualityRuleResource(model={self._model!r})"
+
+    def _rule_id(self) -> str | int:
+        rid = self._model.rule.id
+        if rid is not None:
+            return rid
+        if self._identifier is not None:
+            return self._identifier
+        raise ValueError("Rule id is not available; fetch the rule again.")
+
+    def refresh(self) -> DataQualityRuleResource:
+        self._model = self._client.rule_service.get_dq_rule(self._rule_id())
+        return self
+
+    def execute(
+        self,
+        policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        return self._client.execute_dq_rule(
+            self._rule_id(),
+            policy_execution_request,
+        )
+
+    def policy_executions(
+        self,
+        page: int = 0,
+        size: int = 25,
+        sort_by: str = "finishedAt:DESC",
+    ) -> ExecutionsResponse:
+        return self._client.policy_executions(self._rule_id(), RuleType.DATA_QUALITY, page=page, size=size, sort_by=sort_by)
+
+    def enable(self) -> QualityRule:
+        return self._client.enable_rule(self._rule_id())
+
+    def disable(self) -> QualityRule:
+        return self._client.disable_rule(self._rule_id())
+
+    def get_execution_details(self, execution_id: str | int) -> DataQualityExecution:
+        return self._client.get_dq_rule_execution_details(execution_id)
+
+    def get_result(self, execution_id: str | int) -> ExecutionResult:
+        return self._client.get_dq_rule_result(execution_id)
+
+    def cancel_execution(self, execution_id: str | int) -> ExecutionCancellationResponse:
+        return self._client.cancel_rule_execution(execution_id)
+
+    def execute_policy(
+        self,
+        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:
+        return self._client.execute_policy(
+            RuleType.DATA_QUALITY,
+            self._rule_id(),
+            policy_execution_request,
+            sync=sync,
+            failure_strategy=failure_strategy,
+            sleep_interval=sleep_interval,
+            total_retries=total_retries,
+            transient_retry=transient_retry,
+            pipeline_run_id=pipeline_run_id,
+        )
+
+    def get_policy_execution_status(
+        self,
+        execution_id: str | int,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> RuleExecutionStatus:
+        return self._client.get_policy_execution_status(
+            RuleType.DATA_QUALITY,
+            execution_id,
+            transient_retry=transient_retry,
+        )
+
+    def get_policy_execution_result(
+        self,
+        execution_id: str | int,
+        *,
+        failure_strategy: FailureStrategy = FailureStrategy.DoNotFail,
+        transient_retry: RetryConfig | None = None,
+    ) -> ExecutionResult:
+        return self._client.get_policy_execution_result(
+            RuleType.DATA_QUALITY,
+            execution_id,
+            failure_strategy=failure_strategy,
+            transient_retry=transient_retry,
+        )
+
+
+class ReconciliationRuleResource:
+    """Typed handle for a reconciliation (recon) policy rule (left/right compare); same surface as :class:`DataQualityRuleResource` for executions and results."""
+
+    def __init__(
+        self,
+        client: Any,
+        model: ReconciliationRuleResponse,
+        identifier: str | int | None = None,
+    ) -> None:
+        self._client = client
+        self._model = model
+        self._identifier = identifier
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self._model.to_dict()
+
+    @property
+    def rule_response(self) -> ReconciliationRuleResponse:
+        return self._model
+
+    def __repr__(self) -> str:
+        return f"ReconciliationRuleResource(model={self._model!r})"
+
+    def _rule_id(self) -> str | int:
+        rid = self._model.rule.id
+        if rid is not None:
+            return rid
+        if self._identifier is not None:
+            return self._identifier
+        raise ValueError("Rule id is not available; fetch the rule again.")
+
+    def refresh(self) -> ReconciliationRuleResource:
+        self._model = self._client.rule_service.get_reconciliation_rule(self._rule_id())
+        return self
+
+    def execute(
+        self,
+        policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        return self._client.execute_reconciliation_rule(
+            self._rule_id(),
+            policy_execution_request,
+        )
+
+    def policy_executions(
+        self,
+        page: int = 0,
+        size: int = 25,
+        sort_by: str = "finishedAt:DESC",
+    ) -> ExecutionsResponse:
+        return self._client.policy_executions(
+            self._rule_id(), RuleType.RECONCILIATION, page=page, size=size, sort_by=sort_by
+        )
+
+    def enable(self) -> QualityRule:
+        return self._client.enable_rule(self._rule_id())
+
+    def disable(self) -> QualityRule:
+        return self._client.disable_rule(self._rule_id())
+
+    def get_execution_details(
+        self, execution_id: str | int
+    ) -> ReconciliationRuleExecution:
+        return self._client.get_reconciliation_rule_execution_details(execution_id)
+
+    def get_result(self, execution_id: str | int) -> ExecutionResult:
+        return self._client.get_reconciliation_rule_result(execution_id)
+
+    def cancel_execution(self, execution_id: str | int) -> ExecutionCancellationResponse:
+        return self._client.cancel_rule_execution(execution_id)
+
+    def execute_policy(
+        self,
+        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:
+        return self._client.execute_policy(
+            RuleType.RECONCILIATION,
+            self._rule_id(),
+            policy_execution_request,
+            sync=sync,
+            failure_strategy=failure_strategy,
+            sleep_interval=sleep_interval,
+            total_retries=total_retries,
+            transient_retry=transient_retry,
+            pipeline_run_id=pipeline_run_id,
+        )
+
+    def get_policy_execution_status(
+        self,
+        execution_id: str | int,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> RuleExecutionStatus:
+        return self._client.get_policy_execution_status(
+            RuleType.RECONCILIATION,
+            execution_id,
+            transient_retry=transient_retry,
+        )
+
+    def get_policy_execution_result(
+        self,
+        execution_id: str | int,
+        *,
+        failure_strategy: FailureStrategy = FailureStrategy.DoNotFail,
+        transient_retry: RetryConfig | None = None,
+    ) -> ExecutionResult:
+        return self._client.get_policy_execution_result(
+            RuleType.RECONCILIATION,
+            execution_id,
+            failure_strategy=failure_strategy,
+            transient_retry=transient_retry,
+        )
+
+
+class DataCadenceRuleResource:
+    """Typed handle for a data cadence (freshness) policy rule; API path kind ``DATA_CADENCE``."""
+
+    def __init__(
+        self,
+        client: Any,
+        model: DataCadenceRuleResponse,
+        identifier: str | int | None = None,
+    ) -> None:
+        self._client = client
+        self._model = model
+        self._identifier = identifier
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self._model.to_dict()
+
+    @property
+    def rule_response(self) -> DataCadenceRuleResponse:
+        return self._model
+
+    def __repr__(self) -> str:
+        return f"DataCadenceRuleResource(model={self._model!r})"
+
+    def _rule_id(self) -> str | int:
+        rid = self._model.rule.id
+        if rid is not None:
+            return rid
+        if self._identifier is not None:
+            return self._identifier
+        raise ValueError("Rule id is not available; fetch the rule again.")
+
+    def refresh(self) -> DataCadenceRuleResource:
+        self._model = self._client.rule_service.get_freshness_rule(self._rule_id())
+        return self
+
+    def execute(
+        self,
+        policy_execution_request: PolicyExecutionRequestInput,
+    ) -> GenericExecution:
+        return self._client.execute_freshness_rule(
+            self._rule_id(),
+            policy_execution_request,
+        )
+
+    def policy_executions(
+        self,
+        page: int = 0,
+        size: int = 25,
+        sort_by: str = "finishedAt:DESC",
+    ) -> ExecutionsResponse:
+        return self._client.policy_executions(
+            self._rule_id(), RuleType.DATA_CADENCE, page=page, size=size, sort_by=sort_by
+        )
+
+    def enable(self) -> QualityRule:
+        return self._client.enable_rule(self._rule_id())
+
+    def disable(self) -> QualityRule:
+        return self._client.disable_rule(self._rule_id())
+
+    def get_execution_details(self, execution_id: str | int) -> DataCadenceRuleExecution:
+        return self._client.get_data_cadence_rule_execution_details(execution_id)
+
+    def get_result(self, execution_id: str | int) -> ExecutionResult:
+        return self._client.get_freshness_rule_result(execution_id)
+
+    def cancel_execution(self, execution_id: str | int) -> ExecutionCancellationResponse:
+        return self._client.cancel_rule_execution(execution_id)
+
+    def execute_policy(
+        self,
+        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:
+        return self._client.execute_policy(
+            RuleType.DATA_CADENCE,
+            self._rule_id(),
+            policy_execution_request,
+            sync=sync,
+            failure_strategy=failure_strategy,
+            sleep_interval=sleep_interval,
+            total_retries=total_retries,
+            transient_retry=transient_retry,
+            pipeline_run_id=pipeline_run_id,
+        )
+
+    def get_policy_execution_status(
+        self,
+        execution_id: str | int,
+        *,
+        transient_retry: RetryConfig | None = None,
+    ) -> RuleExecutionStatus:
+        return self._client.get_policy_execution_status(
+            RuleType.DATA_CADENCE,
+            execution_id,
+            transient_retry=transient_retry,
+        )
+
+    def get_policy_execution_result(
+        self,
+        execution_id: str | int,
+        *,
+        failure_strategy: FailureStrategy = FailureStrategy.DoNotFail,
+        transient_retry: RetryConfig | None = None,
+    ) -> ExecutionResult:
+        return self._client.get_policy_execution_result(
+            RuleType.DATA_CADENCE,
+            execution_id,
+            failure_strategy=failure_strategy,
+            transient_retry=transient_retry,
+        )
+
+
+# Naming aliases (import-friendly).
+DQPolicyResource = DataQualityRuleResource
+ReconPolicyResource = ReconciliationRuleResource
+CadencePolicyResource = DataCadenceRuleResource
+# Backward-compatible alias.
+ReconRuleResource = ReconciliationRuleResource

acceldata/models/sdk/catalog/profile_request_resource.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from acceldata.models.api.catalog.profile_cancellation_response import (
+    ProfileCancellationResponse,
+)
+from acceldata.models.api.catalog.profile_request import ProfileRequest
+
+if TYPE_CHECKING:
+    from acceldata.services.asset_service import AssetService
+
+
+class ProfileRequestResource:
+    """
+    SDK wrapper around the generated :class:`~acceldata.models.api.catalog.profile_request.ProfileRequest`
+    for cancel and status calls that need an :class:`~acceldata.services.asset_service.AssetService`.
+    """
+
+    def __init__(
+        self,
+        asset_service: AssetService,
+        model: ProfileRequest,
+        *,
+        operation_message: str | None = None,
+    ) -> None:
+        self._asset_service = asset_service
+        self._model = model
+        self._operation_message = operation_message
+
+    @property
+    def asset_service(self) -> AssetService:
+        return self._asset_service
+
+    @property
+    def profile_request(self) -> ProfileRequest:
+        return self._model
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self._model.to_dict()
+
+    @property
+    def id(self) -> int:
+        return int(self._model.id)
+
+    @property
+    def asset_id(self) -> int:
+        return int(self._model.asset_id)
+
+    def __repr__(self) -> str:
+        return f"ProfileRequestResource(model={self._model!r})"
+
+    @property
+    def message(self) -> str:
+        if self._operation_message:
+            return self._operation_message
+        status = self._model.status or "UNKNOWN"
+        return (
+            f"Profile request {self.id} for asset {self.asset_id} is currently {status}."
+        )
+
+    def cancel(self) -> Optional[ProfileCancellationResponse]:
+        return self._asset_service.cancel_profile(self.id)
+
+    def get_status(self) -> ProfileRequestResource:
+        self._model = self._asset_service.get_profile_request_details(
+            asset_id=self._model.asset_id, req_id=self.id
+        )
+        status = self._model.status or "UNKNOWN"
+        self._operation_message = (
+            f"Profile request {self.id} for asset {self.asset_id} is currently {status}."
+        )
+        return self
+
+
+# Preferred name aligned with other *Resource wrappers.
+ProfileResource = ProfileRequestResource

acceldata/models/sdk/catalog/profiling.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from acceldata.models.api.catalog.start_profiling_request import (
+        StartProfilingRequest,
+    )
+
+from acceldata.services.marker_config import (
+    MarkerConfigInput,
+    prepare_marker_config_for_request,
+)
+
+
+class ProfilingType(str, Enum):
+    """Profiling mode for :meth:`~acceldata.models.sdk.catalog.asset_resource.AssetResource.start_profile`."""
+
+    FULL = "FULL"
+    SELECTIVE = "SELECTIVE"
+    INCREMENTAL = "INCREMENTAL"
+
+    def needs_asset_marker(self) -> bool:
+        """True when profiling must include a marker configuration (incremental runs)."""
+        return self is ProfilingType.INCREMENTAL
+
+
+class ExecutionType(str, Enum):
+    """Same string values as catalog ``profilingType`` for execution classification."""
+
+    SELECTIVE = "SELECTIVE"
+    FULL = "FULL"
+    INCREMENTAL = "INCREMENTAL"
+
+
+@dataclass
+class AssetProfilingParams:
+    """
+    Narrow input for :class:`~acceldata.models.api.catalog.start_profiling_request.StartProfilingRequest`:
+    only ``profilingType`` and ``markerConfig`` are set; other fields use catalog defaults.
+
+    Unrelated to pipeline span events; those use :class:`~acceldata.models.sdk.pipeline.events.log_event.LogEvent`
+    or :class:`~acceldata.models.sdk.pipeline.events.generic_event.GenericEvent` with
+    :meth:`~acceldata.models.sdk.pipeline.span_resource.SpanResource.send_event` depending on the case.
+    """
+
+    profiling_type: ProfilingType
+    marker_config: Optional[MarkerConfigInput] = None
+
+    def validate(self) -> None:
+        from acceldata.models.sdk.catalog.profiling_configuration_error import (
+            ProfilingConfigurationError,
+        )
+
+        if self.profiling_type == ProfilingType.SELECTIVE and not self.marker_config:
+            raise ProfilingConfigurationError(
+                "markerConfig is a mandatory parameter for execution type "
+                f"{ProfilingType.SELECTIVE.value}"
+            )
+        if self.profiling_type.needs_asset_marker() and not self.marker_config:
+            raise ProfilingConfigurationError(
+                "markerConfig is a mandatory parameter for execution type "
+                f"{self.profiling_type.value}"
+            )
+
+    def to_start_profiling_request(self) -> "StartProfilingRequest":
+        from acceldata.models.api.catalog.create_profile import CreateProfile
+        from acceldata.models.api.catalog.start_profiling_request import (
+            StartProfilingRequest,
+        )
+
+        self.validate()
+        # Required by CreateProfile; match generated-model defaults and CreateProfile.from_dict fallbacks.
+        create = CreateProfile(
+            profiling_type=self.profiling_type.value,
+            marker_config=prepare_marker_config_for_request(self.marker_config),
+            execution_mode="MANUAL",
+            job_type="profile",
+        )
+        return StartProfilingRequest(data=create)

acceldata/models/sdk/catalog/profiling_configuration_error.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+
+class ProfilingConfigurationError(ValueError):
+    """Raised when asset profiling parameters are invalid or incomplete."""