Merge pull request #69 from vertti/feat/new-string-checks

Add new value checks for 2.1.0

Author: vertti

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
+## 2.1.0
+
+### New Features
+
+- Added new value checks: `notin`, `str_startswith`, `str_endswith`, `str_contains`, `str_length`
+
 ## 2.0.2
 
 ### Documentation

daffy/checks.py

@@ -31,8 +31,15 @@ def apply_check(series: Any, check_name: str, check_value: Any, max_samples: int
         "eq": lambda: series != check_value,
         "ne": lambda: series == check_value,
         "isin": lambda: nw.to_native(~nws.is_in(check_value)),
+        "notin": lambda: nw.to_native(nws.is_in(check_value)),
         "notnull": lambda: nw.to_native(nws.is_null()),
         "str_regex": lambda: nw.to_native(~nws.str.contains(f"^(?:{check_value})")),
+        "str_startswith": lambda: nw.to_native(~nws.str.starts_with(check_value)),
+        "str_endswith": lambda: nw.to_native(~nws.str.ends_with(check_value)),
+        "str_contains": lambda: nw.to_native(~nws.str.contains(check_value, literal=True)),
+        "str_length": lambda: nw.to_native(
+            ~((nws.str.len_chars() >= check_value[0]) & (nws.str.len_chars() <= check_value[1]))
+        ),
     }
 
     if check_name not in check_masks:

docs/advanced.md

@@ -206,8 +206,13 @@ def process_data(df):
 | `ne` | value | Not equal to | `{"ne": "deleted"}` |
 | `between` | (lo, hi) | Value in range (inclusive) | `{"between": (0, 100)}` |
 | `isin` | list | Value in set | `{"isin": ["a", "b", "c"]}` |
+| `notin` | list | Value not in set | `{"notin": ["x", "y"]}` |
 | `notnull` | True | No null values | `{"notnull": True}` |
 | `str_regex` | pattern | String matches regex | `{"str_regex": r"^\d+$"}` |
