pointblank 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

pointblank/validate.py

@@ -3699,6 +3699,10 @@ class _ValidationInfo:
         The time the validation step was processed. This is in the ISO 8601 format in UTC time.
     proc_duration_s
         The duration of processing for the validation step in seconds.
+    notes
+        An ordered dictionary of notes/footnotes associated with the validation step. Each entry
+        contains both 'markdown' and 'text' versions of the note content. The dictionary preserves
+        insertion order, ensuring notes appear in a consistent sequence in reports and logs.
     """
 
     # Validation plan
@@ -3736,10 +3740,183 @@ class _ValidationInfo:
     val_info: dict[str, any] | None = None
     time_processed: str | None = None
     proc_duration_s: float | None = None
+    notes: dict[str, dict[str, str]] | None = None
 
     def get_val_info(self) -> dict[str, any]:
         return self.val_info
 
+    def _add_note(self, key: str, markdown: str, text: str | None = None) -> None:
+        """
+        Add a note/footnote to the validation step.
+
+        This internal method adds a note entry to the validation step's notes dictionary.
+        Notes are displayed as footnotes in validation reports and included in log output.
+
+        Parameters
+        ----------
+        key
+            A unique identifier for the note. If a note with this key already exists, it will
+            be overwritten.
+        markdown
+            The note content formatted with Markdown. This version is used for display in
+            HTML reports and other rich text formats.
+        text
+            The note content as plain text. This version is used for log files and text-based
+            output. If not provided, the markdown version will be used (with markdown formatting
+            intact).
+
+        Examples
+        --------
+        ```python
+        # Add a note about evaluation failure
+        validation_info._add_note(
+            key="eval_error",
+            markdown="Column expression evaluation **failed**",
+            text="Column expression evaluation failed"
+        )
+
+        # Add a note about LLM response
+        validation_info._add_note(
+            key="llm_response",
+            markdown="LLM validation returned `200` passing rows",
+            text="LLM validation returned 200 passing rows"
+        )
+        ```
+        """
+        # Initialize notes dictionary if it doesn't exist
+        if self.notes is None:
+            self.notes = {}
+
+        # Use markdown as text if text is not provided
+        if text is None:
+            text = markdown
+
+        # Add the note entry
+        self.notes[key] = {"markdown": markdown, "text": text}
+
+    def _get_notes(self, format: str = "dict") -> dict[str, dict[str, str]] | list[str] | None:
+        """
+        Get notes associated with this validation step.
+
+        Parameters
+        ----------
+        format
+            The format to return notes in:
+            - `"dict"`: Returns the full notes dictionary (default)
+            - `"markdown"`: Returns a list of markdown-formatted note values
+            - `"text"`: Returns a list of plain text note values
+            - `"keys"`: Returns a list of note keys
+
+        Returns
+        -------
+        dict, list, or None
+            The notes in the requested format, or `None` if no notes exist.
+
+        Examples
+        --------
+        ```python
+        # Get all notes as dictionary
+        notes = validation_info._get_notes()
+        # Returns: {'key1': {'markdown': '...', 'text': '...'}, ...}
+
+        # Get just markdown versions
+        markdown_notes = validation_info._get_notes(format="markdown")
+        # Returns: ['First note with **emphasis**', 'Second note']
+
+        # Get just plain text versions
+        text_notes = validation_info._get_notes(format="text")
+        # Returns: ['First note with emphasis', 'Second note']
+
+        # Get just the keys
+        keys = validation_info._get_notes(format="keys")
+        # Returns: ['key1', 'key2']
+        ```
+        """
+        if self.notes is None:
+            return None
+
+        if format == "dict":
+            return self.notes
+        elif format == "markdown":
+            return [note["markdown"] for note in self.notes.values()]
+        elif format == "text":
+            return [note["text"] for note in self.notes.values()]
+        elif format == "keys":
+            return list(self.notes.keys())
+        else:
+            raise ValueError(
+                f"Invalid format '{format}'. Must be one of: 'dict', 'markdown', 'text', 'keys'"
+            )
+
+    def _get_note(self, key: str, format: str = "dict") -> dict[str, str] | str | None:
+        """
+        Get a specific note by its key.
+
+        Parameters
+        ----------
+        key
+            The unique identifier of the note to retrieve.
+        format
+            The format to return the note in:
+            - `"dict"`: Returns `{'markdown': '...', 'text': '...'}` (default)
+            - `"markdown"`: Returns just the markdown string
+            - `"text"`: Returns just the plain text string
+
+        Returns
+        -------
+        dict, str, or None
+            The note in the requested format, or `None` if the note doesn't exist.
+
+        Examples
+        --------
+        ```python
+        # Get a specific note as dictionary
+        note = validation_info._get_note("threshold_info")
+        # Returns: {'markdown': 'Using **default** thresholds', 'text': '...'}
+
+        # Get just the markdown version
+        markdown = validation_info._get_note("threshold_info", format="markdown")
+        # Returns: 'Using **default** thresholds'
+
+        # Get just the text version
+        text = validation_info._get_note("threshold_info", format="text")
+        # Returns: 'Using default thresholds'
+        ```
+        """
+        if self.notes is None or key not in self.notes:
+            return None
+
+        note = self.notes[key]
+
+        if format == "dict":
+            return note
+        elif format == "markdown":
+            return note["markdown"]
+        elif format == "text":
+            return note["text"]
+        else:
+            raise ValueError(
+                f"Invalid format '{format}'. Must be one of: 'dict', 'markdown', 'text'"
+            )
+
+    def _has_notes(self) -> bool:
+        """
+        Check if this validation step has any notes.
+
+        Returns
+        -------
+        bool
+            `True` if the validation step has notes, `False` otherwise.
+
+        Examples
+        --------
+        ```python
+        if validation_info._has_notes():
+            print("This step has notes")
+        ```
+        """
+        return self.notes is not None and len(self.notes) > 0
+
 
 def connect_to_table(connection_string: str) -> Any:
     """
@@ -7718,9 +7895,12 @@ class Validate:
 
         return self
 
