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

acryl_datahub_cloud/sdk/assertion_input/smart_column_metric_assertion_input.py

@@ -1,6 +1,9 @@
 import json
 from datetime import datetime
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
+
+if TYPE_CHECKING:
+    pass
 
 from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
     DEFAULT_EVERY_SIX_HOURS_SCHEDULE,
@@ -22,6 +25,19 @@ from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
     _HasSmartAssertionInputs,
     _try_parse_and_validate_schema_classes_enum,
 )
+from acryl_datahub_cloud.sdk.assertion_input.column_metric_constants import (
+    ALLOWED_COLUMN_TYPES_FOR_COLUMN_METRIC_ASSERTION,
+    FIELD_METRIC_TYPE_CONFIG,
+    FIELD_VALUES_OPERATOR_CONFIG,
+    MetricInputType,
+    OperatorType,
+    RangeInputType,
+    RangeTypeInputType,
+    RangeTypeParsedType,
+    ValueInputType,
+    ValueType,
+    ValueTypeInputType,
+)
 from acryl_datahub_cloud.sdk.entities.assertion import TagsInputType
 from acryl_datahub_cloud.sdk.errors import (
     SDKNotYetSupportedError,
@@ -32,129 +48,17 @@ from datahub.metadata import schema_classes as models
 from datahub.metadata.urns import AssertionUrn, CorpUserUrn, DatasetUrn
 from datahub.sdk.entity_client import EntityClient
 
-# Keep this in sync with the frontend in getEligibleFieldColumns
-# datahub-web-react/src/app/entityV2/shared/tabs/Dataset/Validations/assertion/builder/steps/field/utils.ts
-ALLOWED_COLUMN_TYPES_FOR_SMART_COLUMN_METRIC_ASSERTION = [
-    models.StringTypeClass(),
-    models.NumberTypeClass(),
-    models.BooleanTypeClass(),
-    models.DateTypeClass(),
-    models.TimeTypeClass(),
-    models.NullTypeClass(),
-]
+# Keep the smart-specific name for backward compatibility
+ALLOWED_COLUMN_TYPES_FOR_SMART_COLUMN_METRIC_ASSERTION = (
+    ALLOWED_COLUMN_TYPES_FOR_COLUMN_METRIC_ASSERTION
+)
 
-# Keep this in sync with FIELD_VALUES_OPERATOR_CONFIG in the frontend
-# datahub-web-react/src/app/entityV2/shared/tabs/Dataset/Validations/assertion/builder/steps/field/utils.ts
-FIELD_VALUES_OPERATOR_CONFIG = {
-    "StringTypeClass": [
-        models.AssertionStdOperatorClass.NULL,
-        models.AssertionStdOperatorClass.NOT_NULL,
-        models.AssertionStdOperatorClass.EQUAL_TO,
-        models.AssertionStdOperatorClass.IN,
-        models.AssertionStdOperatorClass.GREATER_THAN_OR_EQUAL_TO,
-        models.AssertionStdOperatorClass.REGEX_MATCH,
-        models.AssertionStdOperatorClass.GREATER_THAN,
-        models.AssertionStdOperatorClass.LESS_THAN,
-        models.AssertionStdOperatorClass.BETWEEN,
-    ],
-    "NumberTypeClass": [
-        models.AssertionStdOperatorClass.GREATER_THAN,
-        models.AssertionStdOperatorClass.LESS_THAN,
-        models.AssertionStdOperatorClass.BETWEEN,
-        models.AssertionStdOperatorClass.NULL,
-        models.AssertionStdOperatorClass.NOT_NULL,
-        models.AssertionStdOperatorClass.EQUAL_TO,
-        models.AssertionStdOperatorClass.IN,
-        models.AssertionStdOperatorClass.GREATER_THAN_OR_EQUAL_TO,
-        models.AssertionStdOperatorClass.NOT_EQUAL_TO,
-    ],
-    "BooleanTypeClass": [
-        models.AssertionStdOperatorClass.IS_TRUE,
-        models.AssertionStdOperatorClass.IS_FALSE,
-        models.AssertionStdOperatorClass.NULL,
-        models.AssertionStdOperatorClass.NOT_NULL,
-    ],
-    "DateTypeClass": [
-        models.AssertionStdOperatorClass.NULL,
-        models.AssertionStdOperatorClass.NOT_NULL,
-    ],
-    "TimeTypeClass": [
-        models.AssertionStdOperatorClass.NULL,
-        models.AssertionStdOperatorClass.NOT_NULL,
-    ],
-    "NullTypeClass": [
-        models.AssertionStdOperatorClass.NULL,
-        models.AssertionStdOperatorClass.NOT_NULL,
-    ],
-}
-
-# Keep this in sync with FIELD_METRIC_TYPE_CONFIG in the frontend
-# datahub-web-react/src/app/entityV2/shared/tabs/Dataset/Validations/assertion/builder/steps/field/utils.ts
-FIELD_METRIC_TYPE_CONFIG = {
-    "StringTypeClass": [
-        models.FieldMetricTypeClass.NULL_COUNT,
-        models.FieldMetricTypeClass.NULL_PERCENTAGE,
-        models.FieldMetricTypeClass.UNIQUE_COUNT,
-        models.FieldMetricTypeClass.UNIQUE_PERCENTAGE,
-        models.FieldMetricTypeClass.MAX_LENGTH,
-        models.FieldMetricTypeClass.MIN_LENGTH,
-        models.FieldMetricTypeClass.EMPTY_COUNT,
-        models.FieldMetricTypeClass.EMPTY_PERCENTAGE,
-    ],
-    "NumberTypeClass": [
-        models.FieldMetricTypeClass.NULL_COUNT,
-        models.FieldMetricTypeClass.NULL_PERCENTAGE,
-        models.FieldMetricTypeClass.UNIQUE_COUNT,
-        models.FieldMetricTypeClass.UNIQUE_PERCENTAGE,
-        models.FieldMetricTypeClass.MAX,
-        models.FieldMetricTypeClass.MIN,
-        models.FieldMetricTypeClass.MEAN,
-        models.FieldMetricTypeClass.MEDIAN,
-        models.FieldMetricTypeClass.STDDEV,
-        models.FieldMetricTypeClass.NEGATIVE_COUNT,
-        models.FieldMetricTypeClass.NEGATIVE_PERCENTAGE,
-        models.FieldMetricTypeClass.ZERO_COUNT,
-        models.FieldMetricTypeClass.ZERO_PERCENTAGE,
-    ],
-    "BooleanTypeClass": [
-        models.FieldMetricTypeClass.NULL_COUNT,
-        models.FieldMetricTypeClass.NULL_PERCENTAGE,
-        models.FieldMetricTypeClass.UNIQUE_COUNT,
-        models.FieldMetricTypeClass.UNIQUE_PERCENTAGE,
-    ],
-    "DateTypeClass": [
-        models.FieldMetricTypeClass.NULL_COUNT,
-        models.FieldMetricTypeClass.NULL_PERCENTAGE,
-        models.FieldMetricTypeClass.UNIQUE_COUNT,
-        models.FieldMetricTypeClass.UNIQUE_PERCENTAGE,
-    ],
-    "TimeTypeClass": [
-        models.FieldMetricTypeClass.NULL_COUNT,
-        models.FieldMetricTypeClass.NULL_PERCENTAGE,
-        models.FieldMetricTypeClass.UNIQUE_COUNT,
-        models.FieldMetricTypeClass.UNIQUE_PERCENTAGE,
-    ],
-    "NullTypeClass": [
-        models.FieldMetricTypeClass.NULL_COUNT,
-        models.FieldMetricTypeClass.NULL_PERCENTAGE,
-        models.FieldMetricTypeClass.UNIQUE_COUNT,
-        models.FieldMetricTypeClass.UNIQUE_PERCENTAGE,
-    ],
-}
-
-
-MetricInputType = Union[models.FieldMetricTypeClass, str]
-ValueInputType = Union[str, int, float]
-ValueTypeInputType = Union[str, models.AssertionStdParameterTypeClass]
-RangeInputType = tuple[ValueInputType, ValueInputType]
-RangeTypeInputType = Union[
-    str,
-    tuple[str, str],
-    ValueTypeInputType,
-    tuple[ValueTypeInputType, ValueTypeInputType],
+# New unified criteria parameters type
+SmartColumnMetricAssertionParameters = Union[
+    None,  # For operators that don't require parameters (NULL, NOT_NULL)
+    ValueInputType,  # Single value
+    RangeInputType,  # Range as tuple
 ]
-RangeTypeParsedType = tuple[ValueTypeInputType, ValueTypeInputType]
-OperatorInputType = Union[str, models.AssertionStdOperatorClass]
 
 DEFAULT_DETECTION_MECHANISM_SMART_COLUMN_METRIC_ASSERTION: _AllRowsQuery = (
     _AllRowsQuery()
@@ -166,7 +70,8 @@ class _SmartColumnMetricAssertionInput(_AssertionInput, _HasSmartAssertionInputs
     Input used to create 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 fixed to BETWEEN and criteria_parameters
+    are set to (0, 0) since the actual values will be inferred by AI.
 
     Example using the entity models, not comprehensive for all options:
 
@@ -187,11 +92,15 @@ class _SmartColumnMetricAssertionInput(_AssertionInput, _HasSmartAssertionInputs
                     nativeType="string",  # The native type of the column
                 ),
                 metric=models.FieldMetricTypeClass.NULL_COUNT_PERCENTAGE,  # The metric to validate
-                operator=models.AssertionStdOperatorClass.GREATER_THAN,  # The operator to use
+                operator=models.AssertionStdOperatorClass.BETWEEN,  # Fixed operator for smart assertions
                 parameters=models.AssertionStdParametersClass(
-                    value=models.AssertionStdParameterClass(
-                        value=10,  # The value to validate
-                        type=models.AssertionStdParameterTypeClass.NUMBER,  # The type of the value
+                    minValue=models.AssertionStdParameterClass(
+                        value="0",  # Fixed min value for smart assertions
+                        type=models.AssertionStdParameterTypeClass.NUMBER,
+                    ),
+                    maxValue=models.AssertionStdParameterClass(
+                        value="0",  # Fixed max value for smart assertions
+                        type=models.AssertionStdParameterTypeClass.NUMBER,
                     ),
                 ),
             ),
@@ -268,12 +177,6 @@ class _SmartColumnMetricAssertionInput(_AssertionInput, _HasSmartAssertionInputs
         entity_client: EntityClient,
         column_name: str,
         metric_type: MetricInputType,
-        operator: OperatorInputType,
-        # Optional parameters
-        value: Optional[ValueInputType] = None,
-        value_type: Optional[ValueTypeInputType] = None,
-        range: Optional[RangeInputType] = None,
-        range_type: Optional[RangeTypeInputType] = None,
         urn: Optional[Union[str, AssertionUrn]] = None,
         display_name: Optional[str] = None,
         enabled: bool = True,
@@ -297,11 +200,6 @@ class _SmartColumnMetricAssertionInput(_AssertionInput, _HasSmartAssertionInputs
             entity_client: The entity client.
             column_name: The name of the column to validate.
             metric_type: The metric type to validate.
-            operator: The operator to use.
-            value: The value to validate.
-            value_type: The type of the value.
-            range: The range to validate.
-            range_type: The type of the range.  If single value, we assume the same type for start and end.
             urn: The urn of the assertion.
             display_name: The display name of the assertion.
             enabled: Whether the assertion is enabled.
@@ -350,65 +248,253 @@ class _SmartColumnMetricAssertionInput(_AssertionInput, _HasSmartAssertionInputs
         self.column_name = self._try_parse_and_validate_column_name_is_valid_type(
             column_name
         )
+
+        # Smart assertions use fixed operator and criteria_parameters since they are inferred by AI
         self.operator = _try_parse_and_validate_schema_classes_enum(
-            operator, models.AssertionStdOperatorClass
+            OperatorType.BETWEEN, models.AssertionStdOperatorClass
         )
 
-        # Set type annotations for both raw input or parsed parameters
-        self.value_type: Optional[ValueTypeInputType] = None
-        self.value: Optional[ValueInputType] = None
-        if _is_value_required_for_operator(self.operator):
-            self.value_type = _try_parse_and_validate_value_type(value_type)
-            self.value = _try_parse_and_validate_value(value, self.value_type)
+        # Initialize instance variables with fixed values for smart assertions
+        self.criteria_parameters: Optional[SmartColumnMetricAssertionParameters] = (
+            0,
+            0,
+        )
+        self.criteria_type: Optional[Union[ValueTypeInputType, RangeTypeInputType]] = (
+            ValueType.NUMBER,
+            ValueType.NUMBER,
+        )
+
+        # Validate compatibility:
+        # Skip operator validation for smart assertions since operator is a placeholder (AI inferred)
+        # Only validate metric type compatibility
+        self._validate_field_type_and_metric_type_compatibility(
+            self.column_name, self.metric_type
+        )
+
+    def _infer_criteria_type_from_parameters(
+        self,
+        criteria_parameters: Optional[SmartColumnMetricAssertionParameters],
+    ) -> Optional[Union[ValueTypeInputType, RangeTypeInputType]]:
+        """
+        Infer the criteria type from the parameters based on Python types.
+
+        Args:
+            criteria_parameters: The criteria parameters to infer type from.
+
+        Returns:
+            The inferred type(s) for the criteria parameters.
+        """
+        if criteria_parameters is None:
+            return None
+
+        if isinstance(criteria_parameters, tuple):
+            # Range parameters - infer type for each value
+            if len(criteria_parameters) != 2:
+                raise SDKUsageError(
+                    "Range parameters must be a tuple of exactly 2 values"
+                )
+
+            type1 = self._infer_single_value_type(criteria_parameters[0])
+            type2 = self._infer_single_value_type(criteria_parameters[1])
+            return (type1, type2)
         else:
-            # Set these to what was input for later validation, and skip parsing and validation
-            self.value_type = value_type
-            self.value = value
-
-        # Set type annotations for both raw input or parsed parameters
-        self.range_type: Optional[Union[RangeTypeInputType, RangeTypeParsedType]] = None
-        self.range: Optional[RangeInputType] = None
-        if _is_range_required_for_operator(self.operator):
-            self.range_type = _try_parse_and_validate_range_type(range_type)
-            self.range = _try_parse_and_validate_range(
-                range, self.range_type, self.operator
-            )
+            # Single value parameter
+            return self._infer_single_value_type(criteria_parameters)
+
+    def _infer_single_value_type(self, value: ValueInputType) -> ValueTypeInputType:
+        """
+        Infer the type of a single value based on its Python type.
+
+        Args:
+            value: The value to infer type from.
+
+        Returns:
+            The inferred ValueType.
+        """
+        if isinstance(value, (int, float)):
+            return ValueType.NUMBER
+        elif isinstance(value, str):
+            return ValueType.STRING
         else:
-            # Set these to what was input for later validation, and skip parsing and validation
-            self.range_type = range_type
-            self.range = range
+            # Default fallback
+            return ValueType.UNKNOWN
 
-        _validate_operator_and_input_parameters(
-            operator=self.operator,
-            value=self.value,
-            value_type=_try_parse_and_validate_value_type(self.value_type)
-            if self.value_type is not None
-            else None,
-            range=self.range,
-            range_type=_try_parse_and_validate_range_type(self.range_type)
-            if self.range_type is not None
-            else None,
+    def _process_criteria_parameters_with_gms_type(
+        self,
+        criteria_parameters: Optional[SmartColumnMetricAssertionParameters],
+        gms_type_info: Optional[Union[models.AssertionStdParameterTypeClass, tuple]],
+    ) -> None:
+        """Process criteria_parameters using explicit type information from GMS."""
+        if criteria_parameters is None:
+            self._process_none_parameters()
+        elif isinstance(criteria_parameters, tuple):
+            # Range parameters with GMS types
+            if gms_type_info and isinstance(gms_type_info, tuple):
+                self._process_range_parameters_with_types(
+                    criteria_parameters, gms_type_info
+                )
+            else:
+                self._process_range_parameters(criteria_parameters)
+        else:
+            # Single value with GMS type
+            if gms_type_info and not isinstance(gms_type_info, tuple):
+                self._process_single_value_parameters_with_type(
+                    criteria_parameters, gms_type_info
+                )
+            else:
+                self._process_single_value_parameters(criteria_parameters)
+
+    def _process_criteria_parameters(
+        self,
+        criteria_parameters: Optional[SmartColumnMetricAssertionParameters],
+    ) -> None:
+        """Process the new consolidated criteria_parameters with automatic type inference."""
+        if criteria_parameters is None:
+            self._process_none_parameters()
+        elif isinstance(criteria_parameters, tuple):
+            self._process_range_parameters(criteria_parameters)
+        else:
+            self._process_single_value_parameters(criteria_parameters)
+
+    def _process_none_parameters(self) -> None:
+        """Process None criteria_parameters."""
+        # No parameters - validation is now handled at the client level
+        # This allows both creation and update scenarios to be handled appropriately
+        self.criteria_parameters = None
+        self.criteria_type = None
+
+    def _process_range_parameters(self, criteria_parameters: tuple) -> None:
+        """Process tuple criteria_parameters for range operators."""
+        # Range parameters
+        if not _is_range_required_for_operator(self.operator):
+            raise SDKUsageError(
+                f"Operator {self.operator} does not support range parameters. "
+                "Provide a single value instead of a tuple."
+            )
+
+        # Infer range type automatically
+        inferred_range_type = self._infer_criteria_type_from_parameters(
+            criteria_parameters
         )
 
-        # Validate compatibility:
-        self._validate_field_type_and_operator_compatibility(
-            self.column_name, self.operator
+        # Validate and parse the range type
+        validated_range_type = _try_parse_and_validate_range_type(inferred_range_type)
+
+        # Validate and parse the range values
+        validated_range = _try_parse_and_validate_range(
+            criteria_parameters, validated_range_type, self.operator
         )
-        self._validate_field_type_and_metric_type_compatibility(
-            self.column_name, self.metric_type
+
+        # Store validated parameters
+        self.criteria_parameters = validated_range
+        self.criteria_type = validated_range_type
+
+    def _process_single_value_parameters(
+        self, criteria_parameters: Union[str, int, float]
+    ) -> None:
+        """Process single value criteria_parameters."""
+        # Single value parameters
+        if _is_no_parameter_operator(self.operator):
+            raise SDKUsageError(
+                f"Value parameters should not be provided for operator {self.operator}"
+            )
+        if not _is_value_required_for_operator(self.operator):
+            raise SDKUsageError(
+                f"Operator {self.operator} does not support value parameters. "
+                "Use criteria_parameters=None or omit criteria_parameters."
+            )
+
+        # Infer value type automatically
+        inferred_value_type = self._infer_criteria_type_from_parameters(
+            criteria_parameters
         )
-        self._validate_operator_and_range_or_value_compatibility(
-            self.operator,
-            self.value,
-            _try_parse_and_validate_value_type(self.value_type)
-            if self.value_type is not None
-            else None,
-            self.range,
-            _try_parse_and_validate_range_type(self.range_type)
-            if self.range_type is not None
-            else None,
+
+        # Validate value if required
+        if _is_value_required_for_operator(self.operator):
+            # Validate and parse the value type - make sure it's a single type, not a tuple
+            if isinstance(inferred_value_type, tuple):
+                raise SDKUsageError("Single value type expected, not a tuple type")
+
+            validated_value_type = _try_parse_and_validate_value_type(
+                inferred_value_type
+            )
+            validated_value = _try_parse_and_validate_value(
+                criteria_parameters, validated_value_type
+            )
+
+            # Store validated parameters
+            self.criteria_parameters = validated_value
+            self.criteria_type = validated_value_type
+        else:
+            # Store raw parameters for operators that don't require validation
+            self.criteria_parameters = criteria_parameters
+            self.criteria_type = inferred_value_type
+
+    def _process_single_value_parameters_with_type(
+        self,
+        criteria_parameters: Union[str, int, float],
+        gms_type: models.AssertionStdParameterTypeClass,
+    ) -> None:
+        """Process single value criteria_parameters using explicit GMS type information."""
+        # Single value parameters
+        if _is_no_parameter_operator(self.operator):
+            raise SDKUsageError(
+                f"Value parameters should not be provided for operator {self.operator}"
+            )
+        if not _is_value_required_for_operator(self.operator):
+            raise SDKUsageError(
+                f"Operator {self.operator} does not support value parameters. "
+                "Use criteria_parameters=None or omit criteria_parameters."
+            )
+
+        # Use GMS type instead of inferring
+        validated_value_type = _try_parse_and_validate_value_type(gms_type)
+        validated_value = _try_parse_and_validate_value(
+            criteria_parameters, validated_value_type
         )
 
+        # Store validated parameters
+        self.criteria_parameters = validated_value
+        self.criteria_type = validated_value_type
+
+    def _process_range_parameters_with_types(
+        self,
+        criteria_parameters: tuple,
+        gms_types: tuple,
+    ) -> None:
+        """Process range criteria_parameters using explicit GMS type information."""
+        # Range parameters with GMS types
+        if _is_no_parameter_operator(self.operator):
+            raise SDKUsageError(
+                f"Range parameters should not be provided for operator {self.operator}"
+            )
+        if not _is_range_required_for_operator(self.operator):
+            raise SDKUsageError(
+                f"Operator {self.operator} does not support range parameters. "
+                "Use a single value or criteria_parameters=None."
+            )
+
+        if len(criteria_parameters) != 2:
+            raise SDKUsageError("Range parameters must be a tuple of exactly 2 values")
+
+        min_value, max_value = criteria_parameters
+        min_type, max_type = gms_types
+
+        # Use GMS types instead of inferring
+        validated_min_type = _try_parse_and_validate_value_type(min_type)
+        validated_max_type = _try_parse_and_validate_value_type(max_type)
+
+        validated_min_value = _try_parse_and_validate_value(
+            min_value, validated_min_type
+        )
+        validated_max_value = _try_parse_and_validate_value(
+            max_value, validated_max_type
+        )
+
+        # Store validated parameters
+        self.criteria_parameters = (validated_min_value, validated_max_value)
+        self.criteria_type = (validated_min_type, validated_max_type)
+
     def _create_monitor_info(
         self,
         assertion_urn: AssertionUrn,
@@ -542,6 +628,11 @@ class _SmartColumnMetricAssertionInput(_AssertionInput, _HasSmartAssertionInputs
         """
         source_type = models.DatasetFieldAssertionSourceTypeClass.ALL_ROWS_QUERY
         field = None
+        SUPPORTED_DETECTION_MECHANISMS = [
+            _AllRowsQuery().type,
+            _AllRowsQueryDataHubDatasetProfile().type,
+            _ChangedRowsQuery(column_name="").type,
+        ]
 
         if isinstance(self.detection_mechanism, _ChangedRowsQuery):
             source_type = models.DatasetFieldAssertionSourceTypeClass.CHANGED_ROWS_QUERY
@@ -564,101 +655,11 @@ class _SmartColumnMetricAssertionInput(_AssertionInput, _HasSmartAssertionInputs
             # Note: This is only valid on the all rows query
         else:
             raise SDKNotYetSupportedError(
-                f"Detection mechanism {self.detection_mechanism} is not supported"
+                f"Detection mechanism {self.detection_mechanism} is not supported for smart column metric assertions, please use a supported detection mechanism: {', '.join(SUPPORTED_DETECTION_MECHANISMS)}"
             )
 
         return source_type, field
 
-    def _validate_single_value_operator(
-        self,
-        operator: models.AssertionStdOperatorClass,
-        value: Optional[ValueInputType],
-        value_type: Optional[models.AssertionStdParameterTypeClass],
-        range: Optional[RangeInputType],
-        range_type: Optional[RangeTypeParsedType],
-    ) -> None:
-        """Validate parameters for a single value operator."""
-        if value is None:
-            raise SDKUsageError(f"Value is required for operator {operator}")
-        if value_type is None:
-            raise SDKUsageError(f"Value type is required for operator {operator}")
-        if range is not None or range_type is not None:
-            raise SDKUsageError(
-                f"Range parameters should not be provided for operator {operator}"
-            )
-
-    def _validate_range_operator(
-        self,
-        operator: models.AssertionStdOperatorClass,
-        value: Optional[ValueInputType],
-        value_type: Optional[models.AssertionStdParameterTypeClass],
-        range: Optional[RangeInputType],
-        range_type: Optional[RangeTypeParsedType],
-    ) -> None:
-        """Validate parameters for a range operator."""
-        if range is None:
-            raise SDKUsageError(f"Range is required for operator {operator}")
-        if range_type is None:
-            raise SDKUsageError(f"Range type is required for operator {operator}")
-        if value is not None or value_type is not None:
-            raise SDKUsageError(
-                f"Value parameters should not be provided for operator {operator}"
-            )
-
-    def _validate_no_parameter_operator(
-        self,
-        operator: models.AssertionStdOperatorClass,
-        value: Optional[ValueInputType],
-        value_type: Optional[models.AssertionStdParameterTypeClass],
-        range: Optional[RangeInputType],
-        range_type: Optional[RangeTypeParsedType],
-    ) -> None:
-        """Validate parameters for a no-parameter operator."""
-        if value is not None or value_type is not None:
-            raise SDKUsageError(
-                f"Value parameters should not be provided for operator {operator}"
-            )
-        if range is not None or range_type is not None:
-            raise SDKUsageError(
-                f"Range parameters should not be provided for operator {operator}"
-            )
-
-    def _validate_operator_and_range_or_value_compatibility(
-        self,
-        operator: models.AssertionStdOperatorClass,
-        value: Optional[ValueInputType] = None,
-        value_type: Optional[models.AssertionStdParameterTypeClass] = None,
-        range: Optional[RangeInputType] = None,
-        range_type: Optional[RangeTypeParsedType] = None,
-    ) -> None:
-        """
-        Validate that the operator has the appropriate parameters (range or value) based on its type.
-
-        Args:
-            operator: The operator to validate.
-            value: Optional value parameter.
-            value_type: Optional value type parameter.
-            range: Optional range parameter.
-            range_type: Optional range type parameter.
-
-        Raises:
-            SDKUsageError: If the operator parameters are not compatible with the operator type.
-        """
-        if operator in SINGLE_VALUE_OPERATORS:
-            self._validate_single_value_operator(
-                operator, value, value_type, range, range_type
-            )
-        elif operator in RANGE_OPERATORS:
-            self._validate_range_operator(
-                operator, value, value_type, range, range_type
-            )
-        elif operator in NO_PARAMETER_OPERATORS:
-            self._validate_no_parameter_operator(
-                operator, value, value_type, range, range_type
-            )
-        else:
-            raise SDKUsageError(f"Unsupported operator type: {operator}")
-
     def _create_assertion_parameters(self) -> models.AssertionStdParametersClass:
         """
         Create assertion parameters based on the operator type and provided values.
@@ -670,35 +671,39 @@ class _SmartColumnMetricAssertionInput(_AssertionInput, _HasSmartAssertionInputs
             SDKUsageError: If the parameters are invalid for the operator type.
         """
         if self.operator in SINGLE_VALUE_OPERATORS:
-            if self.value is None:
-                raise SDKUsageError(f"Value is required for operator {self.operator}")
-            if self.value_type is None:
+            if self.criteria_parameters is None or isinstance(
+                self.criteria_parameters, tuple
+            ):
                 raise SDKUsageError(
-                    f"Value type is required for operator {self.operator}"
+                    f"Single value is required for operator {self.operator}"
+                )
+            if self.criteria_type is None or isinstance(self.criteria_type, tuple):
+                raise SDKUsageError(
+                    f"Single value type is required for operator {self.operator}"
                 )
             return models.AssertionStdParametersClass(
                 value=models.AssertionStdParameterClass(
-                    value=str(self.value),
-                    type=self.value_type,
+                    value=str(self.criteria_parameters),
+                    type=self.criteria_type,
                 ),
             )
         elif self.operator in RANGE_OPERATORS:
-            if self.range is None:
-                raise SDKUsageError(f"Range is required for operator {self.operator}")
-            if self.range_type is None:
+            if not isinstance(self.criteria_parameters, tuple):
+                raise SDKUsageError(
+                    f"Range parameters are required for operator {self.operator}"
+                )
+            if not isinstance(self.criteria_type, tuple):
                 raise SDKUsageError(
                     f"Range type is required for operator {self.operator}"
                 )
-            # Ensure we have the parsed range type
-            parsed_range_type = _try_parse_and_validate_range_type(self.range_type)
             return models.AssertionStdParametersClass(
                 minValue=models.AssertionStdParameterClass(
-                    value=str(self.range[0]),
-                    type=parsed_range_type[0],
+                    value=str(self.criteria_parameters[0]),
+                    type=self.criteria_type[0],
                 ),
                 maxValue=models.AssertionStdParameterClass(
-                    value=str(self.range[1]),
-                    type=parsed_range_type[1],
+                    value=str(self.criteria_parameters[1]),
+                    type=self.criteria_type[1],
                 ),
             )
         elif self.operator in NO_PARAMETER_OPERATORS:
@@ -791,42 +796,158 @@ def _try_parse_and_validate_value_type(
     )
 
 
-def _try_parse_and_validate_value(
-    value: Optional[ValueInputType],
-    value_type: ValueTypeInputType,
-) -> ValueInputType:
-    if value is None:
-        raise SDKUsageError("Value parameter is required for the chosen operator")
-    # Accept both Python types and JSON strings
+def _deserialize_json_value(value: ValueInputType) -> ValueInputType:
+    """
+    Deserialize a value that might be a JSON string.
+
+    Args:
+        value: The value to deserialize, potentially a JSON string.
+
+    Returns:
+        The deserialized value or the original value if not JSON.
+    """
     if isinstance(value, str):
-        # Try to parse as JSON, but if it fails, treat as a raw string
         try:
-            deserialized_value = json.loads(value)
+            return json.loads(value)
         except json.JSONDecodeError:
-            deserialized_value = value
-    else:
-        deserialized_value = value
-    # Validate that the value is of the correct type
-    if value_type == models.AssertionStdParameterTypeClass.NUMBER:
-        if not isinstance(deserialized_value, (int, float)):
-            raise SDKUsageError(f"Invalid value: {value}, must be a number")
-    elif value_type == models.AssertionStdParameterTypeClass.STRING:
-        if not isinstance(deserialized_value, str):
-            raise SDKUsageError(f"Invalid value: {value}, must be a string")
-    elif (
-        value_type == models.AssertionStdParameterTypeClass.LIST
-        or value_type == models.AssertionStdParameterTypeClass.SET
+            return value
+    return value
+
+
+def _convert_string_to_number(value: str) -> Union[int, float]:
+    """
+    Convert a string to a number (int or float).
+
+    Args:
+        value: The string value to convert.
+
+    Returns:
+        The converted number.
+
+    Raises:
+        ValueError: If the string cannot be converted to a number.
+    """
+    if "." in value:
+        return float(value)
+    return int(value)
+
+
+def _validate_number_type(
+    value: ValueInputType, original_value: ValueInputType
+) -> ValueInputType:
+    """
+    Validate and convert a value to a number type.
+
+    Args:
+        value: The deserialized value to validate.
+        original_value: The original input value for error messages.
+
+    Returns:
+        The validated number value.
+
+    Raises:
+        SDKUsageError: If the value cannot be converted to a number.
+    """
+    if isinstance(value, (int, float)):
+        return value
+
+    if isinstance(value, str):
+        try:
+            return _convert_string_to_number(value)
+        except ValueError as e:
+            raise SDKUsageError(
+                f"Invalid value: {original_value}, must be a number"
+            ) from e
+
+    raise SDKUsageError(f"Invalid value: {original_value}, must be a number")
+
+
+def _validate_string_type(
+    value: ValueInputType, original_value: ValueInputType
+) -> ValueInputType:
+    """
+    Validate that a value is a string type.
+
+    Args:
+        value: The deserialized value to validate.
+        original_value: The original input value for error messages.
+
+    Returns:
+        The validated string value.
+
+    Raises:
+        SDKUsageError: If the value is not a string.
+    """
+    if not isinstance(value, str):
+        raise SDKUsageError(f"Invalid value: {original_value}, must be a string")
+    return value
+
+
+def _validate_unsupported_types(value_type: ValueTypeInputType) -> None:
+    """
+    Check for unsupported value types and raise appropriate errors.
+
+    Args:
+        value_type: The value type to check.
+
+    Raises:
+        SDKNotYetSupportedError: If the value type is LIST or SET.
+        SDKUsageError: If the value type is invalid.
+    """
+    if value_type in (
+        models.AssertionStdParameterTypeClass.LIST,
+        models.AssertionStdParameterTypeClass.SET,
     ):
         raise SDKNotYetSupportedError(
             "List and set value types are not supported for smart column metric assertions"
         )
-    elif value_type == models.AssertionStdParameterTypeClass.UNKNOWN:
-        pass  # TODO: What to do with unknown?
-    else:
+
+    valid_types = {
+        models.AssertionStdParameterTypeClass.NUMBER,
+        models.AssertionStdParameterTypeClass.STRING,
+        models.AssertionStdParameterTypeClass.UNKNOWN,
+    }
+
+    if value_type not in valid_types:
         raise SDKUsageError(
             f"Invalid value type: {value_type}, valid options are {get_enum_options(models.AssertionStdParameterTypeClass)}"
         )
-    return deserialized_value
+
+
+def _try_parse_and_validate_value(
+    value: Optional[ValueInputType],
+    value_type: ValueTypeInputType,
+) -> ValueInputType:
+    """
+    Parse and validate a value according to its expected type.
+
+    Args:
+        value: The value to parse and validate.
+        value_type: The expected type of the value.
+
+    Returns:
+        The validated and potentially converted value.
+
+    Raises:
+        SDKUsageError: If the value is None, invalid, or cannot be converted.
+        SDKNotYetSupportedError: If the value type is not supported.
+    """
+    if value is None:
+        raise SDKUsageError("Value parameter is required for the chosen operator")
+
+    # Deserialize JSON strings if applicable
+    deserialized_value = _deserialize_json_value(value)
+
+    # Validate based on expected type
+    if value_type == models.AssertionStdParameterTypeClass.NUMBER:
+        return _validate_number_type(deserialized_value, value)
+    elif value_type == models.AssertionStdParameterTypeClass.STRING:
+        return _validate_string_type(deserialized_value, value)
+    elif value_type == models.AssertionStdParameterTypeClass.UNKNOWN:
+        return deserialized_value  # Accept any type for unknown
+    else:
+        _validate_unsupported_types(value_type)
+        return deserialized_value
 
 
 def _is_range_required_for_operator(operator: models.AssertionStdOperatorClass) -> bool:
@@ -841,36 +962,6 @@ def _is_no_parameter_operator(operator: models.AssertionStdOperatorClass) -> boo
     return operator in NO_PARAMETER_OPERATORS
 
 
-def _validate_operator_and_input_parameters(
-    operator: models.AssertionStdOperatorClass,
-    value: Optional[ValueInputType] = None,
-    value_type: Optional[models.AssertionStdParameterTypeClass] = None,
-    range: Optional[RangeInputType] = None,
-    range_type: Optional[RangeTypeParsedType] = None,
-) -> None:
-    if _is_value_required_for_operator(operator):
-        if value is None:
-            raise SDKUsageError(f"Value is required for operator {operator}")
-        if value_type is None:
-            raise SDKUsageError(f"Value type is required for operator {operator}")
-    elif _is_range_required_for_operator(operator):
-        if range is None:
-            raise SDKUsageError(f"Range is required for operator {operator}")
-        if range_type is None:
-            raise SDKUsageError(f"Range type is required for operator {operator}")
-    elif _is_no_parameter_operator(operator):
-        if value is not None or value_type is not None:
-            raise SDKUsageError(
-                f"Value parameters should not be provided for operator {operator}"
-            )
-        if range is not None or range_type is not None:
-            raise SDKUsageError(
-                f"Range parameters should not be provided for operator {operator}"
-            )
-    else:
-        raise SDKUsageError(f"Unsupported operator type: {operator}")
-
-
 def _try_parse_and_validate_range_type(
     range_type: Optional[RangeTypeInputType] = None,
 ) -> RangeTypeParsedType: