acryl-datahub-cloud 0.3.11rc0__py3-none-any.whl → 0.3.16.1rc0__py3-none-any.whl

acryl_datahub_cloud/sdk/assertion/freshness_assertion.py

@@ -0,0 +1,201 @@
+import logging
+from datetime import datetime
+from typing import Optional, Union
+
+from typing_extensions import Self
+
+from acryl_datahub_cloud.sdk.assertion.assertion_base import (
+    AssertionMode,
+    _AssertionPublic,
+    _HasSchedule,
+)
+from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
+    DEFAULT_DETECTION_MECHANISM,
+    AssertionIncidentBehavior,
+    DetectionMechanism,
+    TimeWindowSizeInputTypes,
+    _DetectionMechanismTypes,
+)
+from acryl_datahub_cloud.sdk.entities.assertion import Assertion
+from acryl_datahub_cloud.sdk.entities.monitor import Monitor
+from acryl_datahub_cloud.sdk.errors import SDKNotYetSupportedError
+from datahub.metadata import schema_classes as models
+from datahub.metadata.urns import AssertionUrn, CorpUserUrn, DatasetUrn, TagUrn
+
+logger = logging.getLogger(__name__)
+
+
+class FreshnessAssertion(_HasSchedule, _AssertionPublic):
+    """
+    A class that represents a freshness assertion.
+    """
+
+    def __init__(
+        self,
+        *,
+        urn: AssertionUrn,
+        dataset_urn: DatasetUrn,
+        display_name: str,
+        mode: AssertionMode,
+        schedule: models.CronScheduleClass,
+        freshness_schedule_check_type: Union[
+            str, models.FreshnessAssertionScheduleTypeClass
+        ],
+        lookback_window: Optional[TimeWindowSizeInputTypes],
+        tags: list[TagUrn],
+        incident_behavior: list[AssertionIncidentBehavior],
+        detection_mechanism: Optional[
+            _DetectionMechanismTypes
+        ] = DEFAULT_DETECTION_MECHANISM,
+        created_by: Optional[CorpUserUrn] = None,
+        created_at: Union[datetime, None] = None,
+        updated_by: Optional[CorpUserUrn] = None,
+        updated_at: Optional[datetime] = None,
+    ):
+        """
+        Initialize a freshness assertion.
+
+        Note: Values can be accessed, but not set on the assertion object.
+        To update an assertion, use the `upsert_*` method.
+        Args:
+            urn: The urn of the assertion.
+            dataset_urn: The urn of the dataset that the assertion is for.
+            display_name: The display name of the assertion.
+            mode: The mode of the assertion (active, inactive).
+            schedule: The schedule of the assertion.
+            freshness_schedule_check_type: The type of freshness schedule check to be used for the assertion.
+            lookback_window: The lookback window to be used for the assertion.
+            tags: The tags applied to the assertion.
+            incident_behavior: Whether to raise or resolve an incident when the assertion fails / passes.
+            detection_mechanism: The detection mechanism of the assertion.
+            created_by: The urn of the user that created the assertion.
+            created_at: The timestamp of when the assertion was created.
+            updated_by: The urn of the user that updated the assertion.
+            updated_at: The timestamp of when the assertion was updated.
+        """
+        _HasSchedule.__init__(self, schedule=schedule)
+        _AssertionPublic.__init__(
+            self,
+            urn=urn,
+            dataset_urn=dataset_urn,
+            display_name=display_name,
+            mode=mode,
+            incident_behavior=incident_behavior,
+            detection_mechanism=detection_mechanism,
+            created_by=created_by,
+            created_at=created_at,
+            updated_by=updated_by,
+            updated_at=updated_at,
+            tags=tags,
+        )
+        self._freshness_schedule_check_type = freshness_schedule_check_type
+        self._lookback_window = lookback_window
+
+    @property
+    def freshness_schedule_check_type(
+        self,
+    ) -> Union[str, models.FreshnessAssertionScheduleTypeClass]:
+        return self._freshness_schedule_check_type
+
+    @property
+    def lookback_window(self) -> Optional[TimeWindowSizeInputTypes]:
+        return self._lookback_window
+
+    @staticmethod
+    def _get_freshness_schedule_check_type(
+        assertion: Assertion,
+    ) -> Union[str, models.FreshnessAssertionScheduleTypeClass]:
+        if assertion.info is None:
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} does not have a freshness assertion info, which is not supported"
+            )
+        if isinstance(assertion.info, models.FreshnessAssertionInfoClass):
+            if assertion.info.schedule is None:
+                raise SDKNotYetSupportedError(
+                    f"Traditional freshness assertion {assertion.urn} does not have a schedule, which is not supported"
+                )
+            return assertion.info.schedule.type
+        else:
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} is not a freshness assertion"
+            )
+
+    @staticmethod
+    def _get_lookback_window(
+        assertion: Assertion,
+    ) -> Optional[models.FixedIntervalScheduleClass]:
+        if assertion.info is None:
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} does not have a freshness assertion info, which is not supported"
+            )
+        if isinstance(assertion.info, models.FreshnessAssertionInfoClass):
+            if assertion.info.schedule is None:
+                raise SDKNotYetSupportedError(
+                    f"Traditional freshness assertion {assertion.urn} does not have a schedule, which is not supported"
+                )
+            return assertion.info.schedule.fixedInterval
+        else:
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} is not a freshness assertion"
+            )
+
+    @staticmethod
+    def _get_detection_mechanism(
+        assertion: Assertion,
+        monitor: Monitor,
+        default: Optional[_DetectionMechanismTypes] = DEFAULT_DETECTION_MECHANISM,
+    ) -> Optional[_DetectionMechanismTypes]:
+        """Get the detection mechanism for freshness assertions."""
+        parameters = _AssertionPublic._get_validated_detection_context(
+            monitor,
+            assertion,
+            models.AssertionEvaluationParametersTypeClass.DATASET_FRESHNESS,
+            models.FreshnessAssertionInfoClass,
+            default,
+        )
+        if parameters is None:
+            return default
+        if parameters.datasetFreshnessParameters is None:
+            logger.warning(
+                f"Monitor does not have datasetFreshnessParameters, defaulting detection mechanism to {DEFAULT_DETECTION_MECHANISM}"
+            )
+            return default
+        source_type = parameters.datasetFreshnessParameters.sourceType
+        if source_type == models.DatasetFreshnessSourceTypeClass.INFORMATION_SCHEMA:
+            return DetectionMechanism.INFORMATION_SCHEMA
+        elif source_type == models.DatasetFreshnessSourceTypeClass.AUDIT_LOG:
+            return DetectionMechanism.AUDIT_LOG
+        elif source_type == models.DatasetFreshnessSourceTypeClass.FIELD_VALUE:
+            return _AssertionPublic._get_field_value_detection_mechanism(
+                assertion, parameters
+            )
+        elif source_type == models.DatasetFreshnessSourceTypeClass.DATAHUB_OPERATION:
+            return DetectionMechanism.DATAHUB_OPERATION
+        elif source_type == models.DatasetFreshnessSourceTypeClass.FILE_METADATA:
+            raise SDKNotYetSupportedError("FILE_METADATA DatasetFreshnessSourceType")
+        else:
+            raise SDKNotYetSupportedError(f"DatasetFreshnessSourceType {source_type}")
+
+    @classmethod
+    def _from_entities(cls, assertion: Assertion, monitor: Monitor) -> Self:
+        """
+        Create a freshness assertion from the assertion and monitor entities.
+        """
+        return cls(
+            urn=assertion.urn,
+            dataset_urn=assertion.dataset,
+            display_name=assertion.description or "",
+            mode=cls._get_mode(monitor),
+            schedule=cls._get_schedule(monitor),
+            freshness_schedule_check_type=cls._get_freshness_schedule_check_type(
+                assertion
+            ),
+            lookback_window=cls._get_lookback_window(assertion),
+            incident_behavior=cls._get_incident_behavior(assertion),
+            detection_mechanism=cls._get_detection_mechanism(assertion, monitor),
+            created_by=cls._get_created_by(assertion),
+            created_at=cls._get_created_at(assertion),
+            updated_by=cls._get_updated_by(assertion),
+            updated_at=cls._get_updated_at(assertion),
+            tags=cls._get_tags(assertion),
+        )

