duckcheck 0.4.0__py3-none-any.whl

duckcheck/__init__.py

@@ -0,0 +1,3 @@
+"""DuckDB-powered data quality checks."""
+
+__version__ = "0.4.0"

duckcheck/baseline.py

@@ -0,0 +1,36 @@
+"""SQLite baseline store for row-count delta checks."""
+
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+
+class BaselineStore:
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(str(self.path))
+        self._conn.execute(
+            "CREATE TABLE IF NOT EXISTS row_counts (check_name TEXT PRIMARY KEY, row_count INTEGER NOT NULL)"
+        )
+        self._conn.commit()
+
+    def get(self, check_name: str) -> int | None:
+        row = self._conn.execute(
+            "SELECT row_count FROM row_counts WHERE check_name = ?", (check_name,)
+        ).fetchone()
+        return None if row is None else int(row[0])
+
+    def set(self, check_name: str, row_count: int) -> None:
+        self._conn.execute(
+            """
+            INSERT INTO row_counts (check_name, row_count) VALUES (?, ?)
+            ON CONFLICT(check_name) DO UPDATE SET row_count = excluded.row_count
+            """,
+            (check_name, row_count),
+        )
+        self._conn.commit()
+
+    def close(self) -> None:
+        self._conn.close()

duckcheck/cli.py

@@ -0,0 +1,114 @@
+"""CLI for duckcheck."""
+
+import sys
+from pathlib import Path
+from typing import NoReturn
+
+import click
+import duckdb
+import yaml
+from pydantic import ValidationError
+from rich.console import Console
+from rich.table import Table
+
+from duckcheck import __version__
+from duckcheck.runner import run_suite, to_junit, update_baseline
+from duckcheck.spec import SuiteSpec
+
+console = Console()
+
+
+@click.group()
+@click.version_option(__version__)
+def main() -> None:
+    """Lightweight data quality checks powered by DuckDB."""
+
+
+@main.command("health")
+def health() -> None:
+    console.print(f"[green]duckcheck {__version__} OK[/green]")
+
+
+def _load_suite(suite_path: Path) -> SuiteSpec:
+    try:
+        raw = yaml.safe_load(suite_path.read_text(encoding="utf-8"))
+        return SuiteSpec.model_validate(raw)
+    except (yaml.YAMLError, ValidationError, ValueError, TypeError) as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise SystemExit(2)
+
+
+def _fail(exc: BaseException) -> NoReturn:
+    console.print(f"[red]Error:[/red] {exc}")
+    raise SystemExit(2)
+
+
+@main.command("run")
+@click.argument("suite_path", type=click.Path(exists=True, path_type=Path))
+@click.option("--junit", type=click.Path(path_type=Path), default=None)
+@click.option("--source-table", default=None, help="Override attached SQL table name")
+@click.option("--format", "fmt", type=click.Choice(["text", "json"]), default="text")
+def run_cmd(
+    suite_path: Path,
+    junit: Path | None,
+    source_table: str | None,
+    fmt: str,
+) -> None:
+    suite = _load_suite(suite_path)
+    if source_table:
+        suite.source_table = source_table
+    try:
+        report = run_suite(suite, suite_dir=suite_path.parent)
+    except (FileNotFoundError, ValueError, duckdb.Error) as exc:
+        _fail(exc)
+
+    if fmt == "json":
+        import json
+
+        payload = {
+            "suite": report.suite,
+            "passed": report.passed,
+            "results": [
+                {
+                    "name": r.name,
+                    "passed": r.passed,
+                    "message": r.message,
+                    "rows_failed": r.rows_failed,
+                }
+                for r in report.results
+            ],
+        }
+        console.print_json(json.dumps(payload))
+    else:
+        table = Table(title=f"Results: {report.suite}")
+        table.add_column("Check")
+        table.add_column("Status")
+        table.add_column("Message")
+        for r in report.results:
+            status = "[green]PASS[/green]" if r.passed else "[red]FAIL[/red]"
+            table.add_row(r.name, status, r.message)
+        console.print(table)
+
+    if junit:
+        junit.write_text(to_junit(report), encoding="utf-8")
+        console.print(f"Wrote JUnit report to {junit}")
+
+    if not report.passed:
+        sys.exit(1)
+
+
+@main.command("baseline")
+@click.argument("action", type=click.Choice(["update"]))
+@click.argument("suite_path", type=click.Path(exists=True, path_type=Path))
+def baseline_cmd(action: str, suite_path: Path) -> None:
+    """Persist current row counts for row_count_delta checks."""
+    suite = _load_suite(suite_path)
+    try:
+        path = update_baseline(suite, suite_dir=suite_path.parent)
+    except (FileNotFoundError, ValueError, duckdb.Error) as exc:
+        _fail(exc)
+    console.print(f"[green]Updated baseline[/green] {path}")
+
+
+if __name__ == "__main__":
+    main()

