acryl-datahub-cloud 0.3.12rc1__py3-none-any.whl → 0.3.12rc4__py3-none-any.whl

acryl_datahub_cloud/{_sdk_extras → sdk}/assertion.py

@@ -10,28 +10,32 @@ import logging
 from abc import ABC, abstractmethod
 from datetime import datetime
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Optional, Union
 
 from typing_extensions import Self
 
-from acryl_datahub_cloud._sdk_extras.assertion_input import (
+from acryl_datahub_cloud.sdk.assertion_input.assertion_input import (
     ASSERTION_MONITOR_DEFAULT_TRAINING_LOOKBACK_WINDOW_DAYS,
     DEFAULT_DETECTION_MECHANISM,
+    DEFAULT_SCHEDULE,
     DEFAULT_SENSITIVITY,
     AssertionIncidentBehavior,
     DetectionMechanism,
     ExclusionWindowTypes,
     FixedRangeExclusionWindow,
     InferenceSensitivity,
+    TimeWindowSizeInputTypes,
     _DetectionMechanismTypes,
 )
-from acryl_datahub_cloud._sdk_extras.entities.assertion import Assertion
-from acryl_datahub_cloud._sdk_extras.entities.monitor import Monitor
-from acryl_datahub_cloud._sdk_extras.errors import SDKNotYetSupportedError
+from acryl_datahub_cloud.sdk.entities.assertion import Assertion
+from acryl_datahub_cloud.sdk.entities.monitor import (
+    Monitor,
+    _get_nested_field_for_entity_with_default,
+)
+from acryl_datahub_cloud.sdk.errors import SDKNotYetSupportedError
 from datahub.emitter.mce_builder import parse_ts_millis
 from datahub.metadata import schema_classes as models
 from datahub.metadata.urns import AssertionUrn, CorpUserUrn, DatasetUrn, TagUrn
-from datahub.sdk.entity import Entity
 
 logger = logging.getLogger(__name__)
 
@@ -48,34 +52,33 @@ class AssertionMode(Enum):
     # PASSIVE = "PASSIVE" # Not supported in the user facing interface.
 
 
-def _get_nested_field_for_entity_with_default(
-    entity: Entity,
-    field_path: str,
-    default: Any = None,
-) -> Any:
+class _HasSchedule:
     """
-    Get a nested field from an Entity object, and warn and return default if not found.
-
-    Args:
-        entity: The entity to get the nested field from.
-        field_path: The path to the nested field.
-        default: The default value to return if the field is not found.
+    Mixin class that provides schedule functionality for assertions.
     """
-    fields = field_path.split(".")
-    current = entity
-    last_valid_path = entity.entity_type_name()
-
-    for field in fields:
-        try:
-            current = getattr(current, field)
-            last_valid_path = f"{last_valid_path}.{field}"
-        except AttributeError:
-            logger.warning(
-                f"{entity.entity_type_name().capitalize()} {entity.urn} does not have an `{last_valid_path}` field, defaulting to {default}"
-            )
-            return default
 
-    return current
+    def __init__(self, schedule: models.CronScheduleClass) -> None:
+        self._schedule = schedule
+
+    @property
+    def schedule(self) -> models.CronScheduleClass:
+        return self._schedule
+
+    @staticmethod
+    def _get_schedule(monitor: Monitor) -> models.CronScheduleClass:
+        """Get the schedule from the monitor."""
+        assertion_evaluation_specs = _get_nested_field_for_entity_with_default(
+            monitor,
+            "info.assertionMonitor.assertions",
+            [],
+        )
+        if len(assertion_evaluation_specs) == 0:
+            return DEFAULT_SCHEDULE
+        assertion_evaluation_spec = assertion_evaluation_specs[0]
+        schedule = assertion_evaluation_spec.schedule
+        if schedule is None:
+            return DEFAULT_SCHEDULE
+        return schedule
 
 
 class _HasSmartFunctionality:
@@ -89,10 +92,6 @@ class _HasSmartFunctionality:
         sensitivity: InferenceSensitivity = DEFAULT_SENSITIVITY,
         exclusion_windows: list[ExclusionWindowTypes],
         training_data_lookback_days: int = ASSERTION_MONITOR_DEFAULT_TRAINING_LOOKBACK_WINDOW_DAYS,
-        incident_behavior: list[AssertionIncidentBehavior],
-        detection_mechanism: Optional[
-            _DetectionMechanismTypes
-        ] = DEFAULT_DETECTION_MECHANISM,
     ) -> None:
         """
         Initialize the smart functionality mixin.
@@ -108,8 +107,6 @@ class _HasSmartFunctionality:
         self._sensitivity = sensitivity
         self._exclusion_windows = exclusion_windows
         self._training_data_lookback_days = training_data_lookback_days
-        self._incident_behavior = incident_behavior
-        self._detection_mechanism = detection_mechanism
 
     @property
     def sensitivity(self) -> InferenceSensitivity:
@@ -123,14 +120,6 @@ class _HasSmartFunctionality:
     def training_data_lookback_days(self) -> int:
         return self._training_data_lookback_days
 
-    @property
-    def incident_behavior(self) -> list[AssertionIncidentBehavior]:
-        return self._incident_behavior
-
-    @property
-    def detection_mechanism(self) -> Optional[_DetectionMechanismTypes]:
-        return self._detection_mechanism
-
     @staticmethod
     def _get_sensitivity(monitor: Monitor) -> InferenceSensitivity:
         # 1. Check if the monitor has a sensitivity field
@@ -179,6 +168,115 @@ class _HasSmartFunctionality:
         assert isinstance(retrieved, int)
         return retrieved
 
+
+class _AssertionPublic(ABC):
+    """
+    Abstract base class that represents a public facing assertion and contains the common properties of all assertions.
+    """
+
+    _SUPPORTED_WITH_FILTER_ASSERTION_TYPES = (
+        models.FreshnessAssertionInfoClass,
+        models.VolumeAssertionInfoClass,
+    )
+
+    def __init__(
+        self,
+        *,
+        urn: AssertionUrn,
+        dataset_urn: DatasetUrn,
+        display_name: str,
+        mode: AssertionMode,
+        tags: list[TagUrn],
+        incident_behavior: list[AssertionIncidentBehavior],
+        detection_mechanism: Optional[
+            _DetectionMechanismTypes
+        ] = DEFAULT_DETECTION_MECHANISM,
+        created_by: Optional[CorpUserUrn] = None,
+        created_at: Union[datetime, None] = None,
+        updated_by: Optional[CorpUserUrn] = None,
+        updated_at: Optional[datetime] = None,
+    ):
+        """
+        Initialize the public facing assertion class.
+
+        Args:
+            urn: The urn of the assertion.
+            dataset_urn: The urn of the dataset that the assertion is for.
+            display_name: The display name of the assertion.
+            mode: The mode of the assertion (active, inactive).
+            tags: The tags of the assertion.
+            created_by: The urn of the user that created the assertion.
+            created_at: The timestamp of when the assertion was created.
+            updated_by: The urn of the user that updated the assertion.
+            updated_at: The timestamp of when the assertion was updated.
+        """
+        self._urn = urn
+        self._dataset_urn = dataset_urn
+        self._display_name = display_name
+        self._mode = mode
+        self._incident_behavior = incident_behavior
+        self._detection_mechanism = detection_mechanism
+        self._created_by = created_by
+        self._created_at = created_at
+        self._updated_by = updated_by
+        self._updated_at = updated_at
+        self._tags = tags
+
+    @property
+    def urn(self) -> AssertionUrn:
+        return self._urn
+
+    @property
+    def dataset_urn(self) -> DatasetUrn:
+        return self._dataset_urn
+
+    @property
+    def display_name(self) -> str:
+        return self._display_name
+
+    @property
+    def mode(self) -> AssertionMode:
+        return self._mode
+
+    @property
+    def incident_behavior(self) -> list[AssertionIncidentBehavior]:
+        return self._incident_behavior
+
+    @property
+    def detection_mechanism(self) -> Optional[_DetectionMechanismTypes]:
+        return self._detection_mechanism
+
+    @property
+    def created_by(self) -> Optional[CorpUserUrn]:
+        return self._created_by
+
+    @property
+    def created_at(self) -> Union[datetime, None]:
+        return self._created_at
+
+    @property
+    def updated_by(self) -> Optional[CorpUserUrn]:
+        return self._updated_by
+
+    @property
+    def updated_at(self) -> Union[datetime, None]:
+        return self._updated_at
+
+    @property
+    def tags(self) -> list[TagUrn]:
+        return self._tags
+
+    @staticmethod
+    def _get_incident_behavior(assertion: Assertion) -> list[AssertionIncidentBehavior]:
+        incident_behaviors = []
+        for action in assertion.on_failure + assertion.on_success:
+            if action.type == models.AssertionActionTypeClass.RAISE_INCIDENT:
+                incident_behaviors.append(AssertionIncidentBehavior.RAISE_ON_FAIL)
+            elif action.type == models.AssertionActionTypeClass.RESOLVE_INCIDENT:
+                incident_behaviors.append(AssertionIncidentBehavior.RESOLVE_ON_PASS)
+
+        return incident_behaviors
+
     @staticmethod
     def _get_detection_mechanism(
         assertion: Assertion,
@@ -186,7 +284,7 @@ class _HasSmartFunctionality:
         default: Optional[_DetectionMechanismTypes] = DEFAULT_DETECTION_MECHANISM,
     ) -> Optional[_DetectionMechanismTypes]:
         """Get the detection mechanism from the monitor and assertion."""
-        if not _HasSmartFunctionality._has_valid_monitor_info(monitor):
+        if not _AssertionPublic._has_valid_monitor_info(monitor):
             return default
 
         # 1. Check if the assertion has a parameters field
@@ -199,70 +297,35 @@ class _HasSmartFunctionality:
             )
             return default
 
-        parameters = _HasSmartFunctionality._get_assertion_parameters(monitor, default)
+        parameters = _AssertionPublic._get_assertion_parameters(monitor, default)
         if parameters is None:
             return _warn_and_return_default_detection_mechanism("parameters", default)
 
         # 2. Convert the raw detection mechanism to the SDK detection mechanism
-        if (
-            parameters.type
-            == models.AssertionEvaluationParametersTypeClass.DATASET_FRESHNESS
-        ):
-            # TODO: Add support for other detection mechanisms when other assertion types are supported
-            return _HasSmartFunctionality._get_freshness_detection_mechanism(
-                assertion, parameters, default
-            )
+        if parameters.type in [
+            models.AssertionEvaluationParametersTypeClass.DATASET_FRESHNESS,
+            models.AssertionEvaluationParametersTypeClass.DATASET_VOLUME,
+        ]:
+            if assertion.info is None:
+                return _warn_and_return_default_detection_mechanism("info", default)
+            if isinstance(assertion.info, models.VolumeAssertionInfoClass):
+                return _AssertionPublic._get_volume_detection_mechanism(
+                    assertion, parameters, default
+                )
+            elif isinstance(assertion.info, models.FreshnessAssertionInfoClass):
+                return _AssertionPublic._get_freshness_detection_mechanism(
+                    assertion, parameters, default
+                )
+            # TODO: Consider moving the detection mechanism logic to the assertion classes themselves e.g. _get_assertion_specific_detection_mechanism as an abstract method
+            # TODO: Add support here for other detection mechanisms when other assertion types are supported
+            else:
+                raise SDKNotYetSupportedError(
+                    f"AssertionType {type(assertion.info).__name__}"
+                )
         else:
             raise SDKNotYetSupportedError(
-                f"AssertionEvaluationParametersType {parameters.type}"
-            )
-
-    @staticmethod
-    def _has_valid_monitor_info(monitor: Monitor) -> bool:
-        """Check if monitor has valid info and assertion monitor."""
-
-        def _warn_and_return_false(field_name: str) -> bool:
-            logger.warning(
-                f"Monitor {monitor.urn} does not have an `{field_name}` field, defaulting detection mechanism to {DEFAULT_DETECTION_MECHANISM}"
-            )
-            return False
-
-        if monitor.info is None:
-            return _warn_and_return_false("info")
-        if monitor.info.assertionMonitor is None:
-            return _warn_and_return_false("assertionMonitor")
-        if (
-            monitor.info.assertionMonitor.assertions is None
-            or len(monitor.info.assertionMonitor.assertions) == 0
-        ):
-            return _warn_and_return_false("assertionMonitor.assertions")
-
-        return True
-
-    @staticmethod
-    def _get_assertion_parameters(
-        monitor: Monitor,
-        default: Optional[_DetectionMechanismTypes] = DEFAULT_DETECTION_MECHANISM,
-    ) -> Optional[models.AssertionEvaluationParametersClass]:
-        """Get the assertion parameters from the monitor."""
-        # We know these are not None from _has_valid_monitor_info check
-        assert (
-            monitor is not None
-            and monitor.info is not None
-            and monitor.info.assertionMonitor is not None
-        )
-        assertion_monitor = monitor.info.assertionMonitor
-        assert (
-            assertion_monitor is not None and assertion_monitor.assertions is not None
-        )
-        assertions = assertion_monitor.assertions
-
-        if assertions[0].parameters is None:
-            logger.warning(
-                f"Monitor {monitor.urn} does not have a assertionMonitor.assertions[0].parameters, defaulting detection mechanism to {default}"
+                f"AssertionEvaluationParametersType {parameters.type} not supported"
             )
-            return None
-        return assertions[0].parameters
 
     @staticmethod
     def _get_freshness_detection_mechanism(
@@ -283,7 +346,7 @@ class _HasSmartFunctionality:
         elif source_type == models.DatasetFreshnessSourceTypeClass.AUDIT_LOG:
             return DetectionMechanism.AUDIT_LOG
         elif source_type == models.DatasetFreshnessSourceTypeClass.FIELD_VALUE:
-            return _HasSmartFunctionality._get_field_value_detection_mechanism(
+            return _AssertionPublic._get_field_value_detection_mechanism(
                 assertion, parameters
             )
         elif source_type == models.DatasetFreshnessSourceTypeClass.DATAHUB_OPERATION:
@@ -293,6 +356,33 @@ class _HasSmartFunctionality:
         else:
             raise SDKNotYetSupportedError(f"DatasetFreshnessSourceType {source_type}")
 
+    @staticmethod
+    def _get_volume_detection_mechanism(
+        assertion: Assertion,
+        parameters: models.AssertionEvaluationParametersClass,
+        default: Optional[_DetectionMechanismTypes] = DEFAULT_DETECTION_MECHANISM,
+    ) -> _DetectionMechanismTypes:
+        """Get the detection mechanism for volume assertions."""
+        if parameters.datasetVolumeParameters is None:
+            logger.warning(
+                f"Monitor does not have datasetVolumeParameters, defaulting detection mechanism to {DEFAULT_DETECTION_MECHANISM}"
+            )
+            if default is None:
+                return DEFAULT_DETECTION_MECHANISM
+            else:
+                return default
+
+        source_type = parameters.datasetVolumeParameters.sourceType
+        if source_type == models.DatasetVolumeSourceTypeClass.INFORMATION_SCHEMA:
+            return DetectionMechanism.INFORMATION_SCHEMA
+        elif source_type == models.DatasetVolumeSourceTypeClass.QUERY:
+            additional_filter = _AssertionPublic._get_additional_filter(assertion)
+            return DetectionMechanism.QUERY(additional_filter=additional_filter)
+        elif source_type == models.DatasetVolumeSourceTypeClass.DATAHUB_DATASET_PROFILE:
+            return DetectionMechanism.DATASET_PROFILE
+        else:
+            raise SDKNotYetSupportedError(f"DatasetVolumeSourceType {source_type}")
+
     @staticmethod
     def _get_field_value_detection_mechanism(
         assertion: Assertion,
@@ -310,7 +400,7 @@ class _HasSmartFunctionality:
             return DEFAULT_DETECTION_MECHANISM
 
         column_name = field.path
-        additional_filter = _HasSmartFunctionality._get_additional_filter(assertion)
+        additional_filter = _AssertionPublic._get_additional_filter(assertion)
 
         if field.kind == models.FreshnessFieldKindClass.LAST_MODIFIED:
             return DetectionMechanism.LAST_MODIFIED_COLUMN(
@@ -332,7 +422,10 @@ class _HasSmartFunctionality:
             )
             return None
         if (
-            not isinstance(assertion.info, models.FreshnessAssertionInfoClass)
+            not isinstance(
+                assertion.info,
+                _AssertionPublic._SUPPORTED_WITH_FILTER_ASSERTION_TYPES,
+            )
             or assertion.info.filter is None
         ):
             logger.warning(
@@ -345,95 +438,52 @@ class _HasSmartFunctionality:
             )
         return assertion.info.filter.sql
 
+    @staticmethod
+    def _has_valid_monitor_info(monitor: Monitor) -> bool:
+        """Check if monitor has valid info and assertion monitor."""
 
-class _AssertionPublic(ABC):
-    """
-    Abstract base class that represents a public facing assertion and contains the common properties of all assertions.
-    """
+        def _warn_and_return_false(field_name: str) -> bool:
+            logger.warning(
+                f"Monitor {monitor.urn} does not have an `{field_name}` field, defaulting detection mechanism to {DEFAULT_DETECTION_MECHANISM}"
+            )
+            return False
 
-    def __init__(
-        self,
-        *,
-        urn: AssertionUrn,
-        dataset_urn: DatasetUrn,
-        display_name: str,
-        mode: AssertionMode,
-        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 the public facing assertion class.
+        if monitor.info is None:
+            return _warn_and_return_false("info")
+        if monitor.info.assertionMonitor is None:
+            return _warn_and_return_false("assertionMonitor")
+        if (
+            monitor.info.assertionMonitor.assertions is None
+            or len(monitor.info.assertionMonitor.assertions) == 0
+        ):
+            return _warn_and_return_false("assertionMonitor.assertions")
 
-        Args:
-            urn: The urn of the assertion.
-            dataset_urn: The urn of the dataset that the assertion is for.
-            display_name: The display name of the assertion.
-            mode: The mode of the assertion (active, inactive).
-            tags: The tags of the assertion.
-            created_by: The urn of the user that created the assertion.
-            created_at: The timestamp of when the assertion was created.
-            updated_by: The urn of the user that updated the assertion.
-            updated_at: The timestamp of when the assertion was updated.
-        """
-        self._urn = urn
-        self._dataset_urn = dataset_urn
-        self._display_name = display_name
-        self._mode = mode
-        self._created_by = created_by
-        self._created_at = created_at
-        self._updated_by = updated_by
-        self._updated_at = updated_at
-        self._tags = tags
-
-    @property
-    def urn(self) -> AssertionUrn:
-        return self._urn
-
-    @property
-    def dataset_urn(self) -> DatasetUrn:
-        return self._dataset_urn
-
-    @property
-    def display_name(self) -> str:
-        return self._display_name
-
-    @property
-    def mode(self) -> AssertionMode:
-        return self._mode
-
-    @property
-    def created_by(self) -> Optional[CorpUserUrn]:
-        return self._created_by
-
-    @property
-    def created_at(self) -> Union[datetime, None]:
-        return self._created_at
-
-    @property
-    def updated_by(self) -> Optional[CorpUserUrn]:
-        return self._updated_by
-
-    @property
-    def updated_at(self) -> Union[datetime, None]:
-        return self._updated_at
-
-    @property
-    def tags(self) -> list[TagUrn]:
-        return self._tags
+        return True
 
     @staticmethod