acryl_datahub_cloud/sdk/assertion/schema_assertion.py

@@ -0,0 +1,268 @@
+"""
+Schema assertion module.
+
+This module provides the SchemaAssertion class for representing and working with
+schema assertions that validate dataset schemas match expected field definitions.
+"""
+
+import logging
+from datetime import datetime
+from typing import Optional, Union
+
+from typing_extensions import Self
+
+from acryl_datahub_cloud.sdk.assertion.assertion_base import (
+    AssertionMode,
+    _AssertionPublic,
+    _HasSchedule,
+)
+from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
+    AssertionIncidentBehavior,
+    _DetectionMechanismTypes,
+)
+from acryl_datahub_cloud.sdk.assertion_input.schema_assertion_input import (
+    DEFAULT_SCHEMA_ASSERTION_COMPATIBILITY,
+    SCHEMA_FIELD_CLASS_TO_TYPE_MAP,
+    SchemaAssertionCompatibility,
+    SchemaAssertionField,
+)
+from acryl_datahub_cloud.sdk.entities.assertion import Assertion
+from acryl_datahub_cloud.sdk.entities.monitor import Monitor
+from acryl_datahub_cloud.sdk.errors import SDKNotYetSupportedError
+from datahub.metadata import schema_classes as models
+from datahub.metadata.urns import AssertionUrn, CorpUserUrn, DatasetUrn, TagUrn
+
+logger = logging.getLogger(__name__)
+
+
+class SchemaAssertion(_HasSchedule, _AssertionPublic):
+    """
+    A class that represents a schema assertion.
+
+    Schema assertions validate that a dataset's schema matches expected
+    field definitions with configurable compatibility modes.
+    """
+
+    def __init__(
+        self,
+        *,
+        urn: AssertionUrn,
+        dataset_urn: DatasetUrn,
+        display_name: str,
+        mode: AssertionMode,
+        schedule: models.CronScheduleClass,
+        compatibility: SchemaAssertionCompatibility,
+        fields: list[SchemaAssertionField],
+        tags: list[TagUrn],
+        incident_behavior: list[AssertionIncidentBehavior],
+        created_by: Optional[CorpUserUrn] = None,
+        created_at: Union[datetime, None] = None,
+        updated_by: Optional[CorpUserUrn] = None,
+        updated_at: Optional[datetime] = None,
+    ):
+        """
+        Initialize a schema assertion.
+
+        Note: Values can be accessed, but not set on the assertion object.
+        To update an assertion, use the `sync_schema_assertion` method.
+
+        Args:
+            urn: The URN of the assertion.
+            dataset_urn: The URN of the dataset that the assertion validates.
+            display_name: The display name of the assertion.
+            mode: The mode of the assertion (active, inactive).
+            schedule: The evaluation schedule of the assertion.
+            compatibility: The compatibility mode (EXACT_MATCH, SUPERSET, SUBSET).
+            fields: The expected schema fields to validate.
+            tags: The tags applied to the assertion.
+            incident_behavior: Actions to take on assertion pass/fail.
+            created_by: The user who created the assertion.
+            created_at: The timestamp when the assertion was created.
+            updated_by: The user who last updated the assertion.
+            updated_at: The timestamp when the assertion was last updated.
+        """
+        _HasSchedule.__init__(self, schedule=schedule)
+        _AssertionPublic.__init__(
+            self,
+            urn=urn,
+            dataset_urn=dataset_urn,
+            display_name=display_name,
+            mode=mode,
+            incident_behavior=incident_behavior,
+            detection_mechanism=None,  # Schema assertions don't use detection mechanism
+            created_by=created_by,
+            created_at=created_at,
+            updated_by=updated_by,
+            updated_at=updated_at,
+            tags=tags,
+        )
+        self._compatibility = compatibility
+        self._fields = fields
+
+    @property
+    def compatibility(self) -> SchemaAssertionCompatibility:
+        """The compatibility mode for the schema assertion."""
+        return self._compatibility
+
+    @property
+    def fields(self) -> list[SchemaAssertionField]:
+        """The expected schema fields to validate."""
+        return self._fields
+
+    @staticmethod
+    def _get_detection_mechanism(
+        assertion: Assertion,
+        monitor: Monitor,
+        default: Optional[_DetectionMechanismTypes] = None,
+    ) -> Optional[_DetectionMechanismTypes]:
+        """
+        Schema assertions don't have a detection mechanism.
+        They always use DATAHUB_SCHEMA as the source type.
+        """
+        return None
+
+    @staticmethod
+    def _get_compatibility(assertion: Assertion) -> SchemaAssertionCompatibility:
+        """Extract compatibility from the assertion info."""
+        if assertion.info is None:
+            logger.warning(
+                f"Assertion {assertion.urn} does not have info, "
+                f"defaulting to {DEFAULT_SCHEMA_ASSERTION_COMPATIBILITY}"
+            )
+            return DEFAULT_SCHEMA_ASSERTION_COMPATIBILITY
+
+        if not isinstance(assertion.info, models.SchemaAssertionInfoClass):
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} is not a schema assertion"
+            )
+
+        compatibility_value = assertion.info.compatibility
+        if compatibility_value is None:
+            return DEFAULT_SCHEMA_ASSERTION_COMPATIBILITY
+
+        # Handle enum value extraction
+        try:
+            if hasattr(compatibility_value, "name"):
+                # It's an enum-like object
+                return SchemaAssertionCompatibility(compatibility_value.name)
+            elif isinstance(compatibility_value, str):
+                return SchemaAssertionCompatibility(compatibility_value.upper())
+            else:
+                logger.warning(
+                    f"Unknown compatibility value type {type(compatibility_value)}, "
+                    f"defaulting to {DEFAULT_SCHEMA_ASSERTION_COMPATIBILITY}"
+                )
+                return DEFAULT_SCHEMA_ASSERTION_COMPATIBILITY
+        except ValueError:
+            logger.warning(
+                f"Unknown compatibility value '{compatibility_value}', "
+                f"defaulting to {DEFAULT_SCHEMA_ASSERTION_COMPATIBILITY}"
+            )
+            return DEFAULT_SCHEMA_ASSERTION_COMPATIBILITY
+
+    @staticmethod
+    def _get_fields(assertion: Assertion) -> list[SchemaAssertionField]:
+        """Extract schema fields from the assertion info."""
+        if assertion.info is None:
+            logger.warning(
+                f"Assertion {assertion.urn} does not have info, returning empty fields"
+            )
+            return []
+
+        if not isinstance(assertion.info, models.SchemaAssertionInfoClass):
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} is not a schema assertion"
+            )
+
+        schema = assertion.info.schema
+        if schema is None:
+            logger.warning(
+                f"Assertion {assertion.urn} does not have schema metadata, "
+                "returning empty fields"
+            )
+            return []
+
+        fields = []
+        failed_fields = []
+        for schema_field in schema.fields or []:
+            field = SchemaAssertion._parse_schema_field(schema_field)
+            if field is not None:
+                fields.append(field)
+            else:
+                failed_fields.append(schema_field.fieldPath)
+
+        if failed_fields:
+            logger.warning(
+                f"Failed to parse {len(failed_fields)} field(s) from assertion {assertion.urn}: "
+                f"{', '.join(failed_fields)}. These fields will be excluded from the assertion object. "
+                f"This may indicate unsupported field types or corrupted data."
+            )
+
+        return fields
+
+    @staticmethod
+    def _parse_schema_field(
+        schema_field: models.SchemaFieldClass,
+    ) -> Optional[SchemaAssertionField]:
+        """Parse a SchemaFieldClass into a SchemaAssertionField."""
+        # Explicit attribute checks to fail fast on missing required attributes
+        if not hasattr(schema_field, "fieldPath") or not hasattr(schema_field, "type"):
+            logger.warning(
+                "Schema field missing required attributes: fieldPath or type, skipping"
+            )
+            return None
+
+        # Extract the type from the SchemaFieldDataTypeClass
+        field_data_type = schema_field.type
+        if field_data_type is None or field_data_type.type is None:
+            logger.warning(
+                f"Schema field {schema_field.fieldPath} has no type, skipping"
+            )
+            return None
+
+        # Get the actual type class instance
+        type_instance = field_data_type.type
+        type_class = type(type_instance)
+
+        # Look up the SchemaFieldDataType enum value
+        field_type = SCHEMA_FIELD_CLASS_TO_TYPE_MAP.get(type_class)
+        if field_type is None:
+            logger.warning(
+                f"Unknown schema field type {type_class.__name__} "
+                f"for field {schema_field.fieldPath}, skipping"
+            )
+            return None
+
+        return SchemaAssertionField(
+            path=schema_field.fieldPath,
+            type=field_type,
+            native_type=getattr(schema_field, "nativeDataType", None),
+        )
+
+    @classmethod
+    def _from_entities(cls, assertion: Assertion, monitor: Monitor) -> Self:
+        """
+        Create a SchemaAssertion from the assertion and monitor entities.
+
+        Args:
+            assertion: The assertion entity from the backend.
+            monitor: The monitor entity from the backend.
+
+        Returns:
+            A SchemaAssertion instance populated from the entities.
+        """
+        return cls(
+            urn=assertion.urn,
+            dataset_urn=assertion.dataset,
+            display_name=assertion.description or "",
+            mode=cls._get_mode(monitor),
+            schedule=cls._get_schedule(monitor),
+            compatibility=cls._get_compatibility(assertion),
+            fields=cls._get_fields(assertion),
+            incident_behavior=cls._get_incident_behavior(assertion),
+            created_by=cls._get_created_by(assertion),
+            created_at=cls._get_created_at(assertion),
+            updated_by=cls._get_updated_by(assertion),
+            updated_at=cls._get_updated_at(assertion),
+            tags=cls._get_tags(assertion),
+        )

