acryl-datahub-cloud 0.3.12rc3__py3-none-any.whl → 0.3.12rc5__py3-none-any.whl

acryl_datahub_cloud/sdk/{assertion_input.py → assertion_input/assertion_input.py}

@@ -6,9 +6,10 @@ validate and represent the input for creating an Assertion in DataHub.
 import random
 import string
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
-from typing import Literal, Optional, TypeAlias, Union
+from typing import Callable, Literal, Optional, Type, TypeAlias, TypeVar, Union
 
 import pydantic
 import pytz
@@ -42,12 +43,28 @@ ASSERTION_MONITOR_DEFAULT_TRAINING_LOOKBACK_WINDOW_DAYS = 60
 DEFAULT_NAME_PREFIX = "New Assertion"
 DEFAULT_NAME_SUFFIX_LENGTH = 8
 
-DEFAULT_SCHEDULE = models.CronScheduleClass(
+
+DEFAULT_HOURLY_SCHEDULE: models.CronScheduleClass = models.CronScheduleClass(
     cron="0 * * * *",  # Every hour, matches the UI default
     timezone=str(
         tzlocal.get_localzone()
     ),  # User local timezone, matches the UI default
 )
+DEFAULT_SCHEDULE: models.CronScheduleClass = DEFAULT_HOURLY_SCHEDULE
+
+DEFAULT_DAILY_SCHEDULE = models.CronScheduleClass(
+    cron="0 0 * * *",  # Every day at midnight, matches the UI default
+    timezone=str(
+        tzlocal.get_localzone()
+    ),  # User local timezone, matches the UI default
+)
+
+DEFAULT_EVERY_SIX_HOURS_SCHEDULE = models.CronScheduleClass(
+    cron="0 */6 * * *",  # Every 6 hours, matches the UI default
+    timezone=str(
+        tzlocal.get_localzone()
+    ),  # User local timezone, matches the UI default
+)
 
 
 class AbstractDetectionMechanism(BaseModel, ABC):
@@ -101,6 +118,26 @@ class _Query(AbstractDetectionMechanism):
     additional_filter: Optional[str] = None
 
 
+class _AllRowsQuery(AbstractDetectionMechanism):
+    # For column-based assertions, this is the default detection mechanism.
+    type: Literal["all_rows_query"] = "all_rows_query"
+    additional_filter: Optional[str] = None
+
+
+class _AllRowsQueryDataHubDatasetProfile(AbstractDetectionMechanism):
+    # Used for column-based assertions.
+    type: Literal["all_rows_query_datahub_dataset_profile"] = (
+        "all_rows_query_datahub_dataset_profile"
+    )
+
+
+class _ChangedRowsQuery(AbstractDetectionMechanism):
+    # Used for column-based assertions.
+    type: Literal["changed_rows_query"] = "changed_rows_query"
+    column_name: str
+    additional_filter: Optional[str] = None
+
+
 class _DatasetProfile(AbstractDetectionMechanism):
     type: Literal["dataset_profile"] = "dataset_profile"
 
@@ -114,6 +151,9 @@ _DETECTION_MECHANISM_CONCRETE_TYPES = (
     _DataHubOperation,
     _Query,
     _DatasetProfile,
+    _AllRowsQuery,
+    _ChangedRowsQuery,
+    _AllRowsQueryDataHubDatasetProfile,
 )
 _DetectionMechanismTypes = Union[
     _InformationSchema,
@@ -123,14 +163,21 @@ _DetectionMechanismTypes = Union[
     _DataHubOperation,
     _Query,
     _DatasetProfile,
+    _AllRowsQuery,
+    _ChangedRowsQuery,
+    _AllRowsQueryDataHubDatasetProfile,
 ]
 
 _DETECTION_MECHANISM_TYPES_WITH_ADDITIONAL_FILTER = (
     _LastModifiedColumn,
     _HighWatermarkColumn,
     _Query,
+    _AllRowsQuery,
+    _ChangedRowsQuery,
 )
 
+DEFAULT_DETECTION_MECHANISM: _DetectionMechanismTypes = _InformationSchema()
+
 
 class DetectionMechanism:
     # To have a more enum-like user experience even with sub parameters, we define the detection mechanisms as class attributes.
@@ -141,6 +188,9 @@ class DetectionMechanism:
     HIGH_WATERMARK_COLUMN = _HighWatermarkColumn
     DATAHUB_OPERATION = _DataHubOperation()
     QUERY = _Query
+    ALL_ROWS_QUERY = _AllRowsQuery
+    CHANGED_ROWS_QUERY = _ChangedRowsQuery
+    ALL_ROWS_QUERY_DATAHUB_DATASET_PROFILE = _AllRowsQueryDataHubDatasetProfile()
     DATASET_PROFILE = _DatasetProfile()
 
     _DETECTION_MECHANISM_EXAMPLES = {
@@ -170,6 +220,18 @@ class DetectionMechanism:
         "Query from DetectionMechanism (with optional additional filter)": "DetectionMechanism.QUERY(additional_filter='id > 1000')",
         "Dataset Profile from string": "dataset_profile",
         "Dataset Profile from DetectionMechanism": "DetectionMechanism.DATASET_PROFILE",
+        "All Rows Query from string": "all_rows_query",
+        "All Rows Query from DetectionMechanism": "DetectionMechanism.ALL_ROWS_QUERY",
+        "All Rows Query from DetectionMechanism (with optional additional filter)": "DetectionMechanism.ALL_ROWS_QUERY(additional_filter='id > 1000')",
+        "Changed Rows Query from dict (with optional additional filter)": {
+            "type": "changed_rows_query",
+            "column_name": "id",
+            "additional_filter": "id > 1000",
+        },
+        "Changed Rows Query from DetectionMechanism": "DetectionMechanism.CHANGED_ROWS_QUERY(column_name='id')",
+        "Changed Rows Query from DetectionMechanism (with optional additional filter)": "DetectionMechanism.CHANGED_ROWS_QUERY(column_name='id', additional_filter='id > 1000')",
+        "All Rows Query DataHub Dataset Profile from string": "all_rows_query_datahub_dataset_profile",
+        "All Rows Query DataHub Dataset Profile from DetectionMechanism": "DetectionMechanism.ALL_ROWS_QUERY_DATAHUB_DATASET_PROFILE",
     }
 
     @staticmethod
@@ -177,9 +239,10 @@ class DetectionMechanism:
         detection_mechanism_config: Optional[
             Union[str, dict[str, str], _DetectionMechanismTypes]
         ] = None,
+        default_detection_mechanism: _DetectionMechanismTypes = DEFAULT_DETECTION_MECHANISM,
     ) -> _DetectionMechanismTypes:
         if detection_mechanism_config is None:
-            return DEFAULT_DETECTION_MECHANISM
+            return default_detection_mechanism
         if isinstance(detection_mechanism_config, _DETECTION_MECHANISM_CONCRETE_TYPES):
             return detection_mechanism_config
         elif isinstance(detection_mechanism_config, str):
@@ -260,8 +323,6 @@ class DetectionMechanism:
             ) from e
 
 
