acryl-datahub-cloud 0.3.12.1rc2__py3-none-any.whl → 0.3.12.2__py3-none-any.whl

acryl_datahub_cloud/_codegen_config.json

@@ -1,6 +1,6 @@
 {
   "name": "acryl-datahub-cloud",
-  "version": "0.3.12.1rc2",
+  "version": "0.3.12.2",
   "install_requires": [
     "avro-gen3==0.7.16",
     "acryl-datahub"

acryl_datahub_cloud/sdk/__init__.py

@@ -9,14 +9,27 @@ from acryl_datahub_cloud.sdk.assertion.smart_column_metric_assertion import (
 )
 from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
     AssertionIncidentBehavior,
+    CalendarInterval,
     DetectionMechanism,
     FixedRangeExclusionWindow,
     InferenceSensitivity,
     TimeWindowSize,
 )
+from acryl_datahub_cloud.sdk.assertion_input.column_metric_constants import (
+    MetricType,
+    OperatorType,
+    ValueType,
+)
+from acryl_datahub_cloud.sdk.assertion_input.freshness_assertion_input import (
+    FreshnessAssertionScheduleCheckType,
+)
 from acryl_datahub_cloud.sdk.assertion_input.sql_assertion_input import (
+    SqlAssertionCondition,
     SqlAssertionCriteria,
 )
+from acryl_datahub_cloud.sdk.assertion_input.volume_assertion_input import (
+    VolumeAssertionCondition,
+)
 from acryl_datahub_cloud.sdk.assertions_client import AssertionsClient
 from acryl_datahub_cloud.sdk.resolver_client import ResolverClient
 from acryl_datahub_cloud.sdk.subscription_client import SubscriptionClient
@@ -31,9 +44,16 @@ __all__ = [
     "InferenceSensitivity",
     "FixedRangeExclusionWindow",
     "AssertionIncidentBehavior",
+    "MetricType",
+    "OperatorType",
+    "ValueType",
     "AssertionsClient",
     "ResolverClient",
     "SubscriptionClient",
     "SqlAssertion",
     "SqlAssertionCriteria",
+    "VolumeAssertionCondition",
+    "SqlAssertionCondition",
+    "FreshnessAssertionScheduleCheckType",
+    "CalendarInterval",
 ]

acryl_datahub_cloud/sdk/assertion/assertion_base.py

@@ -28,23 +28,19 @@ from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
     TimeWindowSizeInputTypes,
     _DetectionMechanismTypes,
 )
