pointblank 0.13.1__py3-none-any.whl → 0.13.3__py3-none-any.whl

pointblank/yaml.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from importlib import import_module
 from pathlib import Path
-from typing import Any, Union
+from typing import Any, Iterable, Mapping, Optional, Union
 
 import yaml
 from narwhals.typing import FrameT
@@ -17,7 +18,9 @@ class YAMLValidationError(Exception):
     pass
 
 
-def _safe_eval_python_code(code: str) -> Any:
+def _safe_eval_python_code(
+    code: str, namespaces: Optional[Union[Iterable[str], Mapping[str, str]]] = None
+) -> Any:
     """Safely evaluate Python code with restricted namespace.
 
     This function provides a controlled environment for executing Python code embedded in YAML
@@ -68,6 +71,7 @@ def _safe_eval_python_code(code: str) -> Any:
             "abs": abs,
             "round": round,
             "print": print,
+            "__import__": __import__,
         },
     }
 
@@ -88,12 +92,25 @@ def _safe_eval_python_code(code: str) -> Any:
 
         safe_namespace["pd"] = pd
 
-    # Check for dangerous patterns
+    if namespaces:
+        for alias, module_name in (
+            namespaces.items() if isinstance(namespaces, dict) else ((m, m) for m in namespaces)
+        ):
+            try:
+                safe_namespace[alias] = import_module(module_name)
+            except ImportError as e:
+                raise ImportError(
+                    f"Could not import requested namespace '{module_name}': {e}"
+                ) from e
+
+    # Check for dangerous patterns and be more specific about __import__ to allow legitimate use
     dangerous_patterns = [
-        r"import\s+os",
-        r"import\s+sys",
-        r"import\s+subprocess",
-        r"__import__",
+        r"import\s+os\b",
+        r"import\s+sys\b",
+        r"import\s+subprocess\b",
+        r"__import__\s*\(\s*['\"]os['\"]",
+        r"__import__\s*\(\s*['\"]sys['\"]",
+        r"__import__\s*\(\s*['\"]subprocess['\"]",
         r"exec\s*\(",
         r"eval\s*\(",
         r"open\s*\(",
@@ -142,7 +159,9 @@ def _safe_eval_python_code(code: str) -> Any:
         raise YAMLValidationError(f"Error executing Python code '{code}': {e}")
 
 
-def _process_python_expressions(value: Any) -> Any:
+def _process_python_expressions(
+    value: Any, namespaces: Optional[Union[Iterable[str], Mapping[str, str]]] = None
+) -> Any:
     """Process Python code snippets embedded in YAML values.
 
     This function supports the python: block syntax for embedding Python code:
@@ -152,7 +171,7 @@ def _process_python_expressions(value: Any) -> Any:
       pl.scan_csv("data.csv").head(10)
 
     Note: col_vals_expr() also supports a shortcut syntax where the expr parameter
-    can be written directly without the python: wrapper:
+    can be written directly without the python: wrapper: +
 
     col_vals_expr:
       expr: |
@@ -180,14 +199,14 @@ def _process_python_expressions(value: Any) -> Any:
         # Handle python: block syntax
         if "python" in value and len(value) == 1:
             code = value["python"]
-            return _safe_eval_python_code(code)
+            return _safe_eval_python_code(code, namespaces=namespaces)
 
         # Recursively process dictionary values
-        return {k: _process_python_expressions(v) for k, v in value.items()}
+        return {k: _process_python_expressions(v, namespaces=namespaces) for k, v in value.items()}
 
     elif isinstance(value, list):
         # Recursively process list items
-        return [_process_python_expressions(item) for item in value]
+        return [_process_python_expressions(item, namespaces=namespaces) for item in value]
 
     else:
         # Return primitive types unchanged
@@ -302,7 +321,7 @@ class YAMLValidator:
             raise YAMLValidationError("YAML must contain 'steps' field")
 
         if not isinstance(config["steps"], list):