-    def _get_incident_behavior(assertion: Assertion) -> list[AssertionIncidentBehavior]:
-        incident_behaviors = []
-        for action in assertion.on_failure + assertion.on_success:
-            if action.type == models.AssertionActionTypeClass.RAISE_INCIDENT:
-                incident_behaviors.append(AssertionIncidentBehavior.RAISE_ON_FAIL)
-            elif action.type == models.AssertionActionTypeClass.RESOLVE_INCIDENT:
-                incident_behaviors.append(AssertionIncidentBehavior.RESOLVE_ON_PASS)
+    def _get_assertion_parameters(
+        monitor: Monitor,
+        default: Optional[_DetectionMechanismTypes] = DEFAULT_DETECTION_MECHANISM,
+    ) -> Optional[models.AssertionEvaluationParametersClass]:
+        """Get the assertion parameters from the monitor."""
+        # We know these are not None from _has_valid_monitor_info check
+        assert (
+            monitor is not None
+            and monitor.info is not None
+            and monitor.info.assertionMonitor is not None
+        )
+        assertion_monitor = monitor.info.assertionMonitor
+        assert (
+            assertion_monitor is not None and assertion_monitor.assertions is not None
+        )
+        assertions = assertion_monitor.assertions
 
-        return incident_behaviors
+        if assertions[0].parameters is None:
+            logger.warning(
+                f"Monitor {monitor.urn} does not have a assertionMonitor.assertions[0].parameters, defaulting detection mechanism to {default}"
+            )
+            return None
+        return assertions[0].parameters
 
     @staticmethod
     def _get_created_by(assertion: Assertion) -> Optional[CorpUserUrn]:
@@ -500,19 +550,22 @@ class _AssertionPublic(ABC):
             return AssertionMode.INACTIVE
         return AssertionMode(monitor.info.status.mode)
 
+    @classmethod
     @abstractmethod
-    def from_entities(
+    def _from_entities(
         cls,
         assertion: Assertion,
         monitor: Monitor,
     ) -> Self:
         """
         Create an assertion from the assertion and monitor entities.
+
+        Note: This is a private method since it is intended to be called internally by the client.
         """
         pass
 
 
-class SmartFreshnessAssertion(_HasSmartFunctionality, _AssertionPublic):
+class SmartFreshnessAssertion(_HasSchedule, _HasSmartFunctionality, _AssertionPublic):
     """
     A class that represents a smart freshness assertion.
     """
@@ -524,6 +577,7 @@ class SmartFreshnessAssertion(_HasSmartFunctionality, _AssertionPublic):
         dataset_urn: DatasetUrn,
         display_name: str,
         mode: AssertionMode,
+        schedule: models.CronScheduleClass = DEFAULT_SCHEDULE,
         sensitivity: InferenceSensitivity = DEFAULT_SENSITIVITY,
         exclusion_windows: list[ExclusionWindowTypes],
         training_data_lookback_days: int = ASSERTION_MONITOR_DEFAULT_TRAINING_LOOKBACK_WINDOW_DAYS,
@@ -547,6 +601,7 @@ class SmartFreshnessAssertion(_HasSmartFunctionality, _AssertionPublic):
             dataset_urn: The urn of the dataset that the assertion is for.
             display_name: The display name of the assertion.
             mode: The mode of the assertion (active, inactive).
+            schedule: The schedule of the assertion.
             sensitivity: The sensitivity of the assertion (low, medium, high).
             exclusion_windows: The exclusion windows of the assertion.
             training_data_lookback_days: The max number of days of data to use for training the assertion.
@@ -558,14 +613,111 @@ class SmartFreshnessAssertion(_HasSmartFunctionality, _AssertionPublic):
             updated_by: The urn of the user that updated the assertion.
             updated_at: The timestamp of when the assertion was updated.
         """
-        # Initialize the mixin first
+        # Initialize the mixins first
+        _HasSchedule.__init__(self, schedule=schedule)
         _HasSmartFunctionality.__init__(
             self,
             sensitivity=sensitivity,
             exclusion_windows=exclusion_windows,
             training_data_lookback_days=training_data_lookback_days,
+        )
+        # Then initialize the parent class
+        _AssertionPublic.__init__(
+            self,
+            urn=urn,
+            dataset_urn=dataset_urn,
+            display_name=display_name,
+            mode=mode,
             incident_behavior=incident_behavior,
             detection_mechanism=detection_mechanism,
+            created_by=created_by,
+            created_at=created_at,
+            updated_by=updated_by,
+            updated_at=updated_at,
+            tags=tags,
+        )
+
+    @classmethod
+    def _from_entities(cls, assertion: Assertion, monitor: Monitor) -> Self:
+        """
+        Create a smart freshness assertion from the assertion and monitor entities.
+
+        Note: This is a private method since it is intended to be called internally by the client.
+        """
+        return cls(
+            urn=assertion.urn,
+            dataset_urn=assertion.dataset,
+            display_name=assertion.description or "",
+            mode=cls._get_mode(monitor),
+            schedule=cls._get_schedule(monitor),
+            sensitivity=cls._get_sensitivity(monitor),
+            exclusion_windows=cls._get_exclusion_windows(monitor),
+            training_data_lookback_days=cls._get_training_data_lookback_days(monitor),
+            incident_behavior=cls._get_incident_behavior(assertion),
+            detection_mechanism=cls._get_detection_mechanism(assertion, monitor),
+            created_by=cls._get_created_by(assertion),
+            created_at=cls._get_created_at(assertion),
+            updated_by=cls._get_updated_by(assertion),
+            updated_at=cls._get_updated_at(assertion),
+            tags=cls._get_tags(assertion),
+        )
+
+
+class SmartVolumeAssertion(_HasSchedule, _HasSmartFunctionality, _AssertionPublic):
+    """
+    A class that represents a smart volume assertion.
+    """
+
+    def __init__(
+        self,
+        *,
+        urn: AssertionUrn,
+        dataset_urn: DatasetUrn,
+        display_name: str,
+        mode: AssertionMode,
+        schedule: models.CronScheduleClass,
+        sensitivity: InferenceSensitivity = DEFAULT_SENSITIVITY,
+        exclusion_windows: list[ExclusionWindowTypes],
+        training_data_lookback_days: int = ASSERTION_MONITOR_DEFAULT_TRAINING_LOOKBACK_WINDOW_DAYS,
+        incident_behavior: list[AssertionIncidentBehavior],
+        detection_mechanism: Optional[
+            _DetectionMechanismTypes
+        ] = DEFAULT_DETECTION_MECHANISM,
+        tags: list[TagUrn],
+        created_by: Optional[CorpUserUrn] = None,
+        created_at: Union[datetime, None] = None,
+        updated_by: Optional[CorpUserUrn] = None,
+        updated_at: Optional[datetime] = None,
+    ):
+        """
+        Initialize a smart volume assertion.
+
+        Note: Values can be accessed, but not set on the assertion object.
+        To update an assertion, use the `upsert_*` method.
+        Args:
+            urn: The urn of the assertion.
+            dataset_urn: The urn of the dataset that the assertion is for.
+            display_name: The display name of the assertion.
+            mode: The mode of the assertion (active, inactive).
+            schedule: The schedule of the assertion.
+            sensitivity: The sensitivity of the assertion (low, medium, high).
+            exclusion_windows: The exclusion windows of the assertion.
+            training_data_lookback_days: The max number of days of data to use for training the assertion.
+            incident_behavior: Whether to raise or resolve an incident when the assertion fails / passes.
+            detection_mechanism: The detection mechanism of the assertion.
+            tags: The tags applied to the assertion.
+            created_by: The urn of the user that created the assertion.
+            created_at: The timestamp of when the assertion was created.
+            updated_by: The urn of the user that updated the assertion.
+            updated_at: The timestamp of when the assertion was updated.
+        """
+        # Initialize the mixins first
+        _HasSchedule.__init__(self, schedule=schedule)
+        _HasSmartFunctionality.__init__(
+            self,
+            sensitivity=sensitivity,
+            exclusion_windows=exclusion_windows,
+            training_data_lookback_days=training_data_lookback_days,
         )
         # Then initialize the parent class
         _AssertionPublic.__init__(
@@ -574,6 +726,8 @@ class SmartFreshnessAssertion(_HasSmartFunctionality, _AssertionPublic):
             dataset_urn=dataset_urn,
             display_name=display_name,
             mode=mode,
+            incident_behavior=incident_behavior,
+            detection_mechanism=detection_mechanism,
             created_by=created_by,
             created_at=created_at,
             updated_by=updated_by,
@@ -582,15 +736,18 @@ class SmartFreshnessAssertion(_HasSmartFunctionality, _AssertionPublic):
         )
 
     @classmethod
-    def from_entities(cls, assertion: Assertion, monitor: Monitor) -> Self:
+    def _from_entities(cls, assertion: Assertion, monitor: Monitor) -> Self:
         """
         Create a smart freshness assertion from the assertion and monitor entities.
+
+        Note: This is a private method since it is intended to be called internally by the client.
         """
         return cls(
             urn=assertion.urn,
             dataset_urn=assertion.dataset,
             display_name=assertion.description or "",
             mode=cls._get_mode(monitor),
+            schedule=cls._get_schedule(monitor),
             sensitivity=cls._get_sensitivity(monitor),
             exclusion_windows=cls._get_exclusion_windows(monitor),
             training_data_lookback_days=cls._get_training_data_lookback_days(monitor),
@@ -604,7 +761,158 @@ class SmartFreshnessAssertion(_HasSmartFunctionality, _AssertionPublic):
         )
 
 
+class FreshnessAssertion(_HasSchedule, _AssertionPublic):
+    """
+    A class that represents a freshness assertion.
+    """
+
+    def __init__(
+        self,
+        *,
+        urn: AssertionUrn,
+        dataset_urn: DatasetUrn,
+        display_name: str,
+        mode: AssertionMode,
+        schedule: models.CronScheduleClass,
+        freshness_schedule_check_type: Union[
+            str, models.FreshnessAssertionScheduleTypeClass
+        ],
+        lookback_window: Optional[TimeWindowSizeInputTypes],
+        tags: list[TagUrn],
+        incident_behavior: list[AssertionIncidentBehavior],
+        detection_mechanism: Optional[
+            _DetectionMechanismTypes
+        ] = DEFAULT_DETECTION_MECHANISM,
+        created_by: Optional[CorpUserUrn] = None,
+        created_at: Union[datetime, None] = None,
+        updated_by: Optional[CorpUserUrn] = None,
+        updated_at: Optional[datetime] = None,
+    ):
+        """
+        Initialize a freshness assertion.
+
+        Note: Values can be accessed, but not set on the assertion object.
+        To update an assertion, use the `upsert_*` method.
+        Args:
+            urn: The urn of the assertion.
+            dataset_urn: The urn of the dataset that the assertion is for.
+            display_name: The display name of the assertion.
+            mode: The mode of the assertion (active, inactive).
+            schedule: The schedule of the assertion.
+            freshness_schedule_check_type: The type of freshness schedule check to be used for the assertion.
+            lookback_window: The lookback window to be used for the assertion.
+            tags: The tags applied to the assertion.
+            incident_behavior: Whether to raise or resolve an incident when the assertion fails / passes.
+            detection_mechanism: The detection mechanism of the assertion.
+            created_by: The urn of the user that created the assertion.
+            created_at: The timestamp of when the assertion was created.
+            updated_by: The urn of the user that updated the assertion.
+            updated_at: The timestamp of when the assertion was updated.
+        """
+        _HasSchedule.__init__(self, schedule=schedule)
+        _AssertionPublic.__init__(
+            self,
+            urn=urn,
+            dataset_urn=dataset_urn,
+            display_name=display_name,
+            mode=mode,
+            incident_behavior=incident_behavior,
+            detection_mechanism=detection_mechanism,
+            created_by=created_by,
+            created_at=created_at,
+            updated_by=updated_by,
+            updated_at=updated_at,
+            tags=tags,
+        )
+        self._freshness_schedule_check_type = freshness_schedule_check_type
+        self._lookback_window = lookback_window
+
+    @property
+    def freshness_schedule_check_type(
+        self,
+    ) -> Union[str, models.FreshnessAssertionScheduleTypeClass]:
+        return self._freshness_schedule_check_type
+
+    @property
+    def lookback_window(self) -> Optional[TimeWindowSizeInputTypes]:
+        return self._lookback_window
+
+    @staticmethod
+    def _get_freshness_schedule_check_type(
+        assertion: Assertion,
+    ) -> Union[str, models.FreshnessAssertionScheduleTypeClass]:
+        if assertion.info is None:
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} does not have a freshness assertion info, which is not supported"
+            )
+        if isinstance(assertion.info, models.FreshnessAssertionInfoClass):
+            if assertion.info.schedule is None:
+                raise SDKNotYetSupportedError(
+                    f"Traditional freshness assertion {assertion.urn} does not have a schedule, which is not supported"
+                )
+            return assertion.info.schedule.type
+        else:
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} is not a freshness assertion"
+            )
+
+    @staticmethod
+    def _get_lookback_window(
+        assertion: Assertion,
+    ) -> Optional[models.FixedIntervalScheduleClass]:
+        if assertion.info is None:
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} does not have a freshness assertion info, which is not supported"
+            )
+        if isinstance(assertion.info, models.FreshnessAssertionInfoClass):
+            if assertion.info.schedule is None:
+                raise SDKNotYetSupportedError(
+                    f"Traditional freshness assertion {assertion.urn} does not have a schedule, which is not supported"
+                )
+            return assertion.info.schedule.fixedInterval
+        else:
+            raise SDKNotYetSupportedError(
+                f"Assertion {assertion.urn} is not a freshness assertion"
+            )
+
+    @classmethod
+    def _from_entities(cls, assertion: Assertion, monitor: Monitor) -> Self:
+        """
+        Create a freshness assertion from the assertion and monitor entities.
+        """
+        return cls(
+            urn=assertion.urn,
+            dataset_urn=assertion.dataset,
+            display_name=assertion.description or "",
+            mode=cls._get_mode(monitor),
+            schedule=cls._get_schedule(monitor),
+            freshness_schedule_check_type=cls._get_freshness_schedule_check_type(
+                assertion
+            ),
+            lookback_window=cls._get_lookback_window(assertion),
+            incident_behavior=cls._get_incident_behavior(assertion),
+            detection_mechanism=cls._get_detection_mechanism(assertion, monitor),
+            created_by=cls._get_created_by(assertion),
+            created_at=cls._get_created_at(assertion),
+            updated_by=cls._get_updated_by(assertion),
+            updated_at=cls._get_updated_at(assertion),
+            tags=cls._get_tags(assertion),
+        )
+
+
+class SmartColumnMetricAssertion(_HasSmartFunctionality, _AssertionPublic):
+    """
+    A class that represents a smart column metric assertion.
+    """
+
+    def __init__(self) -> None:
+        raise NotImplementedError("SmartColumnMetricAssertion is not implemented yet")
+
+
 AssertionTypes = Union[
     SmartFreshnessAssertion,
+    SmartVolumeAssertion,
+    FreshnessAssertion,
+    SmartColumnMetricAssertion,
     # TODO: Add other assertion types here as we add them.
 ]