pointblank 0.9.1__py3-none-any.whl → 0.9.4__py3-none-any.whl

pointblank/validate.py

@@ -58,6 +58,7 @@ from pointblank._interrogation import (
     RowCountMatch,
     RowsComplete,
     RowsDistinct,
+    SpeciallyValidation,
 )
 from pointblank._typing import SegmentSpec
 from pointblank._utils import (
@@ -384,7 +385,7 @@ def config(
 
 
 def load_dataset(
-    dataset: Literal["small_table", "game_revenue", "nycflights"] = "small_table",
+    dataset: Literal["small_table", "game_revenue", "nycflights", "global_sales"] = "small_table",
     tbl_type: Literal["polars", "pandas", "duckdb"] = "polars",
 ) -> FrameT | Any:
     """
@@ -400,7 +401,7 @@ def load_dataset(
     ----------
     dataset
         The name of the dataset to load. Current options are `"small_table"`, `"game_revenue"`,
-        and `"nycflights"`.
+        `"nycflights"`, and `"global_sales"`.
     tbl_type
         The type of table to generate from the dataset. The named options are `"polars"`,
         `"pandas"`, and `"duckdb"`.
@@ -422,6 +423,8 @@ def load_dataset(
     they purchased, ads viewed, and the revenue generated.
     - `"nycflights"`: A dataset with 336,776 rows and 18 columns. This dataset provides information
     about flights departing from New York City airports (JFK, LGA, or EWR) in 2013.
+    - `"global_sales"`: A dataset with 50,000 rows and 20 columns. Provides information about
+    global sales of products across different regions and countries.
 
     Supported DataFrame Types
     -------------------------
@@ -433,18 +436,18 @@ def load_dataset(
 
     Examples
     --------
-    Load the `"small_table"` dataset as a Polars DataFrame by calling `load_dataset()` with its
-    defaults:
+    Load the `"small_table"` dataset as a Polars DataFrame by calling `load_dataset()` with
+    `dataset="small_table"` and `tbl_type="polars"`:
 
     ```{python}
     import pointblank as pb
 
-    small_table = pb.load_dataset()
+    small_table = pb.load_dataset(dataset="small_table", tbl_type="polars")
 
     pb.preview(small_table)
     ```
 
-    Note that the `"small_table"` dataset is a simple Polars DataFrame and using the
+    Note that the `"small_table"` dataset is a Polars DataFrame and using the
     [`preview()`](`pointblank.preview`) function will display the table in an HTML viewing
     environment.
 
@@ -472,10 +475,23 @@ def load_dataset(
     The `"nycflights"` dataset is a large dataset with 336,776 rows and 18 columns. This dataset is
     truly a real-world dataset and provides information about flights originating from New York City
     airports in 2013.
+
+    Finally, the `"global_sales"` dataset can be loaded as a Polars table by specifying the dataset
+    name. Since `tbl_type=` is set to `"polars"` by default, we don't need to specify it:
+
+    ```{python}
+    global_sales = pb.load_dataset(dataset="global_sales")
+
+    pb.preview(global_sales)
+    ```
+
+    The `"global_sales"` dataset is a large dataset with 50,000 rows and 20 columns. Each record
+    describes the sales of a particular product to a customer located in one of three global
+    regions: North America, Europe, or Asia.
     """
 
     # Raise an error if the dataset is from the list of provided datasets
-    if dataset not in ["small_table", "game_revenue", "nycflights"]:
+    if dataset not in ["small_table", "game_revenue", "nycflights", "global_sales"]:
         raise ValueError(
             f"The dataset name `{dataset}` is not valid. Choose one of the following:\n"
             "- `small_table`\n"
@@ -517,6 +533,7 @@ def load_dataset(
             "small_table": ["date_time", "date"],
             "game_revenue": ["session_start", "time", "start_day"],
             "nycflights": [],
+            "global_sales": ["timestamp"],
         }
 
         dataset = pd.read_csv(data_path, parse_dates=parse_date_columns[dataset])
@@ -7633,7 +7650,7 @@ class Validate:
 
         val_info = _ValidationInfo(
             assertion_type=assertion_type,
-            column=None,  # This is a rowwise validation, not specific to any column
+            column=None,  # This validation is not specific to any column(s)
             values=values,
             pre=pre,
             thresholds=thresholds,
@@ -7646,6 +7663,351 @@ class Validate:
 
         return self
 
+    def specially(
+        self,
+        expr: Callable,
+        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:
+        """
+        Perform a specialized validation with customized logic.
+
+        The `specially()` validation method allows for the creation of specialized validation
+        expressions that can be used to validate specific conditions or logic in the data. This
+        method provides maximum flexibility by accepting a custom callable that encapsulates
+        your validation logic.
+
+        The callable function can have one of two signatures:
+
+        - a function accepting a single parameter (the data table): `def validate(data): ...`
+        - a function with no parameters: `def validate(): ...`
+
+        The second form is particularly useful for environment validations that don't need to
+        inspect the data table.
+
+        The callable function must ultimately return one of:
+
+        1. a single boolean value or boolean list
+        2. a table where the final column contains boolean values (column name is unimportant)
+
+        The validation will operate over the number of test units that is equal to the number of
+        rows in the data table (if returning a table with boolean values). If returning a scalar
+        boolean value, the validation will operate over a single test unit. For a return of a list
+        of boolean values, the length of the list constitutes the number of test units.
+
+        Parameters
+        ----------
+        expr
+            A callable function that defines the specialized validation logic. This function should:
+            (1) accept the target data table as its single argument (though it may ignore it), or
+            (2) take no parameters at all (for environment validations). The function must
+            ultimately return boolean values representing validation results. Design your function
+            to incorporate any custom parameters directly within the function itself using closure
+            variables or default parameters.
+        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, preview_incl_header=False)
+        ```
+        The `specially()` method offers maximum flexibility for validation, allowing you to create
+        custom validation logic that fits your specific needs. The following examples demonstrate
+        different patterns and use cases for this powerful validation approach.
+
+        ### Simple validation with direct table access
+
+        This example shows the most straightforward use case where we create a function that
+        directly checks if the sum of two columns is positive.
+
+        ```{python}
+        import pointblank as pb
+        import polars as pl
+
+        simple_tbl = pl.DataFrame({
+            "a": [5, 7, 1, 3, 9, 4],
+            "b": [6, 3, 0, 5, 8, 2]
+        })
+
+        # Simple function that validates directly on the table
+        def validate_sum_positive(data):
+            return data.select(pl.col("a") + pl.col("b") > 0)
+
+        (
+            pb.Validate(data=simple_tbl)
+            .specially(expr=validate_sum_positive)
+            .interrogate()
+        )
+        ```
+
+        The function returns a Polars DataFrame with a single boolean column indicating whether
+        the sum of columns `a` and `b` is positive for each row. Each row in the resulting DataFrame
+        is a distinct test unit. This pattern works well for simple validations where you don't need
+        configurable parameters.
+
+        ### Advanced validation with closure variables for parameters
+
+        When you need to make your validation configurable, you can use the function factory pattern
+        (also known as closures) to create parameterized validations:
+
+        ```{python}
+        # Create a parameterized validation function using closures
+        def make_column_ratio_validator(col1, col2, min_ratio):
+            def validate_column_ratio(data):
+                return data.select((pl.col(col1) / pl.col(col2)) > min_ratio)
+            return validate_column_ratio
+
+        (
+            pb.Validate(data=simple_tbl)
+            .specially(
+                expr=make_column_ratio_validator(col1="a", col2="b", min_ratio=0.5)
+            )
+            .interrogate()
+        )
+        ```
+
+        This approach allows you to create reusable validation functions that can be configured with
+        different parameters without modifying the function itself.
+
+        ### Validation function returning a list of booleans
+
+        This example demonstrates how to create a validation function that returns a list of boolean
+        values, where each element represents a separate test unit:
+
+        ```{python}
+        import pointblank as pb
+        import polars as pl
+        import random
+
+        # Create sample data
+        transaction_tbl = pl.DataFrame({
+            "transaction_id": [f"TX{i:04d}" for i in range(1, 11)],
+            "amount": [120.50, 85.25, 50.00, 240.75, 35.20, 150.00, 85.25, 65.00, 210.75, 90.50],
+            "category": ["food", "shopping", "entertainment", "travel", "utilities",
+                        "food", "shopping", "entertainment", "travel", "utilities"]
+        })
+
+        # Define a validation function that returns a list of booleans
+        def validate_transaction_rules(data):
+            # Create a list to store individual test results
+            test_results = []
+
+            # Check each row individually against multiple business rules
+            for row in data.iter_rows(named=True):
+                # Rule: transaction IDs must start with "TX" and be 6 chars long
+                valid_id = row["transaction_id"].startswith("TX") and len(row["transaction_id"]) == 6
+
+                # Rule: Amounts must be appropriate for their category
+                valid_amount = True
+                if row["category"] == "food" and (row["amount"] < 10 or row["amount"] > 200):
+                    valid_amount = False
+                elif row["category"] == "utilities" and (row["amount"] < 20 or row["amount"] > 300):
+                    valid_amount = False
+                elif row["category"] == "entertainment" and row["amount"] > 100:
+                    valid_amount = False
+
+                # A transaction passes if it satisfies both rules
+                test_results.append(valid_id and valid_amount)
+
+            return test_results
+
+        (
+            pb.Validate(data=transaction_tbl)
+            .specially(
+                expr=validate_transaction_rules,
+                brief="Validate transaction IDs and amounts by category."
+            )
+            .interrogate()
+        )
+        ```
+
+        This example shows how to create a validation function that applies multiple business rules
+        to each row and returns a list of boolean results. Each boolean in the list represents a
+        separate test unit, and a test unit passes only if all rules are satisfied for a given row.
+
+        The function iterates through each row in the data table, checking:
+
+        1. if transaction IDs follow the required format
+        2. if transaction amounts are appropriate for their respective categories
+
+        This approach is powerful when you need to apply complex, conditional logic that can't be
+        easily expressed using the built-in validation functions.
+
+        ### Table-level validation returning a single boolean
+
+        Sometimes you need to validate properties of the entire table rather than row-by-row. In
+        these cases, your function can return a single boolean value:
+
+        ```{python}
+        def validate_table_properties(data):
+            # Check if table has at least one row with column 'a' > 10
+            has_large_values = data.filter(pl.col("a") > 10).height > 0
+
+            # Check if mean of column 'b' is positive
+            has_positive_mean = data.select(pl.mean("b")).item() > 0
+
+            # Return a single boolean for the entire table
+            return has_large_values and has_positive_mean
+
+        (
+            pb.Validate(data=simple_tbl)
+            .specially(expr=validate_table_properties)
+            .interrogate()
+        )
+        ```
+
+        This example demonstrates how to perform multiple checks on the table as a whole and combine
+        them into a single validation result.
+
+        ### Environment validation that doesn't use the data table
+
+        The `specially()` validation method can even be used to validate aspects of your environment
+        that are completely independent of the data:
+
+        ```{python}
+        def validate_pointblank_version():
+            try:
+                import importlib.metadata
+                version = importlib.metadata.version("pointblank")
+                version_parts = version.split(".")
+
+                # Get major and minor components regardless of how many parts there are
+                major = int(version_parts[0])
+                minor = int(version_parts[1])
+
+                # Check both major and minor components for version `0.9+`
+                return (major > 0) or (major == 0 and minor >= 9)
+
+            except Exception as e:
+                # More specific error handling could be added here
+                print(f"Version check failed: {e}")
+                return False
+
+        (
+            pb.Validate(data=simple_tbl)
+            .specially(
+                expr=validate_pointblank_version,
+                brief="Check Pointblank version `>=0.9.0`."
+            )
+            .interrogate()
+        )
+        ```
+
+        This pattern shows how to validate external dependencies or environment conditions as part
+        of your validation workflow. Notice that the function doesn't take any parameters at all,
+        which makes it cleaner when the validation doesn't need to access the data table.
+
+        By combining these patterns, you can create sophisticated validation workflows that address
+        virtually any data quality requirement in your organization.
+        """
+
+        assertion_type = _get_fn_name()
+
+        # TODO: add a check for the expression to be a callable
+        # _check_expr_specially(expr=expr)
+        _check_pre(pre=pre)
+        _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)
+        )
+
+        # 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,
+            column=None,  # This validation is not specific to any column(s)
+            values=expr,
+            pre=pre,
+            thresholds=thresholds,
+            actions=actions,
+            brief=brief,
+            active=active,
+        )
+
+        self._add_validation(validation_info=val_info)
+
+        return self
+
     def interrogate(
         self,
         collect_extracts: bool = True,
@@ -7796,6 +8158,7 @@ class Validate:
             inclusive = validation.inclusive
             na_pass = validation.na_pass
             threshold = validation.thresholds
+            segment = validation.segments
 
             assertion_method = ASSERTION_TYPE_METHOD_MAP[assertion_type]
             assertion_category = METHOD_CATEGORY_MAP[assertion_method]
@@ -7803,7 +8166,14 @@ class Validate:
 
             # Process the `brief` text for the validation step by including template variables to
             # the user-supplied text
-            validation.brief = _process_brief(brief=validation.brief, step=validation.i, col=column)
+            validation.brief = _process_brief(
+                brief=validation.brief,
+                step=validation.i,
+                col=column,
+                values=value,
+                thresholds=threshold,
+                segment=segment,
+            )
 
             # Generate the autobrief description for the validation step; it's important to perform
             # that here since text components like the column and the value(s) have been resolved
@@ -8060,12 +8430,39 @@ class Validate:
                     tbl_type=tbl_type,
                 ).get_test_results()
 
-            if assertion_category not in [
-                "COL_EXISTS_HAS_TYPE",
-                "COL_SCHEMA_MATCH",
-                "ROW_COUNT_MATCH",
-                "COL_COUNT_MATCH",
-            ]:
+            if assertion_category == "SPECIALLY":
+                results_tbl_list = SpeciallyValidation(
+                    data_tbl=data_tbl_step,
+                    expression=value,
+                    threshold=threshold,
+                    tbl_type=tbl_type,
+                ).get_test_results()
+
+                #
+                # The result from this could either be a table in the conventional form, or,
+                # a list of boolean values; handle both cases
+                #
+
+                if isinstance(results_tbl_list, list):
+                    # If the result is a list of boolean values, then we need to convert it to a
+                    # set the validation results from the list
+                    validation.all_passed = all(results_tbl_list)
+                    validation.n = len(results_tbl_list)
+                    validation.n_passed = results_tbl_list.count(True)
+                    validation.n_failed = results_tbl_list.count(False)
+
+                    results_tbl = None
+
+                else:
+                    # If the result is not a list, then we assume it's a table in the conventional
+                    # form (where the column is `pb_is_good_` exists, with boolean values)
+
+                    results_tbl = results_tbl_list
+
+            # If the results table is not `None`, then we assume there is a table with a column
+            # called `pb_is_good_` that contains boolean values; we can then use this table to
+            # determine the number of test units that passed and failed
+            if results_tbl is not None:
                 # Extract the `pb_is_good_` column from the table as a results list
                 if tbl_type in IBIS_BACKENDS:
                     # Select the DataFrame library to use for getting the results list
@@ -9967,7 +10364,7 @@ class Validate:
                     # With a column subset list, format with commas between the column names
                     columns_upd.append(", ".join(column))
 
-            elif assertion_type[i] in ["conjointly"]:
+            elif assertion_type[i] in ["conjointly", "specially"]:
                 columns_upd.append("")
             else:
                 columns_upd.append(str(column))
@@ -10029,7 +10426,7 @@ class Validate:
             elif assertion_type[i] in ["col_schema_match"]:
                 values_upd.append("SCHEMA")
 
-            elif assertion_type[i] in ["col_vals_expr"]:
+            elif assertion_type[i] in ["col_vals_expr", "conjointly"]:
                 values_upd.append("COLUMN EXPR")
 
             elif assertion_type[i] in ["row_count_match", "col_count_match"]:
@@ -10041,8 +10438,8 @@ class Validate:
 
                 values_upd.append(str(count))
 
-            elif assertion_type[i] in ["conjointly"]:
-                values_upd.append("COLUMN EXPR")
+            elif assertion_type[i] in ["specially"]:
+                values_upd.append("EXPR")
 
             # If the assertion type is not recognized, add the value as a string
             else:
@@ -11256,7 +11653,14 @@ def _string_date_dttm_conversion(value: any) -> any:
     return value
 
 
-def _process_brief(brief: str | None, step: int, col: str | list[str] | None) -> str:
+def _process_brief(
+    brief: str | None,
+    step: int,
+    col: str | list[str] | None,
+    values: any | None,
+    thresholds: any | None,
+    segment: any | None,
+) -> str:
     # If there is no brief, return `None`
     if brief is None:
         return None
@@ -11276,6 +11680,34 @@ def _process_brief(brief: str | None, step: int, col: str | list[str] | None) ->
         brief = brief.replace("{col}", col)
         brief = brief.replace("{column}", col)
 
+    if values is not None:
+        # If the value is a list, then join the values into a comma-separated string
+        if isinstance(values, list):
+            values = ", ".join([str(v) for v in values])
+
+        brief = brief.replace("{value}", str(values))
+
+    if thresholds is not None:
+        # Get the string representation of thresholds in the form of:
+        # "W: 0.20 / C: 0.40 / E: 1.00"
+
+        warning_val = thresholds._get_threshold_value(level="warning")
+        error_val = thresholds._get_threshold_value(level="error")
+        critical_val = thresholds._get_threshold_value(level="critical")
+
+        thresholds_fmt = f"W: {warning_val} / E: {error_val} / C: {critical_val}"
+
+        brief = brief.replace("{thresholds}", thresholds_fmt)
+
+    if segment is not None:
+        # The segment is always a tuple of the form ("{column}", "{value}")
+
+        segment_fmt = f"{segment[0]} / {segment[1]}"
+
+        brief = brief.replace("{segment}", segment_fmt)
+        brief = brief.replace("{segment_column}", segment[0])
+        brief = brief.replace("{segment_value}", segment[1])
+
     return brief
 
 
@@ -11470,6 +11902,9 @@ def _create_autobrief_or_failure_text(
     if assertion_type == "conjointly":
         return _create_text_conjointly(lang=lang, for_failure=for_failure)
 
+    if assertion_type == "specially":
+        return _create_text_specially(lang=lang, for_failure=for_failure)
+
     return None  # pragma: no cover
 
 
@@ -11668,6 +12103,12 @@ def _create_text_conjointly(lang: str, for_failure: bool = False) -> str:
     return EXPECT_FAIL_TEXT[f"conjointly_{type_}_text"][lang]
 
 
+def _create_text_specially(lang: str, for_failure: bool = False) -> str:
+    type_ = _expect_failure_type(for_failure=for_failure)
+
+    return EXPECT_FAIL_TEXT[f"specially_{type_}_text"][lang]
+
+
 def _prep_column_text(column: str | list[str]) -> str:
     if isinstance(column, list):
         return "`" + str(column[0]) + "`"

{pointblank-0.9.1.dist-info → pointblank-0.9.4.dist-info}/METADATA

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

{pointblank-0.9.1.dist-info → pointblank-0.9.4.dist-info}/RECORD

@@ -1,31 +1,33 @@
 pointblank/__init__.py,sha256=uHrX-ARZOhvWogXXqKV65RO2DXdYLZNCD1oNcm8hE6o,1585
-pointblank/_constants.py,sha256=tlelmeuftW4BpVeEILbsbuuCaMQ7yA_FYqM6PJPXH58,78561
+pointblank/_constants.py,sha256=D4HF0NrNAd-mdb88gZ6VatkRYfVX-9gC6C7TOQjjAw4,81128
 pointblank/_constants_docs.py,sha256=JBmtt16zTYQ-zaM4ElLExtKs-dKlnN553Ys2ML1Y1C8,2099
-pointblank/_constants_translations.py,sha256=FHkY2Bh1VBmBwbiGRIRSMU1tNGxgQAkjoPoYlwOHSKU,180685
-pointblank/_interrogation.py,sha256=BjN60ed7BH4ZnoPtkmVSvVEqJgf8k9mce4Zb63_jv_s,85155
-pointblank/_typing.py,sha256=ConITAbsFxU8CkNXY7l0Lua9hGofeDDJAWw-lGAIVgI,764
-pointblank/_utils.py,sha256=g7vbvV33tKNvznUoYsHcZW90bYm1LPb76njQeDJDPyQ,24715
+pointblank/_constants_translations.py,sha256=HXcCYmKoMjoaFv-Ym4UWv3AsIVXik2zDyAy7xvTvv0Y,186710
+pointblank/_interrogation.py,sha256=U4GQ8Ik5rP75BYBkmunBvHKwf3XvLPHcUx18JwiBQZI,89422
+pointblank/_typing.py,sha256=aItbCbzhbzqjK3lCbL27ltRyXoAH1c3-U6xQdRzg-lU,1594
+pointblank/_utils.py,sha256=CsuUYXNzox-Nc5CjQNhyy2XnmnvYJVJrS5cZxklzIFo,24745
 pointblank/_utils_check_args.py,sha256=rFEc1nbCN8ftsQQWVjCNWmQ2QmUDxkfgmoJclrZeTLs,5489
 pointblank/_utils_html.py,sha256=sTcmnBljkPjRZF1hbpoHl4HmnXOazsA91gC9iWVIrRk,2848
-pointblank/actions.py,sha256=oazJk4pe3lIA14hjyCDtPOr4r_sp4vGGo2eyU_LX5_0,18268
+pointblank/actions.py,sha256=ilk__kbQiS4ieJp-4dM7SDGuobQihUxLyS5ahgiP7qE,18272
 pointblank/assistant.py,sha256=ZIQJKTy9rDwq_Wmr1FMp0J7Q3ekxSgF3_tK0p4PTEUM,14850
 pointblank/column.py,sha256=LumGbnterw5VM7-2-7Za3jdlug1VVS9a3TOH0Y1E5eg,76548
 pointblank/datascan.py,sha256=rRz0hR81uTgd1e9OfLdfsNYXRk8vcpE8PW8exu-GJoE,47697
 pointblank/draft.py,sha256=cusr4fBiNncCKIOU8UwvJcvkBeBuUnqH_UfYp9dtNss,15777
 pointblank/schema.py,sha256=gzUCmtccO2v15MH2bo9uHUYjkKEEne1okQucxcH39pc,44291
 pointblank/tf.py,sha256=8o_8m4i01teulEe3-YYMotSNf3tImjBMInsvdjSAO5Q,8844
-pointblank/thresholds.py,sha256=aAPfdo3VMCw_G_OAh4nEsCYfIynDfNRJOMrG8yDM6U8,25717
-pointblank/validate.py,sha256=EPqtxw5sQG4Xh7WSaViVEUtm4FmpFOsyh4KM9EzuqkU,588834
-pointblank/data/api-docs.txt,sha256=JkV9SdXyB3ftBMXVFdFqGZNpyfBdWUpyisn4QHco56w,467666
+pointblank/thresholds.py,sha256=cweex25DwBPrsvPW12pRoaTQnwFpUUwqTdHyFJXTnN0,25760
+pointblank/validate.py,sha256=9dIWFetyBm70f_Ps0UkroT1gO4b5qACGs8trhObKUHg,608551
+pointblank/data/api-docs.txt,sha256=jKjPSq6X_vU_RRSJAydnVc3C35WvTqNvu-lLKroVO4I,482044
 pointblank/data/game_revenue-duckdb.zip,sha256=tKIVx48OGLYGsQPS3h5AjA2Nyq_rfEpLCjBiFUWhagU,35880
 pointblank/data/game_revenue.zip,sha256=7c9EvHLyi93CHUd4p3dM4CZ-GucFCtXKSPxgLojL32U,33749
+pointblank/data/global_sales-duckdb.zip,sha256=2ok_cvJ1ZuSkXnw0R6_OkKYRTWhJ-jJEMq2VYsv5fqY,1336390
+pointblank/data/global_sales.zip,sha256=JeUnR1apKQ35PPwEcvTKCEIEiYeYQtoGmYjmzbz99DM,2138604
 pointblank/data/nycflights-duckdb.zip,sha256=GQrHO9tp7d9cNGFNSbA9EKF19MLf6t2wZE0U9-hIKow,5293077
 pointblank/data/nycflights.zip,sha256=yVjbUaKUz2LydSdF9cABuir0VReHBBgV7shiNWSd0mU,7828965
 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.9.1.dist-info/licenses/LICENSE,sha256=apLF-HWPNU7pT5bmf5KmZpD5Cklpy2u-BN_0xBoRMLY,1081
-pointblank-0.9.1.dist-info/METADATA,sha256=1o11OgPSmpB4qBDEG1HyHDfVj5emxcT_yxHeFsVPVUc,14732
-pointblank-0.9.1.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-pointblank-0.9.1.dist-info/top_level.txt,sha256=-wHrS1SvV8-nhvc3w-PPYs1C1WtEc1pK-eGjubbCCKc,11
-pointblank-0.9.1.dist-info/RECORD,,
+pointblank-0.9.4.dist-info/licenses/LICENSE,sha256=apLF-HWPNU7pT5bmf5KmZpD5Cklpy2u-BN_0xBoRMLY,1081
+pointblank-0.9.4.dist-info/METADATA,sha256=TO7kSRz1e8_lhuqkF6st8ompJq-I0i5mevVfsCiHumU,14732
+pointblank-0.9.4.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+pointblank-0.9.4.dist-info/top_level.txt,sha256=-wHrS1SvV8-nhvc3w-PPYs1C1WtEc1pK-eGjubbCCKc,11
+pointblank-0.9.4.dist-info/RECORD,,