-            raise YAMLValidationError("'steps' must be a list")
+            raise YAMLValidationError("'steps' must be a list")  # pragma: no cover
 
         if len(config["steps"]) == 0:
             raise YAMLValidationError("'steps' cannot be empty")
@@ -393,9 +412,9 @@ class YAMLValidator:
             if processed_data is processed_tbl_spec and isinstance(processed_tbl_spec, str):
                 return load_dataset(processed_tbl_spec, tbl_type=df_library)
             else:
-                return processed_data
+                return processed_data  # pragma: no cover
 
-        except Exception as e:
+        except Exception as e:  # pragma: no cover
             raise YAMLValidationError(f"Failed to load data source '{tbl_spec}': {e}")
 
     def _load_csv_file(self, file_path: str, df_library: str) -> Any:
@@ -439,16 +458,16 @@ class YAMLValidator:
 
             elif df_library == "duckdb":
                 # For DuckDB, we'll use the existing _process_data since it handles DuckDB
-                from pointblank.validate import _process_data
+                from pointblank.validate import _process_data  # pragma: no cover
 
-                return _process_data(file_path)
+                return _process_data(file_path)  # pragma: no cover
 
             else:
                 raise YAMLValidationError(
                     f"Unsupported df_library: {df_library}. Use 'polars', 'pandas', or 'duckdb'"
                 )
 
-        except Exception as e:
+        except Exception as e:  # pragma: no cover
             raise YAMLValidationError(
                 f"Failed to load CSV file '{file_path}' with {df_library}: {e}"
             )
@@ -547,7 +566,11 @@ class YAMLValidator:
                 f"Schema specification must be a dictionary, got: {type(schema_spec)}"
             )
 
-    def _parse_validation_step(self, step_config: Union[str, dict]) -> tuple[str, dict]:
+    def _parse_validation_step(
+        self,
+        step_config: Union[str, dict],
+        namespaces: Optional[Union[Iterable[str], Mapping[str, str]]] = None,
+    ) -> tuple[str, dict]:
         """Parse a single validation step from YAML configuration.
 
         Parameters
@@ -598,14 +621,16 @@ class YAMLValidator:
             # Special case: `col_vals_expr()`'s `expr=` parameter can use shortcut syntax
             if method_name == "col_vals_expr" and key == "expr" and isinstance(value, str):
                 # Treat string directly as Python code (shortcut syntax)
-                processed_parameters[key] = _safe_eval_python_code(value)
+                processed_parameters[key] = _safe_eval_python_code(value, namespaces=namespaces)
             # Special case: `pre=` parameter can use shortcut syntax (like `expr=`)
             elif key == "pre" and isinstance(value, str):
                 # Treat string directly as Python code (shortcut syntax)
-                processed_parameters[key] = _safe_eval_python_code(value)
+                processed_parameters[key] = _safe_eval_python_code(value, namespaces=namespaces)
             else:
                 # Normal processing (requires python: block syntax)
-                processed_parameters[key] = _process_python_expressions(value)
+                processed_parameters[key] = _process_python_expressions(
+                    value, namespaces=namespaces
+                )
         parameters = processed_parameters
 
         # Convert `columns=` specification
@@ -634,7 +659,7 @@ class YAMLValidator:
                     if isinstance(expr, str):
                         lambda_expressions.append(_safe_eval_python_code(expr))
                     else:
-                        lambda_expressions.append(expr)
+                        lambda_expressions.append(expr)  # pragma: no cover
                 # Pass expressions as positional arguments (stored as special key)
                 parameters["_conjointly_expressions"] = lambda_expressions
             else:
@@ -658,7 +683,9 @@ class YAMLValidator:
 
         return self.validation_method_map[method_name], parameters
 
-    def build_validation(self, config: dict) -> Validate:
+    def build_validation(
+        self, config: dict, namespaces: Optional[Union[Iterable[str], Mapping[str, str]]] = None
+    ) -> Validate:
         """Convert YAML config to Validate object.
 
         Parameters
