pointblank 0.8.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

pointblank/__init__.py

@@ -24,13 +24,14 @@ from pointblank.datascan import DataScan, col_summary_tbl
 from pointblank.draft import DraftValidation
 from pointblank.schema import Schema
 from pointblank.tf import TF
-from pointblank.thresholds import Actions, Thresholds
+from pointblank.thresholds import Actions, FinalActions, Thresholds
 from pointblank.validate import (
     Validate,
     config,
     get_action_metadata,
     get_column_count,
     get_row_count,
+    get_validation_summary,
     load_dataset,
     missing_vals_tbl,
     preview,
@@ -42,6 +43,7 @@ __all__ = [
     "Validate",
     "Thresholds",
     "Actions",
+    "FinalActions",
     "Schema",
     "DataScan",
     "DraftValidation",
@@ -59,6 +61,7 @@ __all__ = [
     "preview",
     "missing_vals_tbl",
     "get_action_metadata",
+    "get_validation_summary",
     "get_column_count",
     "get_row_count",
 ]

pointblank/_constants_translations.py

@@ -78,7 +78,7 @@ EXPECT_FAIL_TEXT = {
         "ro": "Se așteaptă ca valorile din {column_text} să fie {operator} {values_text}.",
         "tr": "Beklenti, {column_text} 'deki değerlerin {operator} {values_text} olması gerektiğidir.",
         "zh-Hans": "预期在{column_text} 的值应当{operator} {values_text}。",
-        "zh-Hant": "{column_text}之值應為{operator} {values_text}。",
+        "zh-Hant": "{column_text}之值應{operator} {values_text}。",
         "ja": "{column_text}の値が{operator} {values_text}であることを期待します。",
         "ko": "{column_text}의 값이 {operator} {values_text}이어야 합니다.",
         "ru": "Ожидайте, что значения в {column_text} должны быть {operator} {values_text}.",
@@ -101,7 +101,7 @@ EXPECT_FAIL_TEXT = {
         "ro": "Depășirea unităților de test eșuate unde valorile din {column_text} ar fi trebuit să fie {operator} {values_text}.",
         "tr": "{column_text} 'deki değerlerin {operator} {values_text} olması gereken başarısız test birimlerinin aşılması.",
         "zh-Hans": "错误过多，其中{column_text}中的值应当被 {operator} {values_text}。",
-        "zh-Hant": "錯誤過多，{column_text}之值應為{operator} {values_text}。",
+        "zh-Hant": "錯誤過多，{column_text}之值應{operator} {values_text}。",
         "ja": "{column_text}の値が{operator} {values_text}であるべきテスト単位の失敗の超過。",
         "ko": "{column_text}의 값이 {operator} {values_text}이어야 했던 실패한 테스트 단위 초과.",
         "ru": "Превышение неудачных тестовых единиц, где значения в {column_text} должны были быть {operator} {values_text}.",

pointblank/thresholds.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Callable
 
-__all__ = ["Thresholds", "Actions"]
+__all__ = ["Thresholds", "Actions", "FinalActions"]
 
 
 @dataclass
@@ -373,6 +373,15 @@ class Actions:
     displayed as `"WARNING: 'col_vals_gt' threshold exceeded for column a."` when the 'warning'
     threshold is exceeded in a 'col_vals_gt' validation step involving column `a`.
 
+    Crafting Callables with `get_action_metadata()`
+    -----------------------------------------------
+    When creating a callable function to be used as an action, you can use the
+    [`get_action_metadata()`](`pointblank.get_action_metadata`) function to retrieve metadata about
+    the step where the action is executed. This metadata contains information about the validation
+    step, including the step type, level, step number, column name, and associated value. You can
+    use this information to craft your action message or to take specific actions based on the
+    metadata provided.
+
     Examples
     --------
     ```{python}
@@ -484,3 +493,138 @@ class Actions:
 
     def _get_action(self, level: str) -> list[str | Callable]:
         return getattr(self, level)
+
+
+@dataclass
+class FinalActions:
+    """
+    Define actions to be taken after validation is complete.
+
+    Final actions are executed after all validation steps have been completed. They provide a
+    mechanism to respond to the overall validation results, such as sending alerts when critical
+    failures are detected or generating summary reports.
+
+    Parameters
+    ----------
+    *actions
+        One or more actions to execute after validation. An action can be (1) a callable function
+        that will be executed with no arguments, or (2) a string message that will be printed to the
+        console.
+
+    Returns
+    -------
+    FinalActions
+        An `FinalActions` object. This can be used when using the
+        [`Validate`](`pointblank.Validate`) class (to set final actions for the validation
+        workflow).
+
+    Types of Actions
+    ----------------
+    Final actions can be defined in two different ways:
+
+    1. **String**: A message to be displayed when the validation is complete.
+    2. **Callable**: A function that is called when the validation is complete.
+
+    The actions are executed at the end of the validation workflow. When providing a string, it will
+    simply be printed to the console. A callable will also be executed at the time of validation
+    completion. Several strings and callables can be provided to the `FinalActions` class, and
+    they will be executed in the order they are provided.
+
+    Crafting Callables with `get_validation_summary()`
+    -------------------------------------------------
+    When creating a callable function to be used as a final action, you can use the
+    [`get_validation_summary()`](`pointblank.get_validation_summary`) function to retrieve the
+    summary of the validation results. This summary contains information about the validation
+    workflow, including the number of test units, the number of failing test units, and the
+    threshold levels that were exceeded. You can use this information to craft your final action
+    message or to take specific actions based on the validation results.
+
+    Examples
+    --------
+    Final actions provide a powerful way to respond to the overall results of a validation workflow.
+    They're especially useful for sending notifications, generating reports, or taking corrective
+    actions based on the complete validation outcome.
+
+    The following example shows how to create a final action that checks for critical failures
+    and sends an alert:
+
+    ```python
+    import pointblank as pb
+
+    def send_alert():
+        summary = pb.get_validation_summary()
+        if summary["highest_severity"] == "critical":
+            print(f"ALERT: Critical validation failures found in {summary['table_name']}")
+
+    validation = (
+        pb.Validate(
+            data=my_data,
+            final_actions=pb.FinalActions(send_alert)
+        )
+        .col_vals_gt(columns="revenue", value=0)
+        .interrogate()
+    )
+    ```
+
+    In this example, the `send_alert()` function is defined to check the validation summary for
+    critical failures. If any are found, an alert message is printed to the console. The function is
+    passed to the `FinalActions` class, which ensures it will be executed after all validation steps
+    are complete. Note that we used the `get_validation_summary()` function to retrieve the summary
+    of the validation results to help craft the alert message.
+
+    Multiple final actions can be provided in a sequence. They will be executed in the order they
+    are specified after all validation steps have completed:
+
+    ```python
+    validation = (
+        pb.Validate(
+            data=my_data,
+            final_actions=pb.FinalActions(
+                "Validation complete.",  # a string message
+                send_alert,              # a callable function
+                generate_report          # another callable function
+            )
+        )
+        .col_vals_gt(columns="revenue", value=0)
+        .interrogate()
+    )
+    ```
+    """
+
+    actions: list | str | Callable
+
+    def __init__(self, *args):
+        # Check that all arguments are either strings or callables
+        for arg in args:
+            if not isinstance(arg, (str, Callable)) and not (
+                isinstance(arg, list) and all(isinstance(item, (str, Callable)) for item in arg)
+            ):
+                raise TypeError(
+                    f"All final actions must be strings, callables, or lists of strings/callables. "
+                    f"Got {type(arg).__name__} instead."
+                )
+
+        if len(args) == 0:
+            self.actions = []
+        elif len(args) == 1:
+            # If a single action is provided, store it directly (not in a list)
+            self.actions = args[0]
+        else:
+            # Multiple actions, store as a list
+            self.actions = list(args)
+
+    def __repr__(self) -> str:
+        if isinstance(self.actions, list):
+            action_reprs = ", ".join(
+                f"'{a}'" if isinstance(a, str) else a.__name__ for a in self.actions
+            )
+            return f"FinalActions([{action_reprs}])"
+        elif isinstance(self.actions, str):
+            return f"FinalActions('{self.actions}')"
+        elif callable(self.actions):
+            return f"FinalActions({self.actions.__name__})"
+        else:
+            return f"FinalActions({self.actions})"  # pragma: no cover
+
+    def __str__(self) -> str:
+        return self.__repr__()

pointblank/validate.py

@@ -73,6 +73,7 @@ from pointblank.column import Column, ColumnLiteral, ColumnSelector, ColumnSelec
 from pointblank.schema import Schema, _get_schema_validation_info
 from pointblank.thresholds import (
     Actions,
+    FinalActions,
     Thresholds,
     _convert_abs_count_to_fraction,
     _normalize_thresholds_creation,
@@ -90,6 +91,7 @@ __all__ = [
     "get_column_count",
     "get_row_count",
     "get_action_metadata",
+    "get_validation_summary",
 ]
 
 # Create a thread-local storage for the metadata
@@ -177,6 +179,129 @@ def get_action_metadata():
         return None  # pragma: no cover
 
 
+# Create a thread-local storage for the metadata
+_final_action_context = threading.local()
+
+
+@contextlib.contextmanager
+def _final_action_context_manager(summary):
+    """Context manager for storing validation summary during final action execution."""
+    _final_action_context.summary = summary
+    try:
+        yield
+    finally:
+        # Clean up after execution
+        if hasattr(_final_action_context, "summary"):
+            delattr(_final_action_context, "summary")
+
+
+def get_validation_summary():
+    """Access validation summary information when authoring final actions.
+
+    This function provides a convenient way to access summary information about the validation
+    process within a final action. It returns a dictionary with key metrics from the validation
+    process.
+
+    Returns
+    -------
+    dict | None
+        A dictionary containing validation metrics, or None if called outside a final action.
+
+    Description of the Summary Fields
+    --------------------------------
+    The summary dictionary contains the following fields:
+
+    - `n_steps` (`int`): The total number of validation steps.
+    - `n_passing_steps` (`int`): The number of validation steps where all test units passed.
+    - `n_failing_steps` (`int`): The number of validation steps that had some failing test units.
+    - `n_warning_steps` (`int`): The number of steps that exceeded a 'warning' threshold.
+    - `n_error_steps` (`int`): The number of steps that exceeded an 'error' threshold.
+    - `n_critical_steps` (`int`): The number of steps that exceeded a 'critical' threshold.
+    - `list_passing_steps` (`list[int]`): List of step numbers where all test units passed.
+    - `list_failing_steps` (`list[int]`): List of step numbers for steps having failing test units.
+    - `dict_n` (`dict`): The number of test units for each validation step.
+    - `dict_n_passed` (`dict`): The number of test units that passed for each validation step.
+    - `dict_n_failed` (`dict`): The number of test units that failed for each validation step.
+    - `dict_f_passed` (`dict`): The fraction of test units that passed for each validation step.
+    - `dict_f_failed` (`dict`): The fraction of test units that failed for each validation step.
+    - `dict_warning` (`dict`): The 'warning' level status for each validation step.
+    - `dict_error` (`dict`): The 'error' level status for each validation step.
+    - `dict_critical` (`dict`): The 'critical' level status for each validation step.
+    - `all_passed` (`bool`): Whether or not every validation step had no failing test units.
+    - `highest_severity` (`str`): The highest severity level encountered during validation. This can
+      be one of the following: `"warning"`, `"error"`, or `"critical"`, `"some failing"`, or
+      `"all passed"`.
+    - `tbl_row_count` (`int`): The number of rows in the target table.
+    - `tbl_column_count` (`int`): The number of columns in the target table.
+    - `tbl_name` (`str`): The name of the target table.
+    - `validation_duration` (`float`): The duration of the validation in seconds.
+
+    Note that the summary dictionary is only available within the context of a final action. If
+    called outside of a final action (i.e., when no final action is being executed), this function
+    will return `None`.
+
+    Examples
+    --------
+    Final actions are executed after the completion of all validation steps. They provide an
+    opportunity to take appropriate actions based on the overall validation results. Here's an
+    example of a final action function (`send_report()`) that sends an alert when critical
+    validation failures are detected:
+
+    ```python
+    import pointblank as pb
+
+    def send_report():
+        summary = pb.get_validation_summary()
+        if summary["highest_severity"] == "critical":
+            # Send an alert email
+            send_alert_email(
+                subject=f"CRITICAL validation failures in {summary['tbl_name']}",
+                body=f"{summary['n_critical_steps']} steps failed with critical severity."
+            )
+
+    validation = (
+        pb.Validate(
+            data=my_data,
+            final_actions=pb.FinalActions(send_report)
+        )
+        .col_vals_gt(columns="revenue", value=0)
+        .interrogate()
+    )
+    ```
+
+    Note that `send_alert_email()` in the example above is a placeholder function that would be
+    implemented by the user to send email alerts. This function is not provided by the Pointblank
+    package.
+
+    The `get_validation_summary()` function can also be used to create custom reporting for
+    validation results:
+
+    ```python
+    def log_validation_results():
+        summary = pb.get_validation_summary()
+
+        print(f"Validation completed with status: {summary['highest_severity'].upper()}")
+        print(f"Steps: {summary['n_steps']} total")
+        print(f"  - {summary['n_passing_steps']} passing, {summary['n_failing_steps']} failing")
+        print(
+            f"  - Severity: {summary['n_warning_steps']} warnings, "
+            f"{summary['n_error_steps']} errors, "
+            f"{summary['n_critical_steps']} critical"
+        )
+
+        if summary['highest_severity'] in ["error", "critical"]:
+            print("⚠️ Action required: Please review failing validation steps!")
+    ```
+
+    Final actions work well with both simple logging and more complex notification systems, allowing
+    you to integrate validation results into your broader data quality workflows.
+    """
+    if hasattr(_final_action_context, "summary"):
+        return _final_action_context.summary
+    else:
+        return None
+
+
 @dataclass
 class PointblankConfig:
     """
@@ -1789,9 +1914,21 @@ class Validate:
         `thresholds=` parameter). The default is `None`, which means that no thresholds will be set.
         Look at the *Thresholds* section for information on how to set threshold levels.
     actions
-        The actions to take when validation steps meet or exceed any set threshold levels. This
-        should be provided in the form of an `Actions` object. If `None` then no global actions
-        will be set.
+        The actions to take when validation steps meet or exceed any set threshold levels. These
+        actions are paired with the threshold levels and are executed during the interrogation
+        process when there are exceedances. The actions are executed right after each step is
+        evaluated. Such actions should be provided in the form of an `Actions` object. If `None`
+        then no global actions will be set. View the *Actions* section for information on how to set
+        actions.
+    final_actions
+        The actions to take when the validation process is complete and the final results are
+        available. This is useful for sending notifications or reporting the overall status of the
+        validation process. The final actions are executed after all validation steps have been
+        processed and the results have been collected. The final actions are not tied to any
+        threshold levels, they are executed regardless of the validation results. Such actions
+        should be provided in the form of a `FinalActions` object. If `None` then no finalizing
+        actions will be set. Please see the *Actions* section for information on how to set final
+        actions.
     brief
         A global setting for briefs, which are optional brief descriptions for validation steps
         (they be displayed in the reporting table). For such a global setting, templating elements
@@ -1860,6 +1997,85 @@ 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).
 
+    Actions
+    -------
+    The `actions=` and `final_actions=` parameters provide mechanisms to respond to validation
+    results. These actions can be used to notify users of validation failures, log issues, or
+    trigger other processes when problems are detected.
+
+    *Step Actions*
+
+    The `actions=` parameter allows you to define actions that are triggered when validation steps
+    exceed specific threshold levels (warning, error, or critical). These actions are executed
+    during the interrogation process, right after each step is evaluated.
+
+    Step actions should be provided using the [`Actions`](`pointblank.Actions`) class, which lets
+    you specify different actions for different severity levels:
+
+    ```python
+    # Define an action that logs a message when warning threshold is exceeded
+    def log_warning():
+        metadata = pb.get_action_metadata()
+        print(f"WARNING: Step {metadata['step']} failed with type {metadata['type']}")
+
+    # Define actions for different threshold levels
+    actions = pb.Actions(
+        warning = log_warning,
+        error = lambda: send_email("Error in validation"),
+        critical = "CRITICAL FAILURE DETECTED"
+    )
+
+    # Use in Validate
+    validation = pb.Validate(
+        data=my_data,
+        actions=actions  # Global actions for all steps
+    )
+    ```
+
+    You can also provide step-specific actions in individual validation methods:
+
+    ```python
+    validation.col_vals_gt(
+        columns="revenue",
+        value=0,
+        actions=pb.Actions(warning=log_warning)  # Only applies to this step
+    )
+    ```
+
+    Step actions have access to step-specific context through the
+    [`get_action_metadata()`](`pointblank.get_action_metadata`) function, which provides details
+    about the current validation step that triggered the action.
+
+    *Final Actions*
+
+    The `final_actions=` parameter lets you define actions that execute after all validation steps
+    have completed. These are useful for providing summaries, sending notifications based on
+    overall validation status, or performing cleanup operations.
+
+    Final actions should be provided using the [`FinalActions`](`pointblank.FinalActions`) class:
+
+    ```python
+    def send_report():
+        summary = pb.get_validation_summary()
+        if summary["status"] == "CRITICAL":
+            send_alert_email(
+                subject=f"CRITICAL validation failures in {summary['table_name']}",
+                body=f"{summary['critical_steps']} steps failed with critical severity."
+            )
+
+    validation = pb.Validate(
+        data=my_data,
+        final_actions=pb.FinalActions(send_report)
+    )
+    ```
+
+    Final actions have access to validation-wide summary information through the
+    [`get_validation_summary()`](`pointblank.get_validation_summary`) function, which provides a
+    comprehensive overview of the entire validation process.
+
+    The combination of step actions and final actions provides a flexible system for responding to
+    data quality issues at both the individual step level and the overall validation level.
+
     Reporting Languages
     -------------------
     Various pieces of reporting in Pointblank can be localized to a specific language. This is done
@@ -2035,6 +2251,7 @@ class Validate:
     label: str | None = None
     thresholds: int | float | bool | tuple | dict | Thresholds | None = None
     actions: Actions | None = None
+    final_actions: FinalActions | None = None
     brief: str | bool | None = None
     lang: str | None = None
     locale: str | None = None
@@ -2046,6 +2263,24 @@ class Validate:
         # Normalize the thresholds value (if any) to a Thresholds object
         self.thresholds = _normalize_thresholds_creation(self.thresholds)
 
+        # Check that `actions` is an Actions object if provided
+        # TODO: allow string, callable, of list of either and upgrade to Actions object
+        if self.actions is not None and not isinstance(self.actions, Actions):  # pragma: no cover
+            raise TypeError(
+                "The `actions=` parameter must be an `Actions` object. "
+                "Please use `Actions()` to wrap your actions."
+            )
+
+        # Check that `final_actions` is a FinalActions object if provided
+        # TODO: allow string, callable, of list of either and upgrade to FinalActions object
+        if self.final_actions is not None and not isinstance(
+            self.final_actions, FinalActions
+        ):  # pragma: no cover
+            raise TypeError(
+                "The `final_actions=` parameter must be a `FinalActions` object. "
+                "Please use `FinalActions()` to wrap your finalizing actions."
+            )
+
         # Normalize the reporting language identifier and error if invalid
         if self.lang not in ["zh-Hans", "zh-Hant"]:
             self.lang = _normalize_reporting_language(lang=self.lang)
@@ -6806,6 +7041,9 @@ class Validate:
 
         self.time_end = datetime.datetime.now(datetime.timezone.utc)
 
+        # Perform any final actions
+        self._execute_final_actions()
+
         return self
 
     def all_passed(self) -> bool:
@@ -9217,6 +9455,80 @@ class Validate:
             if validation.i in i
         }
 
+    def _execute_final_actions(self):
+        """Execute any final actions after interrogation is complete."""
+        if self.final_actions is None:
+            return
+
+        # Get the highest severity level based on the validation results
+        highest_severity = self._get_highest_severity_level()
+
+        # Get row count using the dedicated function that handles all table types correctly
+        row_count = get_row_count(self.data)
+
+        # Get column count using the dedicated function that handles all table types correctly
+        column_count = get_column_count(self.data)
+
+        # Get the validation duration
+        validation_duration = self.validation_duration = (
+            self.time_end - self.time_start
+        ).total_seconds()
+
+        # Create a summary of validation results as a dictionary
+        summary = {
+            "n_steps": len(self.validation_info),
+            "n_passing_steps": sum(1 for step in self.validation_info if step.all_passed),
+            "n_failing_steps": sum(1 for step in self.validation_info if not step.all_passed),
+            "n_warning_steps": sum(1 for step in self.validation_info if step.warning),
+            "n_error_steps": sum(1 for step in self.validation_info if step.error),
+            "n_critical_steps": sum(1 for step in self.validation_info if step.critical),
+            "list_passing_steps": [step.i for step in self.validation_info if step.all_passed],
+            "list_failing_steps": [step.i for step in self.validation_info if not step.all_passed],
+            "dict_n": {step.i: step.n for step in self.validation_info},
+            "dict_n_passed": {step.i: step.n_passed for step in self.validation_info},
+            "dict_n_failed": {step.i: step.n_failed for step in self.validation_info},
+            "dict_f_passed": {step.i: step.f_passed for step in self.validation_info},
+            "dict_f_failed": {step.i: step.f_failed for step in self.validation_info},
+            "dict_warning": {step.i: step.warning for step in self.validation_info},
+            "dict_error": {step.i: step.error for step in self.validation_info},
+            "dict_critical": {step.i: step.critical for step in self.validation_info},
+            "all_passed": all(step.all_passed for step in self.validation_info),
+            "highest_severity": highest_severity,
+            "tbl_row_count": row_count,
+            "tbl_column_count": column_count,
+            "tbl_name": self.tbl_name or "Unknown",
+            "validation_duration": validation_duration,
+        }
+
+        # Extract the actions from FinalActions object and execute
+        action = self.final_actions.actions
+
+        # Execute the action within the context manager
+        with _final_action_context_manager(summary):
+            if isinstance(action, str):
+                print(action)
+            elif callable(action):
+                action()
+            elif isinstance(action, list):
+                for single_action in action:
+                    if isinstance(single_action, str):
+                        print(single_action)
+                    elif callable(single_action):
+                        single_action()
+
+    def _get_highest_severity_level(self):
+        """Get the highest severity level reached across all validation steps."""
+        if any(step.critical for step in self.validation_info):
+            return "critical"
+        elif any(step.error for step in self.validation_info):
+            return "error"
+        elif any(step.warning for step in self.validation_info):
+            return "warning"
+        elif any(not step.all_passed for step in self.validation_info):
+            return "some failing"
+        else:
+            return "all passed"
+
 
 def _normalize_reporting_language(lang: str | None) -> str:
     if lang is None:

{pointblank-0.8.0.dist-info → pointblank-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pointblank
-Version: 0.8.0
+Version: 0.8.1
 Summary: Find out if your data is what you think it is.
 Author-email: Richard Iannone <riannone@me.com>
 License: MIT License

{pointblank-0.8.0.dist-info → pointblank-0.8.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
-pointblank/__init__.py,sha256=5rfnODSkdFVgQ2rvd0UEqub2cplQVNcdw7DXpY7UyQQ,1377
+pointblank/__init__.py,sha256=f7Ndfn3fuPSqA5ivCnkYgeUmfEsuWjW-JeQGbDYsZlU,1469
 pointblank/_constants.py,sha256=Jsvvt2TSZvPXCEuBQl2A3HGQ73o2WPQug-coh6thIzY,72184
 pointblank/_constants_docs.py,sha256=JBmtt16zTYQ-zaM4ElLExtKs-dKlnN553Ys2ML1Y1C8,2099
-pointblank/_constants_translations.py,sha256=aRT97Q-4UaLSZrCpUy-GqVZ8GQLYe4H910dV88jandU,90713
+pointblank/_constants_translations.py,sha256=wlsV2tvoZcevSSa7snj-ehdmcb-yb_t4aCbM1VRkDV8,90707
 pointblank/_interrogation.py,sha256=AtygXSb5iaqUcobnfVF3HjO9mjrtPWkLJ8No9XFSvR8,73186
 pointblank/_typing.py,sha256=YQ6Bt-j-W6Cg91qXHHDzBM-ptc-IEvhMg6T5ugWnGwM,306
 pointblank/_utils.py,sha256=2CDpxwy9twkF8XQayTksmKcdxtoDHqVeBuNZiYFzAqc,23232
@@ -13,8 +13,8 @@ pointblank/datascan.py,sha256=p0b7j4sxbJxNqIvYqq5r-9-8f-i9niswK19PrmWOfFE,47727
 pointblank/draft.py,sha256=lIbSlY9Avi1GbRvJhqR-69sGWCfD11im3Go20XsX8L0,15783
 pointblank/schema.py,sha256=gzUCmtccO2v15MH2bo9uHUYjkKEEne1okQucxcH39pc,44291
 pointblank/tf.py,sha256=8o_8m4i01teulEe3-YYMotSNf3tImjBMInsvdjSAO5Q,8844
-pointblank/thresholds.py,sha256=qtp3vp_yxqyNCPI9j1Ygkw6W12Cc9czt0fAxCDBALCE,19260
-pointblank/validate.py,sha256=f8hRcrQ8Uv3Ii-FYXtD6ad5cxAk0bTi9LPojuU9EOvU,475997
+pointblank/thresholds.py,sha256=C8_Rn2z3MVFu4UH5eaGRd7DkW3slgkWB3Hhim2h5CfU,25340
+pointblank/validate.py,sha256=6m6EWbKWyysRaWo9Q20QaEt7WW_fHgapAiR44mNoL6s,490549
 pointblank/data/api-docs.txt,sha256=ka96DmGzd699dG8shiA8ufTfAoilTKRuN09DECy_OpU,364411
 pointblank/data/game_revenue-duckdb.zip,sha256=tKIVx48OGLYGsQPS3h5AjA2Nyq_rfEpLCjBiFUWhagU,35880
 pointblank/data/game_revenue.zip,sha256=7c9EvHLyi93CHUd4p3dM4CZ-GucFCtXKSPxgLojL32U,33749
@@ -23,8 +23,8 @@ pointblank/data/nycflights.zip,sha256=yVjbUaKUz2LydSdF9cABuir0VReHBBgV7shiNWSd0m
 pointblank/data/polars-api-docs.txt,sha256=KGcS-BOtUs9zgpkWfXD-GFdFh4O_zjdkpX7msHjztLg,198045
 pointblank/data/small_table-duckdb.zip,sha256=BhTaZ2CRS4-9Z1uVhOU6HggvW3XCar7etMznfENIcOc,2028
 pointblank/data/small_table.zip,sha256=lmFb90Nb-v5X559Ikjg31YLAXuRyMkD9yLRElkXPMzQ,472
-pointblank-0.8.0.dist-info/licenses/LICENSE,sha256=apLF-HWPNU7pT5bmf5KmZpD5Cklpy2u-BN_0xBoRMLY,1081
-pointblank-0.8.0.dist-info/METADATA,sha256=l4qxNMk4JhIVbIqfnLjtDmy68uI_GfGLruY2PcFr9oY,12807
-pointblank-0.8.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-pointblank-0.8.0.dist-info/top_level.txt,sha256=-wHrS1SvV8-nhvc3w-PPYs1C1WtEc1pK-eGjubbCCKc,11
-pointblank-0.8.0.dist-info/RECORD,,
+pointblank-0.8.1.dist-info/licenses/LICENSE,sha256=apLF-HWPNU7pT5bmf5KmZpD5Cklpy2u-BN_0xBoRMLY,1081
+pointblank-0.8.1.dist-info/METADATA,sha256=89LXVaMNl8XufSfZtx6VcqNDGbYG3am8zrzwhJ8CuWk,12807
+pointblank-0.8.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pointblank-0.8.1.dist-info/top_level.txt,sha256=-wHrS1SvV8-nhvc3w-PPYs1C1WtEc1pK-eGjubbCCKc,11
+pointblank-0.8.1.dist-info/RECORD,,