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

pointblank/column.py

@@ -268,9 +268,12 @@ def col(
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     If specifying a single column with certainty (you have the exact name), `col()` is not necessary
@@ -568,9 +571,12 @@ def starts_with(text: str, case_sensitive: bool = False) -> StartsWith:
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `starts_with()` selector function doesn't need to be used in isolation. Read the next
@@ -727,9 +733,12 @@ def ends_with(text: str, case_sensitive: bool = False) -> EndsWith:
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `ends_with()` selector function doesn't need to be used in isolation. Read the next section
@@ -887,9 +896,12 @@ def contains(text: str, case_sensitive: bool = False) -> Contains:
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `contains()` selector function doesn't need to be used in isolation. Read the next section
@@ -1047,9 +1059,12 @@ def matches(pattern: str, case_sensitive: bool = False) -> Matches:
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `matches()` selector function doesn't need to be used in isolation. Read the next section
@@ -1189,9 +1204,12 @@ def everything() -> Everything:
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `everything()` selector function doesn't need to be used in isolation. Read the next section
@@ -1341,9 +1359,12 @@ def first_n(n: int, offset: int = 0) -> FirstN:
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `first_n()` selector function doesn't need to be used in isolation. Read the next section
@@ -1497,9 +1518,12 @@ def last_n(n: int, offset: int = 0) -> LastN:
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `last_n()` selector function doesn't need to be used in isolation. Read the next section for

pointblank/data/api-docs.txt

@@ -289,6 +289,16 @@ Validate(data: 'FrameT | Any', tbl_name: 'str | None' = None, label: 'str | None
     - Vietnamese (`"vi"`)
     - Indonesian (`"id"`)
     - Ukrainian (`"uk"`)
+    - Bulgarian (`"bg"`)
+    - Croatian (`"hr"`)
+    - Estonian (`"et"`)
+    - Hungarian (`"hu"`)
+    - Irish (`"ga"`)
+    - Latvian (`"lv"`)
+    - Lithuanian (`"lt"`)
+    - Maltese (`"mt"`)
+    - Slovak (`"sk"`)
+    - Slovenian (`"sl"`)
     - Hebrew (`"he"`)
     - Thai (`"th"`)
     - Persian (`"fa"`)
@@ -5392,6 +5402,247 @@ col_exists(self, columns: 'str | list[str] | Column | ColumnSelector | ColumnSel
         failing validation step (the check for column `c`, which doesn't exist).
         
 
+col_pct_null(self, columns: 'str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals', p: 'float', tol: 'Tolerance' = 0, thresholds: 'int | float | None | bool | tuple | dict | Thresholds' = None, actions: 'Actions | None' = None, brief: 'str | bool | None' = None, active: 'bool' = True) -> 'Validate'
+
+        Validate whether a column has a specific percentage of Null values.
+
+        The `col_pct_null()` validation method checks whether the percentage of Null values in a
+        column matches a specified percentage `p=` (within an optional tolerance `tol=`). This
+        validation operates at the column level, generating a single validation step per column that
+        passes or fails based on whether the actual percentage of Null values falls within the
+        acceptable range defined by `p ± tol`.
+
+        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.
+        p
+            The expected percentage of Null values in the column, expressed as a decimal between
+            `0.0` and `1.0`. For example, `p=0.5` means 50% of values should be Null.
+        tol
+            The tolerance allowed when comparing the actual percentage of Null values to the
+            expected percentage `p=`. The validation passes if the actual percentage falls within
+            the range `[p - tol, p + tol]`. Default is `0`, meaning an exact match is required. See
+            the *Tolerance* section for details on all supported formats (absolute, relative,
+            symmetric, and asymmetric bounds).
+        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.
+
+        Tolerance
+        ---------
+        The `tol=` parameter accepts several different formats to specify the acceptable deviation
+        from the expected percentage `p=`. The tolerance can be expressed as:
+
+        1. *single integer* (absolute tolerance): the exact number of test units that can deviate.
+        For example, `tol=2` means the actual count can differ from the expected count by up to 2
+        units in either direction.
+
+        2. *single float between 0 and 1* (relative tolerance): a proportion of the expected
+        count. For example, if the expected count is 50 and `tol=0.1`, the acceptable range is
+        45 to 55 (50 ± 10% of 50 = 50 ± 5).
+
+        3. *tuple of two integers* (absolute bounds): explicitly specify the lower and upper
+        bounds as absolute deviations. For example, `tol=(1, 3)` means the actual count can be
+        1 unit below or 3 units above the expected count.
+
+        4. *tuple of two floats between 0 and 1* (relative bounds): explicitly specify the lower
+        and upper bounds as proportional deviations. For example, `tol=(0.05, 0.15)` means the
+        lower bound is 5% below and the upper bound is 15% above the expected count.
+
+        When using a single value (integer or float), the tolerance is applied symmetrically in both
+        directions. When using a tuple, you can specify asymmetric tolerances where the lower and
+        upper bounds differ.
+
+        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
+        --------
+        For the examples here, we'll use a simple Polars DataFrame with three columns (`a`, `b`,
+        and `c`) that have different percentages of Null values. The table is shown below:
+
+        ```python
+        import pointblank as pb
+        import polars as pl
+
+        tbl = pl.DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5, 6, 7, 8],
+                "b": [1, None, 3, None, 5, None, 7, None],
+                "c": [None, None, None, None, None, None, 1, 2],
+            }
+        )
+
+        pb.preview(tbl)
+        ```
+
+        Let's validate that column `a` has 0% Null values (i.e., no Null values at all).
+
+        ```python
+        validation = (
+            pb.Validate(data=tbl)
+            .col_pct_null(columns="a", p=0.0)
+            .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_pct_null()`. The validation passed since column `a` has no Null values.
+
+        Now, let's check that column `b` has exactly 50% Null values.
+
+        ```python
+        validation = (
+            pb.Validate(data=tbl)
+            .col_pct_null(columns="b", p=0.5)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This validation also passes, as column `b` has exactly 4 out of 8 values as Null (50%).
+
+        Finally, let's validate column `c` with a tolerance. Column `c` has 75% Null values, so
+        we'll check if it's approximately 70% Null with a tolerance of 10%.
+
+        ```python
+        validation = (
+            pb.Validate(data=tbl)
+            .col_pct_null(columns="c", p=0.70, tol=0.10)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This validation passes because the actual percentage (75%) falls within the acceptable
+        range of 60% to 80% (70% ± 10%).
+
+        The `tol=` parameter supports multiple formats to express tolerance. Let's explore all the
+        different ways to specify tolerance using column `b`, which has exactly 50% Null values
+        (4 out of 8 values).
+
+        *Using an absolute tolerance (integer)*: Specify the exact number of rows that can
+        deviate. With `tol=1`, we allow the count to differ by 1 row in either direction.
+
+        ```python
+        validation = (
+            pb.Validate(data=tbl)
+            .col_pct_null(columns="b", p=0.375, tol=1)  # Expect 3 nulls, allow ±1 (range: 2-4)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This passes because column `b` has 4 Null values, which falls within the acceptable range
+        of 2 to 4 (3 ± 1).
+
+        *Using a relative tolerance (float)*: Specify the tolerance as a proportion of the
+        expected count. With `tol=0.25`, we allow a 25% deviation from the expected count.
+
+        ```python
+        validation = (
+            pb.Validate(data=tbl)
+            .col_pct_null(columns="b", p=0.375, tol=0.25)  # Expect 3 nulls, allow ±25% (range: 2.25-3.75)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This passes because 4 Null values falls within the acceptable range (3 ± 0.75 calculates
+        to 2.25 to 3.75, which rounds down to 2 to 3 rows).
+
+        *Using asymmetric absolute bounds (tuple of integers)*: Specify different lower and
+        upper bounds as absolute values. With `tol=(0, 2)`, we allow no deviation below but up
+        to 2 rows above the expected count.
+
+        ```python
+        validation = (
+            pb.Validate(data=tbl)
+            .col_pct_null(columns="b", p=0.25, tol=(0, 2))  # Expect 2 Nulls, allow +0/-2 (range: 2-4)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This passes because 4 Null values falls within the acceptable range of 2 to 4.
+
+        *Using asymmetric relative bounds (tuple of floats)*: Specify different lower and upper
+        bounds as proportions. With `tol=(0.1, 0.3)`, we allow 10% below and 30% above the
+        expected count.
+
+        ```python
+        validation = (
+            pb.Validate(data=tbl)
+            .col_pct_null(columns="b", p=0.375, tol=(0.1, 0.3)  # Expect 3 Nulls, allow -10%/+30%
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This passes because 4 Null values falls within the acceptable range (3 - 0.3 to 3 + 0.9
+        calculates to 2.7 to 3.9, which rounds down to 2 to 3 rows).
+        
+
 col_schema_match(self, schema: 'Schema', complete: 'bool' = True, in_order: 'bool' = True, case_sensitive_colnames: 'bool' = True, case_sensitive_dtypes: 'bool' = True, full_match_dtypes: 'bool' = True, 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'
 
         Do columns in the table (and their types) match a predefined schema?
@@ -6907,9 +7158,12 @@ col(exprs: 'str | ColumnSelector | ColumnSelectorNarwhals') -> 'Column | ColumnL
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     If specifying a single column with certainty (you have the exact name), `col()` is not necessary
@@ -7191,9 +7445,12 @@ starts_with(text: 'str', case_sensitive: 'bool' = False) -> 'StartsWith'
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `starts_with()` selector function doesn't need to be used in isolation. Read the next
@@ -7341,9 +7598,12 @@ ends_with(text: 'str', case_sensitive: 'bool' = False) -> 'EndsWith'
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `ends_with()` selector function doesn't need to be used in isolation. Read the next section
@@ -7492,9 +7752,12 @@ contains(text: 'str', case_sensitive: 'bool' = False) -> 'Contains'
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `contains()` selector function doesn't need to be used in isolation. Read the next section
@@ -7643,9 +7906,12 @@ matches(pattern: 'str', case_sensitive: 'bool' = False) -> 'Matches'
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `matches()` selector function doesn't need to be used in isolation. Read the next section
@@ -7776,9 +8042,12 @@ everything() -> 'Everything'
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `everything()` selector function doesn't need to be used in isolation. Read the next section
@@ -7919,9 +8188,12 @@ first_n(n: 'int', offset: 'int' = 0) -> 'FirstN'
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `first_n()` selector function doesn't need to be used in isolation. Read the next section
@@ -8066,9 +8338,12 @@ last_n(n: 'int', offset: 'int' = 0) -> 'LastN'
     - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
     - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
     - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+    - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+    - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
     - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
     - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
     - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+    - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
     - [`col_exists()`](`pointblank.Validate.col_exists`)
 
     The `last_n()` selector function doesn't need to be used in isolation. Read the next section for
@@ -8562,7 +8837,7 @@ set_tbl(self, tbl: 'FrameT | Any', tbl_name: 'str | None' = None, label: 'str |
         ```
         
 
-get_tabular_report(self, title: 'str | None' = ':default:', incl_header: 'bool' = None, incl_footer: 'bool' = None) -> 'GT'
+get_tabular_report(self, title: 'str | None' = ':default:', incl_header: 'bool' = None, incl_footer: 'bool' = None, incl_footer_timings: 'bool' = None, incl_footer_notes: 'bool' = None) -> 'GT'
 
         Validation report as a GT table.
 
@@ -8584,6 +8859,20 @@ get_tabular_report(self, title: 'str | None' = ':default:', incl_header: 'bool'
             name of the table as the title for the report. If no title is wanted, then `":none:"`
             can be used. Aside from keyword options, text can be provided for the title. This will
             be interpreted as Markdown text and transformed internally to HTML.
+        incl_header
+            Controls whether the header section should be displayed. If `None`, uses the global
+            configuration setting. The header contains the table name, label, and threshold
+            information.
+        incl_footer
+            Controls whether the footer section should be displayed. If `None`, uses the global
+            configuration setting. The footer can contain validation timing information and notes.
+        incl_footer_timings
+            Controls whether validation timing information (start time, duration, end time) should
+            be displayed in the footer. If `None`, uses the global configuration setting. Only
+            applies when `incl_footer=True`.
+        incl_footer_notes
+            Controls whether notes from validation steps should be displayed in the footer. If
+            `None`, uses the global configuration setting. Only applies when `incl_footer=True`.
 
         Returns
         -------
@@ -8699,11 +8988,15 @@ get_step_report(self, i: 'int', columns_subset: 'str | list[str] | Column | None
         - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
         - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
         - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+        - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+        - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
         - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
         - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
         - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+        - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
         - [`col_vals_expr()`](`pointblank.Validate.col_vals_expr`)
         - [`conjointly()`](`pointblank.Validate.conjointly`)
+        - [`prompt()`](`pointblank.Validate.prompt`)
         - [`rows_complete()`](`pointblank.Validate.rows_complete`)
 
         The [`rows_distinct()`](`pointblank.Validate.rows_distinct`) validation step will produce a
@@ -9040,11 +9333,15 @@ get_data_extracts(self, i: 'int | list[int] | None' = None, frame: 'bool' = Fals
         - [`col_vals_outside()`](`pointblank.Validate.col_vals_outside`)
         - [`col_vals_in_set()`](`pointblank.Validate.col_vals_in_set`)
         - [`col_vals_not_in_set()`](`pointblank.Validate.col_vals_not_in_set`)
+        - [`col_vals_increasing()`](`pointblank.Validate.col_vals_increasing`)
+        - [`col_vals_decreasing()`](`pointblank.Validate.col_vals_decreasing`)
         - [`col_vals_null()`](`pointblank.Validate.col_vals_null`)
         - [`col_vals_not_null()`](`pointblank.Validate.col_vals_not_null`)
         - [`col_vals_regex()`](`pointblank.Validate.col_vals_regex`)
+        - [`col_vals_within_spec()`](`pointblank.Validate.col_vals_within_spec`)
         - [`col_vals_expr()`](`pointblank.Validate.col_vals_expr`)
         - [`conjointly()`](`pointblank.Validate.conjointly`)
+        - [`prompt()`](`pointblank.Validate.prompt`)
 
         An extracted row for these validation methods means that a test unit failed for that row in
         the validation step.
@@ -11036,6 +11333,36 @@ connect_to_table(connection_string: 'str') -> 'Any'
     pip install 'ibis-framework[duckdb]'    # for DuckDB
     pip install 'ibis-framework[postgres]'  # for PostgreSQL
     ```
+    See Also
+    --------
+    print_database_tables : List all available tables in a database for discovery
+    
+
+print_database_tables(connection_string: 'str') -> 'list[str]'
+
+    List all tables in a database from a connection string.
+
+    The `print_database_tables()` function connects to a database and returns a list of all
+    available tables. This is particularly useful for discovering what tables exist in a database
+    before connecting to a specific table with `connect_to_table(). The function automatically
+    filters out temporary Ibis tables (memtables) to show only user tables. It supports all database
+    backends available through Ibis, including DuckDB, SQLite, PostgreSQL, MySQL, BigQuery, and
+    Snowflake.
+
+    Parameters
+    ----------
+    connection_string
+        A database connection string *without* the `::table_name` suffix. Example:
+        `"duckdb:///path/to/database.ddb"`.
+
+    Returns
+    -------
+    list[str]
+        List of table names, excluding temporary Ibis tables.
+
+    See Also
+    --------
+    connect_to_table : Connect to a database table with full connection string documentation
     
 
 
@@ -12238,7 +12565,7 @@ read_file(filepath: 'str | Path') -> 'Validate'
     to disk for later retrieval with this function.
     
 
-config(report_incl_header: 'bool' = True, report_incl_footer: 'bool' = True, preview_incl_header: 'bool' = True) -> 'PointblankConfig'
+config(report_incl_header: 'bool' = True, report_incl_footer: 'bool' = True, report_incl_footer_timings: 'bool' = True, report_incl_footer_notes: 'bool' = True, preview_incl_header: 'bool' = True) -> 'PointblankConfig'
 
     Configuration settings for the Pointblank library.
 
@@ -12250,7 +12577,13 @@ config(report_incl_header: 'bool' = True, report_incl_footer: 'bool' = True, pre
         threshold levels (if set).
     report_incl_footer
         Should the footer of the validation table report be displayed? The footer contains the
-        starting and ending times of the interrogation.
+        starting and ending times of the interrogation and any notes added to validation steps.
+    report_incl_footer_timings
+        Controls whether the validation timing information (start time, duration, and end time)
+        should be displayed in the footer. Only applies when `report_incl_footer=True`.
+    report_incl_footer_notes
+        Controls whether the notes from validation steps should be displayed in the footer. Only
+        applies when `report_incl_footer=True`.
     preview_incl_header
         Whether the header should be present in any preview table (generated via the
         [`preview()`](`pointblank.preview`) function).