@@ -693,7 +720,9 @@ class YAMLValidator:
         # Set actions if provided
         if "actions" in config:
             # Process actions: handle `python:` block syntax for callables
-            processed_actions = _process_python_expressions(config["actions"])
+            processed_actions = _process_python_expressions(
+                config["actions"], namespaces=namespaces
+            )
             # Convert to Actions object
             validate_kwargs["actions"] = Actions(**processed_actions)
 
@@ -713,7 +742,9 @@ class YAMLValidator:
 
         # Add validation steps
         for step_config in config["steps"]:
-            method_name, parameters = self._parse_validation_step(step_config)
+            method_name, parameters = self._parse_validation_step(
+                step_config, namespaces=namespaces
+            )
 
             # Get the method from the validation object
             method = getattr(validation, method_name)
@@ -728,7 +759,9 @@ class YAMLValidator:
 
         return validation
 
-    def execute_workflow(self, config: dict) -> Validate:
+    def execute_workflow(
+        self, config: dict, namespaces: Optional[Union[Iterable[str], Mapping[str, str]]] = None
+    ) -> Validate:
         """Execute a complete YAML validation workflow.
 
         Parameters
@@ -742,7 +775,7 @@ class YAMLValidator:
             Interrogated Validate object with results.
         """
         # Build the validation plan
-        validation = self.build_validation(config)
+        validation = self.build_validation(config, namespaces=namespaces)
 
         # Execute interrogation to get results
         validation = validation.interrogate()
@@ -750,7 +783,11 @@ class YAMLValidator:
         return validation
 
 
-def yaml_interrogate(yaml: Union[str, Path], set_tbl: Union[FrameT, Any, None] = None) -> Validate:
+def yaml_interrogate(
+    yaml: Union[str, Path],
+    set_tbl: Union[FrameT, Any, None] = None,
+    namespaces: Optional[Union[Iterable[str], Mapping[str, str]]] = None,
+) -> Validate:
     """Execute a YAML-based validation workflow.
 
     This is the main entry point for YAML-based validation workflows. It takes YAML configuration
@@ -772,6 +809,10 @@ def yaml_interrogate(yaml: Union[str, Path], set_tbl: Union[FrameT, Any, None] =
         `tbl` field before executing the validation workflow. This can be any supported table type
         including DataFrame objects, Ibis table objects, CSV file paths, Parquet file paths, GitHub
         URLs, or database connection strings.
+    namespaces
+        Optional module namespaces to make available for Python code execution in YAML
+        configurations. Can be a dictionary mapping aliases to module names or a list of module
+        names. See the "Using Namespaces" section below for detailed examples.
 
     Returns
     -------
@@ -786,6 +827,71 @@ def yaml_interrogate(yaml: Union[str, Path], set_tbl: Union[FrameT, Any, None] =
         If the YAML is invalid, malformed, or execution fails. This includes syntax errors, missing
         required fields, unknown validation methods, or data loading failures.
 
+    Using Namespaces
+    ----------------
+    The `namespaces=` parameter enables custom Python modules and functions in YAML configurations.
+    This is particularly useful for custom action functions and advanced Python expressions.
+
+    **Namespace formats:**
+
+    - Dictionary format: `{"alias": "module.name"}` maps aliases to module names
+    - List format: `["module.name", "another.module"]` imports modules directly
+
+    **Option 1: Inline expressions (no namespaces needed)**
+
+    ```{python}
+    import pointblank as pb
+
+    # Simple inline custom action
+    yaml_config = '''
+    tbl: small_table
+    thresholds:
+      warning: 0.01
+    actions:
+      warning:
+        python: "lambda: print('Custom warning triggered')"
+    steps:
+    - col_vals_gt:
+        columns: [a]
+        value: 1000
+    '''
+
+    result = pb.yaml_interrogate(yaml_config)
+    result
+    ```
+
+    **Option 2: External functions with namespaces**
+
+    ```{python}
+    # Define a custom action function
+    def my_custom_action():
+        print("Data validation failed: please check your data.")
+
+    # Add to current module for demo
+    import sys
+    sys.modules[__name__].my_custom_action = my_custom_action
+
+    # YAML that references the external function
+    yaml_config = '''
+    tbl: small_table
+    thresholds:
+      warning: 0.01
+    actions:
+      warning:
+        python: actions.my_custom_action
+    steps:
+    - col_vals_gt:
+        columns: [a]
+        value: 1000  # This will fail
+    '''
+
+    # Use namespaces to make the function available
+    result = pb.yaml_interrogate(yaml_config, namespaces={'actions': '__main__'})
+    result
+    ```
+
+    This approach enables modular, reusable validation workflows with custom business logic.
+
     Examples
     --------
     ```{python}
@@ -928,14 +1034,14 @@ def yaml_interrogate(yaml: Union[str, Path], set_tbl: Union[FrameT, Any, None] =
     # If `set_tbl=` is provided, we need to build the validation workflow and then use `set_tbl()`
     if set_tbl is not None:
         # First build the validation object without interrogation
-        validation = validator.build_validation(config)
+        validation = validator.build_validation(config, namespaces=namespaces)
         # Then replace the table using set_tbl method
         validation = validation.set_tbl(tbl=set_tbl)
         # Finally interrogate with the new table
         return validation.interrogate()
     else:
         # Standard execution without table override (includes interrogation)
-        return validator.execute_workflow(config)
+        return validator.execute_workflow(config, namespaces=namespaces)
 
 
 def load_yaml_config(file_path: Union[str, Path]) -> dict:
@@ -1223,7 +1329,7 @@ def yaml_to_python(yaml: Union[str, Path]) -> str:
     """
     # First, parse the raw YAML to detect Polars/Pandas expressions in the source code
     if isinstance(yaml, Path):
