Upload folder using huggingface_hub

.gitattributes

@@ -59,3 +59,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 data/train.jsonl filter=lfs diff=lfs merge=lfs -text
 meta/discovery_cache/discovered_documents_20250928_195619.json filter=lfs diff=lfs merge=lfs -text
+data/tmpc343c9mc filter=lfs diff=lfs merge=lfs -text
+data/tmpolt7cobs filter=lfs diff=lfs merge=lfs -text

configure.py

@@ -0,0 +1,235 @@
+import argparse
+import copy
+import json
+import logging
+import sys
+import tempfile
+from pathlib import Path
+from typing import Iterable, List, Tuple
+import xml.etree.ElementTree as ET
+
+
+LOGGER = logging.getLogger("configure")
+
+NS = {
+    "leg": "http://www.legislation.gov.uk/namespaces/legislation",
+    "ukm": "http://www.legislation.gov.uk/namespaces/metadata",
+    "dc": "http://purl.org/dc/elements/1.1/",
+    "dct": "http://purl.org/dc/terms/",
+}
+
+
+def enrich(record: dict) -> dict:
+    root = ET.fromstring(record["xml_content"])
+
+    record["coming_into_force_date"] = root.get("RestrictStartDate")
+    extent = root.get("RestrictExtent")
+    record["extent"] = extent.split("+") if extent else None
+
+    meta = root.find("ukm:Metadata", NS)
+    if meta is not None:
+        valid = meta.find("dct:valid", NS)
+        record["publication_date"] = valid.text if valid is not None else None
+
+        status = root.find(".//ukm:PrimaryMetadata/ukm:DocumentClassification/ukm:DocumentStatus", NS)
+        record["status"] = status.get("Value") if status is not None else record.get("status")
+
+        enactment = root.find(".//ukm:PrimaryMetadata/ukm:EnactmentDate", NS)
+        record["enacted_date"] = enactment.get("Date") if enactment is not None else None
+
+    return record
+
+
+def _iter_data_files(config_path: Path, splits: Iterable[str] | None = None) -> List[Tuple[str, Path]]:
+    with config_path.open("r", encoding="utf-8") as handle:
+        config = json.load(handle)
+
+    data_files = config.get("data_files", {})
+    if isinstance(data_files, list):
+        data_files = {"train": data_files}
+    elif isinstance(data_files, str):
+        data_files = {"train": data_files}
+
+    selected_splits = set(splits) if splits else set(data_files.keys())
+
+    resolved: List[Tuple[str, Path]] = []
+    for split, value in data_files.items():
+        if split not in selected_splits:
+            continue
+
+        if isinstance(value, list):
+            paths = value
+        else:
+            paths = [value]
+
+        for rel_path in paths:
+            resolved.append((split, (config_path.parent / rel_path).resolve()))
+
+    if not resolved:
+        raise ValueError("No data files found for the requested splits")
+
+    return resolved
+
+
+def _configure_logging(verbose: bool) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+    LOGGER.setLevel(level)
+    LOGGER.handlers.clear()
+    LOGGER.addHandler(handler)
+    LOGGER.propagate = False
+
+
+def _process_file(path: Path, *, dry_run: bool, strict: bool, limit: int | None) -> Tuple[int, int, int]:
+    total = 0
+    changed = 0
+    errors = 0
+
+    if limit is not None and not dry_run:
+        raise ValueError("--limit can only be used together with --dry-run")
+
+    if not path.exists():
+        raise FileNotFoundError(f"Data file not found: {path}")
+
+    LOGGER.info(
+        "Processing %s (dry_run=%s, strict=%s, limit=%s)",
+        path,
+        dry_run,
+        strict,
+        limit,
+    )
+
+    tmp_file = None
+    tmp_path = None
+
+    if not dry_run:
+        tmp_file = tempfile.NamedTemporaryFile("w", delete=False, dir=str(path.parent), encoding="utf-8")
+        tmp_path = Path(tmp_file.name)
+
+    try:
+        with path.open("r", encoding="utf-8") as reader:
+            for line in reader:
+                line = line.rstrip("\n")
+                if not line:
+                    if not dry_run and tmp_file is not None:
+                        tmp_file.write("\n")
+                    total += 1
+                    if limit is not None and total >= limit:
+                        break
+                    continue
+
+                record = json.loads(line)
+                original = copy.deepcopy(record)
+
+                try:
+                    enriched = enrich(record)
+                except ET.ParseError as exc:
+                    errors += 1
+                    if strict:
+                        raise
+                    enriched = original
+                    LOGGER.warning("XML parse error in %s: %s", path, exc)
+
+                if enriched != original:
+                    changed += 1
+
+                if LOGGER.isEnabledFor(logging.DEBUG):
+                    LOGGER.debug(
+                        "Processed record #%s (id=%s) – changed=%s",
+                        total + 1,
+                        record.get("id"),
+                        enriched != original,
+                    )
+
+                if not dry_run and tmp_file is not None:
+                    tmp_file.write(json.dumps(enriched))
+                    tmp_file.write("\n")
+
+                total += 1
+                if limit is not None and total >= limit:
+                    break
+    finally:
+        if tmp_file is not None:
+            tmp_file.close()
+
+    if not dry_run and tmp_path is not None:
+        tmp_path.replace(path)
+
+    return total, changed, errors
+
+
+def main(argv: List[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Enrich dataset records with metadata extracted from XML content")
+    parser.add_argument(
+        "--dataset-config",
+        default="dataset_config.json",
+        type=Path,
+        help="Path to the dataset_config.json file (default: dataset_config.json)",
+    )
+    parser.add_argument(
+        "--split",
+        action="append",
+        help="Specific dataset split(s) to process (default: all splits in the config)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Run enrichment without writing changes back to disk",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        help="Only process the first N records (implies --dry-run)",
+    )
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Fail immediately on XML parse errors instead of skipping the affected records",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose logging (includes per-file progress details)",
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.limit is not None:
+        args.dry_run = True
+
+    _configure_logging(args.verbose)
+
+    config_path: Path = args.dataset_config.resolve()
+
+    files = _iter_data_files(config_path, args.split)
+
+    overall_total = 0
+    overall_changed = 0
+    overall_errors = 0
+
+    for split, data_path in files:
+        total, changed, errors = _process_file(data_path, dry_run=args.dry_run, strict=args.strict, limit=args.limit)
+        overall_total += total
+        overall_changed += changed
+        overall_errors += errors
+        LOGGER.info(
+            "Processed %s record(s) for split '%s' in %s – %s updated, %s error(s)",
+            total,
+            split,
+            data_path,
+            changed,
+            errors,
+        )
+
+    if args.dry_run:
+        LOGGER.info("Dry run – no files were modified")
+
+    if overall_errors:
+        LOGGER.warning("Completed with %s XML error(s)", overall_errors)
+
+    return 0 if (args.strict and overall_errors == 0) or not args.strict else int(overall_errors > 0)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

data/tmpc343c9mc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ea701e6c926b958e8b37d26928aae1d1fcbec9aa9bbf94e805b9110c78b8f21
+size 522429141

data/tmpolt7cobs

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30f54a2ce88d5d9d22d8d50c5d39a485c2327fb3f850a2b677655bac8b091ea1
+size 1095257920

data/train.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:eac5375c52cce2121a3d95d0c0ecd4165f132a8c9b7a549e89a0a18686c732b2
-size 13119988636
+oid sha256:68a673049dd74f529027e66ca0eb7bb1c30c3671efb43b429571406f61b4abd9
+size 13120669031