-DEFAULT_DETECTION_MECHANISM = DetectionMechanism.INFORMATION_SCHEMA
-
 DetectionMechanismInputTypes: TypeAlias = Union[
     str, dict[str, str], _DetectionMechanismTypes, None
 ]
@@ -328,7 +389,59 @@ class InferenceSensitivity(Enum):
         }[sensitivity]
 
 
-DEFAULT_SENSITIVITY = InferenceSensitivity.MEDIUM
+DEFAULT_SENSITIVITY: InferenceSensitivity = InferenceSensitivity.MEDIUM
+
+TIME_WINDOW_SIZE_EXAMPLES = {
+    "Time window size from models.TimeWindowSizeClass": "models.TimeWindowSizeClass(unit='MINUTE', multiple=10)",
+    "Time window size from object": "TimeWindowSize(unit='MINUTE', multiple=10)",
+}
+
+
+class CalendarInterval(Enum):
+    MINUTE = "MINUTE"
+    HOUR = "HOUR"
+    DAY = "DAY"
+
+
+class TimeWindowSize(BaseModel):
+    unit: Union[CalendarInterval, str]
+    multiple: int
+
+
+TimeWindowSizeInputTypes: TypeAlias = Union[
+    models.TimeWindowSizeClass,
+    models.FixedIntervalScheduleClass,
+    TimeWindowSize,
+]
+
+
+def _try_parse_time_window_size(
+    config: TimeWindowSizeInputTypes,
+) -> models.TimeWindowSizeClass:
+    if isinstance(config, models.TimeWindowSizeClass):
+        return config
+    elif isinstance(config, models.FixedIntervalScheduleClass):
+        return models.TimeWindowSizeClass(
+            unit=_try_parse_and_validate_schema_classes_enum(
+                config.unit, models.CalendarIntervalClass
+            ),
+            multiple=config.multiple,
+        )
+    elif isinstance(config, TimeWindowSize):
+        return models.TimeWindowSizeClass(
+            unit=_try_parse_and_validate_schema_classes_enum(
+                _try_parse_and_validate_schema_classes_enum(
+                    config.unit, CalendarInterval
+                ).value,
+                models.CalendarIntervalClass,
+            ),
+            multiple=config.multiple,
+        )
+    else:
+        raise SDKUsageErrorWithExamples(
+            msg=f"Invalid time window size: {config}",
+            examples=TIME_WINDOW_SIZE_EXAMPLES,
+        )
 
 
 class FixedRangeExclusionWindow(BaseModel):