-        yaml_content = yaml.read_text()
+        yaml_content = yaml.read_text()  # pragma: no cover
     elif isinstance(yaml, str):
         # Check if it's a file path (single line, reasonable length, no newlines)
         if len(yaml) < 260 and "\n" not in yaml and Path(yaml).exists():
@@ -1231,7 +1337,7 @@ def yaml_to_python(yaml: Union[str, Path]) -> str:
         else:
             yaml_content = yaml
     else:
-        yaml_content = str(yaml)
+        yaml_content = str(yaml)  # pragma: no cover
 
     # Track whether we need to import Polars and Pandas by analyzing the raw YAML content
     needs_polars_import = False
@@ -1326,7 +1432,7 @@ def yaml_to_python(yaml: Union[str, Path]) -> str:
             validate_args.append(f'data=pb.load_dataset("{tbl_spec}", tbl_type="{df_library}")')
     else:
         # Fallback to placeholder if we couldn't extract the original expression
-        validate_args.append("data=<python_expression_result>")
+        validate_args.append("data=<python_expression_result>")  # pragma: no cover
 
     # Add table name if present
     if "tbl_name" in config:
@@ -1359,7 +1465,7 @@ def yaml_to_python(yaml: Union[str, Path]) -> str:
                 action_params.append(f'{key}="{value}"')
             else:
                 # For callables or complex expressions, use placeholder
-                action_params.append(f"{key}={value}")
+                action_params.append(f"{key}={value}")  # pragma: no cover
         actions_str = "pb.Actions(" + ", ".join(action_params) + ")"
         validate_args.append(f"actions={actions_str}")
 
@@ -1414,7 +1520,7 @@ def yaml_to_python(yaml: Union[str, Path]) -> str:
             elif isinstance(step_params["expr"], str):
                 original_expressions["expr"] = step_params["expr"]
 
-        method_name, parameters = validator._parse_validation_step(step_config)
+        method_name, parameters = validator._parse_validation_step(step_config, namespaces=None)
 
         # Apply the original expressions to override the converted lambda functions
         if method_name == "conjointly" and "expressions" in original_expressions:
@@ -1446,13 +1552,13 @@ def yaml_to_python(yaml: Union[str, Path]) -> str:
                     expressions_str = "[" + ", ".join([f'"{expr}"' for expr in value]) + "]"
                     param_parts.append(f"expressions={expressions_str}")
                 else:
-                    param_parts.append(f"expressions={value}")
+                    param_parts.append(f"expressions={value}")  # pragma: no cover
             elif key == "expr" and method_name == "specially":
                 # Handle specially expr parameter: should be unquoted lambda expression
                 if isinstance(value, str):
                     param_parts.append(f"expr={value}")
                 else:
-                    param_parts.append(f"expr={value}")
+                    param_parts.append(f"expr={value}")  # pragma: no cover
             elif key in ["columns", "columns_subset"]:
                 if isinstance(value, list):
                     if len(value) == 1:
@@ -1463,7 +1569,7 @@ def yaml_to_python(yaml: Union[str, Path]) -> str:
                         columns_str = "[" + ", ".join([f'"{col}"' for col in value]) + "]"
                         param_parts.append(f"{key}={columns_str}")
                 else:
-                    param_parts.append(f'{key}="{value}"')
+                    param_parts.append(f'{key}="{value}"')  # pragma: no cover
             elif key == "brief":
                 # Handle `brief=` parameter: can be a boolean or a string
                 if isinstance(value, bool):
@@ -1486,25 +1592,29 @@ def yaml_to_python(yaml: Union[str, Path]) -> str:
                         elif isinstance(value.warning, list) and len(value.warning) == 1:
                             action_params.append(f'warning="{value.warning[0]}"')
                         else:
-                            action_params.append(f"warning={value.warning}")
+                            action_params.append(f"warning={value.warning}")  # pragma: no cover
 
                     if value.error is not None:
                         error_expr_path = f"{step_action_base}.error"
                         if error_expr_path in step_expressions:
-                            action_params.append(f"error={step_expressions[error_expr_path]}")
+                            action_params.append(
+                                f"error={step_expressions[error_expr_path]}"
+                            )  # pragma: no cover
                         elif isinstance(value.error, list) and len(value.error) == 1:
                             action_params.append(f'error="{value.error[0]}"')
                         else:
-                            action_params.append(f"error={value.error}")
+                            action_params.append(f"error={value.error}")  # pragma: no cover
 
                     if value.critical is not None:
                         critical_expr_path = f"{step_action_base}.critical"
                         if critical_expr_path in step_expressions:
-                            action_params.append(f"critical={step_expressions[critical_expr_path]}")
+                            action_params.append(
+                                f"critical={step_expressions[critical_expr_path]}"
+                            )  # pragma: no cover
                         elif isinstance(value.critical, list) and len(value.critical) == 1:
                             action_params.append(f'critical="{value.critical[0]}"')
                         else:
-                            action_params.append(f"critical={value.critical}")
+                            action_params.append(f"critical={value.critical}")  # pragma: no cover
 
                     if hasattr(value, "highest_only") and value.highest_only is not True:
                         action_params.append(f"highest_only={value.highest_only}")