-    def col_vals_null(
+    def col_vals_increasing(
         self,
         columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        allow_stationary: bool = False,
+        decreasing_tol: float | None = None,
+        na_pass: bool = False,
         pre: Callable | None = None,
         segments: SegmentSpec | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
@@ -7729,11 +7909,14 @@ class Validate:
         active: bool = True,
     ) -> Validate:
         """
-        Validate whether values in a column are Null.
+        Are column data increasing by row?
 
-        The `col_vals_null()` validation method checks whether column values in a table are Null.
-        This validation will operate over the number of test units that is equal to the number
-        of rows in the table.
+        The `col_vals_increasing()` validation method checks whether column values in a table are
+        increasing when moving down a table. There are options for allowing missing values in the
+        target column, allowing stationary phases (where consecutive values don't change), and even
+        one for allowing decreasing movements up to a certain threshold. This validation will
+        operate over the number of test units that is equal to the number of rows in the table
+        (determined after any `pre=` mutation has been applied).
 
         Parameters
         ----------
@@ -7742,6 +7925,20 @@ class Validate:
             [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
             multiple columns are supplied or resolved, there will be a separate validation step
             generated for each column.
+        allow_stationary
+            An option to allow pauses in increasing values. For example, if the values for the test
+            units are `[80, 82, 82, 85, 88]` then the third unit (`82`, appearing a second time)
+            would be marked as failing when `allow_stationary` is `False`. Using
+            `allow_stationary=True` will result in all the test units in `[80, 82, 82, 85, 88]` to
+            be marked as passing.
+        decreasing_tol
+            An optional threshold value that allows for movement of numerical values in the negative
+            direction. By default this is `None` but using a numerical value will set the absolute
+            threshold of negative travel allowed across numerical test units. Note that setting a
+            value here also has the effect of setting `allow_stationary` to `True`.
+        na_pass
+            Should any encountered None, NA, or Null values be considered as passing test units? By
+            default, this is `False`. Set to `True` to pass test units with missing values.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -7778,89 +7975,6 @@ class Validate:
         Validate
             The `Validate` object with the added validation step.
 
-        Preprocessing
-        -------------
-        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
-        table during interrogation. This function should take a table as input and return a modified
-        table. This is useful for performing any necessary transformations or filtering on the data
-        before the validation step is applied.
-
-        The preprocessing function can be any callable that takes a table as input and returns a
-        modified table. For example, you could use a lambda function to filter the table based on
-        certain criteria or to apply a transformation to the data. Note that you can refer to
-        a column via `columns=` that is expected to be present in the transformed table, but may not
-        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
-        only exists during the validation step and is not stored in the `Validate` object or used in
-        subsequent validation steps.
-
-        Segmentation
-        ------------
-        The `segments=` argument allows for the segmentation of a validation step into multiple
-        segments. This is useful for applying the same validation step to different subsets of the
-        data. The segmentation can be done based on a single column or specific fields within a
-        column.
-
-        Providing a single column name will result in a separate validation step for each unique
-        value in that column. For example, if you have a column called `"region"` with values
-        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
-        region.
-
-        Alternatively, you can provide a tuple that specifies a column name and its corresponding
-        values to segment on. For example, if you have a column called `"date"` and you want to
-        segment on only specific dates, you can provide a tuple like
-        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
-        (i.e., no validation steps will be created for them).
-
-        A list with a combination of column names and tuples can be provided as well. This allows
-        for more complex segmentation scenarios. The following inputs are both valid:
-
-        ```
-        # Segments from all unique values in the `region` column
-        # and specific dates in the `date` column
-        segments=["region", ("date", ["2023-01-01", "2023-01-02"])]
-
-        # Segments from all unique values in the `region` and `date` columns
-        segments=["region", "date"]
-        ```
-
-        The segmentation is performed during interrogation, and the resulting validation steps will
-        be numbered sequentially. Each segment will have its own validation step, and the results
-        will be reported separately. This allows for a more granular analysis of the data and helps
-        identify issues within specific segments.
-
-        Importantly, the segmentation process will be performed after any preprocessing of the data
-        table. Because of this, one can conceivably use the `pre=` argument to generate a column
-        that can be used for segmentation. For example, you could create a new column called
-        `"segment"` through use of `pre=` and then use that column for segmentation.
-
-        Thresholds
-        ----------
-        The `thresholds=` parameter is used to set the failure-condition levels for the validation
-        step. If they are set here at the step level, these thresholds will override any thresholds
-        set at the global level in `Validate(thresholds=...)`.
-
-        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
-        can either be set as a proportion failing of all test units (a value between `0` to `1`),
-        or, the absolute number of failing test units (as integer that's `1` or greater).
-
-        Thresholds can be defined using one of these input schemes:
-
-        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
-        thresholds)
-        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
-        the 'error' level, and position `2` is the 'critical' level
-        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
-        'critical'
-        4. a single integer/float value denoting absolute number or fraction of failing test units
-        for the 'warning' level only
-
-        If the number of failing test units exceeds set thresholds, the validation step will be
-        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
-        set, you're free to set any combination of them.
-
-        Aside from reporting failure conditions, thresholds can be used to determine the actions to
-        take for each level of failure (using the `actions=` parameter).
-
         Examples
         --------
         ```{python}
@@ -7869,8 +7983,9 @@ class Validate:
         import pointblank as pb
         pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
         ```
-        For the examples here, we'll use a simple Polars DataFrame with two numeric columns (`a` and
-        `b`). The table is shown below:
+
+        For the examples here, we'll use a simple Polars DataFrame with a numeric column (`a`). The
+        table is shown below:
 
         ```{python}
         import pointblank as pb
@@ -7878,54 +7993,55 @@ class Validate:
 
         tbl = pl.DataFrame(
             {
-                "a": [None, None, None, None],
-                "b": [None, 2, None, 9],
+                "a": [1, 2, 3, 4, 5, 6],
+                "b": [1, 2, 2, 3, 4, 5],
+                "c": [1, 2, 1, 3, 4, 5],
             }
-        ).with_columns(pl.col("a").cast(pl.Int64))
+        )
 
         pb.preview(tbl)
         ```
 
-        Let's validate that values in column `a` are all Null values. We'll determine if this
-        validation had any failing test units (there are four test units, one for each row).
+        Let's validate that values in column `a` are increasing. We'll determine if this validation
+        had any failing test units (there are six test units, one for each row).
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_null(columns="a")
+            .col_vals_increasing(columns="a")
             .interrogate()
         )
 
         validation
         ```
 
-        Printing the `validation` object shows the validation table in an HTML viewing environment.
-        The validation table shows the single entry that corresponds to the validation step created
-        by using `col_vals_null()`. All test units passed, and there are no failing test units.
-
-        Now, let's use that same set of values for a validation on column `b`.
+        The validation passed as all values in column `a` are increasing. Now let's check column
+        `b` which has a stationary value:
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_null(columns="b")
+            .col_vals_increasing(columns="b")
             .interrogate()
         )
 
         validation
         ```
 
-        The validation table reports two failing test units. The specific failing cases are for the
-        two non-Null values in column `b`.
-        """
-        assertion_type = _get_fn_name()
+        This validation fails at the third row because the value `2` is repeated. If we want to
+        allow stationary values, we can use `allow_stationary=True`:
 
-        _check_column(column=columns)
-        _check_pre(pre=pre)
-        # TODO: add check for segments
-        # _check_segments(segments=segments)
-        _check_thresholds(thresholds=thresholds)
-        _check_boolean_input(param=active, param_name="active")
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_increasing(columns="b", allow_stationary=True)
+            .interrogate()
+        )
+
+        validation
+        ```
+        """
+        assertion_type = "col_vals_increasing"
 
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
         thresholds = (
@@ -7949,21 +8065,30 @@ class Validate:
             val_info = _ValidationInfo(
                 assertion_type=assertion_type,
                 column=column,
+                values="",
+                na_pass=na_pass,
                 pre=pre,
                 segments=segments,
                 thresholds=thresholds,
                 actions=actions,
                 brief=brief,
                 active=active,
+                val_info={
+                    "allow_stationary": allow_stationary,
+                    "decreasing_tol": decreasing_tol if decreasing_tol else 0.0,
+                },
             )
 
             self._add_validation(validation_info=val_info)
 
         return self
 
-    def col_vals_not_null(
+    def col_vals_decreasing(
         self,
         columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        allow_stationary: bool = False,
+        increasing_tol: float | None = None,
+        na_pass: bool = False,
         pre: Callable | None = None,
         segments: SegmentSpec | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
@@ -7972,11 +8097,14 @@ class Validate:
         active: bool = True,
     ) -> Validate:
         """
-        Validate whether values in a column are not Null.
+        Are column data decreasing by row?
 
-        The `col_vals_not_null()` validation method checks whether column values in a table are not
-        Null. This validation will operate over the number of test units that is equal to the number
-        of rows in the table.
+        The `col_vals_decreasing()` validation method checks whether column values in a table are
+        decreasing when moving down a table. There are options for allowing missing values in the
+        target column, allowing stationary phases (where consecutive values don't change), and even
+        one for allowing increasing movements up to a certain threshold. This validation will
+        operate over the number of test units that is equal to the number of rows in the table
+        (determined after any `pre=` mutation has been applied).
 
         Parameters
         ----------
@@ -7985,6 +8113,20 @@ class Validate:
             [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
             multiple columns are supplied or resolved, there will be a separate validation step
             generated for each column.
+        allow_stationary
+            An option to allow pauses in decreasing values. For example, if the values for the test
+            units are `[88, 85, 85, 82, 80]` then the third unit (`85`, appearing a second time)
+            would be marked as failing when `allow_stationary` is `False`. Using
+            `allow_stationary=True` will result in all the test units in `[88, 85, 85, 82, 80]` to
+            be marked as passing.
+        increasing_tol
+            An optional threshold value that allows for movement of numerical values in the positive
+            direction. By default this is `None` but using a numerical value will set the absolute
+            threshold of positive travel allowed across numerical test units. Note that setting a
+            value here also has the effect of setting `allow_stationary` to `True`.
+        na_pass
+            Should any encountered None, NA, or Null values be considered as passing test units? By
+            default, this is `False`. Set to `True` to pass test units with missing values.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -8021,38 +8163,449 @@ class Validate:
         Validate
             The `Validate` object with the added validation step.
 
-        Preprocessing
-        -------------
-        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
-        table during interrogation. This function should take a table as input and return a modified
-        table. This is useful for performing any necessary transformations or filtering on the data
-        before the validation step is applied.
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
+        ```
 
-        The preprocessing function can be any callable that takes a table as input and returns a
-        modified table. For example, you could use a lambda function to filter the table based on
-        certain criteria or to apply a transformation to the data. Note that you can refer to
-        a column via `columns=` that is expected to be present in the transformed table, but may not
-        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
-        only exists during the validation step and is not stored in the `Validate` object or used in
-        subsequent validation steps.
+        For the examples here, we'll use a simple Polars DataFrame with a numeric column (`a`). The
+        table is shown below:
 