@@ -594,6 +707,161 @@ def _try_parse_schedule(
 FieldSpecType = Union[models.FreshnessFieldSpecClass, models.SchemaFieldSpecClass]
 
 
+T = TypeVar("T")
+
+
+def _try_parse_and_validate_schema_classes_enum(
+    value: Union[str, T],
+    enum_class: Type[T],
+) -> T:
+    if isinstance(value, enum_class):
+        return value
+    assert isinstance(value, str)
+    if value.upper() not in get_enum_options(enum_class):
+        raise SDKUsageError(
+            f"Invalid value for {enum_class.__name__}: {value}, valid options are {get_enum_options(enum_class)}"
+        )
+    return getattr(enum_class, value.upper())
+
+
+@dataclass(frozen=True)
+class DatasetSourceType:
+    """
+    DatasetSourceType is used to represent a dataset source type.
+    It is used to check if a source type is valid for a dataset type and assertion type.
+
+    Args:
+        source_type: The source type (e.g. information schema, field value, etc. aka detection mechanism)
+        platform: The platform of the dataset as a string OR "all" for all platforms.
+        assertion_type: The assertion type as a models.AssertionTypeClass string e.g. models.AssertionTypeClass.FRESHNESS OR "all" for all assertion types.
+
+    Example:
+    DatasetSourceType(
+        source_type=_InformationSchema,
+        platform="databricks",
+        assertion_type="all",
+    )
+    This means that the source type _InformationSchema is invalid for the dataset type "databricks" and assertion type "all".
+    "all" in this example means that the source type is invalid for all assertion types.
+    """
+
+    source_type: Type[_DetectionMechanismTypes]
+    platform: str
+    assertion_type: Union[models.AssertionTypeClass, str]
+
+
+INVALID_SOURCE_TYPES = {
+    # Add exceptions here if a source type (detection mechanism) is invalid for a dataset type and assertion type.
+    DatasetSourceType(
+        source_type=_InformationSchema,
+        platform="databricks",
+        assertion_type="all",
+    )
+}
+
+
+def _is_source_type_valid(
+    dataset_source_type: DatasetSourceType,
+    invalid_source_types: set[DatasetSourceType] = INVALID_SOURCE_TYPES,
+) -> bool:
+    for invalid in invalid_source_types:
+        if invalid.source_type == dataset_source_type.source_type:
+            # If both platform and assertion type are "all", the source type is invalid for all combinations
+            if invalid.platform == "all" and invalid.assertion_type == "all":
+                return False
+            # If platform matches and assertion type is "all", the source type is invalid for all assertion types on that platform
+            if (
+                invalid.platform == dataset_source_type.platform
+                and invalid.assertion_type == "all"
+            ):
+                return False
+            # If platform is "all" and assertion type matches, the source type is invalid for all platforms for that assertion type
+            if (
+                invalid.platform == "all"
+                and invalid.assertion_type == dataset_source_type.assertion_type
+            ):
+                return False
+            # If both platform and assertion type match exactly, the source type is invalid
+            if (
+                invalid.platform == dataset_source_type.platform
+                and invalid.assertion_type == dataset_source_type.assertion_type
+            ):
+                return False
+    return True
+
+
+class _HasSmartAssertionInputs:
+    """
+    A class that contains the common inputs for smart assertions.
+    This is used to avoid code duplication in the smart assertion inputs.
+
+    Args:
+        sensitivity: The sensitivity to be applied to the assertion.
+        exclusion_windows: The exclusion windows to be applied to the assertion. If not provided, no exclusion windows will be applied.
+        training_data_lookback_days: The training data lookback days to be applied to the assertion.
+    """
+
+    def __init__(
+        self,
+        *,
+        sensitivity: Optional[Union[str, InferenceSensitivity]] = None,
+        exclusion_windows: Optional[ExclusionWindowInputTypes] = None,
+        training_data_lookback_days: Optional[int] = None,
+    ):
+        self.sensitivity = InferenceSensitivity.parse(sensitivity)
+        self.exclusion_windows = _try_parse_exclusion_window(exclusion_windows)
+        self.training_data_lookback_days = _try_parse_training_data_lookback_days(
+            training_data_lookback_days
+        )
+
+    def _convert_exclusion_windows(
+        self,
+    ) -> list[models.AssertionExclusionWindowClass]:
+        """
+        Convert exclusion windows into AssertionExclusionWindowClass objects including generating display names for them.
+
+        Returns:
+            A list of AssertionExclusionWindowClass objects.
+
+        Raises:
+            SDKUsageErrorWithExamples: If an exclusion window is of an invalid type.
+        """
+        exclusion_windows: list[models.AssertionExclusionWindowClass] = []
+        if self.exclusion_windows:
+            for window in self.exclusion_windows:
+                if not isinstance(window, FixedRangeExclusionWindow):
+                    raise SDKUsageErrorWithExamples(
+                        msg=f"Invalid exclusion window type: {window}",
+                        examples=FIXED_RANGE_EXCLUSION_WINDOW_EXAMPLES,
+                    )
+                # To match the UI, we generate a display name for the exclusion window.
+                # See here for the UI code: https://github.com/acryldata/datahub-fork/blob/acryl-main/datahub-web-react/src/app/entityV2/shared/tabs/Dataset/Validations/assertion/builder/steps/inferred/common/ExclusionWindowAdjuster.tsx#L31
+                # Copied here for reference: displayName: `${dayjs(startTime).format('MMM D, h:mm A')} - ${dayjs(endTime).format('MMM D, h:mm A')}`,
+                generated_display_name = f"{window.start.strftime('%b %-d, %-I:%M %p')} - {window.end.strftime('%b %-d, %-I:%M %p')}"
+                exclusion_windows.append(
+                    models.AssertionExclusionWindowClass(
+                        type=models.AssertionExclusionWindowTypeClass.FIXED_RANGE,  # Currently only fixed range is supported
+                        displayName=generated_display_name,
+                        fixedRange=models.AbsoluteTimeWindowClass(
+                            startTimeMillis=make_ts_millis(window.start),
+                            endTimeMillis=make_ts_millis(window.end),
+                        ),
+                    )
+                )
+        return exclusion_windows
+
+    def _convert_sensitivity(self) -> models.AssertionMonitorSensitivityClass:
+        """
+        Convert sensitivity into an AssertionMonitorSensitivityClass.
+
+        Returns:
+            An AssertionMonitorSensitivityClass with the appropriate sensitivity.
+        """
+        return models.AssertionMonitorSensitivityClass(
+            level=InferenceSensitivity.to_int(self.sensitivity),
+        )
+
+
 class _AssertionInput(ABC):
     def __init__(
         self,
@@ -609,9 +877,6 @@ class _AssertionInput(ABC):
         enabled: bool = True,
         schedule: Optional[Union[str, models.CronScheduleClass]] = None,
         detection_mechanism: DetectionMechanismInputTypes = None,
-        sensitivity: Optional[Union[str, InferenceSensitivity]] = None,
-        exclusion_windows: Optional[ExclusionWindowInputTypes] = None,
-        training_data_lookback_days: Optional[int] = None,
         incident_behavior: Optional[
             Union[AssertionIncidentBehavior, list[AssertionIncidentBehavior]]
         ] = None,
@@ -621,6 +886,7 @@ class _AssertionInput(ABC):
         created_at: datetime,
         updated_by: Union[str, CorpUserUrn],
         updated_at: datetime,
+        default_detection_mechanism: _DetectionMechanismTypes = DEFAULT_DETECTION_MECHANISM,
     ):
         """
         Create an AssertionInput object.
@@ -632,9 +898,6 @@ class _AssertionInput(ABC):
             display_name: The display name of the assertion. If not provided, a random display name will be generated.
             enabled: Whether the assertion is enabled. Defaults to True.
             detection_mechanism: The detection mechanism to be used for the assertion.
-            sensitivity: The sensitivity to be applied to the assertion.
-            exclusion_windows: The exclusion windows to be applied to the assertion. If not provided, no exclusion windows will be applied.
-            training_data_lookback_days: The training data lookback days to be applied to the assertion.
             incident_behavior: The incident behavior to be applied to the assertion.
             tags: The tags to be applied to the assertion.
             source_type: The source type of the assertion. Defaults to models.AssertionSourceTypeClass.NATIVE.
@@ -653,12 +916,19 @@ class _AssertionInput(ABC):
         )
         self.enabled = enabled
         self.schedule = _try_parse_schedule(schedule)
-        self.detection_mechanism = DetectionMechanism.parse(detection_mechanism)
-        self.sensitivity = InferenceSensitivity.parse(sensitivity)
-        self.exclusion_windows = _try_parse_exclusion_window(exclusion_windows)
-        self.training_data_lookback_days = _try_parse_training_data_lookback_days(
-            training_data_lookback_days
+        self.detection_mechanism = DetectionMechanism.parse(
+            detection_mechanism, default_detection_mechanism
         )
+        if not _is_source_type_valid(
+            DatasetSourceType(
+                source_type=type(self.detection_mechanism),
+                platform=self.dataset_urn.platform,
+                assertion_type=self._assertion_type(),
+            )
+        ):
+            raise SDKUsageError(
+                f"Invalid source type: {self.detection_mechanism} for dataset type: {self.dataset_urn.platform} and assertion type: {self._assertion_type()}"
+            )
         self.incident_behavior = _try_parse_incident_behavior(incident_behavior)
         self.tags = tags
         if source_type not in get_enum_options(models.AssertionSourceTypeClass):
@@ -670,7 +940,6 @@ class _AssertionInput(ABC):
         self.created_at = created_at
         self.updated_by = updated_by
         self.updated_at = updated_at
-
         self.cached_dataset: Optional[Dataset] = None
 
     def to_assertion_and_monitor_entities(self) -> tuple[Assertion, Monitor]:
@@ -836,8 +1105,6 @@ class _AssertionInput(ABC):
                 schedule=self._convert_schedule(),
                 source_type=source_type,
                 field=field,
-                sensitivity=self._convert_sensitivity(),
-                exclusion_windows=self._convert_exclusion_windows(),
             ),
         )
 
@@ -854,53 +1121,6 @@ class _AssertionInput(ABC):
             else models.MonitorModeClass.INACTIVE,
         )
 
-    def _convert_exclusion_windows(
-        self,
-    ) -> list[models.AssertionExclusionWindowClass]:
-        """
-        Convert exclusion windows into AssertionExclusionWindowClass objects including generating display names for them.
-
-        Returns:
-            A list of AssertionExclusionWindowClass objects.
-
-        Raises:
-            SDKUsageErrorWithExamples: If an exclusion window is of an invalid type.
-        """
-        exclusion_windows: list[models.AssertionExclusionWindowClass] = []
-        if self.exclusion_windows:
-            for window in self.exclusion_windows:
-                if not isinstance(window, FixedRangeExclusionWindow):
-                    raise SDKUsageErrorWithExamples(
-                        msg=f"Invalid exclusion window type: {window}",
-                        examples=FIXED_RANGE_EXCLUSION_WINDOW_EXAMPLES,
-                    )
-                # To match the UI, we generate a display name for the exclusion window.
-                # See here for the UI code: https://github.com/acryldata/datahub-fork/blob/acryl-main/datahub-web-react/src/app/entityV2/shared/tabs/Dataset/Validations/assertion/builder/steps/inferred/common/ExclusionWindowAdjuster.tsx#L31
-                # Copied here for reference: displayName: `${dayjs(startTime).format('MMM D, h:mm A')} - ${dayjs(endTime).format('MMM D, h:mm A')}`,
-                generated_display_name = f"{window.start.strftime('%b %-d, %-I:%M %p')} - {window.end.strftime('%b %-d, %-I:%M %p')}"
-                exclusion_windows.append(
-                    models.AssertionExclusionWindowClass(
-                        type=models.AssertionExclusionWindowTypeClass.FIXED_RANGE,  # Currently only fixed range is supported
-                        displayName=generated_display_name,
-                        fixedRange=models.AbsoluteTimeWindowClass(
-                            startTimeMillis=make_ts_millis(window.start),
-                            endTimeMillis=make_ts_millis(window.end),
-                        ),
-                    )
-                )
-        return exclusion_windows
-
-    def _convert_sensitivity(self) -> models.AssertionMonitorSensitivityClass:
-        """
-        Convert sensitivity into an AssertionMonitorSensitivityClass.
-
-        Returns:
-            An AssertionMonitorSensitivityClass with the appropriate sensitivity.
-        """
-        return models.AssertionMonitorSensitivityClass(
-            level=InferenceSensitivity.to_int(self.sensitivity),
-        )
-
     def _get_schema_field_spec(self, column_name: str) -> models.SchemaFieldSpecClass:
         """
         Get the schema field spec for the detection mechanism if needed.
@@ -956,6 +1176,7 @@ class _AssertionInput(ABC):
                 f"Allowed types are {allowed_type_names}.",
             )
 
