pointblank 0.7.3__tar.gz → 0.8.1__tar.gz

{pointblank-0.7.3 → pointblank-0.8.1}/.github/ISSUE_TEMPLATE/bug.md

@@ -1,6 +1,6 @@
 ---
 name: Bug
-about: Something is wrong with 'pointblank'.
+about: Something is wrong with 'Pointblank'.
 title: ""
 labels: "Type: ☹︎ Bug"
 ---
@@ -28,7 +28,7 @@ What should have happened? Please be as specific as possible.
 ## Development environment
 
 - Operating System: [e.g., Linux, macOS, Windows]
-- pointblank Version: [e.g., 0.0.1]
+- Pointblank Version: [e.g., 0.0.1]
 
 ## Additional context
 

{pointblank-0.7.3 → pointblank-0.8.1}/.github/ISSUE_TEMPLATE/feature.md

@@ -7,7 +7,7 @@ labels: "Type: ★ Enhancement"
 
 ## Prework
 
-- [ ] Read and abide by the pointblank [code of conduct](https://www.contributor-covenant.org/version/2/1/code_of_conduct/) and [contributing guidelines](https://github.com/posit-dev/pointblank/blob/main/.github/CONTRIBUTING.md).
+- [ ] Read and abide by the Pointblank [code of conduct](https://www.contributor-covenant.org/version/2/1/code_of_conduct/) and [contributing guidelines](https://github.com/posit-dev/pointblank/blob/main/.github/CONTRIBUTING.md).
 - [ ] Search for duplicates among the [existing issues](https://github.com/posit-dev/pointblank/issues) (both open and closed).
 
 ## Proposal

{pointblank-0.7.3 → pointblank-0.8.1}/.github/PULL_REQUEST_TEMPLATE.md

@@ -1,6 +1,6 @@
 # Summary
 
-Thank you for contributing to pointblank! To make this process easier for everyone, please explain the context and purpose of your contribution. Also, list the changes made to the existing code or documentation.
+Thank you for contributing to Pointblank! To make this process easier for everyone, please explain the context and purpose of your contribution. Also, list the changes made to the existing code or documentation.
 
 # Related GitHub Issues and PRs
 

pointblank-0.8.1/.github/SECURITY.md

@@ -0,0 +1,14 @@
+# Security Policy
+
+## Supported Versions
+
+The following provides information on the versions of Pointblank that are
+currently being supported with security updates.
+
+| Version  | Supported          |
+| -------- | ------------------ |
+| >= 0.7.3 | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+Please report any security vulnerabilities to rich@posit.co.

{pointblank-0.7.3 → pointblank-0.8.1}/.github/workflows/ci-tests.yaml

@@ -29,7 +29,7 @@ jobs:
           pip install -e '.[dev]'
       - name: Install test dependencies
         run: |
-          pip install pytest pytest-cov pytest-snapshot pandas polars ibis-framework[duckdb,mysql,postgres,sqlite]>=9.5.0 chatlas shiny
+          pip install pytest pytest-cov pytest-snapshot pandas polars ibis-framework[duckdb,mysql,postgres,sqlite]>=9.5.0 chatlas requests shiny
       - name: pytest unit tests
         run: |
           make test

{pointblank-0.7.3 → pointblank-0.8.1}/CITATION.cff

@@ -1,9 +1,9 @@
 cff-version: 1.2.0
-message: 'If you wish to cite the "pointblank" package use:'
+message: 'If you wish to cite the "Pointblank" package use:'
 type: software
 license: MIT
-title: "pointblank: Find out if your data is what you think it is"
-version: 0.5.0
+title: "Pointblank: Find out if your data is what you think it is"
+version: 0.7.3
 abstract: Validate data in Polars and Pandas DataFrames and database tables.
   Validation pipelines can be made using easily-readable, consecutive validation
   steps. Upon execution of the validation plan, several reporting options are available.

{pointblank-0.7.3 → pointblank-0.8.1}/CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing Guidelines
 
-There are many ways to contribute to the ongoing development of the pointblank package. Some contributions can be rather easy to do (e.g., fixing typos, improving documentation, filing issues for feature requests or problems, etc.) whereas other contributions can require more time and patience (like answering questions and submitting pull requests with code changes). Just know that help provided in any capacity is very much appreciated.
+There are many ways to contribute to the ongoing development of the Pointblank package. Some contributions can be rather easy to do (e.g., fixing typos, improving documentation, filing issues for feature requests or problems, etc.) whereas other contributions can require more time and patience (like answering questions and submitting pull requests with code changes). Just know that help provided in any capacity is very much appreciated.
 
 ## Filing Issues
 
@@ -10,7 +10,7 @@ If you believe you found a bug, minimal reproducible example (MRE) for your post
 
 One way to help is by simply answering questions. It's amazing how a little conversation could lead to better insights on a problem. Don't quite know the answer? That's okay too. We're all in this together.
 
-Where might you answer user questions? Some of the forums for Q&A on pointblank include the _Issues_ and _Discussion_ pages in the repo. Good etiquette is key during these interactions: be a good person to all who ask questions.
+Where might you answer user questions? Some of the forums for Q&A on Pointblank include the _Issues_ and _Discussion_ pages in the repo. Good etiquette is key during these interactions: be a good person to all who ask questions.
 
 ### Making Pull Requests
 
@@ -19,7 +19,7 @@ Should you consider making a pull request (PR), please file an issue first and e
 Once there is consensus that a PR based on the issue would be helpful, adhering to the following process will make things proceed more quickly:
 
 - Create a separate Git branch for each PR
-- The pointblank package follows the [Style Guide for Python Code](https://peps.python.org/pep-0008/) so please adopt those guidelines in your submitted code as best as possible
+- The Pointblank package follows the [Style Guide for Python Code](https://peps.python.org/pep-0008/) so please adopt those guidelines in your submitted code as best as possible
 - Comment your code, particularly in those hard-to-understand areas
 - Add test cases that cover the changes made in the PR; having tests for any new codepaths will help guard against regressions
 

{pointblank-0.7.3 → pointblank-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pointblank
-Version: 0.7.3
+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
@@ -177,6 +177,13 @@ You can install Pointblank using pip:
 pip install pointblank
 ```
 
+You can also install [Pointblank from Conda-Forge](https://anaconda.org/conda-forge/pointblank) by
+using:
+
+```bash
+conda install conda-forge::pointblank
+```
+
 If you don't have Polars or Pandas installed, you'll need to install one of them to use Pointblank.
 
 ```bash

{pointblank-0.7.3 → pointblank-0.8.1}/README.md

@@ -96,6 +96,13 @@ You can install Pointblank using pip:
 pip install pointblank
 ```
 
+You can also install [Pointblank from Conda-Forge](https://anaconda.org/conda-forge/pointblank) by
+using:
+
+```bash
+conda install conda-forge::pointblank
+```
+
 If you don't have Polars or Pandas installed, you'll need to install one of them to use Pointblank.
 
 ```bash

{pointblank-0.7.3 → pointblank-0.8.1}/docs/_quarto.yml

@@ -42,6 +42,8 @@ website:
         file: demos/index.qmd
       - href: reference/index.qmd
         text: API Reference
+      - href: blog/index.qmd
+        text: Pointblog
     right:
       - icon: discord
         href: https://discord.com/invite/YH7CybCNCQ
@@ -96,6 +98,8 @@ quartodoc:
           members: []
         - name: Thresholds
         - name: Actions
+          members: []
+        - name: FinalActions
         - name: Schema
           members: []
         - name: DraftValidation
@@ -193,4 +197,5 @@ quartodoc:
         - name: get_column_count
         - name: get_row_count
         - name: get_action_metadata
+        - name: get_validation_summary
         - name: config

pointblank-0.8.1/docs/blog/index.qmd

@@ -0,0 +1,10 @@
+---
+listing:
+  type: table
+  sort: "date desc"
+  feed: true
+  contents:
+    - "**.qmd"
+---
+
+![](./pointblank_blog_logo.png)

pointblank-0.8.1/docs/blog/intro-pointblank/index.qmd

@@ -0,0 +1,263 @@
+---
+jupyter: python3
+html-table-processing: none
+title: "Introducing Pointblank"
+author: Rich Iannone
+date: 2024-04-04
+freeze: true
+---
+
+If you have tabular data (and who doesn't?) this is the package for you! I've long been interested
+in data quality and so I've spent a lot of time building tooling that makes it possible to perform
+data quality checks. And there's so many reasons to care about data quality. If I were to put down
+just one good reason for why data quality is worth your time it is because having good data quality
+strongly determines the quality of decisions.
+
+Having the ability to distinguish bad data from good data is the first step in solving DQ issues,
+and the sustained practice of doing data validation will guard against intrusions of poor-quality
+data. Pointblank has been designed to really help here. Though it's a fairly new package it is
+currently quite capable. And it's available in PyPI, so you can install it by using:
+
+```bash
+pip install pointblank
+```
+
+::: {.callout-note}
+To run the examples in this post, you'll need to have a DataFrame library installed. Pointblank
+works seamlessly with both Polars and Pandas but you'll need to install at least one of them on your
+own. We also have a DuckDB example that's running via Ibis (so, you'll have to install Ibis with
+the DuckDB backend for that to work).
+:::
+
+## How Pointblank Transforms Your Data Validation Workflow
+
+What sets Pointblank apart is its intuitive, expressive approach to data validation. Rather than
+writing dozens of ad-hoc checks scattered throughout your codebase, Pointblank lets you define a
+comprehensive validation plan with just a few lines of code. The fluent API makes your validation
+intentions crystal clear, whether you're ensuring numeric values fall within expected ranges, text
+fields match specific patterns, or relationships between columns remain consistent.
+
+But say you find problems. What are you gonna do about it? Well, Pointblank wants to help at not
+just finding problems but helping you understand them. When validation failures occur, the detailed
+reporting capabilities (in the form of beautiful, sharable tables) show you exactly where issues
+are. Right down to the specific rows and columns. This transforms data validation from a binary
+pass/fail exercise into a super-insightful diagnostic tool.
+
+![](./step_report.png)
+
+Here's the the best part: Pointblank is designed to work with your existing data stack. Whether
+you're using Polars, Pandas, DuckDB, or other database systems, Pointblank tries hard to integrate
+without forcing you to change your workflow. We also have international spoken language support for
+reporting, meaning that validation reports can be localized to your team's preferred language. This
+making data quality accessible to everyone in your organization (like a team sport!).
+
+![](./pointblank-localized.png)
+
+Alright! Let's look at a few demonstrations of Pointblank's capabilities for data validation.
+
+## The Data Validation Workflow
+
+Let's get right to performing a basic check of a Polars DataFrame. We'll make use of the included
+`small_table` dataset.
+
+```{python}
+import pointblank as pb
+
+small_table = pb.load_dataset(dataset="small_table", tbl_type="polars")
+
+validation_1 = (
+    pb.Validate(
+        data=small_table,
+        tbl_name="small_table",
+        label="Example Validation"
+    )
+    .col_vals_lt(columns="a", value=10)
+    .col_vals_between(columns="d", left=0, right=5000)
+    .col_vals_in_set(columns="f", set=["low", "mid", "high"])
+    .col_vals_regex(columns="b", pattern=r"^[0-9]-[a-z]{3}-[0-9]{3}$")
+    .interrogate()
+)
+
+validation_1
+```
+
+There's a lot to take in here so let's break down the code first! Note these three key pieces:
+
+- the `Validate(data=...)` argument takes a DataFrame (or database table) that you want to validate
+- the methods starting with `col_*` specify validation steps that run on specific columns
+- the `interrogate()` method executes the validation plan on the table (it's the finishing step)
+
+This common pattern is used in a validation workflow, where
+[`Validate`](https://posit-dev.github.io/pointblank/reference/Validate.html) and
+[`interrogate()`](https://posit-dev.github.io/pointblank/reference/Validate.interrogate.html)
+bookend a validation plan generated through calling validation methods.
+
+Now, onto the result: it's a table! Naturally, we're using the awesome Great Tables package here in
+Pointblank to really give you the goods on how the validation went down. Each row in this reporting
+table represents a single validation step (one for each invocation of a `col_vals_*()` validation
+method). Generally speaking, the left side of the validation report tables outlines the key
+validation rules, and the right side provides the results of each validation step.
+
+We tried to keep it simple in principle, but a lot of useful information can be packed into this
+validation table. Here's a diagram that describes a few of the important parts of the validation
+report table:
+
+![](validation-table-diagram.png){width=100%}
+
+All of those numbers under the `UNITS`, `PASS`, and `FAIL` columns have to do with test units, a
+measure of central importance in Pointblank. Each validation step will execute a type of validation
+test on the target table. For example, a
+[`col_vals_lt()`](https://posit-dev.github.io/pointblank/reference/Validate.col_vals_lt.html)
+validation step can test that each value in a column is less than a specified number. The key
+finding that’s reported as a result of this test is the number of test units that pass or fail. This
+little diagram explains what those numbers mean:
+
+![](validation-test-units.png){width=50%, text-align=center}
+
+Failing test units can be tied to threshold levels, which can provide a better indication of whether
+failures should raise some basic awareness or spur you into action. Here's a validation workflow
+that sets three failure threshold levels that signal the severity of data quality problems:
+
+```{python}
+import pointblank as pb
+import polars as pl
+
+validation_2 = (
+    pb.Validate(
+        data=pb.load_dataset(dataset="game_revenue", tbl_type="polars"),
+        tbl_name="game_revenue",
+        label="Data validation with threshold levels set.",
+        thresholds=pb.Thresholds(warning=1, error=20, critical=0.10),
+    )
+    .col_vals_regex(columns="player_id", pattern=r"^[A-Z]{12}[0-9]{3}$")        # STEP 1
+    .col_vals_gt(columns="session_duration", value=5)                           # STEP 2
+    .col_vals_ge(columns="item_revenue", value=0.02)                            # STEP 3
+    .col_vals_in_set(columns="item_type", set=["iap", "ad"])                    # STEP 4
+    .col_vals_in_set(                                                           # STEP 5
+        columns="acquisition",
+        set=["google", "facebook", "organic", "crosspromo", "other_campaign"]
+    )
+    .col_vals_not_in_set(columns="country", set=["Mongolia", "Germany"])        # STEP 6
+    .col_vals_between(                                                          # STEP 7
+        columns="session_duration",
+        left=10, right=50,
+        pre = lambda df: df.select(pl.median("session_duration"))
+    )
+    .rows_distinct(columns_subset=["player_id", "session_id", "time"])          # STEP 8
+    .row_count_match(count=2000)                                                # STEP 9
+    .col_exists(columns="start_day")                                            # STEP 10
+    .interrogate()
+)
+
+validation_2
+```
+
+This data validation makes use of the many
+[validation methods available in the library](https://posit-dev.github.io/pointblank/reference/#validation-steps).
+Because thresholds have been set at the `Validate(thresholds=)` parameter, we can now see where
+certain validation steps have greater amounts of failures. Any validation steps with green
+indicators passed with flying colors, whereas: (1) gray indicates the 'warning' condition was met
+(at least one test unit failing), (2) yellow is for the 'error' condition (20 or more test units
+failing), and (3) red means 'critical' and that's tripped when 10% of all test units are failing
+ones.
+
+Reporting tables are essential to the package and they help communicate what went wrong (or well) in
+a validation workflow. Now let's look at some additional reporting that Pointblank can give you to
+better understand *where* things might've gone wrong.
+
+## Reporting for Individual Validation Steps
+
+The second validation step of the previous data validation showed 18 failing test units. That
+translates to 18 spots in a 2,000 row DataFrame where a data quality assertion failed. We often
+would like to know exactly what that failing data is; it's usually the next step toward addressing
+data quality issues.
+
+Pointblank offers a method that gives you a tabular report on a specific step:
+[`get_step_report()`](https://posit-dev.github.io/pointblank/reference/Validate.get_step_report.html).
+The previous tables you've seen (the validation report table) dealt with providing a summary of all
+validation steps. In contrast, a focused report on a single step can help to get to the heart of a data
+quality issue. Here's how that looks for Step 2:
+
+```{python}
+validation_2.get_step_report(i=2)
+```
+
+This report provides the 18 rows where the failure occurred. If you scroll the table to the right
+you'll see the column that underwent testing (`session_duration`) is highlighted in red. All of
+these values are `5.0` or less, which is in violation of the assertion (in the header) that
+`session_duration > 5`.
+
+These types of bespoke reports are useful for finding a needle in a haystack. Another good use for
+a step report is when validating a table schema. Using the
+[`col_schema_match()`](https://posit-dev.github.io/pointblank/reference/Validate.col_schema_match.html)
+validation method with a table schema prepared with the
+[`Schema`](https://posit-dev.github.io/pointblank/reference/Schema.html) class allows us to verify
+our understanding of the table structure. Here is a validation that performs a schema validation
+with the `small_table` dataset prepared as a DuckDB table:
+
+```{python}
+import pointblank as pb
+
+# Create a schema for the target table (`small_table` as a DuckDB table)
+schema = pb.Schema(
+    columns=[
+        ("date_time", "timestamp(6)"),
+        ("dates", "date"),
+        ("a", "int64"),
+        ("b",),
+        ("c",),
+        ("d", "float64"),
+        ("e", ["bool", "boolean"]),
+        ("f", "str"),
+    ]
+)
+
+# Use the `col_schema_match()` validation method to perform a schema check
+validation_3 = (
+    pb.Validate(
+        data=pb.load_dataset(dataset="small_table", tbl_type="duckdb"),
+        tbl_name="small_table",
+        label="Schema check"
+    )
+    .col_schema_match(schema=schema)
+    .interrogate()
+)
+
+validation_3
+```
+
+This step fails, but the validation report table doesn't tell us how (or where). Using
+[`get_step_report()](https://posit-dev.github.io/pointblank/reference/Validate.get_step_report.html)
+will show us what the underlying issues are:
+
+```{python}
+validation_3.get_step_report(i=1)
+```
+
+The step report here shows the target table's schema on the left side and the expectation of the
+schema on the right side. There appears to be two problems with our supplied schema:
+
+1. the second column is actually `date` instead of `dates`
+2. the dtype of the `f` column is `"string"` and not `"str"`
+
+The convenience of this step report means we only have to look at one display of information, rather
+than having to collect up the individual pieces and make careful comparisons.
+
+## Much More in Store
+
+Pointblank tries really hard to make it easy for you to test your data. All sorts of input tables
+are supported since we integrate with the brilliant
+[Narwhals](https://narwhals-dev.github.io/narwhals/) and
+[Ibis](https://ibis-project.org) libraries. And even through the project has only started four
+months ago, we already have an extensive catalog of well-tested validation methods.
+
+We care a great deal about documentation so much recent effort has been placed on getting the
+[**User Guide**](https://posit-dev.github.io/pointblank/user-guide/) written. We hope it provides
+for gentle introduction to the major features of the library. If you want some quick examples to get
+your imagination going, check out our
+[gallery of examples](https://posit-dev.github.io/pointblank/demos/).
+
+We really care about what **you** want in a validation package, so talk to us :) We just started a
+[Discord](https://discord.com/invite/YH7CybCNCQ) so feel free to hop on and ask us anything.
+Alternatively, we always like to get [issues](https://github.com/posit-dev/pointblank/issues) so
+don't be shy in letting us know how we could improve!

{pointblank-0.7.3 → pointblank-0.8.1}/docs/styles.css

@@ -9,7 +9,7 @@
 }
 
 body {
-    background-color: #EBEEF7;
+    background-color: #F7F8FC;
 }
 
 p a {

{pointblank-0.7.3 → pointblank-0.8.1}/docs/user-guide/actions.qmd

@@ -70,7 +70,7 @@ considered optional. Put another way, you can set various thresholds and various
 and the interrogation phase will determine whether all the requirements are met for executing
 an action.
 
-## Ways to Express Actions: Text or Custom Functions
+## Expressing Actions with a String
 
 There are a few options in how to define the actions:
 
@@ -99,10 +99,9 @@ Here's an example where we prepare a console message with a number of value plac
 (`action_str`) and use it globally at `Actions(critical=)`:
 
 ```{python}
-
 action_str = "[{LEVEL}: {TYPE}]: Step {step} has failed validation. ({time})"
 
-validation = (
+validation_2 = (
     pb.Validate(
         data=pb.load_dataset(dataset="game_revenue", tbl_type="duckdb"),
         thresholds=pb.Thresholds(warning=0.05, error=0.10, critical=0.15),
@@ -113,6 +112,8 @@ validation = (
     .col_vals_ge(columns="session_duration", value=15)
     .interrogate()
 )
+
+validation_2
 ```
 
 What we get here are two messages in the console, corresponding to critical failures in steps 2 and
@@ -121,16 +122,19 @@ resulting text is capitalized (e.g., `"CRITICAL"`, `"COL_VALS_GT"`, etc.) and th
 capitalized the placeholder text itself. Have a look at the documentation article of
 [`Actions`](https://posit-dev.github.io/pointblank/reference/Actions.html) for more details on this.
 
+## Making Actions with Callables
+
 Aside from strings, any callable can be used as an action value. Here's an example where we use a
 custom function as part of an action:
 
 ```{python}
-def dq_issue():
+def duration_issue():
     from datetime import datetime
 
     print(f"Data quality issue found ({datetime.now()}).")
 
-validation = (
+
+validation_3 = (
     pb.Validate(
         data=pb.load_dataset(dataset="game_revenue", tbl_type="duckdb"),
         thresholds=pb.Thresholds(warning=0.05, error=0.10, critical=0.15),
@@ -140,12 +144,12 @@ validation = (
     .col_vals_gt(
         columns="session_duration",
         value=15,
-        actions=pb.Actions(warning=dq_issue),
+        actions=pb.Actions(warning=duration_issue),
     )
     .interrogate()
 )
 
-validation
+validation_3
 ```
 
 In this case, the 'warning' action is set to call the user's `dq_issue()` function. This action is
@@ -159,3 +163,62 @@ applied to step 3. You are free to mix and match both threshold and action setti
 level (i.e., set in the [`Validate`](https://posit-dev.github.io/pointblank/reference/Validate.html)
 call) or at the step level. The key thing to be aware of is that step-level settings of thresholds
 and actions take precedence.
+
+## Using `get_action_metadata()` to Access Metadata When Building an Action Callable
+
+To access information about the validation step where an action was triggered, we can call
+[`get_action_metadata()`](https://posit-dev.github.io/pointblank/reference/get_action_metadata.html)
+in the body of a function to be used within `Actions`. The dictionary that's returned by that
+function allows us to make more generalized actions that could react accordingly to different
+failure states.
+
+In the following example, we'll make a function called `print_problem()` that prints information to
+the console about the failure state for a validation step. In this case, the action will be applied
+to any threshold level being exceeded (by using `Actions(default=print_problem)`). And only the most
+severe level exceeded per step will execute `print_problem()` since `Actions(highest_only=True)` by
+default.
+
+```{python}
+def print_problem():
+    m = pb.get_action_metadata()
+    print(f"{m['level']} ({m['level_num']}) for Step {m['step']}: {m['failure_text']}")
+
+
+validation = (
+    pb.Validate(
+        data=pb.load_dataset(dataset="game_revenue", tbl_type="duckdb"),
+        thresholds=pb.Thresholds(warning=0.05, error=0.10, critical=0.15),
+        actions=pb.Actions(default=print_problem),
+        brief=True,
+    )
+    .col_vals_regex(columns="player_id", pattern=r"[A-Z]{12}\d{3}")
+    .col_vals_gt(columns="item_revenue", value=0.05)
+    .col_vals_gt(
+        columns="session_duration",
+        value=15,
+    )
+    .interrogate()
+)
+
+validation
+```
+
+We end up seeing two messages printed for failures in Steps 2 and 3. And though those steps had more
+than one threshold exceeded, only the most severe level in each yielded a console message.
+
+Alse note that we set the action in `Validate(actions=)` so that the action would apply to all
+validation steps where thresholds are exceeded. This obviated the need to set `actions=` at every
+validation step (though you can do this as a local override, even setting `actions=None` to disable
+globally set actions).
+
+The metadata dictionary contains the following fields for a given validation step:
+
+- `step`: The step number.
+- `column`: The column name.
+- `value`: The value being compared (only available in certain validation steps).
+- `type`: The assertion type (e.g., `"col_vals_gt"`, etc.).
+- `time`: The time the validation step was executed (in ISO format).
+- `level`: The severity level (`"warning"`, `"error"`, or `"critical"`).
+- `level_num`: The severity level as a numeric value (`30`, `40`, or `50`).
+- `autobrief`: A localized and brief statement of the expectation for the step.
+- `failure_text`: Localized text that explains how the validation step failed.

{pointblank-0.7.3 → pointblank-0.8.1}/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-0.7.3 → pointblank-0.8.1}/pointblank/_constants.py

@@ -13,8 +13,8 @@ COMPATIBLE_DTYPES = {
     "ne": ["numeric", "datetime"],
     "ge": ["numeric", "datetime"],
     "le": ["numeric", "datetime"],
-    "between": ["numeric"],
-    "outside": ["numeric"],
+    "between": ["numeric", "datetime"],
+    "outside": ["numeric", "datetime"],
     "in_set": ["numeric", "str"],
     "not_in_set": ["numeric", "str"],
     "regex": ["str"],
@@ -159,14 +159,21 @@ REPORTING_LANGUAGES = [
     "it",
     "es",
     "pt",
+    "ro",
     "tr",
     "zh-Hans",
     "zh-Hant",
+    "ja",
+    "ko",
     "ru",
+    "cs",
     "pl",
     "da",
     "sv",
+    "nb",
     "nl",
+    "fi",
+    "is",
 ]
 
 SEVERITY_LEVEL_COLORS = {