duckcheck/runner.py

@@ -0,0 +1,352 @@
+"""Execute data quality checks via DuckDB."""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from xml.etree.ElementTree import Element, SubElement, tostring
+
+import duckdb
+import structlog
+
+from duckcheck.baseline import BaselineStore
+from duckcheck.spec import CheckSpec, SuiteSpec
+
+log = structlog.get_logger()
+
+IDENT = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+AGE = re.compile(r"^(\d+)([smhd])$")
+
+
+@dataclass
+class CheckResult:
+    name: str
+    passed: bool
+    message: str
+    rows_failed: int = 0
+
+
+@dataclass
+class RunReport:
+    suite: str
+    results: list[CheckResult]
+
+    @property
+    def passed(self) -> bool:
+        return all(r.passed for r in self.results)
+
+
+def _ident(name: str) -> str:
+    if not IDENT.match(name):
+        raise ValueError(f"Invalid identifier: {name!r}")
+    return name
+
+
+def _sql_literal(value: str) -> str:
+    return "'" + value.replace("'", "''") + "'"
+
+
+def _substitute_env(value: str) -> str:
+    def repl(match: re.Match[str]) -> str:
+        return os.environ.get(match.group(1), "")
+
+    return re.sub(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}", repl, value)
+
+
+def run_suite(suite: SuiteSpec, suite_dir: Path | None = None) -> RunReport:
+    conn = duckdb.connect()
+    source = _substitute_env(suite.source)
+    _register_source(conn, source, suite.source_table, suite_dir)
+    baseline = _open_baseline(suite, suite_dir)
+    results: list[CheckResult] = []
+    for check in suite.checks:
+        results.append(_run_check(conn, check, baseline))
+    conn.close()
+    if baseline is not None:
+        baseline.close()
+    return RunReport(suite=suite.name, results=results)
+
+
+def update_baseline(suite: SuiteSpec, suite_dir: Path | None = None) -> Path:
+    """Persist current row counts for row_count_delta checks."""
+    conn = duckdb.connect()
+    source = _substitute_env(suite.source)
+    _register_source(conn, source, suite.source_table, suite_dir)
+    path = _baseline_path(suite, suite_dir)
+    store = BaselineStore(path)
+    count = conn.execute("SELECT COUNT(*) FROM source_data").fetchone()[0]
+    for check in suite.checks:
+        if check.type == "row_count_delta":
+            store.set(check.name, int(count))
+    store.close()
+    conn.close()
+    return path
+
+
+def _register_source(
+    conn: duckdb.DuckDBPyConnection,
+    source: str,
+    source_table: str | None,
+    suite_dir: Path | None,
+) -> None:
+    if source.startswith(("postgres://", "postgresql://")):
+        conn.execute("INSTALL postgres; LOAD postgres;")
+        conn.execute(f"ATTACH {_sql_literal(source)} AS remote (TYPE POSTGRES)")
+        table = _ident(source_table or "orders")
+        conn.execute(f"CREATE OR REPLACE VIEW source_data AS SELECT * FROM remote.{table}")
+        return
+    if source.startswith("mysql://"):
+        conn.execute("INSTALL mysql; LOAD mysql;")
+        conn.execute(f"ATTACH {_sql_literal(source)} AS remote (TYPE MYSQL)")
+        table = _ident(source_table or "orders")
+        conn.execute(f"CREATE OR REPLACE VIEW source_data AS SELECT * FROM remote.{table}")
+        return
+    if source.startswith("sqlite://") or source.endswith((".db", ".sqlite")):
+        db_path = source.removeprefix("sqlite://")
+        path = _resolve_file_source(db_path, suite_dir)
+        table = _ident(source_table or "source_data")
+        conn.execute(f"ATTACH {_sql_literal(str(path))} AS remote (TYPE SQLITE)")
+        conn.execute(f"CREATE OR REPLACE VIEW source_data AS SELECT * FROM remote.{table}")
+        return
+
+    path = _resolve_file_source(source, suite_dir)
+    resolved = str(path)
+    quoted = _sql_literal(resolved)
+    if resolved.endswith(".csv"):
+        conn.execute(f"CREATE OR REPLACE VIEW source_data AS SELECT * FROM read_csv_auto({quoted})")
+    elif resolved.endswith(".parquet"):
+        conn.execute(f"CREATE OR REPLACE VIEW source_data AS SELECT * FROM read_parquet({quoted})")
+    else:
+        raise ValueError(f"Unsupported source format: {source}")
+
+
+def _resolve_file_source(source: str, suite_dir: Path | None) -> Path:
+    path = Path(source)
+    if path.is_absolute():
+        if not path.exists():
+            raise FileNotFoundError(f"Source not found: {path}")
+        return path
+    candidates: list[Path] = []
+    if suite_dir is not None:
+        candidates.append(suite_dir / path)
+        candidates.append(suite_dir / path.name)
+    candidates.append(Path.cwd() / path)
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    tried = ", ".join(str(c) for c in candidates)
+    raise FileNotFoundError(f"Source not found: {source} (tried {tried})")
+
+
+def _baseline_path(suite: SuiteSpec, suite_dir: Path | None) -> Path:
+    raw = suite.baseline or ".duckcheck/baseline.db"
+    path = Path(raw)
+    if path.is_absolute():
+        return path
+    root = suite_dir or Path.cwd()
+    return root / path
+
+
+def _open_baseline(suite: SuiteSpec, suite_dir: Path | None) -> BaselineStore | None:
+    if not any(c.type == "row_count_delta" for c in suite.checks):
+        return None
+    return BaselineStore(_baseline_path(suite, suite_dir))
+
+
+def _now_sql() -> str:
+    raw = os.environ.get("DUCKCHECK_NOW")
+    if raw:
+        return f"TIMESTAMP '{raw}'"
+    return "now()"
+
+
+def _run_check(
+    conn: duckdb.DuckDBPyConnection,
+    check: CheckSpec,
+    baseline: BaselineStore | None = None,
+) -> CheckResult:
+    log.info("running_check", name=check.name, type=check.type)
+    dispatch = {
+        "not_null": _check_not_null,
+        "unique": _check_unique,
+        "accepted_values": _check_accepted_values,
+        "custom_sql": _check_custom_sql,
+        "freshness": _check_freshness,
+        "row_count": _check_row_count,
+        "row_count_delta": lambda c, spec: _check_row_count_delta(c, spec, baseline),
+    }
+    handler = dispatch.get(check.type)
+    if handler is None:
+        return CheckResult(check.name, False, f"Unknown check type: {check.type}")
+    return handler(conn, check)
+
+
+def _check_not_null(conn: duckdb.DuckDBPyConnection, check: CheckSpec) -> CheckResult:
+    col = _ident(check.column or "")
+    count = conn.execute(f"SELECT COUNT(*) FROM source_data WHERE {col} IS NULL").fetchone()[0]
+    passed = count == 0
+    return CheckResult(
+        check.name,
+        passed,
+        f"{count} null values in {col}" if not passed else f"{col} has no nulls",
+        rows_failed=count,
+    )
+
+
+def _check_unique(conn: duckdb.DuckDBPyConnection, check: CheckSpec) -> CheckResult:
+    col = _ident(check.column or "")
+    dupes = conn.execute(
+        f"SELECT COUNT(*) - COUNT(DISTINCT {col}) FROM source_data"
+    ).fetchone()[0]
+    passed = dupes == 0
+    return CheckResult(
+        check.name,
+        passed,
+        f"{dupes} duplicate values in {col}" if not passed else f"{col} is unique",
+        rows_failed=dupes,
+    )
+
+
+def _check_accepted_values(conn: duckdb.DuckDBPyConnection, check: CheckSpec) -> CheckResult:
+    col = _ident(check.column or "")
+    allowed = ", ".join(f"'{v}'" for v in check.values)
+    bad = conn.execute(
+        f"SELECT COUNT(*) FROM source_data WHERE {col} NOT IN ({allowed})"
+    ).fetchone()[0]
+    passed = bad == 0
+    return CheckResult(
+        check.name,
+        passed,
+        f"{bad} rows with invalid {col}" if not passed else f"{col} values accepted",
+        rows_failed=bad,
+    )
+
+
+def _eval_expect(count: int, expect: str | int | None) -> tuple[bool, str]:
+    """Return (passed, human message) for custom_sql row counts."""
+    raw = "0" if expect is None else str(expect).strip()
+    if raw.isdigit() or (raw.startswith("=") and raw[1:].strip().isdigit()):
+        want = int(raw[1:].strip() if raw.startswith("=") else raw)
+        passed = count == want
+        return passed, f"got {count} rows, expect ={want}"
+    if raw.startswith(">") and raw[1:].strip().isdigit():
+        want = int(raw[1:].strip())
+        passed = count > want
+        return passed, f"got {count} rows, expect >{want}"
+    if raw.startswith("<") and raw[1:].strip().isdigit():
+        want = int(raw[1:].strip())
+        passed = count < want
+        return passed, f"got {count} rows, expect <{want}"
+    if raw.startswith(">=") and raw[2:].strip().isdigit():
+        want = int(raw[2:].strip())
+        passed = count >= want
+        return passed, f"got {count} rows, expect >={want}"
+    if raw.startswith("<=") and raw[2:].strip().isdigit():
+        want = int(raw[2:].strip())
+        passed = count <= want
+        return passed, f"got {count} rows, expect <={want}"
+    raise ValueError(f"Invalid expect {expect!r}. Use 0, =N, >N, <N, >=N, or <=N.")
+
+
+def _check_custom_sql(conn: duckdb.DuckDBPyConnection, check: CheckSpec) -> CheckResult:
+    sql = (check.sql or "").strip()
+    if not sql.lower().startswith("select"):
+        return CheckResult(check.name, False, "custom_sql must be a SELECT statement.")
+    rows = conn.execute(sql).fetchall()
+    count = len(rows)
+    try:
+        passed, detail = _eval_expect(count, check.expect)
+    except ValueError as exc:
+        return CheckResult(check.name, False, str(exc))
+    return CheckResult(
+        check.name,
+        passed,
+        detail if not passed else f"custom SQL ok ({detail})",
+        rows_failed=0 if passed else count,
+    )
+
+
+def _parse_age(spec: str) -> str:
+    match = AGE.match(spec)
+    if not match:
+        raise ValueError(f"Invalid max_age '{spec}'. Use Ns/Nm/Nh/Nd.")
+    value, unit = match.groups()
+    mapping = {"s": "SECOND", "m": "MINUTE", "h": "HOUR", "d": "DAY"}
+    return f"INTERVAL {int(value)} {mapping[unit]}"
+
+
+def _check_freshness(conn: duckdb.DuckDBPyConnection, check: CheckSpec) -> CheckResult:
+    col = _ident(check.column or "")
+    interval = _parse_age(check.max_age or "24h")
+    stale = conn.execute(
+        f"SELECT COUNT(*) FROM source_data WHERE {col} < {_now_sql()} - {interval}"
+    ).fetchone()[0]
+    passed = stale == 0
+    return CheckResult(
+        check.name,
+        passed,
+        f"{stale} stale rows in {col}" if not passed else f"{col} is fresh",
+        rows_failed=stale,
+    )
+
+
+def _check_row_count(conn: duckdb.DuckDBPyConnection, check: CheckSpec) -> CheckResult:
+    count = conn.execute("SELECT COUNT(*) FROM source_data").fetchone()[0]
+    too_few = check.min_rows is not None and count < check.min_rows
+    too_many = check.max_rows is not None and count > check.max_rows
+    passed = not too_few and not too_many
+    return CheckResult(
+        check.name,
+        passed,
+        f"row count {count} outside [{check.min_rows}, {check.max_rows}]"
+        if not passed
+        else f"row count {count} within bounds",
+        rows_failed=0 if passed else 1,
+    )
+
+
+def _check_row_count_delta(
+    conn: duckdb.DuckDBPyConnection,
+    check: CheckSpec,
+    baseline: BaselineStore | None,
+) -> CheckResult:
+    count = int(conn.execute("SELECT COUNT(*) FROM source_data").fetchone()[0])
+    if baseline is None:
+        return CheckResult(check.name, False, "row_count_delta requires a baseline store")
+    previous = baseline.get(check.name)
+    if previous is None:
+        return CheckResult(
+            check.name,
+            False,
+            f"no baseline for {check.name}; run duckcheck baseline update",
+        )
+    if previous == 0:
+        drift = 0.0 if count == 0 else 100.0
+    else:
+        drift = abs(count - previous) / previous * 100.0
+    tol = check.tolerance_pct if check.tolerance_pct is not None else 10.0
+    passed = drift <= tol
+    return CheckResult(
+        check.name,
+        passed,
+        f"row count {count} vs baseline {previous} ({drift:.1f}% drift, tol {tol}%)"
+        if not passed
+        else f"row count {count} within {tol}% of baseline {previous}",
+        rows_failed=0 if passed else 1,
+    )
+
+
+def to_junit(report: RunReport) -> str:
+    """Serialize results as JUnit XML for CI dashboards."""
+    suite = Element("testsuite", name=report.suite, tests=str(len(report.results)))
+    failures = 0
+    for result in report.results:
+        case = SubElement(suite, "testcase", name=result.name, classname=report.suite)
+        if not result.passed:
+            failures += 1
+            failure = SubElement(case, "failure", message=result.message)
+            failure.text = result.message
+    suite.set("failures", str(failures))
+    return tostring(suite, encoding="unicode")

