dqscore 0.1.0__tar.gz

dqscore-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Digvijay Waghela
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dqscore-0.1.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: dqscore
+Version: 0.1.0
+Summary: A lightweight data quality toolkit for pandas: profiling, validation schemas, and a zero-config scan.
+Author-email: YOUR NAME <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/dqscore
+Project-URL: Repository, https://github.com/YOUR_USERNAME/dqscore
+Project-URL: Issues, https://github.com/YOUR_USERNAME/dqscore/issues
+Keywords: data-quality,pandas,validation,data-profiling,etl,dataframe
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# dqscore
+
+> A lightweight **data quality toolkit for pandas** — profile any DataFrame, declare
+> expectations with a fluent schema, or run a zero-config scan. No heavy dependencies,
+> no config files required.
+
+[![CI](https://github.com/dgvj-work/dqscore/actions/workflows/ci.yml/badge.svg)](https://github.com/dgvj-work/dqscore/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+`dqscore` helps you catch the boring-but-costly data problems — nulls where there
+shouldn't be any, duplicate keys, out-of-range values, malformed strings — before
+they reach a model, a dashboard, or a stakeholder.
+
+---
+## Why this exists ?
+Data quality issues are the silent killers of analytics and ML work. A null in the wrong column, a duplicate primary key, a value outside its expected range — these don't crash your pipeline. They quietly corrupt your output, and you find out three weeks later in a stakeholder meeting.
+The Python ecosystem already has excellent tools for this. Great Expectations is comprehensive and battle-tested. Pandera offers powerful schema-based validation. ydata-profiling produces rich exploratory reports. If you're building a long-lived production data platform, those are the right answers.
+But there's a gap in shape. When an analyst gets a fresh CSV and wants a fast read on whether it's trustworthy, the existing tools ask for a lot upfront — a schema, a config, a project structure, sometimes a framework integration. The lightest possible question — is this data OK? — doesn't have a one-line answer in any of them. And once you do set up checks, getting a single number you can put on a dashboard, or a non-zero exit code you can wire into CI, often needs custom code on top.
+dqscore is built for that middle ground. It has one dependency (pandas) and three things to learn: profile a DataFrame, declare a schema with a fluent API, or run a zero-config scan that infers sensible defaults. Every validation produces a 0–100 quality score and a report that exports to HTML, Markdown, or JSON. The CLI returns exit code 1 on failure, so dqscore scan data.csv drops straight into a CI pipeline or a pre-commit hook with no glue code.
+It's not a replacement for Great Expectations or pandera. It's the tool you reach for at the start of a project, or when reviewing a new dataset, or when you want a simple quality gate in CI without standing up a whole framework. That's the gap, and I think it's a useful one to fill — especially for individuals, smaller teams, and educators where the ceremony of heavier tools is the actual barrier to checking data at all.
+The package is MIT-licensed and feedback is welcome. If a check is missing, a report format would be useful, or the auto-scan heuristics could be smarter for your data, open an issue.
+
+---
+
+## Why dqscore?
+
+- **Tiny surface area.** Three things to learn: `profile`, `Schema`, `auto_scan`.
+- **Readable reports.** Every result exports to dict, JSON, Markdown, or styled HTML.
+- **Scoreable.** Each validation produces a 0–100 quality score for dashboards/CI.
+- **CLI included.** `dqscore scan data.csv` returns a non-zero exit code on failure,
+  so it drops straight into a pipeline or pre-commit hook.
+- **One dependency:** pandas.
+
+---
+
+## Installation
+
+```bash
+pip install dqscore
+```
+
+Or install the latest from source:
+
+```bash
+git clone https://github.com/dgvj-work/dqscore.git
+cd dqscore
+pip install -e ".[dev]"
+```
+
+---
+
+## Quick start
+
+### 1. Profile a DataFrame
+
+```python
+import pandas as pd
+import dqscore as dq
+
+df = pd.read_csv("customers.csv")
+profile = dq.profile(df)
+
+print(profile.to_markdown())   # per-column stats
+profile.to_html("profile.html")
+```
+
+### 2. Validate against a schema
+
+```python
+schema = dq.Schema("customers")
+schema.column("id").not_null().unique()
+schema.column("age").in_range(0, 120)
+schema.column("email").matches(r"^[^@]+@[^@]+\.[^@]+$")
+schema.column("country").in_set(["US", "CA", "MX"])
+schema.no_duplicate_rows()
+
+result = schema.validate(df)
+
+print(result.summary())        # human-readable report
+print("Quality score:", result.score)
+result.to_html("dq_report.html")
+
+if not result.passed:
+    raise SystemExit("Data quality checks failed")
+```
+
+### 3. Zero-config scan
+
+When you just want a quick read on a new file:
+
+```python
+result = dq.auto_scan(df)       # checks nulls, duplicate keys, duplicate rows
+print(result.summary())
+```
+
+---
+
+## Command line
+
+```bash
+# Profile every column
+dqscore profile data.csv --html profile.html
+
+# Quick quality scan (exit code 1 if it fails — great for CI)
+dqscore scan data.csv --json report.json
+dqscore scan data.csv --max-null-pct 5
+```
+
+---
+
+## Available checks
+
+| Method                              | Fails when…                                  |
+| ----------------------------------- | -------------------------------------------- |
+| `not_null()`                        | value is null / NaN / NaT                    |
+| `unique()`                          | a non-null value occurs more than once       |
+| `in_range(min, max, inclusive)`     | numeric value is outside the bounds          |
+| `in_set([...])`                     | value is not one of the allowed values       |
+| `matches(pattern, full_match)`      | string does not match the regex              |
+| `is_numeric()` / `is_integer()`     | value can't be parsed as a number / integer  |
+| `is_datetime(fmt)`                  | value can't be parsed as a date/time         |
+| `string_length(min_len, max_len)`   | string length is out of bounds               |
+| `custom(fn, name)`                  | your function returns `True` for a row        |
+| `Schema.no_duplicate_rows(subset)`  | rows are exact duplicates                     |
+
+Checks chain on a column and most let nulls pass, so `not_null()` stays the single
+source of truth for missing values:
+
+```python
+schema.column("score").not_null().is_numeric().in_range(0, 100)
+```
+
+---
+
+## Reports & scoring
+
+A `ValidationResult` gives you:
+
+- `result.passed` — `True`/`False`
+- `result.score` — percentage of checks passed (0–100)
+- `result.failures` — only the failing checks (with sample failing values & indices)
+- `result.summary()` / `to_markdown()` / `to_json()` / `to_html(path)`
+
+---
+
+## Contributing
+
+Contributions and feedback are very welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+Found a bug or want a new check? [Open an issue](https://github.com/dgvj-work/dqscore/issues).
+
+## License
+
+[MIT](LICENSE)

dqscore-0.1.0/README.md

@@ -0,0 +1,154 @@
+# dqscore
+
+> A lightweight **data quality toolkit for pandas** — profile any DataFrame, declare
+> expectations with a fluent schema, or run a zero-config scan. No heavy dependencies,
+> no config files required.
+
+[![CI](https://github.com/dgvj-work/dqscore/actions/workflows/ci.yml/badge.svg)](https://github.com/dgvj-work/dqscore/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+`dqscore` helps you catch the boring-but-costly data problems — nulls where there
+shouldn't be any, duplicate keys, out-of-range values, malformed strings — before
+they reach a model, a dashboard, or a stakeholder.
+
+---
+## Why this exists ?
+Data quality issues are the silent killers of analytics and ML work. A null in the wrong column, a duplicate primary key, a value outside its expected range — these don't crash your pipeline. They quietly corrupt your output, and you find out three weeks later in a stakeholder meeting.
+The Python ecosystem already has excellent tools for this. Great Expectations is comprehensive and battle-tested. Pandera offers powerful schema-based validation. ydata-profiling produces rich exploratory reports. If you're building a long-lived production data platform, those are the right answers.
+But there's a gap in shape. When an analyst gets a fresh CSV and wants a fast read on whether it's trustworthy, the existing tools ask for a lot upfront — a schema, a config, a project structure, sometimes a framework integration. The lightest possible question — is this data OK? — doesn't have a one-line answer in any of them. And once you do set up checks, getting a single number you can put on a dashboard, or a non-zero exit code you can wire into CI, often needs custom code on top.
+dqscore is built for that middle ground. It has one dependency (pandas) and three things to learn: profile a DataFrame, declare a schema with a fluent API, or run a zero-config scan that infers sensible defaults. Every validation produces a 0–100 quality score and a report that exports to HTML, Markdown, or JSON. The CLI returns exit code 1 on failure, so dqscore scan data.csv drops straight into a CI pipeline or a pre-commit hook with no glue code.
+It's not a replacement for Great Expectations or pandera. It's the tool you reach for at the start of a project, or when reviewing a new dataset, or when you want a simple quality gate in CI without standing up a whole framework. That's the gap, and I think it's a useful one to fill — especially for individuals, smaller teams, and educators where the ceremony of heavier tools is the actual barrier to checking data at all.
+The package is MIT-licensed and feedback is welcome. If a check is missing, a report format would be useful, or the auto-scan heuristics could be smarter for your data, open an issue.
+
+---
+
+## Why dqscore?
+
+- **Tiny surface area.** Three things to learn: `profile`, `Schema`, `auto_scan`.
+- **Readable reports.** Every result exports to dict, JSON, Markdown, or styled HTML.
+- **Scoreable.** Each validation produces a 0–100 quality score for dashboards/CI.
+- **CLI included.** `dqscore scan data.csv` returns a non-zero exit code on failure,
+  so it drops straight into a pipeline or pre-commit hook.
+- **One dependency:** pandas.
+
+---
+
+## Installation
+
+```bash
+pip install dqscore
+```
+
+Or install the latest from source:
+
+```bash
+git clone https://github.com/dgvj-work/dqscore.git
+cd dqscore
+pip install -e ".[dev]"
+```
+
+---
+
+## Quick start
+
+### 1. Profile a DataFrame
+
+```python
+import pandas as pd
+import dqscore as dq
+
+df = pd.read_csv("customers.csv")
+profile = dq.profile(df)
+
+print(profile.to_markdown())   # per-column stats
+profile.to_html("profile.html")
+```
+
+### 2. Validate against a schema
+
+```python
+schema = dq.Schema("customers")
+schema.column("id").not_null().unique()
+schema.column("age").in_range(0, 120)
+schema.column("email").matches(r"^[^@]+@[^@]+\.[^@]+$")
+schema.column("country").in_set(["US", "CA", "MX"])
+schema.no_duplicate_rows()
+
+result = schema.validate(df)
+
+print(result.summary())        # human-readable report
+print("Quality score:", result.score)
+result.to_html("dq_report.html")
+
+if not result.passed:
+    raise SystemExit("Data quality checks failed")
+```
+
+### 3. Zero-config scan
+
+When you just want a quick read on a new file:
+
+```python
+result = dq.auto_scan(df)       # checks nulls, duplicate keys, duplicate rows
+print(result.summary())
+```
+
+---
+
+## Command line
+
+```bash
+# Profile every column
+dqscore profile data.csv --html profile.html
+
+# Quick quality scan (exit code 1 if it fails — great for CI)
+dqscore scan data.csv --json report.json
+dqscore scan data.csv --max-null-pct 5
+```
+
+---
+
+## Available checks
+
+| Method                              | Fails when…                                  |
+| ----------------------------------- | -------------------------------------------- |
+| `not_null()`                        | value is null / NaN / NaT                    |
+| `unique()`                          | a non-null value occurs more than once       |
+| `in_range(min, max, inclusive)`     | numeric value is outside the bounds          |
+| `in_set([...])`                     | value is not one of the allowed values       |
+| `matches(pattern, full_match)`      | string does not match the regex              |
+| `is_numeric()` / `is_integer()`     | value can't be parsed as a number / integer  |
+| `is_datetime(fmt)`                  | value can't be parsed as a date/time         |
+| `string_length(min_len, max_len)`   | string length is out of bounds               |
+| `custom(fn, name)`                  | your function returns `True` for a row        |
+| `Schema.no_duplicate_rows(subset)`  | rows are exact duplicates                     |
+
+Checks chain on a column and most let nulls pass, so `not_null()` stays the single
+source of truth for missing values:
+
+```python
+schema.column("score").not_null().is_numeric().in_range(0, 100)
+```
+
+---
+
+## Reports & scoring
+
+A `ValidationResult` gives you:
+
+- `result.passed` — `True`/`False`
+- `result.score` — percentage of checks passed (0–100)
+- `result.failures` — only the failing checks (with sample failing values & indices)
+- `result.summary()` / `to_markdown()` / `to_json()` / `to_html(path)`
+
+---
+
+## Contributing
+
+Contributions and feedback are very welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+Found a bug or want a new check? [Open an issue](https://github.com/dgvj-work/dqscore/issues).
+
+## License
+
+[MIT](LICENSE)

dqscore-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dqscore"
+version = "0.1.0"
+description = "A lightweight data quality toolkit for pandas: profiling, validation schemas, and a zero-config scan."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "YOUR NAME", email = "you@example.com" }]
+keywords = ["data-quality", "pandas", "validation", "data-profiling", "etl", "dataframe"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = ["pandas>=1.3"]
+
+[project.urls]
+Homepage = "https://github.com/YOUR_USERNAME/dqscore"
+Repository = "https://github.com/YOUR_USERNAME/dqscore"
+Issues = "https://github.com/YOUR_USERNAME/dqscore/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-cov"]
+
+[project.scripts]
+dqscore = "dqscore.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+dqscore = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

dqscore-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dqscore-0.1.0/src/dqscore/__init__.py

@@ -0,0 +1,40 @@
+"""dqscore — a lightweight data quality toolkit for pandas.
+
+Quick start
+-----------
+>>> import pandas as pd
+>>> import dqscore as dq
+>>> df = pd.DataFrame({"id": [1, 2, 2], "age": [30, -1, 41]})
+>>> result = dq.auto_scan(df)
+>>> result.passed
+False
+
+Declare expectations explicitly with a :class:`~dqscore.Schema`::
+
+    schema = dq.Schema("people")
+    schema.column("id").not_null().unique()
+    schema.column("age").in_range(0, 120)
+    report = schema.validate(df)
+    print(report.summary())
+"""
+from __future__ import annotations
+
+from . import checks
+from .autoscan import auto_scan
+from .profiling import Profile, profile
+from .report import CheckResult, ValidationResult
+from .validator import ColumnSchema, Schema
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Schema",
+    "ColumnSchema",
+    "profile",
+    "Profile",
+    "auto_scan",
+    "ValidationResult",
+    "CheckResult",
+    "checks",
+    "__version__",
+]

dqscore-0.1.0/src/dqscore/autoscan.py

@@ -0,0 +1,60 @@
+"""Zero-config quality scan: infer sensible default checks for any DataFrame."""
+from __future__ import annotations
+
+from typing import Optional
+
+import pandas as pd
+
+from .report import ValidationResult
+from .validator import Schema
+
+__all__ = ["auto_scan"]
+
+
+def _looks_like_id(name: str) -> bool:
+    lowered = str(name).lower()
+    return lowered == "id" or lowered.endswith("_id") or lowered.endswith("id")
+
+
+def auto_scan(
+    df: pd.DataFrame,
+    max_null_pct: float = 0.0,
+    name: str = "auto_scan",
+) -> ValidationResult:
+    """Run a quick, opinionated quality scan with no schema required.
+
+    Heuristics applied:
+
+    * every column is expected to have at most ``max_null_pct`` percent nulls;
+    * columns that look like identifiers (``id`` / ``*_id``) are expected to be
+      unique;
+    * the frame is expected to have no fully duplicated rows.
+
+    Parameters
+    ----------
+    df:
+        The DataFrame to scan.
+    max_null_pct:
+        Allowed percentage of nulls per column before the column's null check
+        fails. ``0.0`` means "no nulls allowed".
+    """
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError("auto_scan() expects a pandas DataFrame")
+
+    n = len(df)
+    threshold = max_null_pct / 100.0
+    schema = Schema(name)
+
+    for col in df.columns:
+        series = df[col]
+        null_frac = series.isna().mean() if n else 0.0
+        if null_frac > threshold:
+            # Flag missingness explicitly via the not_null check.
+            schema.column(col).not_null()
+        if _looks_like_id(col):
+            # Identifier-like columns are expected to be unique; this surfaces
+            # accidental duplicate keys, a common data quality defect.
+            schema.column(col).unique()
+
+    schema.no_duplicate_rows()
+    return schema.validate(df)

dqscore-0.1.0/src/dqscore/checks.py

@@ -0,0 +1,127 @@
+"""Low-level data quality checks.
+
+Every check takes a :class:`pandas.Series` (or DataFrame, for frame-level
+checks) and returns a boolean mask aligned to the input where ``True`` marks a
+*failing* row. Null handling is deliberate: most checks let nulls pass so that
+``not_null`` is the single source of truth for missing values. Combine checks to
+express richer expectations.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any, Iterable, Optional
+
+import pandas as pd
+
+__all__ = [
+    "not_null",
+    "unique",
+    "in_range",
+    "in_set",
+    "matches",
+    "is_numeric",
+    "is_integer",
+    "is_datetime",
+    "string_length",
+    "no_duplicate_rows",
+]
+
+
+def _as_bool_mask(mask: pd.Series, index: pd.Index) -> pd.Series:
+    """Coerce a mask to a clean boolean Series aligned to ``index``."""
+    return pd.Series(mask, index=index).fillna(False).astype(bool)
+
+
+def not_null(series: pd.Series) -> pd.Series:
+    """Fail rows whose value is null / NaN / NaT."""
+    return series.isna()
+
+
+def unique(series: pd.Series) -> pd.Series:
+    """Fail rows whose (non-null) value appears more than once."""
+    duplicated = series.duplicated(keep=False)
+    return _as_bool_mask(duplicated & series.notna(), series.index)
+
+
+def in_range(
+    series: pd.Series,
+    min_value: Optional[float] = None,
+    max_value: Optional[float] = None,
+    inclusive: bool = True,
+) -> pd.Series:
+    """Fail rows outside ``[min_value, max_value]``.
+
+    Non-numeric, non-null values fail as well. Nulls pass (use ``not_null``).
+    """
+    numeric = pd.to_numeric(series, errors="coerce")
+    fail = pd.Series(False, index=series.index)
+    if min_value is not None:
+        fail |= (numeric < min_value) if inclusive else (numeric <= min_value)
+    if max_value is not None:
+        fail |= (numeric > max_value) if inclusive else (numeric >= max_value)
+    non_numeric = numeric.isna() & series.notna()
+    fail |= non_numeric
+    return _as_bool_mask(fail, series.index)
+
+
+def in_set(series: pd.Series, allowed: Iterable[Any]) -> pd.Series:
+    """Fail rows whose (non-null) value is not in ``allowed``."""
+    allowed_set = set(allowed)
+    fail = ~series.isin(allowed_set) & series.notna()
+    return _as_bool_mask(fail, series.index)
+
+
+def matches(series: pd.Series, pattern: str, full_match: bool = False) -> pd.Series:
+    """Fail rows whose (non-null) string value does not match ``pattern``."""
+    compiled = re.compile(pattern)
+    finder = compiled.fullmatch if full_match else compiled.search
+
+    def _fails(value: Any) -> bool:
+        if pd.isna(value):
+            return False
+        return finder(str(value)) is None
+
+    return _as_bool_mask(series.map(_fails), series.index)
+
+
+def is_numeric(series: pd.Series) -> pd.Series:
+    """Fail non-null values that cannot be parsed as numbers."""
+    coerced = pd.to_numeric(series, errors="coerce")
+    return _as_bool_mask(coerced.isna() & series.notna(), series.index)
+
+
+def is_integer(series: pd.Series) -> pd.Series:
+    """Fail non-null values that are not whole numbers."""
+    coerced = pd.to_numeric(series, errors="coerce")
+    non_numeric = coerced.isna() & series.notna()
+    non_integer = coerced.notna() & (coerced % 1 != 0)
+    return _as_bool_mask(non_numeric | non_integer, series.index)
+
+
+def is_datetime(series: pd.Series, fmt: Optional[str] = None) -> pd.Series:
+    """Fail non-null values that cannot be parsed as dates/times."""
+    coerced = pd.to_datetime(series, errors="coerce", format=fmt)
+    return _as_bool_mask(coerced.isna() & series.notna(), series.index)
+
+
+def string_length(
+    series: pd.Series,
+    min_len: Optional[int] = None,
+    max_len: Optional[int] = None,
+) -> pd.Series:
+    """Fail non-null values whose string length is outside the bounds."""
+    lengths = series.dropna().astype(str).str.len()
+    fail = pd.Series(False, index=series.index)
+    if min_len is not None:
+        fail.loc[lengths.index] |= lengths < min_len
+    if max_len is not None:
+        fail.loc[lengths.index] |= lengths > max_len
+    return _as_bool_mask(fail, series.index)
+
+
+def no_duplicate_rows(
+    df: pd.DataFrame, subset: Optional[Iterable[str]] = None
+) -> pd.Series:
+    """Fail rows that are exact duplicates (optionally over ``subset``)."""
+    subset_list = list(subset) if subset is not None else None
+    return _as_bool_mask(df.duplicated(subset=subset_list, keep=False), df.index)