{pointblank-0.13.1.dist-info → pointblank-0.13.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pointblank
-Version: 0.13.1
+Version: 0.13.3
 Summary: Find out if your data is what you think it is.
 Author-email: Richard Iannone <riannone@me.com>
 License: MIT License
@@ -52,7 +52,7 @@ Requires-Dist: pyyaml>=6.0.0
 Provides-Extra: pd
 Requires-Dist: pandas>=2.2.3; extra == "pd"
 Provides-Extra: pl
-Requires-Dist: polars>=1.24.0; extra == "pl"
+Requires-Dist: polars>=1.33.0; extra == "pl"
 Provides-Extra: pyspark
 Requires-Dist: pyspark==3.5.6; extra == "pyspark"
 Provides-Extra: generate
@@ -91,6 +91,7 @@ Requires-Dist: pandas>=2.2.3; extra == "docs"
 Requires-Dist: polars>=1.17.1; extra == "docs"
 Requires-Dist: pyspark==3.5.6; extra == "docs"
 Requires-Dist: openpyxl>=3.0.0; extra == "docs"
+Requires-Dist: duckdb<1.3.3,>=1.2.0; extra == "docs"
 Dynamic: license-file
 
 <div align="center">

{pointblank-0.13.1.dist-info → pointblank-0.13.3.dist-info}/RECORD

@@ -1,9 +1,9 @@
-pointblank/__init__.py,sha256=Qt6HEcSoduSkphatxf2Bqy4KNP-wXssRv9zlEslhTJk,1915
-pointblank/_constants.py,sha256=rB8qTnhabwmSQURevHqokC1pp5lfaWMCzhmbMZ0CP8A,81512
+pointblank/__init__.py,sha256=IZ-JwGWr2DOFBfq4XvE0SzceWMkFewtBN10V4F9pIGg,1876
+pointblank/_constants.py,sha256=HHiGuso_To-PsKQLxVDYa_Iczy92iPoIYurTy6BAtL4,80778
 pointblank/_constants_docs.py,sha256=JBmtt16zTYQ-zaM4ElLExtKs-dKlnN553Ys2ML1Y1C8,2099
-pointblank/_constants_translations.py,sha256=HXcCYmKoMjoaFv-Ym4UWv3AsIVXik2zDyAy7xvTvv0Y,186710
+pointblank/_constants_translations.py,sha256=NBVGX9veULXMwEHwSrlzpCpM9hcFeyS1xBmyBt_8_mU,190053
 pointblank/_datascan_utils.py,sha256=EMfeabXm_ZsCUKPROB7rFhyOpjtRs8jcnZ_9nBtMyws,1750
-pointblank/_interrogation.py,sha256=p3qPTgcsYiDEyV9d5pWLzAqz9rU9-IsfmSFV4sWRBNI,76932
+pointblank/_interrogation.py,sha256=FbzFa_QJIYQjH0l4D6XaMW73r71gwMrfA8lXiF4r2a4,76540
 pointblank/_typing.py,sha256=aItbCbzhbzqjK3lCbL27ltRyXoAH1c3-U6xQdRzg-lU,1594
 pointblank/_utils.py,sha256=ikgkFomoAEOxaiItHZUo3NTHu0MJHWfKAF_fnX9rRnA,30685
 pointblank/_utils_check_args.py,sha256=rFEc1nbCN8ftsQQWVjCNWmQ2QmUDxkfgmoJclrZeTLs,5489
@@ -11,18 +11,17 @@ pointblank/_utils_html.py,sha256=uJWvS9JwQVEZgwsGmScA_u_EBRND75rzUvnJPalbRVs,373
 pointblank/actions.py,sha256=D6o9B2_ES9PNQg9HZwREacrrt-3A5bhdrBkL1UXz__s,18281
 pointblank/assistant.py,sha256=vcdFgXmdVSiylQgTW3e62c13X3vAicBPjyG8OTZXmGM,15902
 pointblank/cli.py,sha256=p2cO-NKInQ41hqRMy6TNmxOj48pR5vq8s7JTLXfcP4M,228188
-pointblank/column.py,sha256=_FJjpjv760D1p6YGgqbwmKYktouG7AJ2A9uIMYQBTYA,76560
+pointblank/column.py,sha256=w41CBg3lt3ZzKS_j-SYdkRmnOWcP5xXa0rRjsPVRE_M,76781
 pointblank/compare.py,sha256=kFd18CehHz7g-2MF1kSmJSdOoAP80q_9PaF6QzHC1ds,866
-pointblank/datascan.py,sha256=nmTcRLW8nAZfvRS_Nf00Wgx4oUX-o6WFOZqLDbedbu8,24563
+pointblank/datascan.py,sha256=tQiwe9x0jAbK9OJLQe53R_qRl2uBKireaWsMlM8K1sw,24630
 pointblank/draft.py,sha256=cusr4fBiNncCKIOU8UwvJcvkBeBuUnqH_UfYp9dtNss,15777
 pointblank/scan_profile.py,sha256=lZU5hlnzznDATNn9W3gNdyuFm05WDP8y1RjDJEcE5zg,10426
 pointblank/scan_profile_stats.py,sha256=qdzoGXB-zi2hmpA4mTz6LLTqMnb-NRG9ndxU9cxS72w,4461
-pointblank/schema.py,sha256=vwGF8UKy2riRSQzcwatcI6L0t_6ccdbOayrKonvyodE,45777
+pointblank/schema.py,sha256=hjALMuYppNfELC_nAqfM9fLjPdN1w2M3rDMusrPqFYA,50757
 pointblank/segments.py,sha256=RXp3lPr3FboVseadNqLgIeoMBh_mykrQSFp1WtV41Yg,5570
-pointblank/tf.py,sha256=8o_8m4i01teulEe3-YYMotSNf3tImjBMInsvdjSAO5Q,8844
 pointblank/thresholds.py,sha256=mybeLzTVdmN04NLKoV-jiSBXsWknwHO0Gox0ttVN_MU,25766
-pointblank/validate.py,sha256=py6w239Mh7tbAfXJkanDLARCkWE5EFhTlfvS0KOjnWA,697215
-pointblank/yaml.py,sha256=Sy802CZBOgEZGwbIes8wcXPPt2a5rXO0b3lh9tsLS8w,58966
+pointblank/validate.py,sha256=v4jzFOYufrck_3CPIz4Jo53Y_5VYYTTFcqMq6B4LttY,713196
+pointblank/yaml.py,sha256=cHwDvybhp_oLOGR1rA83trEDQWYuRGhT4iEa6FMXi6w,63074
 pointblank/data/api-docs.txt,sha256=w2nIkIL_fJpXlPR9clogqcgdiv-uHvdSDI8gjkP_mCQ,531711
 pointblank/data/game_revenue-duckdb.zip,sha256=tKIVx48OGLYGsQPS3h5AjA2Nyq_rfEpLCjBiFUWhagU,35880
 pointblank/data/game_revenue.zip,sha256=7c9EvHLyi93CHUd4p3dM4CZ-GucFCtXKSPxgLojL32U,33749
@@ -33,9 +32,9 @@ 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.13.1.dist-info/licenses/LICENSE,sha256=apLF-HWPNU7pT5bmf5KmZpD5Cklpy2u-BN_0xBoRMLY,1081
-pointblank-0.13.1.dist-info/METADATA,sha256=nuywCyQQooecMF-WiWVnM-AHN2kCL0roQgWi5s2hSwU,19529
-pointblank-0.13.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pointblank-0.13.1.dist-info/entry_points.txt,sha256=GqqqOTOH8uZe22wLcvYjzpizqk_j4MNcUo2YM14ryCw,42
-pointblank-0.13.1.dist-info/top_level.txt,sha256=-wHrS1SvV8-nhvc3w-PPYs1C1WtEc1pK-eGjubbCCKc,11
-pointblank-0.13.1.dist-info/RECORD,,
+pointblank-0.13.3.dist-info/licenses/LICENSE,sha256=apLF-HWPNU7pT5bmf5KmZpD5Cklpy2u-BN_0xBoRMLY,1081
+pointblank-0.13.3.dist-info/METADATA,sha256=jXGDWi-DW5kAdRyUTjgVfRTB-6tMgyYd-uqeeyCvvKk,19582
+pointblank-0.13.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pointblank-0.13.3.dist-info/entry_points.txt,sha256=GqqqOTOH8uZe22wLcvYjzpizqk_j4MNcUo2YM14ryCw,42
+pointblank-0.13.3.dist-info/top_level.txt,sha256=-wHrS1SvV8-nhvc3w-PPYs1C1WtEc1pK-eGjubbCCKc,11
+pointblank-0.13.3.dist-info/RECORD,,