duckcheck/spec.py

@@ -0,0 +1,26 @@
+"""Check specification models."""
+
+from pydantic import BaseModel, Field
+
+
+class CheckSpec(BaseModel):
+    name: str
+    type: str
+    table: str = "source_data"
+    column: str | None = None
+    values: list[str] = Field(default_factory=list)
+    sql: str | None = None
+    # custom_sql: pass when row count matches expect ("0", "=3", ">0", "<10")
+    expect: str | int | None = "0"
+    max_age: str | None = None
+    min_rows: int | None = None
+    max_rows: int | None = None
+    tolerance_pct: float | None = None
+
+
+class SuiteSpec(BaseModel):
+    name: str
+    source: str
+    source_table: str | None = None
+    baseline: str | None = None
+    checks: list[CheckSpec] = Field(default_factory=list)

duckcheck-0.4.0.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.5
+Name: duckcheck
+Version: 0.4.0
+Summary: Lightweight data quality checks powered by DuckDB
+Project-URL: Homepage, https://github.com/yashshah9/duckcheck
+Project-URL: Repository, https://github.com/yashshah9/duckcheck
+Project-URL: Issues, https://github.com/yashshah9/duckcheck/issues
+Author-email: Yash Shah <yash376351@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1
+Requires-Dist: duckdb>=1.0
+Requires-Dist: pydantic>=2.6
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: structlog>=24.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.9; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# duckcheck
+
+Lightweight data quality checks powered by **DuckDB** — the anti–Great Expectations for teams who want `pip install`, one YAML file, and one command.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![CI](https://github.com/yashshah9/duckcheck/actions/workflows/ci.yml/badge.svg)](https://github.com/yashshah9/duckcheck/actions/workflows/ci.yml)
+
+> **Status:** v0.4 — CSV/Parquet/SQLite sources, custom SQL with `expect` operators, freshness, baselines, JUnit, and `--format json`.
+
+## 60-second try
+
+```bash
+docker compose run --rm run-example  # duckcheck run examples/clean.yaml
+docker compose run --rm test         # pytest
+```
+
+## Why this vs alternatives
+
+| Approach | Strength | Gap |
+|----------|----------|-----|
+| **duckcheck** | One YAML + DuckDB, local files, CI-friendly | Not a full observability platform |
+| Great Expectations | Rich ecosystem | Heavyweight setup for simple column checks |
+| Soda Core | Familiar check DSL | Cloud-oriented workflow |
+| Ad-hoc SQL in CI | Zero new tools | No standard report / JUnit / baselines |
+
+## Problem
+
+Data teams need to assert column quality in CI, but Great Expectations is heavyweight and Soda Core funnels to cloud. Ad-hoc SQL checks have no reporting standard.
+
+## Key features (v0.4)
+
+- YAML check definitions
+- DuckDB scans CSV, Parquet, and SQLite locally — no server
+- Checks: `not_null`, `unique`, `accepted_values`, `custom_sql`, `freshness`, `row_count`, `row_count_delta`
+- `custom_sql` `expect` operators: `0`, `=N`, `>N`, `<N`, `>=N`, `<=N` (default `0`)
+- `--format json` and `--junit` for CI dashboards
+- `${ENV}` in source URIs; `--source-table` for SQL ATTACH
+
+## Architecture
+
+```
+duckcheck run checks.yaml
+    └── SuiteSpec (Pydantic)
+            └── DuckDB in-process
+                    └── source_data view from CSV/Parquet
+```
+
+| Component | Technology | Why |
+|-----------|------------|-----|
+| Engine | DuckDB | Single dependency, scans files + SQL databases |
+| CLI | Click + Rich | Simple, good terminal UX |
+| Spec | YAML + Pydantic | Version-controllable checks |
+
+## Installation
+
+```bash
+pip install duckcheck
+pip install -e ".[dev]"
+```
+
+## Usage
+
+```bash
+duckcheck health
+duckcheck run examples/clean.yaml
+duckcheck run examples/checks.yaml   # fixture with known failures
+duckcheck run examples/clean.yaml --junit /tmp/duckcheck.xml
+duckcheck run examples/clean.yaml --format json
+duckcheck baseline update examples/clean.yaml
+```
+
+Example `checks.yaml`:
+
+```yaml
+name: sample-suite
+source: examples/sample.csv
+checks:
+  - name: id_not_null
+    type: not_null
+    column: id
+  - name: status_values
+    type: accepted_values
+    column: status
+    values: [active, inactive]
+  - name: three_active
+    type: custom_sql
+    sql: "SELECT * FROM source_data WHERE status = 'active'"
+    expect: "=3"
+```
+
+## Docker
+
+```bash
+docker compose run --rm test
+docker compose run --rm run-example
+```
+
+## Running tests
+
+```bash
+pytest tests/ -v
+```
+
+## Roadmap
+
+- [x] Freshness + row_count + custom_sql + JUnit
+- [x] Row-count baseline delta store (`duckcheck baseline update`)
+- [x] custom_sql `expect` operators + `--format json`
+- [ ] Live Postgres/MySQL ATTACH integration tests
+- [ ] Airflow/Dagster operators
+
+## License
+
+MIT
+
+## Known limitations (v0.4)
+
+- Postgres/MySQL ATTACH is stubbed (`INSTALL/LOAD`) — no live DB in CI yet
+- `examples/checks.yaml` is a failing fixture; `examples/clean.yaml` is the happy path
+- Checks still run against a `source_data` view

duckcheck-0.4.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+duckcheck/__init__.py,sha256=kKKgBq_q4-vqb8QA_WvhdqR0QLCACuaQKGcRue2EnI0,65
+duckcheck/baseline.py,sha256=PS5TM_h6bkyE9frgQAPl6ULkQWaoPpc4oYtTeTloBQE,1163
+duckcheck/cli.py,sha256=Fd_-t8apCZn7KyPLysyawfB1KQgSME1f00GgAOELous,3389
+duckcheck/runner.py,sha256=SHKhOjBVtxpkKN50zB5yPYkh4EomwEDen-8-NIPb8aY,12353
+duckcheck/spec.py,sha256=wZx-Vp5mEkFfIuqFIsDZxkt67e-Uozm1TBUTD4AkRX8,704
+duckcheck-0.4.0.dist-info/METADATA,sha256=apb-sNwFgufQXkTKevfzKIwWUx5ywlBxsLqOfAmmp1o,4457
+duckcheck-0.4.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+duckcheck-0.4.0.dist-info/entry_points.txt,sha256=pBnGIP-XwvpLepF_R4kij6R0cxneIL2xlmnLwICIJLs,49
+duckcheck-0.4.0.dist-info/licenses/LICENSE,sha256=AvzqSNURip5YZfXN3-QN_nLlFeC8ob_qbLijyMrFP8w,1079
+duckcheck-0.4.0.dist-info/RECORD,,

duckcheck-0.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

duckcheck-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+duckcheck = duckcheck.cli:main

duckcheck-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 duckcheck contributors
+
+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.