pointblank 0.13.3__tar.gz → 0.13.4__tar.gz

{pointblank-0.13.3 → pointblank-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pointblank
-Version: 0.13.3
+Version: 0.13.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.13.3 → pointblank-0.13.4}/pointblank/_constants_translations.py

@@ -512,6 +512,60 @@ EXPECT_FAIL_TEXT = {
         "hi": "{column_text} में मान नियमित अभिव्यक्ति से मेल खाने चाहिए थे: {values_text}, ऐसे असफल परीक्षण इकाइयों की अधिकता।",
         "el": "Υπέρβαση αποτυχημένων μονάδων δοκιμής όπου οι τιμές στη στήλη {column_text} θα έπρεπε να ταιριάζουν με την κανονική έκφραση: {values_text}.",
     },
+    "regex_inverse_expectation_text": {
+        "en": "Expect that values in {column_text} should not match the regular expression: {values_text}.",
+        "fr": "On s'attend à ce que les valeurs de {column_text} ne correspondent pas à l'expression régulière : {values_text}.",
+        "de": "Erwarten Sie, dass die Werte in {column_text} nicht mit dem regulären Ausdruck {values_text} übereinstimmen.",
+        "it": "Aspettati che i valori in {column_text} non debbano corrispondere all'espressione regolare: {values_text}.",
+        "es": "Se espera que los valores en {column_text} no coincidan con la expresión regular: {values_text}.",
+        "pt": "Espera-se que os valores em {column_text} não concorde com a expressão regular: {values_text}.",
+        "ro": "Se așteaptă ca valorile din {column_text} să nu corespundă expresiei regulate: {values_text}.",
+        "tr": "Beklenti, {column_text} 'deki değerlerin şu normal ifadeyle eşleşmemesi gerektiğidir: {values_text}.",
+        "zh-Hans": "预期在{column_text} 的值不应当匹配正则表达式。",
+        "zh-Hant": "{column_text}之值不應該匹配正則表達式。",
+        "ja": "{column_text}の値が正規表現: {values_text}に一致しないことを期待します。",
+        "ko": "{column_text}의 값이 정규식 {values_text}와 일치하지 않아야 합니다.",
+        "vi": "Kỳ vọng các giá trị trong {column_text} không được khớp với biểu thức chính quy: {values_text}.",
+        "ru": "Ожидайте, что значения в {column_text} не должны соответствовать регулярному выражению: {values_text}.",
+        "cs": "Očekává se, že hodnoty ve sloupci {column_text} nebudou odpovídat regulárnímu výrazu: {values_text}.",
+        "pl": "Spodziewaj się, że wartości w {column_text} nie powinny byc zgodne z wyrażeniem regularnym: {values_text}.",
+        "da": "Forvent at værdierne i {column_text} ikke stemmer overens med følgende regular expression: {values_text}.",
+        "sv": "Förvänta dig att värdena i {column_text} inte ska matcha följande reguljära uttryck: {values_text}.",
+        "nb": "Forvent at verdier i {column_text} ikke skal samsvare med regulæruttrykket: {values_text}.",
+        "nl": "Verwacht dat de waarden in {column_text} niet overeenkomen met de reguliere expressie {values_text}.",
+        "fi": "Odota, että arvot sarakkeessa {column_text} eivät vastaa säännöllistä lauseketta: {values_text}.",
+        "is": "Væntir þess að gildi í {column_text} passi ekki við reglulega segðina: {values_text}.",
+        "ar": "توقع ألا تتطابق القيم في {column_text} مع التعبير المنتظم: {values_text}.",
+        "hi": "अपेक्षा है कि {column_text} में मान नियमित अभिव्यक्ति से मेल नहीं खाने चाहिए: {values_text}।",
+        "el": "Αναμένεται οι τιμές στη στήλη {column_text} να μην ταιριάζουν με την κανονική έκφραση: {values_text}.",
+    },
+    "regex_inverse_failure_text": {
+        "en": "Exceedance of failed test units where values in {column_text} should not have matched the regular expression: {values_text}.",
+        "fr": "Dépassement des unités de test ayant échoué où les valeurs dans {column_text} n'auraient pas dû correspondre à l'expression régulière : {values_text}.",
+        "de": "Überschreitung fehlgeschlagener Testeinheiten, bei denen die Werte in {column_text} nicht mit dem regulären Ausdruck {values_text} übereinstimmen sollten.",
+        "it": "Superamento delle unità di test non riuscite in cui i valori in {column_text} non avrebbero dovuto corrispondere all'espressione regolare: {values_text}.",
+        "es": "Se superó el número de unidades de prueba fallidas en que los valores en {column_text} no deberían coincidir con la expresión regular: {values_text}.",
+        "pt": "Excedeu o número de unidades de teste com falha onde os valores em {column_text} não deve concordar com a expressão regular: {values_text}.",
+        "ro": "Depășirea unităților de test eșuate unde valorile din {column_text} nu ar fi trebuit să corespundă expresiei regulate: {values_text}.",
+        "tr": "{column_text} daki değerlerin normal ifade {values_text} ile eşleşmemesi gereken başarısız test birimlerinin aşılması.",
+        "zh-Hans": "错误过多，其中{column_text}中的值不应当匹配正则表达式。",
+        "zh-Hant": "錯誤過多，{column_text}之值不應該匹配正則表達式。",
+        "ja": "{column_text}の値が正規表現: {values_text}に一致すべきでないテスト単位の失敗の超過。",
+        "ko": "{column_text}의 값이 정규식 {values_text}와 일치하지 않았어야 했던 실패한 테스트 단위 초과.",
+        "vi": "Vượt quá số đơn vị kiểm tra thất bại trong đó các giá trị trong {column_text} đáng lẽ không được khớp với biểu thức chính quy: {values_text}.",
+        "ru": "Превышение неудачных тестовых единиц, где значения в {column_text} не должны были соответствовать регулярному выражению: {values_text}.",
+        "cs": "Překročení počtu neúspěšných testů, kde hodnoty ve sloupci {column_text} neměly odpovídat regulárnímu výrazu: {values_text}.",
+        "pl": "Wystapiło przekroczenie liczby jednostek testowych zakończonych niepowodzeniem, w przypadku których wartości w {column_text} nie powinny odpowiadac wyrażeniu regularnemu: {values_text}.",
+        "da": "Overskridelse af antallet af fejlslagne testenheder, hvor værdier {column_text} ikke skulle have været i overensstemmelse med følgende regular expression: {values_text}.",
+        "sv": "Överskrider antalet misslyckade testenheter där värden {column_text} inte borde ha matchat följande reguljära uttryck: {values_text}.",
+        "nb": "Overskridelse av mislykkede testenheter hvor verdier i {column_text} ikke skulle ha samsvart med regulæruttrykket: {values_text}.",
+        "nl": "Overschrijding van mislukte testeenheden waarbij waarden in {column_text} niet overeen mogen komen met de reguliere expressie: {values_text}.",
+        "fi": "Epäonnistuneiden testiyksikköjen ylitys, joissa sarakkeen {column_text} arvojen ei olisi pitänyt vastata säännöllistä lauseketta: {values_text}.",
+        "is": "Of mörg misheppnuð próf þar sem gildi í {column_text} hefðu ekki átt að passa við reglulega segðina: {values_text}.",
+        "ar": "تجاوز وحدات الاختبار الفاشلة حيث كان يجب ألا تتطابق القيم في {column_text} مع التعبير المنتظم: {values_text}.",
+        "hi": "{column_text} में मान नियमित अभिव्यक्ति से मेल नहीं खाने चाहिए थे: {values_text}, ऐसे असफल परीक्षण इकाइयों की अधिकता।",
+        "el": "Υπέρβαση αποτυχημένων μονάδων δοκιμής όπου οι τιμές στη στήλη {column_text} δεν θα έπρεπε να ταιριάζουν με την κανονική έκφραση: {values_text}.",
+    },
     "col_vals_expr_expectation_text": {
         "en": "Expect that values should agree with the given Python expression.",
         "fr": "On s'attend à ce que les valeurs soient en accord avec l'expression Python donnée.",

{pointblank-0.13.3 → pointblank-0.13.4}/pointblank/_interrogation.py

@@ -1688,15 +1688,30 @@ def interrogate_notin(tbl: FrameT, column: str, set_values: any) -> FrameT:
     return result_tbl.to_native()
 
 
-def interrogate_regex(tbl: FrameT, column: str, pattern: str, na_pass: bool) -> FrameT:
+def interrogate_regex(tbl: FrameT, column: str, values: dict | str, na_pass: bool) -> FrameT:
     """Regex interrogation."""
 
+    # Handle both old and new formats for backward compatibility
+    if isinstance(values, str):
+        pattern = values
+        inverse = False
+    else:
+        pattern = values["pattern"]
+        inverse = values["inverse"]
+
     nw_tbl = nw.from_native(tbl)
     result_tbl = nw_tbl.with_columns(
         pb_is_good_1=nw.col(column).is_null() & na_pass,
         pb_is_good_2=nw.col(column).str.contains(pattern, literal=False).fill_null(False),
     )
 
+    # Apply inverse logic if needed
+    if inverse:
+        # Use explicit boolean logic instead of bitwise NOT for pandas compatibility
+        result_tbl = result_tbl.with_columns(
+            pb_is_good_2=nw.when(nw.col("pb_is_good_2")).then(False).otherwise(True)
+        )
+
     result_tbl = result_tbl.with_columns(
         pb_is_good_=nw.col("pb_is_good_1") | nw.col("pb_is_good_2")
     ).drop("pb_is_good_1", "pb_is_good_2")

{pointblank-0.13.3 → pointblank-0.13.4}/pointblank/_utils.py

@@ -240,6 +240,46 @@ def _select_df_lib(preference: str = "polars") -> Any:
     return pl if pl is not None else pd
 
 
+def _copy_dataframe(df):
+    """
+    Create a copy of a DataFrame, handling different DataFrame types.
+
+    This function attempts to create a proper copy of the DataFrame using
+    the most appropriate method for each DataFrame type.
+    """
+    # Try standard copy methods first
+    if hasattr(df, "copy") and callable(getattr(df, "copy")):
+        try:
+            return df.copy()
+        except Exception:
+            pass
+
+    if hasattr(df, "clone") and callable(getattr(df, "clone")):
+        try:
+            return df.clone()
+        except Exception:
+            pass
+
+    # Try the select('*') approach for DataFrames that support it
+    # This works well for PySpark and other SQL-like DataFrames
+    if hasattr(df, "select") and callable(getattr(df, "select")):
+        try:
+            return df.select("*")
+        except Exception:
+            pass
+
+    # For DataFrames that can't be copied, return original
+    # This provides some protection while avoiding crashes
+    try:
+        import copy
+
+        return copy.deepcopy(df)
+    except Exception:
+        # If all else fails, return the original DataFrame
+        # This is better than crashing the validation
+        return df
+
+
 def _convert_to_narwhals(df: FrameT) -> nw.DataFrame:
     # Convert the DataFrame to a format that narwhals can work with
     return nw.from_native(df)

{pointblank-0.13.3 → pointblank-0.13.4}/pointblank/validate.py

@@ -10,6 +10,7 @@ import re
 import tempfile
 import threading
 from dataclasses import dataclass
+from enum import Enum
 from importlib.metadata import version
 from typing import TYPE_CHECKING, Any, Callable, Literal
 from zipfile import ZipFile
@@ -74,6 +75,7 @@ from pointblank._utils import (
     _check_any_df_lib,
     _check_invalid_fields,
     _column_test_prep,
+    _copy_dataframe,
     _count_null_values_in_column,
     _count_true_values_in_column,
     _derive_bounds,
@@ -2650,6 +2652,48 @@ def get_column_count(data: FrameT | Any) -> int:
             raise ValueError("The input table type supplied in `data=` is not supported.")
 
 
+def _extract_enum_values(set_values: Any) -> list[Any]:
+    """
+    Extract values from Enum classes or collections containing Enum instances.
+
+    This helper function handles:
+    1. Enum classes: extracts all enum values
+    2. Collections containing Enum instances: extracts their values
+    3. Regular collections: returns as-is
+
+    Parameters
+    ----------
+    set_values
+        The input collection that may contain Enum class or Enum instances.
+
+    Returns
+    -------
+    list[Any]
+        A list of extracted values
+    """
+    from collections.abc import Collection
+
+    # Check if set_values is an Enum class (not an instance)
+    if inspect.isclass(set_values) and issubclass(set_values, Enum):
+        # Extract all values from the Enum class
+        return [enum_member.value for enum_member in set_values]
+
+    # Check if set_values is a collection
+    if isinstance(set_values, Collection) and not isinstance(set_values, (str, bytes)):
+        extracted_values = []
+        for item in set_values:
+            if isinstance(item, Enum):
+                # If item is an Enum instance, extract its value
+                extracted_values.append(item.value)
+            else:
+                # If item is not an Enum instance, keep as-is
+                extracted_values.append(item)
+        return extracted_values
+
+    # If set_values is neither an Enum class nor a collection, return as list
+    return [set_values]
+
+
 def get_row_count(data: FrameT | Any) -> int:
     """
     Get the number of rows in a table.
@@ -6332,7 +6376,10 @@ class Validate:
             multiple columns are supplied or resolved, there will be a separate validation step
             generated for each column.
         set
-            A list of values to compare against.
+            A collection of values to compare against. Can be a list of values, a Python Enum class,
+            or a collection containing Enum instances. When an Enum class is provided, all enum
+            values will be used. When a collection contains Enum instances, their values will be
+            extracted automatically.
         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.
@@ -6509,12 +6556,69 @@ class Validate:
 
         The validation table reports two failing test units. The specific failing cases are for the
         column `b` values of `8` and `1`, which are not in the set of `[2, 3, 4, 5, 6]`.
+
+        **Using Python Enums**
+
+        The `col_vals_in_set()` method also supports Python Enum classes and instances, which can
+        make validations more readable and maintainable:
+
+        ```{python}
+        from enum import Enum
+
+        class Color(Enum):
+            RED = "red"
+            GREEN = "green"
+            BLUE = "blue"
+
+        # Create a table with color data
+        tbl_colors = pl.DataFrame({
+            "product": ["shirt", "pants", "hat", "shoes"],
+            "color": ["red", "blue", "green", "yellow"]
+        })
+
+        # Validate using an Enum class (all enum values are allowed)
+        validation = (
+            pb.Validate(data=tbl_colors)
+            .col_vals_in_set(columns="color", set=Color)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This validation will fail for the `"yellow"` value since it's not in the `Color` enum.
+
+        You can also use specific Enum instances or mix them with regular values:
+
+        ```{python}
+        # Validate using specific Enum instances
+        validation = (
+            pb.Validate(data=tbl_colors)
+            .col_vals_in_set(columns="color", set=[Color.RED, Color.BLUE])
+            .interrogate()
+        )
+
+        # Mix Enum instances with regular values
+        validation = (
+            pb.Validate(data=tbl_colors)
+            .col_vals_in_set(columns="color", set=[Color.RED, Color.BLUE, "yellow"])
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        In this case, the `"green"` value will cause a failing test unit since it's not part of the
+        specified set.
         """
 
         assertion_type = _get_fn_name()
 
         _check_column(column=columns)
 
+        # Extract values from Enum classes or Enum instances if present
+        set = _extract_enum_values(set)
+
         for val in set:
             if val is None:
                 continue
@@ -6565,7 +6669,7 @@ class Validate:
     def col_vals_not_in_set(
         self,
         columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
-        set: list[float | int],
+        set: Collection[Any],
         pre: Callable | None = None,
         segments: SegmentSpec | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
@@ -6589,7 +6693,10 @@ class Validate:
             multiple columns are supplied or resolved, there will be a separate validation step
             generated for each column.
         set
-            A list of values to compare against.
+            A collection of values to compare against. Can be a list of values, a Python Enum class,
+            or a collection containing Enum instances. When an Enum class is provided, all enum
+            values will be used. When a collection contains Enum instances, their values will be
+            extracted automatically.
         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.
@@ -6767,11 +6874,45 @@ class Validate:
 
         The validation table reports two failing test units. The specific failing cases are for the
         column `b` values of `2` and `6`, both of which are in the set of `[2, 3, 4, 5, 6]`.
+
+        **Using Python Enums**
+
+        Like `col_vals_in_set()`, this method also supports Python Enum classes and instances:
+
+        ```{python}
+        from enum import Enum
+
+        class InvalidStatus(Enum):
+            DELETED = "deleted"
+            ARCHIVED = "archived"
+
+        # Create a table with status data
+        status_table = pl.DataFrame({
+            "product": ["widget", "gadget", "tool", "device"],
+            "status": ["active", "pending", "deleted", "active"]
+        })
+
+        # Validate that no values are in the invalid status set
+        validation = (
+            pb.Validate(data=status_table)
+            .col_vals_not_in_set(columns="status", set=InvalidStatus)
+            .interrogate()
+        )
+
+        validation
+        ```
+
+        This `"deleted"` value in the `status` column will fail since it matches one of the invalid
+        statuses in the `InvalidStatus` enum.
         """
 
         assertion_type = _get_fn_name()
 
         _check_column(column=columns)
+
+        # Extract values from Enum classes or Enum instances if present
+        set = _extract_enum_values(set)
+
         _check_set_types(set=set)
         _check_pre(pre=pre)
         # TODO: add check for segments
@@ -7305,6 +7446,7 @@ class Validate:
         columns: str | list[str] | Column | ColumnSelector | ColumnSelectorNarwhals,
         pattern: str,
         na_pass: bool = False,
+        inverse: bool = False,
         pre: Callable | None = None,
         segments: SegmentSpec | None = None,
         thresholds: int | float | bool | tuple | dict | Thresholds = None,
@@ -7332,6 +7474,9 @@ class Validate:
         na_pass
             Should any encountered None, NA, or Null values be considered as passing test units? By
             default, this is `False`. Set to `True` to pass test units with missing values.
+        inverse
+            Should the validation step be inverted? If `True`, then the expectation is that column
+            values should *not* match the specified `pattern=` regex.
         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.
@@ -7518,6 +7663,7 @@ class Validate:
         # _check_segments(segments=segments)
         _check_thresholds(thresholds=thresholds)
         _check_boolean_input(param=na_pass, param_name="na_pass")
+        _check_boolean_input(param=inverse, param_name="inverse")
         _check_boolean_input(param=active, param_name="active")
 
         # Determine threshold to use (global or local) and normalize a local `thresholds=` value
@@ -7537,12 +7683,15 @@ class Validate:
         # 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)
 
+        # Package up the `pattern=` and boolean params into a dictionary for later interrogation
+        values = {"pattern": pattern, "inverse": inverse}
+
         # Iterate over the columns and create a validation step for each
         for column in columns:
             val_info = _ValidationInfo(
                 assertion_type=assertion_type,
                 column=column,
-                values=pattern,
+                values=values,
                 na_pass=na_pass,
                 pre=pre,
                 segments=segments,
@@ -9838,8 +9987,9 @@ class Validate:
                 validation.active = False
                 continue
 
-            # Make a copy of the table for this step
-            data_tbl_step = data_tbl
+            # Make a deep copy of the table for this step to ensure proper isolation
+            # This prevents modifications from one validation step affecting others
+            data_tbl_step = _copy_dataframe(data_tbl)
 
             # ------------------------------------------------
             # Preprocessing stage
@@ -10006,7 +10156,7 @@ class Validate:
 
                         elif assertion_type == "col_vals_regex":
                             results_tbl = interrogate_regex(
-                                tbl=tbl, column=column, pattern=value, na_pass=na_pass
+                                tbl=tbl, column=column, values=value, na_pass=na_pass
                             )
 
                     elif assertion_type == "col_vals_expr":
@@ -12569,6 +12719,11 @@ class Validate:
             elif assertion_type[i] in ["specially"]:
                 values_upd.append("EXPR")
 
+            elif assertion_type[i] in ["col_vals_regex"]:
+                pattern = value["pattern"]
+
+                values_upd.append(str(pattern))
+
             # If the assertion type is not recognized, add the value as a string
             else:
                 values_upd.append(str(value))
@@ -14218,15 +14373,30 @@ def _create_text_null(
 
 
 def _create_text_regex(
-    lang: str, column: str | None, pattern: str, for_failure: bool = False
+    lang: str, column: str | None, pattern: str | dict, for_failure: bool = False
 ) -> str:
     type_ = _expect_failure_type(for_failure=for_failure)
 
     column_text = _prep_column_text(column=column)
 
-    return EXPECT_FAIL_TEXT[f"regex_{type_}_text"][lang].format(
+    # Handle case where pattern is a dictionary containing `pattern` and `inverse`
+    if isinstance(pattern, dict):
+        pattern_str = pattern["pattern"]
+        inverse = pattern.get("inverse", False)
+    else:
+        # For backward compatibility, assume it's just the pattern string
+        pattern_str = pattern
+        inverse = False
+
+    # Use inverse-specific translations if inverse=True
+    if inverse:
+        text_key = f"regex_inverse_{type_}_text"
+    else:
+        text_key = f"regex_{type_}_text"
+
+    return EXPECT_FAIL_TEXT[text_key][lang].format(
         column_text=column_text,
-        values_text=pattern,
+        values_text=pattern_str,
     )
 
 
@@ -15379,7 +15549,8 @@ def _step_report_row_based(
         elements = ", ".join(values)
         text = f"{column} ∉ {{{elements}}}"
     elif assertion_type == "col_vals_regex":
-        text = STEP_REPORT_TEXT["column_matches_regex"][lang].format(column=column, values=values)
+        pattern = values["pattern"]
+        text = STEP_REPORT_TEXT["column_matches_regex"][lang].format(column=column, values=pattern)
     elif assertion_type == "col_vals_null":
         text = STEP_REPORT_TEXT["column_is_null"][lang].format(column=column)
     elif assertion_type == "col_vals_not_null":

{pointblank-0.13.3 → pointblank-0.13.4}/pointblank.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pointblank
-Version: 0.13.3
+Version: 0.13.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.13.3 → pointblank-0.13.4}/pointblank.egg-info/SOURCES.txt

@@ -171,7 +171,6 @@ images/pointblank-tabular-report.png
 images/pointblank_logo.svg
 pointblank/__init__.py
 pointblank/_constants.py
-pointblank/_constants_docs.py
 pointblank/_constants_translations.py
 pointblank/_datascan_utils.py
 pointblank/_interrogation.py