-        Segmentation
-        ------------
-        The `segments=` argument allows for the segmentation of a validation step into multiple
-        segments. This is useful for applying the same validation step to different subsets of the
-        data. The segmentation can be done based on a single column or specific fields within a
-        column.
+        ```{python}
+        import pointblank as pb
+        import polars as pl
 
-        Providing a single column name will result in a separate validation step for each unique
-        value in that column. For example, if you have a column called `"region"` with values
-        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
-        region.
+        tbl = pl.DataFrame(
+            {
+                "a": [6, 5, 4, 3, 2, 1],
+                "b": [5, 4, 4, 3, 2, 1],
+                "c": [5, 4, 5, 3, 2, 1],
+            }
+        )
 
-        Alternatively, you can provide a tuple that specifies a column name and its corresponding
-        values to segment on. For example, if you have a column called `"date"` and you want to
-        segment on only specific dates, you can provide a tuple like
-        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
-        (i.e., no validation steps will be created for them).
+        pb.preview(tbl)
+        ```
+
+        Let's validate that values in column `a` are decreasing. We'll determine if this validation
+        had any failing test units (there are six test units, one for each row).
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_decreasing(columns="a")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation passed as all values in column `a` are decreasing. Now let's check column
+        `b` which has a stationary value:
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_decreasing(columns="b")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This validation fails at the third row because the value `4` is repeated. If we want to
+        allow stationary values, we can use `allow_stationary=True`:
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_decreasing(columns="b", allow_stationary=True)
+            .interrogate()
+        )
+
+        validation
+        ```
+        """
+        assertion_type = "col_vals_decreasing"
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        # If `columns` is a ColumnSelector or Narwhals selector, call `col()` on it to later
+        # resolve the columns
+        if isinstance(columns, (ColumnSelector, nw.selectors.Selector)):
+            columns = col(columns)
+
+        # If `columns` is Column value or a string, place it in a list for iteration
+        if isinstance(columns, (Column, str)):
+            columns = [columns]
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        # Iterate over the columns and create a validation step for each
+        for column in columns:
+            val_info = _ValidationInfo(
+                assertion_type=assertion_type,
+                column=column,
+                values="",
+                na_pass=na_pass,
+                pre=pre,
+                segments=segments,
+                thresholds=thresholds,
+                actions=actions,
+                brief=brief,
+                active=active,
+                val_info={
+                    "allow_stationary": allow_stationary,
+                    "increasing_tol": increasing_tol if increasing_tol else 0.0,
+                },
+            )
+
+            self._add_validation(validation_info=val_info)
+
+        return self
+
+    def col_vals_null(
+        self,
+        columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        pre: Callable | None = None,
+        segments: SegmentSpec | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate whether values in a column are Null.
+
+        The `col_vals_null()` validation method checks whether column values in a table are Null.
+        This validation will operate over the number of test units that is equal to the number
+        of rows in the table.
+
+        Parameters
+        ----------
+        columns
+            A single column or a list of columns to validate. Can also use
+            [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
+            multiple columns are supplied or resolved, there will be a separate validation step
+            generated for each column.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+            Have a look at the *Preprocessing* section for more information on how to use this
+            argument.
+        segments
+            An optional directive on segmentation, which serves to split a validation step into
+            multiple (one step per segment). Can be a single column name, a tuple that specifies a
+            column name and its corresponding values to segment on, or a combination of both
+            (provided as a list). Read the *Segmentation* section for usage information.
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
+            section for information on how to set threshold levels.
+        actions
+            Optional actions to take when the validation step(s) meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Preprocessing
+        -------------
+        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
+        table during interrogation. This function should take a table as input and return a modified
+        table. This is useful for performing any necessary transformations or filtering on the data
+        before the validation step is applied.
+
+        The preprocessing function can be any callable that takes a table as input and returns a
+        modified table. For example, you could use a lambda function to filter the table based on
+        certain criteria or to apply a transformation to the data. Note that you can refer to
+        a column via `columns=` that is expected to be present in the transformed table, but may not
+        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
+        only exists during the validation step and is not stored in the `Validate` object or used in
+        subsequent validation steps.
+
+        Segmentation
+        ------------
+        The `segments=` argument allows for the segmentation of a validation step into multiple
+        segments. This is useful for applying the same validation step to different subsets of the
+        data. The segmentation can be done based on a single column or specific fields within a
+        column.
+
+        Providing a single column name will result in a separate validation step for each unique
+        value in that column. For example, if you have a column called `"region"` with values
+        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
+        region.
+
+        Alternatively, you can provide a tuple that specifies a column name and its corresponding
+        values to segment on. For example, if you have a column called `"date"` and you want to
+        segment on only specific dates, you can provide a tuple like
+        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
+        (i.e., no validation steps will be created for them).
+
+        A list with a combination of column names and tuples can be provided as well. This allows
+        for more complex segmentation scenarios. The following inputs are both valid:
+
+        ```
+        # Segments from all unique values in the `region` column
+        # and specific dates in the `date` column
+        segments=["region", ("date", ["2023-01-01", "2023-01-02"])]
+
+        # Segments from all unique values in the `region` and `date` columns
+        segments=["region", "date"]
+        ```
+
+        The segmentation is performed during interrogation, and the resulting validation steps will
+        be numbered sequentially. Each segment will have its own validation step, and the results
+        will be reported separately. This allows for a more granular analysis of the data and helps
+        identify issues within specific segments.
+
+        Importantly, the segmentation process will be performed after any preprocessing of the data
+        table. Because of this, one can conceivably use the `pre=` argument to generate a column
+        that can be used for segmentation. For example, you could create a new column called
+        `"segment"` through use of `pre=` and then use that column for segmentation.
+
+        Thresholds
+        ----------
+        The `thresholds=` parameter is used to set the failure-condition levels for the validation
+        step. If they are set here at the step level, these thresholds will override any thresholds
+        set at the global level in `Validate(thresholds=...)`.
+
+        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
+        can either be set as a proportion failing of all test units (a value between `0` to `1`),
+        or, the absolute number of failing test units (as integer that's `1` or greater).
+
+        Thresholds can be defined using one of these input schemes:
+
+        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
+        thresholds)
+        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
+        the 'error' level, and position `2` is the 'critical' level
+        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
+        'critical'
+        4. a single integer/float value denoting absolute number or fraction of failing test units
+        for the 'warning' level only
+
+        If the number of failing test units exceeds set thresholds, the validation step will be
+        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
+        set, you're free to set any combination of them.
+
+        Aside from reporting failure conditions, thresholds can be used to determine the actions to
+        take for each level of failure (using the `actions=` parameter).
+
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
+        ```
+        For the examples here, we'll use a simple Polars DataFrame with two numeric columns (`a` and
+        `b`). The table is shown below:
+
+        ```{python}
+        import pointblank as pb
+        import polars as pl
+
+        tbl = pl.DataFrame(
+            {
+                "a": [None, None, None, None],
+                "b": [None, 2, None, 9],
+            }
+        ).with_columns(pl.col("a").cast(pl.Int64))
+
+        pb.preview(tbl)
+        ```
+
+        Let's validate that values in column `a` are all Null values. We'll determine if this
+        validation had any failing test units (there are four test units, one for each row).
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_null(columns="a")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        Printing the `validation` object shows the validation table in an HTML viewing environment.
+        The validation table shows the single entry that corresponds to the validation step created
+        by using `col_vals_null()`. All test units passed, and there are no failing test units.
+
+        Now, let's use that same set of values for a validation on column `b`.
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_null(columns="b")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table reports two failing test units. The specific failing cases are for the
+        two non-Null values in column `b`.
+        """
+        assertion_type = _get_fn_name()
+
+        _check_column(column=columns)
+        _check_pre(pre=pre)
+        # TODO: add check for segments
+        # _check_segments(segments=segments)
+        _check_thresholds(thresholds=thresholds)
+        _check_boolean_input(param=active, param_name="active")
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        # If `columns` is a ColumnSelector or Narwhals selector, call `col()` on it to later
+        # resolve the columns
+        if isinstance(columns, (ColumnSelector, nw.selectors.Selector)):
+            columns = col(columns)
+
+        # If `columns` is Column value or a string, place it in a list for iteration
+        if isinstance(columns, (Column, str)):
+            columns = [columns]
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        # Iterate over the columns and create a validation step for each
+        for column in columns:
+            val_info = _ValidationInfo(
+                assertion_type=assertion_type,
+                column=column,
+                pre=pre,
+                segments=segments,
+                thresholds=thresholds,
+                actions=actions,
+                brief=brief,
+                active=active,
+            )
+
+            self._add_validation(validation_info=val_info)
+
+        return self
+
+    def col_vals_not_null(
+        self,
+        columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        pre: Callable | None = None,
+        segments: SegmentSpec | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate whether values in a column are not Null.
+
+        The `col_vals_not_null()` validation method checks whether column values in a table are not
+        Null. This validation will operate over the number of test units that is equal to the number
+        of rows in the table.
+
+        Parameters
+        ----------
+        columns
+            A single column or a list of columns to validate. Can also use
+            [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
+            multiple columns are supplied or resolved, there will be a separate validation step
+            generated for each column.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+            Have a look at the *Preprocessing* section for more information on how to use this
+            argument.
+        segments
+            An optional directive on segmentation, which serves to split a validation step into
+            multiple (one step per segment). Can be a single column name, a tuple that specifies a
+            column name and its corresponding values to segment on, or a combination of both
+            (provided as a list). Read the *Segmentation* section for usage information.
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
+            section for information on how to set threshold levels.
+        actions
+            Optional actions to take when the validation step(s) meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Preprocessing
+        -------------
+        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
+        table during interrogation. This function should take a table as input and return a modified
+        table. This is useful for performing any necessary transformations or filtering on the data
+        before the validation step is applied.
+
+        The preprocessing function can be any callable that takes a table as input and returns a
+        modified table. For example, you could use a lambda function to filter the table based on
+        certain criteria or to apply a transformation to the data. Note that you can refer to
+        a column via `columns=` that is expected to be present in the transformed table, but may not
+        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
+        only exists during the validation step and is not stored in the `Validate` object or used in
+        subsequent validation steps.
+
+        Segmentation
+        ------------
+        The `segments=` argument allows for the segmentation of a validation step into multiple
+        segments. This is useful for applying the same validation step to different subsets of the
+        data. The segmentation can be done based on a single column or specific fields within a
+        column.
+
+        Providing a single column name will result in a separate validation step for each unique
+        value in that column. For example, if you have a column called `"region"` with values
+        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
+        region.
+
+        Alternatively, you can provide a tuple that specifies a column name and its corresponding
+        values to segment on. For example, if you have a column called `"date"` and you want to
+        segment on only specific dates, you can provide a tuple like
+        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
+        (i.e., no validation steps will be created for them).
 
         A list with a combination of column names and tuples can be provided as well. This allows
         for more complex segmentation scenarios. The following inputs are both valid:
@@ -8232,14 +8785,278 @@ class Validate:
             [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
             multiple columns are supplied or resolved, there will be a separate validation step
             generated for each column.
-        pattern
-            A regular expression pattern to compare against.
+        pattern
+            A regular expression pattern to compare against.
+        na_pass
+            Should any encountered None, NA, or Null values be considered as passing test units? By
+            default, this is `False`. Set to `True` to pass test units with missing values.
+        inverse
+            Should the validation step be inverted? If `True`, then the expectation is that column
+            values should *not* match the specified `pattern=` regex.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+            Have a look at the *Preprocessing* section for more information on how to use this
+            argument.
+        segments
+            An optional directive on segmentation, which serves to split a validation step into
+            multiple (one step per segment). Can be a single column name, a tuple that specifies a
+            column name and its corresponding values to segment on, or a combination of both
+            (provided as a list). Read the *Segmentation* section for usage information.
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
+            section for information on how to set threshold levels.
+        actions
+            Optional actions to take when the validation step(s) meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Preprocessing
+        -------------
+        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
+        table during interrogation. This function should take a table as input and return a modified
+        table. This is useful for performing any necessary transformations or filtering on the data
+        before the validation step is applied.
+
+        The preprocessing function can be any callable that takes a table as input and returns a
+        modified table. For example, you could use a lambda function to filter the table based on
+        certain criteria or to apply a transformation to the data. Note that you can refer to
+        a column via `columns=` that is expected to be present in the transformed table, but may not
+        exist in the table before preprocessing. Regarding the lifetime of the transformed table, it
+        only exists during the validation step and is not stored in the `Validate` object or used in
+        subsequent validation steps.
+
+        Segmentation
+        ------------
+        The `segments=` argument allows for the segmentation of a validation step into multiple
+        segments. This is useful for applying the same validation step to different subsets of the
+        data. The segmentation can be done based on a single column or specific fields within a
+        column.
+
+        Providing a single column name will result in a separate validation step for each unique
+        value in that column. For example, if you have a column called `"region"` with values
+        `"North"`, `"South"`, and `"East"`, the validation step will be applied separately to each
+        region.
+
+        Alternatively, you can provide a tuple that specifies a column name and its corresponding
+        values to segment on. For example, if you have a column called `"date"` and you want to
+        segment on only specific dates, you can provide a tuple like
+        `("date", ["2023-01-01", "2023-01-02"])`. Any other values in the column will be disregarded
+        (i.e., no validation steps will be created for them).
+
+        A list with a combination of column names and tuples can be provided as well. This allows
+        for more complex segmentation scenarios. The following inputs are both valid:
+
+        ```
+        # Segments from all unique values in the `region` column
+        # and specific dates in the `date` column
+        segments=["region", ("date", ["2023-01-01", "2023-01-02"])]
+
+        # Segments from all unique values in the `region` and `date` columns
+        segments=["region", "date"]
+        ```
+
+        The segmentation is performed during interrogation, and the resulting validation steps will
+        be numbered sequentially. Each segment will have its own validation step, and the results
+        will be reported separately. This allows for a more granular analysis of the data and helps
+        identify issues within specific segments.
+
+        Importantly, the segmentation process will be performed after any preprocessing of the data
+        table. Because of this, one can conceivably use the `pre=` argument to generate a column
+        that can be used for segmentation. For example, you could create a new column called
+        `"segment"` through use of `pre=` and then use that column for segmentation.
+
+        Thresholds
+        ----------
+        The `thresholds=` parameter is used to set the failure-condition levels for the validation
+        step. If they are set here at the step level, these thresholds will override any thresholds
+        set at the global level in `Validate(thresholds=...)`.
+
+        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
+        can either be set as a proportion failing of all test units (a value between `0` to `1`),
+        or, the absolute number of failing test units (as integer that's `1` or greater).
+
+        Thresholds can be defined using one of these input schemes:
+
+        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
+        thresholds)
+        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
+        the 'error' level, and position `2` is the 'critical' level
+        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
+        'critical'
+        4. a single integer/float value denoting absolute number or fraction of failing test units
+        for the 'warning' level only
+
+        If the number of failing test units exceeds set thresholds, the validation step will be
+        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
+        set, you're free to set any combination of them.
+
+        Aside from reporting failure conditions, thresholds can be used to determine the actions to
+        take for each level of failure (using the `actions=` parameter).
+
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
+        ```
+        For the examples here, we'll use a simple Polars DataFrame with two string columns (`a` and
+        `b`). The table is shown below:
+
+        ```{python}
+        import pointblank as pb
+        import polars as pl
+
+        tbl = pl.DataFrame(
+            {
+                "a": ["rb-0343", "ra-0232", "ry-0954", "rc-1343"],
+                "b": ["ra-0628", "ra-583", "rya-0826", "rb-0735"],
+            }
+        )
+
+        pb.preview(tbl)
+        ```
+
+        Let's validate that all of the values in column `a` match a particular regex pattern. We'll
+        determine if this validation had any failing test units (there are four test units, one for
+        each row).
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_regex(columns="a", pattern=r"r[a-z]-[0-9]{4}")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        Printing the `validation` object shows the validation table in an HTML viewing environment.
+        The validation table shows the single entry that corresponds to the validation step created
+        by using `col_vals_regex()`. All test units passed, and there are no failing test units.
+
+        Now, let's use the same regex for a validation on column `b`.
+
+        ```{python}
+        validation = (
+            pb.Validate(data=tbl)
+            .col_vals_regex(columns="b", pattern=r"r[a-z]-[0-9]{4}")
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table reports two failing test units. The specific failing cases are for the
+        string values of rows 1 and 2 in column `b`.
+        """
+
+        assertion_type = _get_fn_name()
+
+        _check_column(column=columns)
+        _check_pre(pre=pre)
+        # TODO: add check for segments
+        # _check_segments(segments=segments)
+        _check_thresholds(thresholds=thresholds)
+        _check_boolean_input(param=na_pass, param_name="na_pass")
+        _check_boolean_input(param=inverse, param_name="inverse")
+        _check_boolean_input(param=active, param_name="active")
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        # If `columns` is a ColumnSelector or Narwhals selector, call `col()` on it to later
+        # resolve the columns
+        if isinstance(columns, (ColumnSelector, nw.selectors.Selector)):
+            columns = col(columns)
+
+        # If `columns` is Column value or a string, place it in a list for iteration
+        if isinstance(columns, (Column, str)):
+            columns = [columns]
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        # Package up the `pattern=` and boolean params into a dictionary for later interrogation
+        values = {"pattern": pattern, "inverse": inverse}
+
+        # Iterate over the columns and create a validation step for each
+        for column in columns:
+            val_info = _ValidationInfo(
+                assertion_type=assertion_type,
+                column=column,
+                values=values,
+                na_pass=na_pass,
+                pre=pre,
+                segments=segments,
+                thresholds=thresholds,
+                actions=actions,
+                brief=brief,
+                active=active,
+            )
+
+            self._add_validation(validation_info=val_info)
+
+        return self
+
+    def col_vals_within_spec(
+        self,
+        columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
+        spec: str,
+        na_pass: bool = False,
+        pre: Callable | None = None,
+        segments: SegmentSpec | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate whether column values fit within a specification.
+
+        The `col_vals_within_spec()` validation method checks whether column values in a table
+        correspond to a specification (`spec=`) type (details of which are available in the
+        *Specifications* section). Specifications include common data types like email addresses,
+        URLs, postal codes, vehicle identification numbers (VINs), International Bank Account
+        Numbers (IBANs), and more. This validation will operate over the number of test units that
+        is equal to the number of rows in the table.
+
+        Parameters
+        ----------
+        columns
+            A single column or a list of columns to validate. Can also use
+            [`col()`](`pointblank.col`) with column selectors to specify one or more columns. If
+            multiple columns are supplied or resolved, there will be a separate validation step
+            generated for each column.
+        spec
+            A specification string for defining the specification type. Examples are `"email"`,
+            `"url"`, and `"postal_code[USA]"`. See the *Specifications* section for all available
+            options.
         na_pass
             Should any encountered None, NA, or Null values be considered as passing test units? By
             default, this is `False`. Set to `True` to pass test units with missing values.
-        inverse
-            Should the validation step be inverted? If `True`, then the expectation is that column
-            values should *not* match the specified `pattern=` regex.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -8276,6 +9093,40 @@ class Validate:
         Validate
             The `Validate` object with the added validation step.
 
+        Specifications
+        --------------
+        A specification type must be used with the `spec=` argument. This is a string-based keyword
+        that corresponds to the type of data in the specified columns. The following keywords can
+        be used:
+
+        - `"isbn"`: The International Standard Book Number (ISBN) is a unique numerical identifier
+          for books. This keyword validates both 10-digit and 13-digit ISBNs.
+
+        - `"vin"`: A vehicle identification number (VIN) is a unique code used by the automotive
+          industry to identify individual motor vehicles.
+
+        - `"postal_code[<country_code>]"`: A postal code (also known as postcodes, PIN, or ZIP
+          codes) is a series of letters, digits, or both included in a postal address. Because the
+          coding varies by country, a country code in either the 2-letter (ISO 3166-1 alpha-2) or
+          3-letter (ISO 3166-1 alpha-3) format needs to be supplied (e.g., `"postal_code[US]"` or
+          `"postal_code[USA]"`). The keyword alias `"zip"` can be used for US ZIP codes.
+
+        - `"credit_card"`: A credit card number can be validated across a variety of issuers. The
+          validation uses the Luhn algorithm.
+
+        - `"iban[<country_code>]"`: The International Bank Account Number (IBAN) is a system of
+          identifying bank accounts across countries. Because the length and coding varies by
+          country, a country code needs to be supplied (e.g., `"iban[DE]"` or `"iban[DEU]"`).
+
+        - `"swift"`: Business Identifier Codes (also known as SWIFT-BIC, BIC, or SWIFT code) are
+          unique identifiers for financial and non-financial institutions.
+
+        - `"phone"`, `"email"`, `"url"`, `"ipv4"`, `"ipv6"`, `"mac"`: Phone numbers, email
+          addresses, Internet URLs, IPv4 or IPv6 addresses, and MAC addresses can be validated with
+          their respective keywords.
+
+        Only a single `spec=` value should be provided per function call.
+
         Preprocessing
         -------------
         The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
@@ -8367,8 +9218,9 @@ class Validate:
         import pointblank as pb
         pb.config(report_incl_header=False, report_incl_footer=False, preview_incl_header=False)
         ```
-        For the examples here, we'll use a simple Polars DataFrame with two string columns (`a` and
-        `b`). The table is shown below:
+
+        For the examples here, we'll use a simple Polars DataFrame with an email column. The table
+        is shown below:
 
         ```{python}
         import pointblank as pb
@@ -8376,46 +9228,33 @@ class Validate:
 
         tbl = pl.DataFrame(
             {
-                "a": ["rb-0343", "ra-0232", "ry-0954", "rc-1343"],
-                "b": ["ra-0628", "ra-583", "rya-0826", "rb-0735"],
+                "email": [
+                    "user@example.com",
+                    "admin@test.org",
+                    "invalid-email",
+                    "contact@company.co.uk",
+                ],
             }
         )
 
         pb.preview(tbl)
         ```
 
-        Let's validate that all of the values in column `a` match a particular regex pattern. We'll
-        determine if this validation had any failing test units (there are four test units, one for
-        each row).
-
-        ```{python}
-        validation = (
-            pb.Validate(data=tbl)
-            .col_vals_regex(columns="a", pattern=r"r[a-z]-[0-9]{4}")
-            .interrogate()
-        )
-
-        validation
-        ```
-
-        Printing the `validation` object shows the validation table in an HTML viewing environment.
-        The validation table shows the single entry that corresponds to the validation step created
-        by using `col_vals_regex()`. All test units passed, and there are no failing test units.
-
-        Now, let's use the same regex for a validation on column `b`.
+        Let's validate that all of the values in the `email` column are valid email addresses.
+        We'll determine if this validation had any failing test units (there are four test units,
+        one for each row).
 
         ```{python}
         validation = (
             pb.Validate(data=tbl)
-            .col_vals_regex(columns="b", pattern=r"r[a-z]-[0-9]{4}")
+            .col_vals_within_spec(columns="email", spec="email")
             .interrogate()
         )
 
         validation
         ```
 
-        The validation table reports two failing test units. The specific failing cases are for the
-        string values of rows 1 and 2 in column `b`.
+        The validation table shows that one test unit failed (the invalid email address in row 3).
         """
 
         assertion_type = _get_fn_name()
@@ -8426,7 +9265,6 @@ class Validate:
         # _check_segments(segments=segments)
         _check_thresholds(thresholds=thresholds)
         _check_boolean_input(param=na_pass, param_name="na_pass")
-        _check_boolean_input(param=inverse, param_name="inverse")
         _check_boolean_input(param=active, param_name="active")
 
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
@@ -8446,8 +9284,8 @@ class Validate:
         # Determine brief to use (global or local) and transform any shorthands of `brief=`
         brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
 
-        # Package up the `pattern=` and boolean params into a dictionary for later interrogation
-        values = {"pattern": pattern, "inverse": inverse}
+        # Package up the `spec=` param into a dictionary for later interrogation
+        values = {"spec": spec}
 
         # Iterate over the columns and create a validation step for each
         for column in columns:
@@ -9396,10 +10234,10 @@ class Validate:
             so try to include only the columns necessary for the validation.
         model
             The model to be used. This should be in the form of `provider:model` (e.g.,
-            `"anthropic:claude-3-5-sonnet-latest"`). Supported providers are `"anthropic"`,
-            `"openai"`, `"ollama"`, and `"bedrock"`. The model name should be the specific model to
-            be used from the provider. Model names are subject to change so consult the provider's
-            documentation for the most up-to-date model names.
+            `"anthropic:claude-sonnet-4-5"`). Supported providers are `"anthropic"`, `"openai"`,
+            `"ollama"`, and `"bedrock"`. The model name should be the specific model to be used from
+            the provider. Model names are subject to change so consult the provider's documentation
+            for the most up-to-date model names.
         batch_size
             Number of rows to process in each batch. Larger batches are more efficient but may hit
             API limits. Default is `1000`.
@@ -9551,13 +10389,6 @@ class Validate:
         - "Describe the quality of each row" (asks for description, not validation)
         - "How would you improve this data?" (asks for suggestions, not pass/fail)
 
-        Provider Setup
-        --------------
-        **OpenAI**: Set `OPENAI_API_KEY` environment variable or create `.env` file.
-        **Anthropic**: Set `ANTHROPIC_API_KEY` environment variable or create `.env` file.
-        **Ollama**: Ensure Ollama is running locally (default: http://localhost:11434).
-        **Bedrock**: Configure AWS credentials and region.
-
         Performance Considerations
         --------------------------
         AI validation is significantly slower than traditional validation methods due to API calls
@@ -10089,63 +10920,242 @@ class Validate:
         pb.config(report_incl_header=False, report_incl_footer=False)
         ```
 
-        For the examples here, we'll use the built in dataset `"small_table"`. The table can be
-        obtained by calling `load_dataset("small_table")`.
+        For the examples here, we'll use the built in dataset `"small_table"`. The table can be
+        obtained by calling `load_dataset("small_table")`.
+
+        ```{python}
+        import pointblank as pb
+
+        small_table = pb.load_dataset("small_table")
+
+        pb.preview(small_table)
+        ```
+
+        Let's validate that the number of rows in the table matches a fixed value. In this case, we
+        will use the value `13` as the expected row count.
+
+        ```{python}
+        validation = (
+            pb.Validate(data=small_table)
+            .row_count_match(count=13)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table shows that the expectation value of `13` matches the actual count of
+        rows in the target table. So, the single test unit passed.
+
+
+        Let's modify our example to show the different ways we can allow some tolerance to our validation
+        by using the `tol` argument.
+
+        ```{python}
+        smaller_small_table = small_table.sample(n = 12) # within the lower bound
+        validation = (
+            pb.Validate(data=smaller_small_table)
+            .row_count_match(count=13,tol=(2, 0)) # minus 2 but plus 0, ie. 11-13
+            .interrogate()
+        )
+
+        validation
+
+        validation = (
+            pb.Validate(data=smaller_small_table)
+            .row_count_match(count=13,tol=.05) # .05% tolerance of 13
+            .interrogate()
+        )
+
+        even_smaller_table = small_table.sample(n = 2)
+        validation = (
+            pb.Validate(data=even_smaller_table)
+            .row_count_match(count=13,tol=5) # plus or minus 5; this test will fail
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        """
+
+        assertion_type = _get_fn_name()
+
+        _check_pre(pre=pre)
+        _check_thresholds(thresholds=thresholds)
+        _check_boolean_input(param=active, param_name="active")
+        _check_boolean_input(param=inverse, param_name="inverse")
+
+        # Determine threshold to use (global or local) and normalize a local `thresholds=` value
+        thresholds = (
+            self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
+        )
+
+        # If `count` is a DataFrame or table then use the row count of the DataFrame as
+        # the expected count
+        if _is_value_a_df(count) or "ibis.expr.types.relations.Table" in str(type(count)):
+            count = get_row_count(count)
+
+        # Check the integrity of tolerance
+        bounds: AbsoluteBounds = _derive_bounds(ref=int(count), tol=tol)
+
+        # Package up the `count=` and boolean params into a dictionary for later interrogation
+        values = {"count": count, "inverse": inverse, "abs_tol_bounds": bounds}
+
+        # Determine brief to use (global or local) and transform any shorthands of `brief=`
+        brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
+
+        val_info = _ValidationInfo(
+            assertion_type=assertion_type,
+            values=values,
+            pre=pre,
+            thresholds=thresholds,
+            actions=actions,
+            brief=brief,
+            active=active,
+        )
+
+        self._add_validation(validation_info=val_info)
+
+        return self
+
+    def col_count_match(
+        self,
+        count: int | FrameT | Any,
+        inverse: bool = False,
+        pre: Callable | None = None,
+        thresholds: int | float | bool | tuple | dict | Thresholds = None,
+        actions: Actions | None = None,
+        brief: str | bool | None = None,
+        active: bool = True,
+    ) -> Validate:
+        """
+        Validate whether the column count of the table matches a specified count.
+
+        The `col_count_match()` method checks whether the column count of the target table matches a
+        specified count. This validation will operate over a single test unit, which is whether the
+        column count matches the specified count.
+
+        We also have the option to invert the validation step by setting `inverse=True`. This will
+        make the expectation that column row count of the target table *does not* match the
+        specified count.
+
+        Parameters
+        ----------
+        count
+            The expected column count of the table. This can be an integer value, a Polars or Pandas
+            DataFrame object, or an Ibis backend table. If a DataFrame/table is provided, the column
+            count of that object will be used as the expected count.
+        inverse
+            Should the validation step be inverted? If `True`, then the expectation is that the
+            column count of the target table should not match the specified `count=` value.
+        pre
+            An optional preprocessing function or lambda to apply to the data table during
+            interrogation. This function should take a table as input and return a modified table.
+            Have a look at the *Preprocessing* section for more information on how to use this
+            argument.
+        thresholds
+            Set threshold failure levels for reporting and reacting to exceedences of the levels.
+            The thresholds are set at the step level and will override any global thresholds set in
+            `Validate(thresholds=...)`. The default is `None`, which means that no thresholds will
+            be set locally and global thresholds (if any) will take effect. Look at the *Thresholds*
+            section for information on how to set threshold levels.
+        actions
+            Optional actions to take when the validation step meets or exceeds any set threshold
+            levels. If provided, the [`Actions`](`pointblank.Actions`) class should be used to
+            define the actions.
+        brief
+            An optional brief description of the validation step that will be displayed in the
+            reporting table. You can use the templating elements like `"{step}"` to insert
+            the step number, or `"{auto}"` to include an automatically generated brief. If `True`
+            the entire brief will be automatically generated. If `None` (the default) then there
+            won't be a brief.
+        active
+            A boolean value indicating whether the validation step should be active. Using `False`
+            will make the validation step inactive (still reporting its presence and keeping indexes
+            for the steps unchanged).
+
+        Returns
+        -------
+        Validate
+            The `Validate` object with the added validation step.
+
+        Preprocessing
+        -------------
+        The `pre=` argument allows for a preprocessing function or lambda to be applied to the data
+        table during interrogation. This function should take a table as input and return a modified
+        table. This is useful for performing any necessary transformations or filtering on the data
+        before the validation step is applied.
+
+        The preprocessing function can be any callable that takes a table as input and returns a
+        modified table. For example, you could use a lambda function to filter the table based on
+        certain criteria or to apply a transformation to the data. Regarding the lifetime of the
+        transformed table, it only exists during the validation step and is not stored in the
+        `Validate` object or used in subsequent validation steps.
+
+        Thresholds
+        ----------
+        The `thresholds=` parameter is used to set the failure-condition levels for the validation
+        step. If they are set here at the step level, these thresholds will override any thresholds
+        set at the global level in `Validate(thresholds=...)`.
+
+        There are three threshold levels: 'warning', 'error', and 'critical'. The threshold values
+        can either be set as a proportion failing of all test units (a value between `0` to `1`),
+        or, the absolute number of failing test units (as integer that's `1` or greater).
+
+        Thresholds can be defined using one of these input schemes:
+
+        1. use the [`Thresholds`](`pointblank.Thresholds`) class (the most direct way to create
+        thresholds)
+        2. provide a tuple of 1-3 values, where position `0` is the 'warning' level, position `1` is
+        the 'error' level, and position `2` is the 'critical' level
+        3. create a dictionary of 1-3 value entries; the valid keys: are 'warning', 'error', and
+        'critical'
+        4. a single integer/float value denoting absolute number or fraction of failing test units
+        for the 'warning' level only
+
+        If the number of failing test units exceeds set thresholds, the validation step will be
+        marked as 'warning', 'error', or 'critical'. All of the threshold levels don't need to be
+        set, you're free to set any combination of them.
+
+        Aside from reporting failure conditions, thresholds can be used to determine the actions to
+        take for each level of failure (using the `actions=` parameter).
+
+        Examples
+        --------
+        ```{python}
+        #| echo: false
+        #| output: false
+        import pointblank as pb
+        pb.config(report_incl_header=False, report_incl_footer=False)
+        ```
+
+        For the examples here, we'll use the built in dataset `"game_revenue"`. The table can be
+        obtained by calling `load_dataset("game_revenue")`.
 
         ```{python}
         import pointblank as pb
 
-        small_table = pb.load_dataset("small_table")
-
-        pb.preview(small_table)
-        ```
-
-        Let's validate that the number of rows in the table matches a fixed value. In this case, we
-        will use the value `13` as the expected row count.
-
-        ```{python}
-        validation = (
-            pb.Validate(data=small_table)
-            .row_count_match(count=13)
-            .interrogate()
-        )
+        game_revenue = pb.load_dataset("game_revenue")
 
-        validation
+        pb.preview(game_revenue)
         ```
 
-        The validation table shows that the expectation value of `13` matches the actual count of
-        rows in the target table. So, the single test unit passed.
-
-
-        Let's modify our example to show the different ways we can allow some tolerance to our validation
-        by using the `tol` argument.
+        Let's validate that the number of columns in the table matches a fixed value. In this case,
+        we will use the value `11` as the expected column count.
 
         ```{python}
-        smaller_small_table = small_table.sample(n = 12) # within the lower bound
-        validation = (
-            pb.Validate(data=smaller_small_table)
-            .row_count_match(count=13,tol=(2, 0)) # minus 2 but plus 0, ie. 11-13
-            .interrogate()
-        )
-
-        validation
-
-        validation = (
-            pb.Validate(data=smaller_small_table)
-            .row_count_match(count=13,tol=.05) # .05% tolerance of 13
-            .interrogate()
-        )
-
-        even_smaller_table = small_table.sample(n = 2)
         validation = (
-            pb.Validate(data=even_smaller_table)
-            .row_count_match(count=13,tol=5) # plus or minus 5; this test will fail
+            pb.Validate(data=game_revenue)
+            .col_count_match(count=11)
             .interrogate()
         )
 
         validation
         ```
 
+        The validation table shows that the expectation value of `11` matches the actual count of
+        columns in the target table. So, the single test unit passed.
         """
 
         assertion_type = _get_fn_name()
@@ -10160,16 +11170,13 @@ class Validate:
             self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
         )
 
-        # If `count` is a DataFrame or table then use the row count of the DataFrame as
+        # If `count` is a DataFrame or table then use the column count of the DataFrame as
         # the expected count
         if _is_value_a_df(count) or "ibis.expr.types.relations.Table" in str(type(count)):
-            count = get_row_count(count)
-
-        # Check the integrity of tolerance
-        bounds: AbsoluteBounds = _derive_bounds(ref=int(count), tol=tol)
+            count = get_column_count(count)
 
         # Package up the `count=` and boolean params into a dictionary for later interrogation
-        values = {"count": count, "inverse": inverse, "abs_tol_bounds": bounds}
+        values = {"count": count, "inverse": inverse}
 
         # Determine brief to use (global or local) and transform any shorthands of `brief=`
         brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
@@ -10188,10 +11195,9 @@ class Validate:
 
         return self
 
-    def col_count_match(
+    def tbl_match(
         self,
-        count: int | FrameT | Any,
-        inverse: bool = False,
+        tbl_compare: FrameT | Any,
         pre: Callable | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
         actions: Actions | None = None,
@@ -10199,25 +11205,29 @@ class Validate:
         active: bool = True,
     ) -> Validate:
         """
-        Validate whether the column count of the table matches a specified count.
+        Validate whether the target table matches a comparison table.
 
-        The `col_count_match()` method checks whether the column count of the target table matches a
-        specified count. This validation will operate over a single test unit, which is whether the
-        column count matches the specified count.
+        The `tbl_match()` method checks whether the target table's composition matches that of a
+        comparison table. The validation performs a comprehensive comparison using progressively
+        stricter checks (from least to most stringent):
 
-        We also have the option to invert the validation step by setting `inverse=True`. This will
-        make the expectation that column row count of the target table *does not* match the
-        specified count.
+        1. **Column count match**: both tables must have the same number of columns
+        2. **Row count match**: both tables must have the same number of rows
+        3. **Schema match (loose)**: column names and dtypes match (case-insensitive, any order)
+        4. **Schema match (order)**: columns in the correct order (case-insensitive names)
+        5. **Schema match (exact)**: column names match exactly (case-sensitive, correct order)
+        6. **Data match**: values in corresponding cells must be identical
+
+        This progressive approach helps identify exactly where tables differ. The validation will
+        fail at the first check that doesn't pass, making it easier to diagnose mismatches. This
+        validation operates over a single test unit (pass/fail for complete table match).
 
         Parameters
         ----------
-        count
-            The expected column count of the table. This can be an integer value, a Polars or Pandas
-            DataFrame object, or an Ibis backend table. If a DataFrame/table is provided, the column
-            count of that object will be used as the expected count.
-        inverse
-            Should the validation step be inverted? If `True`, then the expectation is that the
-            column count of the target table should not match the specified `count=` value.
+        tbl_compare
+            The comparison table to validate against. This can be a DataFrame object (Polars or
+            Pandas), an Ibis table object, or a callable that returns a table. If a callable is
+            provided, it will be executed during interrogation to obtain the comparison table.
         pre
             An optional preprocessing function or lambda to apply to the data table during
             interrogation. This function should take a table as input and return a modified table.
@@ -10258,9 +11268,10 @@ class Validate:
 
         The preprocessing function can be any callable that takes a table as input and returns a
         modified table. For example, you could use a lambda function to filter the table based on
-        certain criteria or to apply a transformation to the data. Regarding the lifetime of the
-        transformed table, it only exists during the validation step and is not stored in the
-        `Validate` object or used in subsequent validation steps.
+        certain criteria or to apply a transformation to the data. Note that the same preprocessing
+        is **not** applied to the comparison table; only the target table is preprocessed. Regarding
+        the lifetime of the transformed table, it only exists during the validation step and is not
+        stored in the `Validate` object or used in subsequent validation steps.
 
         Thresholds
         ----------
@@ -10290,6 +11301,66 @@ class Validate:
         Aside from reporting failure conditions, thresholds can be used to determine the actions to
         take for each level of failure (using the `actions=` parameter).
 
+        Cross-Backend Validation
+        ------------------------
+        The `tbl_match()` method supports **automatic backend coercion** when comparing tables from
+        different backends (e.g., comparing a Polars DataFrame against a Pandas DataFrame, or
+        comparing database tables from DuckDB/SQLite against in-memory DataFrames). When tables with
+        different backends are detected, the comparison table is automatically converted to match the
+        data table's backend before validation proceeds.
+
+        **Certified Backend Combinations:**
+
+        All combinations of the following backends have been tested and certified to work (in both
+        directions):
+
+        - Pandas DataFrame
+        - Polars DataFrame
+        - DuckDB (native)
+        - DuckDB (as Ibis table)
+        - SQLite (via Ibis)
+
+        Note that database backends (DuckDB, SQLite, PostgreSQL, MySQL, Snowflake, BigQuery) are
+        automatically materialized during validation:
+
+        - if comparing **against Polars**: materialized to Polars
+        - if comparing **against Pandas**: materialized to Pandas
+        - if **both tables are database backends**: both materialized to Polars
+
+        This ensures optimal performance and type consistency.
+
+        **Data Types That Work Best in Cross-Backend Validation:**
+
+        - numeric types: int, float columns (including proper NaN handling)
+        - string types: text columns with consistent encodings
+        - boolean types: True/False values
+        - null values: `None` and `NaN` are treated as equivalent across backends
+        - list columns: nested list structures (with basic types)
+
+        **Known Limitations:**
+
+        While many data types work well in cross-backend validation, there are some known
+        limitations to be aware of:
+
+        - date/datetime types: When converting between Polars and Pandas, date objects may be
+          represented differently. For example, `datetime.date` objects in Pandas may become
+          `pd.Timestamp` objects when converted from Polars, leading to false mismatches. To work
+          around this, ensure both tables use the same datetime representation before comparison.
+        - custom types: User-defined types or complex nested structures may not convert cleanly
+          between backends and could cause unexpected comparison failures.
+        - categorical types: Categorical/factor columns may have different internal
+          representations across backends.
+        - timezone-aware datetimes: Timezone handling differs between backends and may cause
+          comparison issues.
+
+        Here are some ideas to overcome such limitations:
+
+        - for date/datetime columns, consider using `pre=` preprocessing to normalize representations
+          before comparison.
+        - when working with custom types, manually convert tables to the same backend before using
+          `tbl_match()`.
+        - use the same datetime precision (e.g., milliseconds vs microseconds) in both tables.
+
         Examples
         --------
         ```{python}
@@ -10299,32 +11370,67 @@ class Validate:
         pb.config(report_incl_header=False, report_incl_footer=False)
         ```
 
-        For the examples here, we'll use the built in dataset `"game_revenue"`. The table can be
-        obtained by calling `load_dataset("game_revenue")`.
+        For the examples here, we'll create two simple tables to demonstrate the `tbl_match()`
+        validation.
 
         ```{python}
         import pointblank as pb
+        import polars as pl
 
-        game_revenue = pb.load_dataset("game_revenue")
+        # Create the first table
+        tbl_1 = pl.DataFrame({
+            "a": [1, 2, 3, 4],
+            "b": ["w", "x", "y", "z"],
+            "c": [4.0, 5.0, 6.0, 7.0]
+        })
 
-        pb.preview(game_revenue)
+        # Create an identical table
+        tbl_2 = pl.DataFrame({
+            "a": [1, 2, 3, 4],
+            "b": ["w", "x", "y", "z"],
+            "c": [4.0, 5.0, 6.0, 7.0]
+        })
+
+        pb.preview(tbl_1)
         ```
 
-        Let's validate that the number of columns in the table matches a fixed value. In this case,
-        we will use the value `11` as the expected column count.
+        Let's validate that `tbl_1` matches `tbl_2`. Since these tables are identical, the
+        validation should pass.
 
         ```{python}
         validation = (
-            pb.Validate(data=game_revenue)
-            .col_count_match(count=11)
+            pb.Validate(data=tbl_1)
+            .tbl_match(tbl_compare=tbl_2)
             .interrogate()
         )
 
         validation
         ```
 
-        The validation table shows that the expectation value of `11` matches the actual count of
-        columns in the target table. So, the single test unit passed.
+        The validation table shows that the single test unit passed, indicating that the two tables
+        match completely.
+
+        Now, let's create a table with a slight difference and see what happens.
+
+        ```{python}
+        # Create a table with one different value
+        tbl_3 = pl.DataFrame({
+            "a": [1, 2, 3, 4],
+            "b": ["w", "x", "y", "z"],
+            "c": [4.0, 5.5, 6.0, 7.0]  # Changed 5.0 to 5.5
+        })
+
+        validation = (
+            pb.Validate(data=tbl_1)
+            .tbl_match(tbl_compare=tbl_3)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        The validation table shows that the single test unit failed because the tables don't match
+        (one value is different in column `c`).
         """
 
         assertion_type = _get_fn_name()
@@ -10332,20 +11438,14 @@ class Validate:
         _check_pre(pre=pre)
         _check_thresholds(thresholds=thresholds)
         _check_boolean_input(param=active, param_name="active")
-        _check_boolean_input(param=inverse, param_name="inverse")
 
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
         thresholds = (
             self.thresholds if thresholds is None else _normalize_thresholds_creation(thresholds)
         )
 
-        # If `count` is a DataFrame or table then use the column count of the DataFrame as
-        # the expected count
-        if _is_value_a_df(count) or "ibis.expr.types.relations.Table" in str(type(count)):
-            count = get_column_count(count)
-
-        # Package up the `count=` and boolean params into a dictionary for later interrogation
-        values = {"count": count, "inverse": inverse}
+        # Package up the `tbl_compare` into a dictionary for later interrogation
+        values = {"tbl_compare": tbl_compare}
 
         # Determine brief to use (global or local) and transform any shorthands of `brief=`
         brief = self.brief if brief is None else _transform_auto_brief(brief=brief)
@@ -11275,11 +12375,14 @@ class Validate:
                         "col_vals_le",
                         "col_vals_null",
                         "col_vals_not_null",
+                        "col_vals_increasing",
+                        "col_vals_decreasing",
                         "col_vals_between",
                         "col_vals_outside",
                         "col_vals_in_set",
                         "col_vals_not_in_set",
                         "col_vals_regex",
+                        "col_vals_within_spec",
                     ]:
                         # Process table for column validation
                         tbl = _column_test_prep(
@@ -11315,6 +12418,36 @@ class Validate:
                         elif assertion_method == "not_null":
                             results_tbl = interrogate_not_null(tbl=tbl, column=column)
 
+                        elif assertion_type == "col_vals_increasing":
+                            from pointblank._interrogation import interrogate_increasing
+
+                            # Extract direction options from val_info
+                            allow_stationary = validation.val_info.get("allow_stationary", False)
+                            decreasing_tol = validation.val_info.get("decreasing_tol", 0.0)
+
+                            results_tbl = interrogate_increasing(
+                                tbl=tbl,
+                                column=column,
+                                allow_stationary=allow_stationary,
+                                decreasing_tol=decreasing_tol,
+                                na_pass=na_pass,
+                            )
+
+                        elif assertion_type == "col_vals_decreasing":
+                            from pointblank._interrogation import interrogate_decreasing
+
+                            # Extract direction options from val_info
+                            allow_stationary = validation.val_info.get("allow_stationary", False)
+                            increasing_tol = validation.val_info.get("increasing_tol", 0.0)
+
+                            results_tbl = interrogate_decreasing(
+                                tbl=tbl,
+                                column=column,
+                                allow_stationary=allow_stationary,
+                                increasing_tol=increasing_tol,
+                                na_pass=na_pass,
+                            )
+
                         elif assertion_type == "col_vals_between":
                             results_tbl = interrogate_between(
                                 tbl=tbl,
@@ -11348,6 +12481,13 @@ class Validate:
                                 tbl=tbl, column=column, values=value, na_pass=na_pass
                             )
 
+                        elif assertion_type == "col_vals_within_spec":
+                            from pointblank._interrogation import interrogate_within_spec
+
+                            results_tbl = interrogate_within_spec(
+                                tbl=tbl, column=column, values=value, na_pass=na_pass
+                            )
+
                     elif assertion_type == "col_vals_expr":
                         results_tbl = col_vals_expr(
                             data_tbl=data_tbl_step, expr=value, tbl_type=tbl_type
@@ -11441,6 +12581,25 @@ class Validate:
 
                         results_tbl = None
 
+                    elif assertion_type == "tbl_match":
+                        from pointblank._interrogation import tbl_match
+
+                        # Get the comparison table (could be callable or actual table)
+                        tbl_compare = value["tbl_compare"]
+
+                        # If tbl_compare is callable, execute it to get the table
+                        if callable(tbl_compare):
+                            tbl_compare = tbl_compare()
+
+                        result_bool = tbl_match(data_tbl=data_tbl_step, tbl_compare=tbl_compare)
+
+                        validation.all_passed = result_bool
+                        validation.n = 1
+                        validation.n_passed = int(result_bool)
+                        validation.n_failed = 1 - result_bool
+
+                        results_tbl = None
+
                     elif assertion_type == "conjointly":
                         results_tbl = conjointly_validation(
                             data_tbl=data_tbl_step,
@@ -13501,6 +14660,151 @@ class Validate:
 
         return sundered_tbl
 
+    def get_notes(
+        self, i: int, format: str = "dict"
+    ) -> dict[str, dict[str, str]] | list[str] | None:
+        """
+        Get notes from a validation step by its step number.
+
+        This is a convenience method that retrieves notes from a specific validation step using
+        the step number (1-indexed). It provides easier access to step notes without having to
+        navigate through the `validation_info` list.
+
+        Parameters
+        ----------
+        i
+            The step number (1-indexed) to retrieve notes from. This corresponds to the step
+            numbers shown in validation reports.
+        format
+            The format to return notes in:
+            - `"dict"`: Returns the full notes dictionary (default)
+            - `"markdown"`: Returns a list of markdown-formatted note values
+            - `"text"`: Returns a list of plain text note values
+            - `"keys"`: Returns a list of note keys
+
+        Returns
+        -------
+        dict, list, or None
+            The notes in the requested format, or `None` if the step doesn't exist or has no notes.
+
+        Examples
+        --------
+        ```python
+        import pointblank as pb
+        import polars as pl
+
+        # Create validation with notes
+        validation = pb.Validate(pl.DataFrame({"x": [1, 2, 3]}))
+        validation.col_vals_gt(columns="x", value=0)
+
+        # Add a note to step 1
+        validation.validation_info[0]._add_note(
+            key="info",
+            markdown="This is a **test** note",
+            text="This is a test note"
+        )
+
+        # Interrogate
+        validation.interrogate()
+
+        # Get notes from step 1 using the step number
+        notes = validation.get_notes(1)
+        # Returns: {'info': {'markdown': 'This is a **test** note', 'text': '...'}}
+
+        # Get just the markdown versions
+        markdown_notes = validation.get_notes(1, format="markdown")
+        # Returns: ['This is a **test** note']
+
+        # Get just the keys
+        keys = validation.get_notes(1, format="keys")
+        # Returns: ['info']
+        ```
+        """
+        # Validate step number
+        if not isinstance(i, int) or i < 1:
+            raise ValueError(f"Step number must be a positive integer, got: {i}")
+
+        # Find the validation step with the matching step number
+        # Note: validation_info may contain multiple steps after segmentation,
+        # so we need to find the one with the matching `i` value
+        for validation in self.validation_info:
+            if validation.i == i:
+                return validation._get_notes(format=format)
+
+        # Step not found
+        return None
+
+    def get_note(self, i: int, key: str, format: str = "dict") -> dict[str, str] | str | None:
+        """
+        Get a specific note from a validation step by its step number and note key.
+
+        This method retrieves a specific note from a validation step using the step number
+        (1-indexed) and the note key. It provides easier access to individual notes without having
+        to navigate through the `validation_info` list or retrieve all notes.
+
+        Parameters
+        ----------
+        i
+            The step number (1-indexed) to retrieve the note from. This corresponds to the step
+            numbers shown in validation reports.
+        key
+            The key of the note to retrieve.
+        format
+            The format to return the note in:
+            - `"dict"`: Returns the note as a dictionary with 'markdown' and 'text' keys (default)
+            - `"markdown"`: Returns just the markdown-formatted note value
+            - `"text"`: Returns just the plain text note value
+
+        Returns
+        -------
+        dict, str, or None
+            The note in the requested format, or `None` if the step or note doesn't exist.
+
+        Examples
+        --------
+        ```python
+        import pointblank as pb
+        import polars as pl
+
+        # Create validation with notes
+        validation = pb.Validate(pl.DataFrame({"x": [1, 2, 3]}))
+        validation.col_vals_gt(columns="x", value=0)
+
+        # Add a note to step 1
+        validation.validation_info[0]._add_note(
+            key="threshold_info",
+            markdown="Using **default** thresholds",
+            text="Using default thresholds"
+        )
+
+        # Interrogate
+        validation.interrogate()
+
+        # Get a specific note from step 1 using step number and key
+        note = validation.get_note(1, "threshold_info")
+        # Returns: {'markdown': 'Using **default** thresholds', 'text': '...'}
+
+        # Get just the markdown version
+        markdown = validation.get_note(1, "threshold_info", format="markdown")
+        # Returns: 'Using **default** thresholds'
+
+        # Get just the text version
+        text = validation.get_note(1, "threshold_info", format="text")
+        # Returns: 'Using default thresholds'
+        ```
+        """
+        # Validate step number
+        if not isinstance(i, int) or i < 1:
+            raise ValueError(f"Step number must be a positive integer, got: {i}")
+
+        # Find the validation step with the matching step number
+        for validation in self.validation_info:
+            if validation.i == i:
+                return validation._get_note(key=key, format=format)
+
+        # Step not found
+        return None
+
     def get_tabular_report(
         self, title: str | None = ":default:", incl_header: bool = None, incl_footer: bool = None
     ) -> GT:
@@ -13907,6 +15211,9 @@ class Validate:
             elif assertion_type[i] in ["col_vals_expr", "conjointly"]:
                 values_upd.append("COLUMN EXPR")
 
+            elif assertion_type[i] in ["col_vals_increasing", "col_vals_decreasing"]:
+                values_upd.append("")
+
             elif assertion_type[i] in ["row_count_match", "col_count_match"]:
                 count = values[i]["count"]
                 inverse = values[i]["inverse"]
@@ -13916,6 +15223,9 @@ class Validate:
 
                 values_upd.append(str(count))
 
+            elif assertion_type[i] in ["tbl_match"]:
+                values_upd.append("EXTERNAL TABLE")
+
             elif assertion_type[i] in ["specially"]:
                 values_upd.append("EXPR")
 
@@ -13924,6 +15234,11 @@ class Validate:
 
                 values_upd.append(str(pattern))
 
+            elif assertion_type[i] in ["col_vals_within_spec"]:
+                spec = value["spec"]
+
+                values_upd.append(str(spec))
+
             elif assertion_type[i] in ["prompt"]:  # pragma: no cover
                 # For AI validation, show only the prompt, not the full config
                 if isinstance(value, dict) and "prompt" in value:  # pragma: no cover
@@ -14180,6 +15495,7 @@ class Validate:
         validation_info_dict.pop("label")
         validation_info_dict.pop("active")
         validation_info_dict.pop("all_passed")
+        validation_info_dict.pop("notes")
 
         # If no interrogation performed, populate the `i` entry with a sequence of integers
         # from `1` to the number of validation steps
@@ -14364,8 +15680,14 @@ class Validate:
             gt_tbl = gt_tbl.tab_header(title=html(title_text), subtitle=html(combined_subtitle))
 
         if incl_footer:
+            # Add table time as HTML source note
             gt_tbl = gt_tbl.tab_source_note(source_note=html(table_time))
 
+            # Create notes markdown from validation steps and add as separate source note
+            notes_markdown = _create_notes_html(self.validation_info)
+            if notes_markdown:
+                gt_tbl = gt_tbl.tab_source_note(source_note=md(notes_markdown))
+
         # If the interrogation has not been performed, then style the table columns dealing with
         # interrogation data as grayed out
         if not interrogation_performed:
@@ -16064,6 +17386,7 @@ def _validation_info_as_dict(validation_info: _ValidationInfo) -> dict:
         "critical",
         "extract",
         "proc_duration_s",
+        "notes",
     ]
 
     # Filter the validation information to include only the selected fields
@@ -16407,6 +17730,14 @@ def _transform_assertion_str(
         # Use Markdown-to-HTML conversion to format the `brief_str` text
         brief_str = [commonmark.commonmark(x) for x in brief_str]
 
+        # Add inline styles to <p> tags for proper rendering in all environments
+        # In some sandboxed HTML environments (e.g., Streamlit), <p> tags don't inherit
+        # font-size from parent divs, so we add inline styles directly to the <p> tags
+        brief_str = [
+            re.sub(r"<p>", r'<p style="font-size: inherit; margin: 0;">', x) if x.strip() else x
+            for x in brief_str
+        ]
+
     # Obtain the number of characters contained in the assertion
     # string; this is important for sizing components appropriately
     assertion_type_nchar = [len(x) for x in assertion_str]
@@ -16535,6 +17866,86 @@ def _create_table_time_html(
     )
 
 
+def _create_notes_html(validation_info: list) -> str:
+    """
+    Create markdown text for validation notes/footnotes.
+
+    This function collects notes from all validation steps and formats them as footnotes
+    for display in the report footer. Each note is prefixed with the step number in
+    uppercase small caps bold formatting, and the note content is rendered as markdown.
+
+    Parameters
+    ----------
+    validation_info
+        List of _ValidationInfo objects from which to extract notes.
+
+    Returns
+    -------
+    str
+        Markdown string containing formatted footnotes, or empty string if no notes exist.
+    """
+    # Collect all notes from validation steps
+    all_notes = []
+    for step in validation_info:
+        if step.notes:
+            for key, content in step.notes.items():
+                # Store note with step number for context
+                all_notes.append(
+                    {
+                        "step": step.i,
+                        "key": key,
+                        "markdown": content["markdown"],
+                        "text": content["text"],
+                    }
+                )
+
+    # If no notes, return empty string
+    if not all_notes:
+        return ""
+
+    # Build markdown for notes section
+    # Start with a styled horizontal rule and bold "Notes" header
+    notes_parts = [
+        (
+            "<hr style='border: none; border-top-width: 1px; border-top-style: dotted; "
+            "border-top-color: #B5B5B5; margin-top: -3px; margin-bottom: 3px;'>"
+        ),
+        "<strong>Notes</strong>",
+        "",
+    ]
+
+    previous_step = None
+    for note in all_notes:
+        # Determine if this is the first note for this step
+        is_first_for_step = note["step"] != previous_step
+        previous_step = note["step"]
+
+        # Format step label with HTML for uppercase small caps bold
+        # Use lighter color for subsequent notes of the same step
+        step_color = "#333333" if is_first_for_step else "#999999"
+        step_label = (
+            f"<span style='font-variant: small-caps; font-weight: bold; font-size: smaller; "
+            f"text-transform: uppercase; color: {step_color};'>Step {note['step']}</span>"
+        )
+
+        # Format note key in monospaced font with smaller size
+        note_key = f"<span style='font-family: \"IBM Plex Mono\", monospace; font-size: smaller;'>({note['key']})</span>"
+
+        # Combine step label, note key, and markdown content
+        note_text = f"{step_label} {note_key} {note['markdown']}"
+        notes_parts.append(note_text)
+        notes_parts.append("")  # Add blank line between notes
+
+    # Remove trailing blank line
+    if notes_parts[-1] == "":
+        notes_parts.pop()
+
+    # Join with newlines to create markdown text
+    notes_markdown = "\n".join(notes_parts)
+
+    return notes_markdown
+
+
 def _create_label_html(label: str | None, start_time: str) -> str:
     if label is None:
         # Remove the decimal and everything beyond that