+    @abstractmethod
     def _create_monitor_info(
         self,
         assertion_urn: AssertionUrn,
@@ -963,8 +1184,6 @@ class _AssertionInput(ABC):
         schedule: models.CronScheduleClass,
         source_type: Union[str, models.DatasetFreshnessSourceTypeClass],
         field: Optional[FieldSpecType],
-        sensitivity: models.AssertionMonitorSensitivityClass,
-        exclusion_windows: list[models.AssertionExclusionWindowClass],
     ) -> models.MonitorInfoClass:
         """
         Create a MonitorInfoClass with all the necessary components.
@@ -974,34 +1193,15 @@ class _AssertionInput(ABC):
             schedule: The monitor schedule.
             source_type: The source type.
             field: Optional field specification.
-            sensitivity: The monitor sensitivity.
-            exclusion_windows: List of exclusion windows.
-
         Returns:
             A MonitorInfoClass configured with all the provided components.
         """
-        return models.MonitorInfoClass(
-            type=models.MonitorTypeClass.ASSERTION,
-            status=status,
-            assertionMonitor=models.AssertionMonitorClass(
-                assertions=[
-                    models.AssertionEvaluationSpecClass(
-                        assertion=str(assertion_urn),
-                        schedule=schedule,
-                        parameters=self._get_assertion_evaluation_parameters(
-                            str(source_type), field
-                        ),
-                    )
-                ],
-                settings=models.AssertionMonitorSettingsClass(
-                    adjustmentSettings=models.AssertionAdjustmentSettingsClass(
-                        sensitivity=sensitivity,
-                        exclusionWindows=exclusion_windows,
-                        trainingDataLookbackWindowDays=self.training_data_lookback_days,
-                    ),
-                ),
-            ),
-        )
+        pass
+
+    @abstractmethod
+    def _assertion_type(self) -> str:
+        """Get the assertion type."""
+        pass
 
     @abstractmethod
     def _create_assertion_info(
@@ -1030,7 +1230,55 @@ class _AssertionInput(ABC):
         pass
 
 
-class _SmartFreshnessAssertionInput(_AssertionInput):
+class _HasFreshnessFeatures:
+    def _create_field_spec(
+        self,
+        column_name: str,
+        allowed_types: list[DictWrapper],  # TODO: Use the type from the PDL
+        field_type_name: str,
+        kind: str,
+        get_schema_field_spec: Callable[[str], models.SchemaFieldSpecClass],
+        validate_field_type: Callable[
+            [models.SchemaFieldSpecClass, str, list[DictWrapper], str], None
+        ],
+    ) -> models.FreshnessFieldSpecClass:
+        """
+        Create a field specification for a column, validating its type.
+
+        Args:
+            column_name: The name of the column to create a spec for
+            allowed_types: List of allowed field types
+            field_type_name: Human-readable name of the field type for error messages
+            kind: The kind of field to create
+
+        Returns:
+            A FreshnessFieldSpecClass for the column
+
+        Raises:
+            SDKUsageError: If the column is not found or has an invalid type
+        """
+        SUPPORTED_KINDS = [
+            models.FreshnessFieldKindClass.LAST_MODIFIED,
+            models.FreshnessFieldKindClass.HIGH_WATERMARK,
+        ]
+        if kind not in SUPPORTED_KINDS:
+            raise SDKUsageError(
+                msg=f"Invalid kind: {kind}. Must be one of {SUPPORTED_KINDS}",
+            )
+
+        field_spec = get_schema_field_spec(column_name)
+        validate_field_type(field_spec, column_name, allowed_types, field_type_name)
+        return models.FreshnessFieldSpecClass(
+            path=field_spec.path,
+            type=field_spec.type,
+            nativeType=field_spec.nativeType,
+            kind=kind,
+        )
+
+
+class _SmartFreshnessAssertionInput(
+    _AssertionInput, _HasSmartAssertionInputs, _HasFreshnessFeatures
+):
     def __init__(
         self,
         *,
@@ -1055,7 +1303,8 @@ class _SmartFreshnessAssertionInput(_AssertionInput):
         updated_by: Union[str, CorpUserUrn],
         updated_at: datetime,
     ):
-        super().__init__(
+        _AssertionInput.__init__(
+            self,
             dataset_urn=dataset_urn,
             entity_client=entity_client,
             urn=urn,
@@ -1063,11 +1312,8 @@ class _SmartFreshnessAssertionInput(_AssertionInput):
             enabled=enabled,
             schedule=schedule
             if schedule is not None
-            else DEFAULT_SCHEDULE,  # Use provided schedule or default for create case
+            else DEFAULT_HOURLY_SCHEDULE,  # Use provided schedule or default for create case
             detection_mechanism=detection_mechanism,
-            sensitivity=sensitivity,
-            exclusion_windows=exclusion_windows,
-            training_data_lookback_days=training_data_lookback_days,
             incident_behavior=incident_behavior,
             tags=tags,
             source_type=models.AssertionSourceTypeClass.INFERRED,  # Smart assertions are of type inferred, not native
@@ -1076,6 +1322,16 @@ class _SmartFreshnessAssertionInput(_AssertionInput):
             updated_by=updated_by,
             updated_at=updated_at,
         )
+        _HasSmartAssertionInputs.__init__(
+            self,
+            sensitivity=sensitivity,
+            exclusion_windows=exclusion_windows,
+            training_data_lookback_days=training_data_lookback_days,
+        )
+
+    def _assertion_type(self) -> str:
+        """Get the assertion type."""
+        return models.AssertionTypeClass.FRESHNESS
 
     def _create_assertion_info(
         self, filter: Optional[models.DatasetFilterClass]
@@ -1099,7 +1355,7 @@ class _SmartFreshnessAssertionInput(_AssertionInput):
     def _convert_schedule(self) -> models.CronScheduleClass:
         """Create a schedule for a smart freshness assertion.
 
-        For create case, uses DEFAULT_SCHEDULE. For update case, preserves existing schedule.
+        For create case, uses DEFAULT_HOURLY_SCHEDULE. For update case, preserves existing schedule.
 
         Returns:
             A CronScheduleClass with appropriate schedule settings.
@@ -1155,6 +1411,8 @@ class _SmartFreshnessAssertionInput(_AssertionInput):
                 LAST_MODIFIED_ALLOWED_FIELD_TYPES,
                 "last modified column",
                 models.FreshnessFieldKindClass.LAST_MODIFIED,
+                self._get_schema_field_spec,
+                self._validate_field_type,
             )
         elif isinstance(self.detection_mechanism, _InformationSchema):
             source_type = models.DatasetFreshnessSourceTypeClass.INFORMATION_SCHEMA
@@ -1169,50 +1427,42 @@ class _SmartFreshnessAssertionInput(_AssertionInput):
 
         return source_type, field
 
-    def _create_field_spec(
+    def _create_monitor_info(
         self,
-        column_name: str,
-        allowed_types: list[DictWrapper],  # TODO: Use the type from the PDL
-        field_type_name: str,
-        kind: str,
-    ) -> models.FreshnessFieldSpecClass:
+        assertion_urn: AssertionUrn,
+        status: models.MonitorStatusClass,
+        schedule: models.CronScheduleClass,
+        source_type: Union[str, models.DatasetFreshnessSourceTypeClass],
+        field: Optional[FieldSpecType],
+    ) -> models.MonitorInfoClass:
         """
-        Create a field specification for a column, validating its type.
-
-        Args:
-            column_name: The name of the column to create a spec for
-            allowed_types: List of allowed field types
-            field_type_name: Human-readable name of the field type for error messages
-            kind: The kind of field to create
-
-        Returns:
-            A FreshnessFieldSpecClass for the column
-
-        Raises:
-            SDKUsageError: If the column is not found or has an invalid type
+        Create a MonitorInfoClass with all the necessary components.
         """
-        SUPPORTED_KINDS = [
-            models.FreshnessFieldKindClass.LAST_MODIFIED,
-            models.FreshnessFieldKindClass.HIGH_WATERMARK,
-        ]
-        if kind not in SUPPORTED_KINDS:
-            raise SDKUsageError(
-                msg=f"Invalid kind: {kind}. Must be one of {SUPPORTED_KINDS}",
-            )
-
-        field_spec = self._get_schema_field_spec(column_name)
-        self._validate_field_type(
-            field_spec, column_name, allowed_types, field_type_name
-        )
-        return models.FreshnessFieldSpecClass(
-            path=field_spec.path,
-            type=field_spec.type,
-            nativeType=field_spec.nativeType,
-            kind=kind,
+        return models.MonitorInfoClass(
+            type=models.MonitorTypeClass.ASSERTION,
+            status=status,
+            assertionMonitor=models.AssertionMonitorClass(
+                assertions=[
+                    models.AssertionEvaluationSpecClass(
+                        assertion=str(assertion_urn),
+                        schedule=schedule,
+                        parameters=self._get_assertion_evaluation_parameters(
+                            str(source_type), field
+                        ),
+                    ),
+                ],
+                settings=models.AssertionMonitorSettingsClass(
+                    adjustmentSettings=models.AssertionAdjustmentSettingsClass(
+                        sensitivity=self._convert_sensitivity(),
+                        exclusionWindows=self._convert_exclusion_windows(),
+                        trainingDataLookbackWindowDays=self.training_data_lookback_days,
+                    ),
+                ),
+            ),
         )
 
 
-class _SmartVolumeAssertionInput(_AssertionInput):
+class _SmartVolumeAssertionInput(_AssertionInput, _HasSmartAssertionInputs):
     def __init__(
         self,
         *,
@@ -1237,7 +1487,8 @@ class _SmartVolumeAssertionInput(_AssertionInput):
         updated_by: Union[str, CorpUserUrn],
         updated_at: datetime,
     ):
-        super().__init__(
+        _AssertionInput.__init__(
+            self,
             dataset_urn=dataset_urn,
             entity_client=entity_client,
             urn=urn,
@@ -1245,9 +1496,6 @@ class _SmartVolumeAssertionInput(_AssertionInput):
             enabled=enabled,
             schedule=schedule,
             detection_mechanism=detection_mechanism,
-            sensitivity=sensitivity,
-            exclusion_windows=exclusion_windows,
-            training_data_lookback_days=training_data_lookback_days,
             incident_behavior=incident_behavior,
             tags=tags,
             source_type=models.AssertionSourceTypeClass.INFERRED,  # Smart assertions are of type inferred, not native
@@ -1256,6 +1504,12 @@ class _SmartVolumeAssertionInput(_AssertionInput):
             updated_by=updated_by,
             updated_at=updated_at,
         )
+        _HasSmartAssertionInputs.__init__(
+            self,
+            sensitivity=sensitivity,
+            exclusion_windows=exclusion_windows,
+            training_data_lookback_days=training_data_lookback_days,
+        )
 
     def _create_assertion_info(
         self, filter: Optional[models.DatasetFilterClass]
@@ -1276,15 +1530,13 @@ class _SmartVolumeAssertionInput(_AssertionInput):
         )
 
     def _convert_schedule(self) -> models.CronScheduleClass:
-        """Create a schedule for a smart freshness assertion.
-
-        Since the schedule is not used for smart freshness assertions, we return a default schedule.
+        """Create a schedule for a smart volume assertion.
 
         Returns:
             A CronScheduleClass with appropriate schedule settings.
         """
         if self.schedule is None:
-            return DEFAULT_SCHEDULE
+            return DEFAULT_HOURLY_SCHEDULE
 
         return models.CronScheduleClass(
             cron=self.schedule.cron,
@@ -1333,3 +1585,41 @@ class _SmartVolumeAssertionInput(_AssertionInput):
             )
 
         return source_type, field
+
+    def _create_monitor_info(
+        self,
+        assertion_urn: AssertionUrn,
+        status: models.MonitorStatusClass,
+        schedule: models.CronScheduleClass,
+        source_type: Union[str, models.DatasetFreshnessSourceTypeClass],
+        field: Optional[FieldSpecType],
+    ) -> models.MonitorInfoClass:
+        """
+        Create a MonitorInfoClass with all the necessary components.
+        """
+        return models.MonitorInfoClass(
+            type=models.MonitorTypeClass.ASSERTION,
+            status=status,
+            assertionMonitor=models.AssertionMonitorClass(
+                assertions=[
+                    models.AssertionEvaluationSpecClass(
+                        assertion=str(assertion_urn),
+                        schedule=schedule,
+                        parameters=self._get_assertion_evaluation_parameters(
+                            str(source_type), field
+                        ),
+                    ),
+                ],
+                settings=models.AssertionMonitorSettingsClass(
+                    adjustmentSettings=models.AssertionAdjustmentSettingsClass(
+                        sensitivity=self._convert_sensitivity(),
+                        exclusionWindows=self._convert_exclusion_windows(),
+                        trainingDataLookbackWindowDays=self.training_data_lookback_days,
+                    ),
+                ),
+            ),
+        )
+
+    def _assertion_type(self) -> str:
+        """Get the assertion type."""
+        return models.AssertionTypeClass.VOLUME