acryl_datahub_cloud/sdk/assertion/smart_column_metric_assertion.py

@@ -0,0 +1,212 @@
+import logging
+from datetime import datetime
+from typing import Optional, Union
+
+from typing_extensions import Self
+
+from acryl_datahub_cloud.sdk.assertion.assertion_base import (
+    AssertionMode,
+    _AssertionPublic,
+    _HasColumnMetricFunctionality,
+    _HasSchedule,
+    _HasSmartFunctionality,
+)
+from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
+    ASSERTION_MONITOR_DEFAULT_TRAINING_LOOKBACK_WINDOW_DAYS,
+    DEFAULT_DETECTION_MECHANISM,
+    DEFAULT_SCHEDULE,
+    DEFAULT_SENSITIVITY,
+    AssertionIncidentBehavior,
+    DetectionMechanism,
+    ExclusionWindowTypes,
+    InferenceSensitivity,
+    _DetectionMechanismTypes,
+)
+from acryl_datahub_cloud.sdk.assertion_input.column_metric_constants import (
+    OperatorType,
+)
+from acryl_datahub_cloud.sdk.assertion_input.smart_column_metric_assertion_input import (
+    MetricInputType,
+)
+from acryl_datahub_cloud.sdk.entities.assertion import Assertion
+from acryl_datahub_cloud.sdk.entities.monitor import Monitor
+from datahub.metadata import schema_classes as models
+from datahub.metadata.urns import AssertionUrn, CorpUserUrn, DatasetUrn, TagUrn
+
+logger = logging.getLogger(__name__)
+
+
+class SmartColumnMetricAssertion(
+    _HasColumnMetricFunctionality,
+    _HasSmartFunctionality,
+    _HasSchedule,
+    _AssertionPublic,
+):
+    """
+    A class that represents a smart column metric assertion.
+    This assertion is used to validate the value of a common field / column metric (e.g. aggregation) such as null count + percentage,
+    min, max, median, and more. It uses AI to infer the assertion parameters. The operator is automatically set to BETWEEN with
+    criteria_parameters of (0, 0) since the actual values will be inferred by AI.
+    """
+
+    def __init__(
+        self,
+        *,
+        urn: AssertionUrn,
+        dataset_urn: DatasetUrn,
+        column_name: str,
+        metric_type: MetricInputType,
+        # TODO: Evaluate these params:
+        display_name: str,
+        mode: AssertionMode,
+        schedule: models.CronScheduleClass = DEFAULT_SCHEDULE,
+        sensitivity: InferenceSensitivity = DEFAULT_SENSITIVITY,
+        exclusion_windows: list[ExclusionWindowTypes],
+        training_data_lookback_days: int = ASSERTION_MONITOR_DEFAULT_TRAINING_LOOKBACK_WINDOW_DAYS,
+        incident_behavior: list[AssertionIncidentBehavior],
+        detection_mechanism: Optional[
+            _DetectionMechanismTypes
+        ] = DEFAULT_DETECTION_MECHANISM,
+        tags: list[TagUrn],
+        created_by: Optional[CorpUserUrn] = None,
+        created_at: Union[datetime, None] = None,
+        updated_by: Optional[CorpUserUrn] = None,
+        updated_at: Optional[datetime] = None,
+    ):
+        """
+        Initialize a smart column metric assertion.
+
+        Args:
+            urn: The URN of the assertion.
+            dataset_urn: The URN of the dataset to monitor.
+            display_name: The display name of the assertion.
+            mode: The mode of the assertion (active/inactive).
+            sensitivity: The sensitivity of the assertion (low/medium/high).
+            exclusion_windows: The exclusion windows to apply to the assertion.
+            training_data_lookback_days: The number of days of data to use for training.
+            incident_behavior: The behavior when incidents occur.
+            detection_mechanism: The mechanism used to detect changes.
+            tags: The tags to apply to the assertion.
+            created_by: The URN of the user who created the assertion.
+            created_at: The timestamp when the assertion was created.
+            updated_by: The URN of the user who last updated the assertion.
+            updated_at: The timestamp when the assertion was last updated.
+        """
+        _AssertionPublic.__init__(
+            self,
+            urn=urn,
+            dataset_urn=dataset_urn,
+            display_name=display_name,
+            mode=mode,
+            tags=tags,
+            incident_behavior=incident_behavior,
+            detection_mechanism=detection_mechanism,
+            created_by=created_by,
+            created_at=created_at,
+            updated_by=updated_by,
+            updated_at=updated_at,
+        )
+        _HasSmartFunctionality.__init__(
+            self,
+            sensitivity=sensitivity,
+            exclusion_windows=exclusion_windows,
+            training_data_lookback_days=training_data_lookback_days,
+        )
+        _HasSchedule.__init__(
+            self,
+            schedule=schedule,
+        )
+        _HasColumnMetricFunctionality.__init__(
+            self,
+            column_name=column_name,
+            metric_type=metric_type,
+            operator=OperatorType.BETWEEN,  # Fixed operator for smart assertions
+            criteria_parameters=(
+                0,
+                0,
+            ),  # Fixed criteria_parameters for smart assertions
+        )
+
+    @classmethod
+    def _from_entities(cls, assertion: Assertion, monitor: Monitor) -> Self:
+        """
+        Create a SmartColumnMetricAssertion from an Assertion and Monitor entity.
+
+        Args:
+            assertion: The Assertion entity.
+            monitor: The Monitor entity.
+
+        Returns:
+            A SmartColumnMetricAssertion instance.
+        """
+        return cls(
+            urn=assertion.urn,
+            dataset_urn=assertion.dataset,
+            column_name=cls._get_column_name(assertion),
+            metric_type=cls._get_metric_type(assertion),
+            display_name=assertion.description or "",
+            mode=cls._get_mode(monitor),
+            schedule=cls._get_schedule(monitor),
+            sensitivity=cls._get_sensitivity(monitor),
+            exclusion_windows=cls._get_exclusion_windows(monitor),
+            training_data_lookback_days=cls._get_training_data_lookback_days(monitor),
+            incident_behavior=cls._get_incident_behavior(assertion),
+            detection_mechanism=cls._get_detection_mechanism(assertion, monitor),
+            tags=cls._get_tags(assertion),
+            created_by=cls._get_created_by(assertion),
+            created_at=cls._get_created_at(assertion),
+            updated_by=cls._get_updated_by(assertion),
+            updated_at=cls._get_updated_at(assertion),
+        )
+
+    @staticmethod
+    def _get_detection_mechanism(
+        assertion: Assertion,
+        monitor: Monitor,
+        default: Optional[_DetectionMechanismTypes] = DEFAULT_DETECTION_MECHANISM,
+    ) -> Optional[_DetectionMechanismTypes]:
+        """Get the detection mechanism for column metric assertions."""
+        parameters = _AssertionPublic._get_validated_detection_context(
+            monitor,
+            assertion,
+            models.AssertionEvaluationParametersTypeClass.DATASET_FIELD,
+            models.FieldAssertionInfoClass,
+            default,
+        )
+        if parameters is None:
+            return default
+        if parameters.datasetFieldParameters is None:
+            logger.warning(
+                f"Monitor does not have datasetFieldParameters, defaulting detection mechanism to {default}"
+            )
+            return default
+        source_type = parameters.datasetFieldParameters.sourceType
+        if source_type == models.DatasetFieldAssertionSourceTypeClass.ALL_ROWS_QUERY:
+            additional_filter = _AssertionPublic._get_additional_filter(assertion)
+            return DetectionMechanism.ALL_ROWS_QUERY(
+                additional_filter=additional_filter
+            )
+        elif (
+            source_type
+            == models.DatasetFieldAssertionSourceTypeClass.CHANGED_ROWS_QUERY
+        ):
+            if parameters.datasetFieldParameters.changedRowsField is None:
+                logger.warning(
+                    f"Monitor has CHANGED_ROWS_QUERY source type but no changedRowsField, defaulting detection mechanism to {default}"
+                )
+                return default
+            column_name = parameters.datasetFieldParameters.changedRowsField.path
+            additional_filter = _AssertionPublic._get_additional_filter(assertion)
+            return DetectionMechanism.CHANGED_ROWS_QUERY(
+                column_name=column_name, additional_filter=additional_filter
+            )
+        elif (
+            source_type
+            == models.DatasetFieldAssertionSourceTypeClass.DATAHUB_DATASET_PROFILE
+        ):
+            return DetectionMechanism.ALL_ROWS_QUERY_DATAHUB_DATASET_PROFILE
+        else:
+            logger.warning(
+                f"Unsupported DatasetFieldAssertionSourceType {source_type}, defaulting detection mechanism to {default}"
+            )
+            return default