-from acryl_datahub_cloud.sdk.assertion_input.smart_column_metric_assertion_input import (
+from acryl_datahub_cloud.sdk.assertion_input.column_metric_constants import (
     MetricInputType,
     OperatorInputType,
-    RangeInputType,
-    RangeTypeInputType,
-    ValueInputType,
-    ValueTypeInputType,
+)
+from acryl_datahub_cloud.sdk.assertion_input.smart_column_metric_assertion_input import (
+    SmartColumnMetricAssertionParameters,
 )
 from acryl_datahub_cloud.sdk.assertion_input.sql_assertion_input import (
-    SqlAssertionChangeType,
+    SqlAssertionCondition,
     SqlAssertionCriteria,
-    SqlAssertionOperator,
-    SqlAssertionType,
 )
 from acryl_datahub_cloud.sdk.assertion_input.volume_assertion_input import (
-    VolumeAssertionDefinition,
-    _VolumeAssertionDefinitionTypes,
+    VolumeAssertionCriteria,
 )
 from acryl_datahub_cloud.sdk.entities.assertion import Assertion
 from acryl_datahub_cloud.sdk.entities.monitor import (
@@ -200,18 +196,12 @@ class _HasColumnMetricFunctionality:
         column_name: str,
         metric_type: MetricInputType,
         operator: OperatorInputType,
-        value: Optional[ValueInputType] = None,
-        value_type: Optional[ValueTypeInputType] = None,
-        range: Optional[RangeInputType] = None,
-        range_type: Optional[RangeTypeInputType] = None,
+        criteria_parameters: Optional[SmartColumnMetricAssertionParameters] = None,
     ):
         self._column_name = column_name
         self._metric_type = metric_type
         self._operator = operator
-        self._value = value
-        self._value_type = value_type
-        self._range = range
-        self._range_type = range_type
+        self._criteria_parameters = criteria_parameters
 
     @property
     def column_name(self) -> str:
@@ -226,20 +216,8 @@ class _HasColumnMetricFunctionality:
         return self._operator
 
     @property
-    def value(self) -> Optional[ValueInputType]:
-        return self._value
-
-    @property
-    def value_type(self) -> Optional[ValueTypeInputType]:
-        return self._value_type
-
-    @property
-    def range(self) -> Optional[RangeInputType]:
-        return self._range
-
-    @property
-    def range_type(self) -> Optional[RangeTypeInputType]:
-        return self._range_type
+    def criteria_parameters(self) -> Optional[SmartColumnMetricAssertionParameters]:
+        return self._criteria_parameters
 
     @staticmethod
     def _get_column_name(assertion: Assertion) -> str:
@@ -281,25 +259,19 @@ class _HasColumnMetricFunctionality:
         return operator
 
     @staticmethod
-    def _get_value(assertion: Assertion) -> Optional[ValueInputType]:
-        value = _get_nested_field_for_entity_with_default(
-            assertion,
-            field_path="info.fieldMetricAssertion.parameters.value.value",
-            default=None,
-        )
-        return value
-
-    @staticmethod
-    def _get_value_type(assertion: Assertion) -> Optional[ValueTypeInputType]:
-        value_type = _get_nested_field_for_entity_with_default(
+    def _get_criteria_parameters(
+        assertion: Assertion,
+    ) -> Optional[SmartColumnMetricAssertionParameters]:
+        # First check if there's a single value parameter
+        value_param = _get_nested_field_for_entity_with_default(
             assertion,
-            field_path="info.fieldMetricAssertion.parameters.value.type",
+            field_path="info.fieldMetricAssertion.parameters.value",
             default=None,
         )
-        return value_type
+        if value_param is not None:
+            return value_param.value
 
-    @staticmethod
-    def _get_range(assertion: Assertion) -> Optional[RangeInputType]:
+        # Then check for range parameters
         min_value = _get_nested_field_for_entity_with_default(
             assertion,
             field_path="info.fieldMetricAssertion.parameters.minValue",
@@ -311,36 +283,59 @@ class _HasColumnMetricFunctionality:
             default=None,
         )
 
-        # If both are None, return None
-        if min_value is None and max_value is None:
-            return None
-
-        # Extract the value from the parameter objects if they exist
-        if min_value is not None and hasattr(min_value, "value"):
-            min_value = min_value.value
-        if max_value is not None and hasattr(max_value, "value"):
-            max_value = max_value.value
+        # If both range values exist, extract their values and return as tuple
+        if min_value is not None and max_value is not None:
+            if hasattr(min_value, "value"):
+                min_value = min_value.value
+            if hasattr(max_value, "value"):
+                max_value = max_value.value
+            return (min_value, max_value)
 
-        return (min_value, max_value)
+        # If no parameters found, return None
+        return None
 
     @staticmethod
-    def _get_range_type(assertion: Assertion) -> Optional[RangeTypeInputType]:
-        min_value_range_type = _get_nested_field_for_entity_with_default(
+    def _get_criteria_parameters_with_type(
+        assertion: Assertion,
+    ) -> Optional[tuple]:
+        """
+        Get criteria parameters along with their type information from the backend.
+
+        Returns:
+            For single values: (value, type)
+            For ranges: ((min_value, max_value), (min_type, max_type))
+            None if no parameters found
+        """
+        # First check if there's a single value parameter
+        value_param = _get_nested_field_for_entity_with_default(
+            assertion,
+            field_path="info.fieldMetricAssertion.parameters.value",
+            default=None,
+        )
+        if value_param is not None:
+            return (value_param.value, value_param.type)
+
+        # Then check for range parameters
+        min_param = _get_nested_field_for_entity_with_default(
             assertion,
-            field_path="info.fieldMetricAssertion.parameters.minValue.type",
+            field_path="info.fieldMetricAssertion.parameters.minValue",
             default=None,
         )
-        max_value_range_type = _get_nested_field_for_entity_with_default(
+        max_param = _get_nested_field_for_entity_with_default(
             assertion,
-            field_path="info.fieldMetricAssertion.parameters.maxValue.type",
+            field_path="info.fieldMetricAssertion.parameters.maxValue",
             default=None,
         )
 
-        # If both are None, return None instead of a tuple of Nones
-        if min_value_range_type is None and max_value_range_type is None:
-            return None
+        # If both range parameters exist, return values and types
+        if min_param is not None and max_param is not None:
+            return (
+                (min_param.value, max_param.value),
+                (min_param.type, max_param.type),
+            )
 
-        return (min_value_range_type, max_value_range_type)
+        # If no parameters found, return None
+        return None
 
 
 class _AssertionPublic(ABC):
@@ -1001,7 +996,7 @@ class VolumeAssertion(_HasSchedule, _AssertionPublic):
         display_name: str,
         mode: AssertionMode,
         schedule: models.CronScheduleClass,
-        definition: _VolumeAssertionDefinitionTypes,
+        criteria: VolumeAssertionCriteria,
         tags: list[TagUrn],
         incident_behavior: list[AssertionIncidentBehavior],
         detection_mechanism: Optional[
@@ -1023,7 +1018,7 @@ class VolumeAssertion(_HasSchedule, _AssertionPublic):
             display_name: The display name of the assertion.
             mode: The mode of the assertion (active, inactive).
             schedule: The schedule of the assertion.
-            definition: The volume assertion definition (RowCountTotal or RowCountChange).
+            criteria: The volume assertion criteria.
             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.
@@ -1047,18 +1042,18 @@ class VolumeAssertion(_HasSchedule, _AssertionPublic):
             updated_at=updated_at,
             tags=tags,
         )
-        self._definition = definition
+        self._criteria = criteria
 
     @property
-    def definition(self) -> _VolumeAssertionDefinitionTypes:
-        return self._definition
+    def criteria(self) -> VolumeAssertionCriteria:
+        return self._criteria
 
     @staticmethod
     def _get_volume_definition(
         assertion: Assertion,
-    ) -> _VolumeAssertionDefinitionTypes:
+    ) -> VolumeAssertionCriteria:
         """Get volume assertion definition from a DataHub assertion entity."""
-        return VolumeAssertionDefinition.from_assertion(assertion)
+        return VolumeAssertionCriteria.from_assertion(assertion)
 
     @staticmethod
     def _get_detection_mechanism(
@@ -1106,7 +1101,7 @@ class VolumeAssertion(_HasSchedule, _AssertionPublic):
             display_name=assertion.description or "",
             mode=cls._get_mode(monitor),
             schedule=cls._get_schedule(monitor),
-            definition=cls._get_volume_definition(assertion),
+            criteria=cls._get_volume_definition(assertion),
             incident_behavior=cls._get_incident_behavior(assertion),
             detection_mechanism=cls._get_detection_mechanism(assertion, monitor),
             created_by=cls._get_created_by(assertion),
@@ -1359,16 +1354,8 @@ class SqlAssertion(_AssertionPublic, _HasSchedule):
         return self._statement
 
     @property
-    def criteria_type(self) -> Union[SqlAssertionType, str]:
-        return self._criteria.type
-
-    @property
-    def criteria_change_type(self) -> Optional[Union[SqlAssertionChangeType, str]]:
-        return self._criteria.change_type
-
-    @property
-    def criteria_operator(self) -> Union[SqlAssertionOperator, str]:
-        return self._criteria.operator
+    def criteria_condition(self) -> Union[SqlAssertionCondition, str]:
+        return self._criteria.condition
 
     @property
     def criteria_parameters(
@@ -1398,6 +1385,76 @@ class SqlAssertion(_AssertionPublic, _HasSchedule):
                 f"Assertion {assertion.urn} is not a SQL assertion"
             )
 
+    @staticmethod
+    def _get_condition_from_model_assertion_info(
+        assertion_info: models.SqlAssertionInfoClass,
+    ) -> SqlAssertionCondition:
+        """Convert stored assertion info to condition enum."""
+        # Handle value-based conditions (no change type)
+        if str(assertion_info.type) == str(models.SqlAssertionTypeClass.METRIC):
+            value_conditions = {
+                str(
+                    models.AssertionStdOperatorClass.EQUAL_TO
+                ): SqlAssertionCondition.IS_EQUAL_TO,
+                str(
+                    models.AssertionStdOperatorClass.NOT_EQUAL_TO
+                ): SqlAssertionCondition.IS_NOT_EQUAL_TO,
+                str(
+                    models.AssertionStdOperatorClass.GREATER_THAN
+                ): SqlAssertionCondition.IS_GREATER_THAN,
+                str(
+                    models.AssertionStdOperatorClass.LESS_THAN
+                ): SqlAssertionCondition.IS_LESS_THAN,
+                str(
+                    models.AssertionStdOperatorClass.BETWEEN
+                ): SqlAssertionCondition.IS_WITHIN_A_RANGE,
+            }
+            if str(assertion_info.operator) in value_conditions:
+                return value_conditions[str(assertion_info.operator)]
+
+        # Handle growth-based conditions (with change type)
+        elif str(assertion_info.type) == str(
+            models.SqlAssertionTypeClass.METRIC_CHANGE
+        ):
+            assert assertion_info.changeType is not None, (
+                "changeType must be present for METRIC_CHANGE assertions"
+            )
+
+            growth_conditions = {
+                (
+                    str(models.AssertionStdOperatorClass.LESS_THAN_OR_EQUAL_TO),
+                    str(models.AssertionValueChangeTypeClass.ABSOLUTE),
+                ): SqlAssertionCondition.GROWS_AT_MOST_ABSOLUTE,
+                (
+                    str(models.AssertionStdOperatorClass.LESS_THAN_OR_EQUAL_TO),
+                    str(models.AssertionValueChangeTypeClass.PERCENTAGE),
+                ): SqlAssertionCondition.GROWS_AT_MOST_PERCENTAGE,
+                (
+                    str(models.AssertionStdOperatorClass.GREATER_THAN_OR_EQUAL_TO),
+                    str(models.AssertionValueChangeTypeClass.ABSOLUTE),
+                ): SqlAssertionCondition.GROWS_AT_LEAST_ABSOLUTE,
+                (
+                    str(models.AssertionStdOperatorClass.GREATER_THAN_OR_EQUAL_TO),
+                    str(models.AssertionValueChangeTypeClass.PERCENTAGE),
+                ): SqlAssertionCondition.GROWS_AT_LEAST_PERCENTAGE,
+                (
+                    str(models.AssertionStdOperatorClass.BETWEEN),
+                    str(models.AssertionValueChangeTypeClass.ABSOLUTE),
+                ): SqlAssertionCondition.GROWS_WITHIN_A_RANGE_ABSOLUTE,
+                (
+                    str(models.AssertionStdOperatorClass.BETWEEN),
+                    str(models.AssertionValueChangeTypeClass.PERCENTAGE),
+                ): SqlAssertionCondition.GROWS_WITHIN_A_RANGE_PERCENTAGE,
+            }
+
+            key = (str(assertion_info.operator), str(assertion_info.changeType))
+            if key in growth_conditions:
+                return growth_conditions[key]
+
+        raise ValueError(
+            f"Unsupported combination: type={assertion_info.type}, operator={assertion_info.operator}, changeType={assertion_info.changeType}"
+        )
+
     @staticmethod
     def _get_criteria(assertion: Assertion) -> SqlAssertionCriteria:
         if assertion.info is None:
@@ -1422,20 +1479,12 @@ class SqlAssertion(_AssertionPublic, _HasSchedule):
                     f"Assertion {assertion.urn} does not have a valid parameters for the SQL assertion"
                 )
 
+            condition = SqlAssertion._get_condition_from_model_assertion_info(
+                assertion.info
+            )
+
             return SqlAssertionCriteria(
-                type=assertion.info.type
-                if isinstance(assertion.info.type, str)
-                else str(assertion.info.type),
-                change_type=assertion.info.changeType
-                if assertion.info.changeType is None
-                else (
-                    assertion.info.changeType
-                    if isinstance(assertion.info.changeType, str)
-                    else str(assertion.info.changeType)
-                ),
-                operator=assertion.info.operator
-                if isinstance(assertion.info.operator, str)
-                else str(assertion.info.operator),
+                condition=condition,
                 parameters=parameters,
             )
         else:

acryl_datahub_cloud/sdk/assertion/column_metric_assertion.py

@@ -0,0 +1,191 @@
+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,
+)
+from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
+    DEFAULT_DETECTION_MECHANISM,
+    DEFAULT_SCHEDULE,
+    AssertionIncidentBehavior,
+    DetectionMechanism,
+    _DetectionMechanismTypes,
+)
+from acryl_datahub_cloud.sdk.assertion_input.column_metric_assertion_input import (
+    ColumnMetricAssertionParameters,
+    MetricInputType,
+    OperatorInputType,
+)
+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 ColumnMetricAssertion(
+    _HasColumnMetricFunctionality,
+    _HasSchedule,
+    _AssertionPublic,
+):
+    """
+    A class that represents a 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 native source types without AI inference.
+    """
+
+    def __init__(
+        self,
+        *,
+        urn: AssertionUrn,
+        dataset_urn: DatasetUrn,
+        column_name: str,
+        metric_type: MetricInputType,
+        operator: OperatorInputType,
+        # Consolidated criteria parameters
+        criteria_parameters: Optional[ColumnMetricAssertionParameters] = None,
+        # Standard assertion parameters:
+        display_name: str,
+        mode: AssertionMode,
+        schedule: models.CronScheduleClass = DEFAULT_SCHEDULE,
+        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 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).
+            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,
+        )
+        _HasSchedule.__init__(
+            self,
+            schedule=schedule,
+        )
+        _HasColumnMetricFunctionality.__init__(
+            self,
+            column_name=column_name,
+            metric_type=metric_type,
+            operator=operator,
+            criteria_parameters=criteria_parameters,
+        )
+
+    @classmethod
+    def _from_entities(cls, assertion: Assertion, monitor: Monitor) -> Self:
+        """
+        Create a ColumnMetricAssertion from an Assertion and Monitor entity.
+
+        Args:
+            assertion: The Assertion entity.
+            monitor: The Monitor entity.
+
+        Returns:
+            A ColumnMetricAssertion instance.
+        """
+        return cls(
+            urn=assertion.urn,
+            dataset_urn=assertion.dataset,
+            column_name=cls._get_column_name(assertion),
+            metric_type=cls._get_metric_type(assertion),
+            operator=cls._get_operator(assertion),
+            criteria_parameters=cls._get_criteria_parameters(assertion),
+            display_name=assertion.description or "",
+            mode=cls._get_mode(monitor),
+            schedule=cls._get_schedule(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

acryl_datahub_cloud/sdk/assertion/smart_column_metric_assertion.py

@@ -22,13 +22,11 @@ from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
     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,
-    OperatorInputType,
-    RangeInputType,
-    RangeTypeInputType,
-    ValueInputType,
-    ValueTypeInputType,
 )
 from acryl_datahub_cloud.sdk.entities.assertion import Assertion
 from acryl_datahub_cloud.sdk.entities.monitor import Monitor
@@ -47,7 +45,8 @@ class SmartColumnMetricAssertion(
     """
     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.
+    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__(
@@ -57,12 +56,6 @@ class SmartColumnMetricAssertion(
         dataset_urn: DatasetUrn,
         column_name: str,
         metric_type: MetricInputType,
-        operator: OperatorInputType,
-        # Depending on the operator, value, range (and corresponding type) or no parameters are required:
-        value: Optional[ValueInputType] = None,
-        value_type: Optional[ValueTypeInputType] = None,
-        range: Optional[RangeInputType] = None,
-        range_type: Optional[RangeTypeInputType] = None,
         # TODO: Evaluate these params:
         display_name: str,
         mode: AssertionMode,
@@ -127,11 +120,11 @@ class SmartColumnMetricAssertion(
             self,
             column_name=column_name,
             metric_type=metric_type,
-            operator=operator,
-            value=value,
-            value_type=value_type,
-            range=range,
-            range_type=range_type,
+            operator=OperatorType.BETWEEN,  # Fixed operator for smart assertions
+            criteria_parameters=(
+                0,
+                0,
+            ),  # Fixed criteria_parameters for smart assertions
         )
 
     @classmethod
@@ -151,11 +144,6 @@ class SmartColumnMetricAssertion(
             dataset_urn=assertion.dataset,
             column_name=cls._get_column_name(assertion),
             metric_type=cls._get_metric_type(assertion),
-            operator=cls._get_operator(assertion),
-            value=cls._get_value(assertion),
-            value_type=cls._get_value_type(assertion),
-            range=cls._get_range(assertion),
-            range_type=cls._get_range_type(assertion),
             display_name=assertion.description or "",
             mode=cls._get_mode(monitor),
             schedule=cls._get_schedule(monitor),