+| `str_startswith` | string | String starts with prefix | `{"str_startswith": "pre_"}` |
+| `str_endswith` | string | String ends with suffix | `{"str_endswith": ".csv"}` |
+| `str_contains` | string | String contains substring | `{"str_contains": "@"}` |
+| `str_length` | (min, max) | String length in range | `{"str_length": (1, 100)}` |
 
 ### Multiple Checks
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "daffy"
-version = "2.0.2"
+version = "2.1.0"
 description = "Function decorators for DataFrame validation - columns, data types, and row-level validation with Pydantic. Supports Pandas, Polars, Modin, and PyArrow."
 authors = [
  { name="Janne Sinivirta", email="janne.sinivirta@gmail.com" },

tests/test_checks.py

@@ -132,6 +132,30 @@ def test_isin_with_numbers(self) -> None:
         assert samples == [99]
 
 
+class TestNotinCheck:
+    def test_notin_passes(self) -> None:
+        series = pd.Series(["a", "b", "c"])
+        fail_count, samples = apply_check(series, "notin", ["x", "y", "z"])
+        assert fail_count == 0
+
+    def test_notin_fails(self) -> None:
+        series = pd.Series(["a", "b", "x"])
+        fail_count, samples = apply_check(series, "notin", ["x", "y", "z"])
+        assert fail_count == 1
+        assert samples == ["x"]
+
+    def test_notin_with_numbers(self) -> None:
+        series = pd.Series([1, 2, 3])
+        fail_count, samples = apply_check(series, "notin", [3, 4, 5])
+        assert fail_count == 1
+        assert samples == [3]
+
+    def test_notin_all_forbidden(self) -> None:
+        series = pd.Series(["x", "y", "z"])
+        fail_count, samples = apply_check(series, "notin", ["x", "y", "z"])
+        assert fail_count == 3
+
+
 class TestNotnullCheck:
     def test_notnull_passes(self) -> None:
         series = pd.Series([1, 2, 3])
@@ -164,6 +188,93 @@ def test_str_regex_email_pattern(self) -> None:
         assert samples == ["invalid"]
 
 
+class TestStrStartswithCheck:
+    def test_str_startswith_passes(self) -> None:
+        series = pd.Series(["hello", "hi", "hey"])
+        fail_count, samples = apply_check(series, "str_startswith", "h")
+        assert fail_count == 0
+
+    def test_str_startswith_fails(self) -> None:
+        series = pd.Series(["hello", "world"])
+        fail_count, samples = apply_check(series, "str_startswith", "h")
+        assert fail_count == 1
+        assert samples == ["world"]
+
+    def test_str_startswith_prefix(self) -> None:
+        series = pd.Series(["pre_name", "pre_value", "other"])
+        fail_count, samples = apply_check(series, "str_startswith", "pre_")
+        assert fail_count == 1
+        assert samples == ["other"]
+
+
+class TestStrEndswithCheck:
+    def test_str_endswith_passes(self) -> None:
+        series = pd.Series(["test.py", "main.py"])
+        fail_count, samples = apply_check(series, "str_endswith", ".py")
+        assert fail_count == 0
+
+    def test_str_endswith_fails(self) -> None:
+        series = pd.Series(["test.py", "readme.md"])
+        fail_count, samples = apply_check(series, "str_endswith", ".py")
+        assert fail_count == 1
+        assert samples == ["readme.md"]
+
+
+class TestStrContainsCheck:
+    def test_str_contains_passes(self) -> None:
+        series = pd.Series(["hello world", "world peace"])
+        fail_count, samples = apply_check(series, "str_contains", "world")
+        assert fail_count == 0
+
+    def test_str_contains_fails(self) -> None:
+        series = pd.Series(["hello", "goodbye"])
+        fail_count, samples = apply_check(series, "str_contains", "world")
+        assert fail_count == 2
+
+    def test_str_contains_literal_not_regex(self) -> None:
+        # Ensure . is treated as literal, not regex wildcard
+        series = pd.Series(["a.b", "axb"])
+        fail_count, samples = apply_check(series, "str_contains", ".")
+        assert fail_count == 1
+        assert samples == ["axb"]
+
+    def test_str_contains_at_symbol(self) -> None:
+        series = pd.Series(["user@example.com", "no-at-here"])
+        fail_count, samples = apply_check(series, "str_contains", "@")
+        assert fail_count == 1
+        assert samples == ["no-at-here"]
+
+
+class TestStrLengthCheck:
+    def test_str_length_passes(self) -> None:
+        series = pd.Series(["ab", "abc", "abcd"])
+        fail_count, samples = apply_check(series, "str_length", (2, 4))
+        assert fail_count == 0
+
+    def test_str_length_fails_too_short(self) -> None:
+        series = pd.Series(["a", "abc"])
+        fail_count, samples = apply_check(series, "str_length", (2, 4))
+        assert fail_count == 1
+        assert samples == ["a"]
+
+    def test_str_length_fails_too_long(self) -> None:
+        series = pd.Series(["abc", "abcdef"])
+        fail_count, samples = apply_check(series, "str_length", (2, 4))
+        assert fail_count == 1
+        assert samples == ["abcdef"]
+
+    def test_str_length_inclusive(self) -> None:
+        series = pd.Series(["ab", "abcd"])
+        fail_count, samples = apply_check(series, "str_length", (2, 4))
+        assert fail_count == 0
+
+    def test_str_length_exact(self) -> None:
+        # Can use same min/max for exact length
+        series = pd.Series(["abc", "ab", "abcd"])
+        fail_count, samples = apply_check(series, "str_length", (3, 3))
+        assert fail_count == 2
+
+
 class TestMaxSamples:
     def test_max_samples_limits_returned_values(self) -> None:
         series = pd.Series([0, -1, -2, -3, -4, -5, -6, -7, -8, -9])