py-devo 0.2.0__tar.gz

py_devo-0.2.0/LICENSE

@@ -0,0 +1,6 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+... (standard MIT text elided for brevity) ...

py_devo-0.2.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: py-devo
+Version: 0.2.0
+Summary: DEVO — CSV to iCSV enrichment and Frictionless validation
+License-Expression: MIT
+Project-URL: Source, https://github.com/envidat/devo
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: frictionless>=4.0.0
+Provides-Extra: webui
+Requires-Dist: flask>=2.0.0; extra == "webui"
+Dynamic: license-file
+
+# DEVO
+<img title="whip it" alt="you know you should" height="50" src="/images/DEVO_Pixels_1.webp">
+
+**Data Enrichment and Validation Operator.** Takes a plain CSV, infers types and constraints, writes a self-documenting [iCSV](https://envidat.github.io/iCSV/) file plus a Frictionless schema, and validates the data against it.
+
+If you give it a `.csv`, it enriches → schema → validates. If you give it an `.icsv`, it skips enrichment.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+For the Flask web demo:
+
+```bash
+pip install -e ".[webui]"
+```
+
+Requires Python 3.9+ and `frictionless` (v4 or v5).
+
+## Try it out
+
+A small sample dataset lives at `examples/sample.csv` — three columns (`timestamp`, `PSUM`, `TA`) representing hourly weather observations. Use it to take DEVO for a spin without needing your own data.
+
+### CLI
+
+```bash
+# Enrich, build schema, and validate in one command
+devo run examples/sample.csv
+
+# Results land in DEVO_output/ by default:
+#   sample.icsv               — annotated iCSV
+#   sample_schema.json        — Frictionless Table Schema
+#   sample_DEVO_report.txt    — human-readable validation report
+```
+
+Run `devo run examples/sample.csv --out my_output` to write to a different directory.
+
+### Python
+
+```python
+from devo.enrich import ICSVEnricher
+from devo.validate import validate_icsv
+
+icsv, schema = ICSVEnricher().make_icsv("examples/sample.csv", "DEVO_output")
+report_path, valid = validate_icsv(icsv, schema_path=schema)
+
+print(f"Valid: {valid}")
+print(f"Report written to: {report_path}")
+```
+
+### Web demo
+
+Install the optional Flask dependency first (if you haven't already):
+
+```bash
+pip install -e ".[webui]"
+```
+
+Start the local server:
+
+```bash
+flask --app devo.webui run
+```
+
+Then open `http://127.0.0.1:5000` in your browser. Click **Choose File**, select `examples/sample.csv`, and click **Upload**. The page will display the paths to the generated iCSV, schema, and report, along with the overall `Valid` result.
+
+> The web UI is a local demo only — do not expose it to a network.
+
+---
+
+## CLI
+
+```bash
+devo enrich   data.csv                    # write data.icsv + data_schema.json
+devo validate data.icsv                   # validate against neighbouring schema
+devo run      data.csv                    # do both in one go
+```
+
+Common flags: `--out DIR` (default `DEVO_output/`), `--delimiter CHAR`, `--nodata VALUE`, `--app PROFILE`, `--schema PATH`.
+
+Exit codes: `0` = success, `1` = validation failed, `2` = usage or runtime error.
+
+## What lands on disk
+
+For input `data.csv`, after `devo run`:
+
+| File | What |
+|---|---|
+| `DEVO_output/data.icsv` | iCSV with `# [METADATA]`, `# [FIELDS]`, `# [DATA]` |
+| `DEVO_output/data_schema.json` | Frictionless Table Schema JSON |
+| `DEVO_output/data_DEVO_report.txt` | Validation report (read this) |
+
+## Python API
+
+```python
+from devo.enrich import ICSVEnricher
+from devo.validate import validate_icsv
+
+icsv, schema = ICSVEnricher().make_icsv("data.csv", "DEVO_output")
+report_path, valid = validate_icsv(icsv, schema_path=schema)
+```
+
+## Files
+
+```
+devo/
+├── cli.py          # argparse front-end (enrich / validate / run)
+├── enrich.py       # CSV → iCSV + schema (ICSVEnricher class)
+├── validate.py     # iCSV + schema → Frictionless validation + report
+├── _infer.py       # pure type-inference functions (shared by enrich + validate)
+├── _parser.py      # iCSV header parser (shared by enrich + validate)
+├── _schema.py      # per-column statistics + Frictionless schema builder
+├── _report.py      # plain-text report writer
+├── exceptions.py   # DEVOError hierarchy
+└── webui.py        # Flask demo (optional; requires pip install -e ".[webui]")
+tests/
+├── conftest.py
+├── fixtures/       # sample CSV and iCSV files
+└── test_*.py
+```
+
+## How it works
+
+### Enrichment (`devo enrich`)
+
+1. **Read** — the CSV is read in one pass. If no `--delimiter` is given, `csv.Sniffer` detects it from the first 10 lines.
+2. **Delimiter mapping** — comma is remapped to pipe in the iCSV output (pipe is also the default fallback for non-spec delimiters). Column names that contain the output delimiter are rejected with a clear error.
+3. **Normalisation** — every row is padded or clipped to header length and stripped of leading/trailing whitespace.
+4. **Type inference** — each column is classified: `integer → number → datetime → string`. Scientific notation (`1.5e-3`, `2E10`) is recognised as `number`. Missing-value sentinels (and any custom `--nodata` value) are excluded before inference.
+5. **Statistics** — per-column `min`, `max`, and `missing_count` are computed from the normalised data and written to the iCSV `# [FIELDS]` section. They do not appear in the Frictionless schema JSON.
+6. **Geometry detection** — if the header contains `lat`/`latitude` + `lon`/`lng`/`longitude`, DEVO writes `geometry = column:lat,lon` and `srid = EPSG:4326` to metadata. A single column named `geometry` (WKT) gets `geometry = column:geometry` only — no `srid`, because WKT embeds its own CRS.
+7. **Write** — the normalised rows are written to the iCSV `# [DATA]` section, and the Frictionless schema is written to `_schema.json`.
+
+### Validation (`devo validate`)
+
+1. **Parse header** — `_parser.py` reads the `# [METADATA]` and `# [FIELDS]` sections, using `field_delimiter` from metadata to split field values.
+2. **Metadata check** — required keys are verified. `geometry` and `srid` are only checked when spatial column names are present; `srid` is only required for lat/lon columns (not WKT).
+3. **Type cross-check (Option A)** — column types are re-inferred from up to 500 data rows and compared to the declared types. The iCSV's own `nodata` sentinel is merged with the standard missing-value set before re-inference so custom sentinels are not mistaken for real data. Inferred type narrower than or equal to declared → `[OK]`. Inferred wider → `[WARN]`.
+4. **Frictionless validation** — data is written to a temporary comma-delimited CSV and validated against the schema using `frictionless.Resource`. The temp file is always deleted in a `finally` block.
+5. **Report** — a plain-text `.txt` report is written with three sections: `METADATA`, `TYPE CONSISTENCY`, and `DATA VALIDATION`. `Valid: YES` only when metadata has no `[FAIL]` entries and Frictionless reports no data errors. Type warnings do not affect the valid flag.
+
+## Limitations
+
+- Type inference is conservative: `integer → number → datetime → string`. Mixed-format columns fall back to `string`.
+- Datetime detection uses `datetime.fromisoformat()` and a fixed list of common strptime formats. Unusual formats need a custom schema.
+- Column descriptions are left blank in the iCSV `# [FIELDS]` section; fill them in by hand.
+- The web UI (`webui.py`) is a local demo only — do not expose it to a network.
+
+## License
+
+MIT. See `LICENSE`.

py_devo-0.2.0/README.md

@@ -0,0 +1,153 @@
+# DEVO
+<img title="whip it" alt="you know you should" height="50" src="/images/DEVO_Pixels_1.webp">
+
+**Data Enrichment and Validation Operator.** Takes a plain CSV, infers types and constraints, writes a self-documenting [iCSV](https://envidat.github.io/iCSV/) file plus a Frictionless schema, and validates the data against it.
+
+If you give it a `.csv`, it enriches → schema → validates. If you give it an `.icsv`, it skips enrichment.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+For the Flask web demo:
+
+```bash
+pip install -e ".[webui]"
+```
+
+Requires Python 3.9+ and `frictionless` (v4 or v5).
+
+## Try it out
+
+A small sample dataset lives at `examples/sample.csv` — three columns (`timestamp`, `PSUM`, `TA`) representing hourly weather observations. Use it to take DEVO for a spin without needing your own data.
+
+### CLI
+
+```bash
+# Enrich, build schema, and validate in one command
+devo run examples/sample.csv
+
+# Results land in DEVO_output/ by default:
+#   sample.icsv               — annotated iCSV
+#   sample_schema.json        — Frictionless Table Schema
+#   sample_DEVO_report.txt    — human-readable validation report
+```
+
+Run `devo run examples/sample.csv --out my_output` to write to a different directory.
+
+### Python
+
+```python
+from devo.enrich import ICSVEnricher
+from devo.validate import validate_icsv
+
+icsv, schema = ICSVEnricher().make_icsv("examples/sample.csv", "DEVO_output")
+report_path, valid = validate_icsv(icsv, schema_path=schema)
+
+print(f"Valid: {valid}")
+print(f"Report written to: {report_path}")
+```
+
+### Web demo
+
+Install the optional Flask dependency first (if you haven't already):
+
+```bash
+pip install -e ".[webui]"
+```
+
+Start the local server:
+
+```bash
+flask --app devo.webui run
+```
+
+Then open `http://127.0.0.1:5000` in your browser. Click **Choose File**, select `examples/sample.csv`, and click **Upload**. The page will display the paths to the generated iCSV, schema, and report, along with the overall `Valid` result.
+
+> The web UI is a local demo only — do not expose it to a network.
+
+---
+
+## CLI
+
+```bash
+devo enrich   data.csv                    # write data.icsv + data_schema.json
+devo validate data.icsv                   # validate against neighbouring schema
+devo run      data.csv                    # do both in one go
+```
+
+Common flags: `--out DIR` (default `DEVO_output/`), `--delimiter CHAR`, `--nodata VALUE`, `--app PROFILE`, `--schema PATH`.
+
+Exit codes: `0` = success, `1` = validation failed, `2` = usage or runtime error.
+
+## What lands on disk
+
+For input `data.csv`, after `devo run`:
+
+| File | What |
+|---|---|
+| `DEVO_output/data.icsv` | iCSV with `# [METADATA]`, `# [FIELDS]`, `# [DATA]` |
+| `DEVO_output/data_schema.json` | Frictionless Table Schema JSON |
+| `DEVO_output/data_DEVO_report.txt` | Validation report (read this) |
+
+## Python API
+
+```python
+from devo.enrich import ICSVEnricher
+from devo.validate import validate_icsv
+
+icsv, schema = ICSVEnricher().make_icsv("data.csv", "DEVO_output")
+report_path, valid = validate_icsv(icsv, schema_path=schema)
+```
+
+## Files
+
+```
+devo/
+├── cli.py          # argparse front-end (enrich / validate / run)
+├── enrich.py       # CSV → iCSV + schema (ICSVEnricher class)
+├── validate.py     # iCSV + schema → Frictionless validation + report
+├── _infer.py       # pure type-inference functions (shared by enrich + validate)
+├── _parser.py      # iCSV header parser (shared by enrich + validate)
+├── _schema.py      # per-column statistics + Frictionless schema builder
+├── _report.py      # plain-text report writer
+├── exceptions.py   # DEVOError hierarchy
+└── webui.py        # Flask demo (optional; requires pip install -e ".[webui]")
+tests/
+├── conftest.py
+├── fixtures/       # sample CSV and iCSV files
+└── test_*.py
+```
+
+## How it works
+
+### Enrichment (`devo enrich`)
+
+1. **Read** — the CSV is read in one pass. If no `--delimiter` is given, `csv.Sniffer` detects it from the first 10 lines.
+2. **Delimiter mapping** — comma is remapped to pipe in the iCSV output (pipe is also the default fallback for non-spec delimiters). Column names that contain the output delimiter are rejected with a clear error.
+3. **Normalisation** — every row is padded or clipped to header length and stripped of leading/trailing whitespace.
+4. **Type inference** — each column is classified: `integer → number → datetime → string`. Scientific notation (`1.5e-3`, `2E10`) is recognised as `number`. Missing-value sentinels (and any custom `--nodata` value) are excluded before inference.
+5. **Statistics** — per-column `min`, `max`, and `missing_count` are computed from the normalised data and written to the iCSV `# [FIELDS]` section. They do not appear in the Frictionless schema JSON.
+6. **Geometry detection** — if the header contains `lat`/`latitude` + `lon`/`lng`/`longitude`, DEVO writes `geometry = column:lat,lon` and `srid = EPSG:4326` to metadata. A single column named `geometry` (WKT) gets `geometry = column:geometry` only — no `srid`, because WKT embeds its own CRS.
+7. **Write** — the normalised rows are written to the iCSV `# [DATA]` section, and the Frictionless schema is written to `_schema.json`.
+
+### Validation (`devo validate`)
+
+1. **Parse header** — `_parser.py` reads the `# [METADATA]` and `# [FIELDS]` sections, using `field_delimiter` from metadata to split field values.
+2. **Metadata check** — required keys are verified. `geometry` and `srid` are only checked when spatial column names are present; `srid` is only required for lat/lon columns (not WKT).
+3. **Type cross-check (Option A)** — column types are re-inferred from up to 500 data rows and compared to the declared types. The iCSV's own `nodata` sentinel is merged with the standard missing-value set before re-inference so custom sentinels are not mistaken for real data. Inferred type narrower than or equal to declared → `[OK]`. Inferred wider → `[WARN]`.
+4. **Frictionless validation** — data is written to a temporary comma-delimited CSV and validated against the schema using `frictionless.Resource`. The temp file is always deleted in a `finally` block.
+5. **Report** — a plain-text `.txt` report is written with three sections: `METADATA`, `TYPE CONSISTENCY`, and `DATA VALIDATION`. `Valid: YES` only when metadata has no `[FAIL]` entries and Frictionless reports no data errors. Type warnings do not affect the valid flag.
+
+## Limitations
+
+- Type inference is conservative: `integer → number → datetime → string`. Mixed-format columns fall back to `string`.
+- Datetime detection uses `datetime.fromisoformat()` and a fixed list of common strptime formats. Unusual formats need a custom schema.
+- Column descriptions are left blank in the iCSV `# [FIELDS]` section; fill them in by hand.
+- The web UI (`webui.py`) is a local demo only — do not expose it to a network.
+
+## License
+
+MIT. See `LICENSE`.

py_devo-0.2.0/devo/__init__.py

@@ -0,0 +1,11 @@
+"""DEVO — CSV to iCSV enrichment and validation.
+
+Public API:
+    from devo.enrich import ICSVEnricher
+    from devo.validate import validate_icsv
+
+Intentionally imports nothing on package load to avoid side effects
+(frictionless, flask) in environments where only one function is needed.
+"""
+
+__version__ = "0.2.0"

py_devo-0.2.0/devo/_infer.py

@@ -0,0 +1,112 @@
+"""Pure type-inference functions — no I/O, no side effects.
+
+All functions in this module are deterministic and dependency-free.
+They are shared by the enricher (CSV → type) and the validator (data re-inference).
+"""
+from __future__ import annotations
+
+import re
+from datetime import datetime
+
+# --- Constants ---
+
+INT_RE = re.compile(r"^-?\d+$")
+# Optional decimal: matches "5" and "5.0" — needed so mixed int/float columns
+# resolve to 'number' rather than falling through to 'string'.
+FLOAT_RE = re.compile(r"^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$")
+
+# Tried after fromisoformat fails; restored from DEVO_enricher.py (was dropped in refactor).
+STRPTIME_FORMATS: tuple[str, ...] = (
+    "%Y-%m-%d %H:%M:%S",
+    "%Y-%m-%d %H:%M",
+    "%Y-%m-%d",
+    "%d.%m.%Y",
+    "%d/%m/%Y",
+    "%m/%d/%Y",
+    "%Y/%m/%d",
+    "%d-%m-%Y",
+    "%Y%m%dT%H%M%S",
+    "%Y-%m-%dT%H:%M:%S%z",
+    "%Y-%m-%dT%H:%M:%S",
+)
+
+# iCSV spec EBNF: field_delimiter ::= [,|\/:;] — tab is not in the allowed set.
+VALID_ICSV_DELIMITERS: frozenset[str] = frozenset({",", "|", "\\", "/", ":", ";"})
+
+# Common missing-value sentinels. Single source of truth shared by enricher and validator.
+# EnviDat has no standardised sentinel, so we cast a wide net.
+COMMON_MISSING: frozenset[str] = frozenset({
+    "", "NA", "N/A", "na", "n/a", "NULL", "null", "nan", "NaN",
+    "-999", "-999.0", "-999.000000",
+})
+
+# Type subtype lattice: inferred → set of declared types it is valid under.
+# integer ⊂ number ⊂ string; datetime ⊂ string.
+# Used by the validator for Option-A cross-check (declared type is authoritative).
+_SUBTYPES: dict[str, frozenset[str]] = {
+    "integer":  frozenset({"integer", "number", "string"}),
+    "number":   frozenset({"number", "string"}),
+    "datetime": frozenset({"datetime", "string"}),
+    "string":   frozenset({"string"}),
+}
+
+
+# --- Type checkers ---
+
+def _is_integer(s: str) -> bool:
+    return bool(INT_RE.match(s))
+
+
+def _is_number(s: str) -> bool:
+    return bool(INT_RE.match(s) or FLOAT_RE.match(s))
+
+
+def _is_datetime(s: str) -> bool:
+    """Try fromisoformat first, then a fixed list of strptime formats."""
+    s = s.strip()
+    if not s:
+        return False
+    try:
+        datetime.fromisoformat(s)
+        return True
+    except (ValueError, TypeError):
+        pass
+    for fmt in STRPTIME_FORMATS:
+        try:
+            datetime.strptime(s, fmt)
+            return True
+        except (ValueError, TypeError):
+            continue
+    return False
+
+
+# --- Public API ---
+
+def infer_type(values: list[str], missing: frozenset[str] = COMMON_MISSING) -> str:
+    """
+    Infer a Frictionless field type from a list of string values.
+    Cascade: integer → number → datetime → string.
+    Missing-value sentinels are excluded before testing.
+    An all-missing or empty column returns 'string'.
+    """
+    pruned = [v.strip() for v in values if v.strip() not in missing]
+    if not pruned:
+        return "string"
+    if all(_is_integer(v) for v in pruned):
+        return "integer"
+    if all(_is_number(v) for v in pruned):
+        return "number"
+    if all(_is_datetime(v) for v in pruned):
+        return "datetime"
+    return "string"
+
+
+def is_subtype_or_equal(inferred: str, declared: str) -> bool:
+    """
+    True when the inferred type is at least as specific as (or equal to) the declared type.
+    This means existing data satisfies the declared schema:
+      - inferred=integer, declared=number  → True  (integers pass number validation)
+      - inferred=number,  declared=integer → False (floats fail integer validation)
+    Used by the validator to produce [WARN] when inferred is wider than declared.
+    """
+    return declared in _SUBTYPES.get(inferred, frozenset())

py_devo-0.2.0/devo/_parser.py

@@ -0,0 +1,91 @@
+"""Canonical iCSV header parser — single implementation shared by enricher and validator.
+
+Parses [METADATA] and [FIELDS] sections from iCSV files per the iCSV 1.0 spec.
+Stops at # [DATA] and does not read data rows.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .exceptions import ParseError
+
+
+@dataclass
+class ICSVHeader:
+    metadata: dict[str, str]
+    fields_meta: dict[str, list[str]]
+    field_delimiter: str
+
+
+def is_icsv(path: Path) -> bool:
+    """Return True if the file's first line marks it as an iCSV file."""
+    try:
+        # utf-8-sig strips the BOM if present
+        with open(path, "r", encoding="utf-8-sig") as fh:
+            return fh.readline().strip().startswith("# iCSV")
+    except (OSError, UnicodeDecodeError):
+        return False
+
+
+def parse_header(path: Path) -> ICSVHeader:
+    """
+    Parse [METADATA] and [FIELDS] sections of an iCSV file.
+
+    field_delimiter is read from metadata before the FIELDS section is split,
+    so key order in the file does not matter — the correct delimiter is always used.
+    Raises ParseError if the file is unreadable or has no [METADATA] section.
+    """
+    metadata: dict[str, str] = {}
+    raw_fields: dict[str, str] = {}  # key → unsplit value string; split after delimiter known
+    section: str | None = None
+
+    try:
+        with open(path, "r", encoding="utf-8-sig") as fh:
+            for line in fh:
+                stripped = line.rstrip("\r\n")
+
+                if not stripped.startswith("#"):
+                    continue
+
+                content = stripped.lstrip("#").strip()
+
+                if content == "[METADATA]":
+                    section = "metadata"
+                    continue
+                if content == "[FIELDS]":
+                    section = "fields"
+                    continue
+                if content == "[DATA]":
+                    break
+
+                # Skip blank comment lines and section headers
+                if not content or "=" not in content or section is None:
+                    continue
+
+                key, _, val = content.partition("=")
+                key = key.strip()
+                val = val.strip()
+
+                if section == "metadata":
+                    metadata[key] = val
+                else:
+                    raw_fields[key] = val
+
+    except OSError as e:
+        raise ParseError(f"Cannot read {path}: {e}") from e
+
+    if not metadata:
+        raise ParseError(f"{path.name}: no [METADATA] section found or file is empty")
+
+    field_delimiter = metadata.get("field_delimiter", ",")
+    fields_meta = {
+        k: [v.strip() for v in raw.split(field_delimiter)]
+        for k, raw in raw_fields.items()
+    }
+
+    return ICSVHeader(
+        metadata=metadata,
+        fields_meta=fields_meta,
+        field_delimiter=field_delimiter,
+    )

py_devo-0.2.0/devo/_report.py

@@ -0,0 +1,88 @@
+"""Plain-text validation report writer.
+
+Produces a human-readable .txt file covering three checks:
+  1. Metadata completeness
+  2. Type consistency (declared vs re-inferred)
+  3. Frictionless data validation
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def write_report(
+    path: Path,
+    icsv_name: str,
+    metadata_issues: list[str],
+    type_issues: list[tuple[str, str, str, bool]],
+    frictionless_report: Any,
+    is_valid: bool,
+) -> None:
+    """
+    Write a plain-text DEVO validation report to `path`.
+
+    type_issues: list of (column_name, declared_type, inferred_type, is_ok).
+      is_ok=True means inferred is a subtype of (or equal to) declared.
+    frictionless_report: the object returned by frictionless Resource.validate().
+    """
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    _SEP = "-" * 40
+
+    with open(path, "w", encoding="utf-8") as fh:
+
+        fh.write("DEVO Validation Report\n")
+        fh.write("=" * 22 + "\n")
+        fh.write(f"File:  {icsv_name}\n")
+        fh.write(f"Date:  {now}\n")
+        fh.write(f"Valid: {'YES' if is_valid else 'NO'}\n\n")
+
+        # --- Metadata ---
+        fh.write("METADATA\n")
+        fh.write(_SEP + "\n")
+        if metadata_issues:
+            for issue in metadata_issues:
+                fh.write(f"{issue}\n")
+        else:
+            fh.write("[OK] All required metadata present.\n")
+        fh.write("\n")
+
+        # --- Type consistency (Option A cross-check) ---
+        fh.write("TYPE CONSISTENCY\n")
+        fh.write(_SEP + "\n")
+        if not type_issues:
+            fh.write("[OK] No declared types to cross-check.\n")
+        else:
+            for col, declared, inferred, ok in type_issues:
+                if ok:
+                    fh.write(f"[OK]   {col}: declared={declared}, inferred={inferred}\n")
+                else:
+                    fh.write(f"[WARN] {col}: declared={declared}, inferred={inferred}\n")
+                    fh.write(
+                        f"       Inferred type is wider than declared. "
+                        f"Data may not satisfy '{declared}' constraints.\n"
+                    )
+        fh.write("\n")
+
+        # --- Frictionless data validation ---
+        fh.write("DATA VALIDATION\n")
+        fh.write(_SEP + "\n")
+        try:
+            errors = frictionless_report.flatten(
+                ["rowNumber", "fieldNumber", "fieldName", "code", "message"]
+            )
+        except (AttributeError, TypeError):
+            errors = []
+            fh.write("[WARN] Could not extract error details from frictionless report.\n")
+
+        if not errors:
+            fh.write("[PASS] No data errors found.\n")
+        else:
+            shown = errors[:50]
+            suffix = f" (showing first 50 of {len(errors)})" if len(errors) > 50 else ""
+            fh.write(f"[FAIL] {len(errors)} error(s) found{suffix}:\n")
+            for row, col_num, col_name, code, message in shown:
+                row_str = str(row) if row is not None else "?"
+                col_str = col_name or (str(col_num) if col_num is not None else "?")
+                fh.write(f"  Row {row_str}, Col {col_str} [{code}]: {message}\n")