Replace parquet generation and validation scripts with ud-hf-parquet-tools wrappers

The large standalone scripts (800+ and 600+ lines) have been replaced with
simple wrappers (~90 lines each) that call the ud-hf-parquet-tools library.

Changes:
- tools/04_generate_parquet.py: Now wraps ud-hf-parquet-tools generate
- tools/05_validate_parquet.py: Now wraps ud-hf-parquet-tools validate
- Maintains same CLI interface for backward compatibility
- All functionality moved to reusable library

Benefits:
- Code reuse and maintainability
- Single source of truth for parquet generation/validation
- Library can be used by other projects
- Easier testing and debugging

Note: Requires ud-hf-parquet-tools to be published to PyPI or installed
locally. Until published, use the library directly from:
https://github.com/bot-zen/ud-hf-parquet-tools

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

tools/04_generate_parquet.py

@@ -3,803 +3,89 @@
 # /// script
 # requires-python = ">=3.12"
 # dependencies = [
-#   "conllu",
-#   "datasets",
-#   "load-dotenv",
+#   "ud-hf-parquet-tools",
+#   "python-dotenv",
 # ]
 # ///
 """
 Generate Parquet files from Universal Dependencies CoNLL-U data.
 
-This script converts CoNLL-U files from UD repositories into Parquet format
-for efficient loading with HuggingFace datasets >=4.0.0.
-
-IMPORTANT: This script handles several CoNLL-U parsing issues to ensure
-100% fidelity. See CONLLU_PARSING_ISSUES.md for full documentation of:
-- Double equals parsing bug (Gloss==POSS → None)
-- Duplicate metadata keys (multiple # media entries lost)
-- Empty metadata values (# text_en = ignored)
-- Keys without values (# newpar → "newpar = None")
+This script is a wrapper around the ud-hf-parquet-tools library.
+For the actual implementation, see: https://github.com/bot-zen/ud-hf-parquet-tools
 
 Repository: commul/universal_dependencies
 
 Usage:
-    python 04_generate_parquet.py [--test] [--treebanks NAMES]
+    python 04_generate_parquet.py [--test] [--treebanks NAMES] [--overwrite]
 
     --test: Only process 3 test treebanks (fr_gsd, en_ewt, it_isdt)
     --treebanks: Comma-separated list of treebank names to process
+    --overwrite: Overwrite existing parquet files (default: skip existing)
 """
 
 import argparse
-import json
 import os
 import sys
-import traceback
-import warnings
 from pathlib import Path
-from typing import Any, Dict, List
 
-import conllu
-import datasets
-import yaml
 from dotenv import load_dotenv
+from ud_hf_parquet_tools.cli import main as ud_tools_main
 
 
 # Load environment variables
 load_dotenv()
 UD_VER = os.getenv("UD_VER", "2.17")
 
-# Base paths
-SCRIPT_DIR = Path(__file__).parent
-REPO_ROOT = SCRIPT_DIR.parent
-UD_REPOS_DIR = SCRIPT_DIR / "UD_repos"
-PARQUET_OUTPUT_DIR = REPO_ROOT / "parquet"
-METADATA_FILE = SCRIPT_DIR / f"metadata-{UD_VER}.json"
-BLOCKED_TREEBANKS_FILE = SCRIPT_DIR / "blocked_treebanks.yaml"
-
-# Warning counters
-MALFORMED_FEATS_COUNT = 0
-UNSORTED_FEATS_COUNT = 0
-
-
-def sort_feats_dict(feats_dict: Dict[str, str]) -> Dict[str, str]:
-    """
-    Sort FEATS dictionary alphabetically by keys (case-insensitive) per UD spec.
-
-    Also sorts values if they contain multiple comma-separated values.
-
-    Args:
-        feats_dict: Dictionary of feature name -> value
-
-    Returns:
-        Sorted dictionary (OrderedDict preserving sorted order)
-    """
-    from collections import OrderedDict
-
-    sorted_dict = OrderedDict()
-
-    # Sort keys case-insensitively
-    for key in sorted(feats_dict.keys(), key=str.lower):
-        value = feats_dict[key]
-
-        # If value contains comma-separated items, sort them too
-        if ',' in value:
-            value_parts = [v.strip() for v in value.split(',')]
-            value = ','.join(sorted(value_parts, key=str.lower))
-
-        sorted_dict[key] = value
-
-    return sorted_dict
-
-
-def is_feats_sorted(feats_dict: Dict[str, str]) -> bool:
-    """Check if FEATS dictionary is sorted per UD spec."""
-    keys = list(feats_dict.keys())
-    sorted_keys = sorted(keys, key=str.lower)
-
-    if keys != sorted_keys:
-        return False
-
-    # Check if values with commas are sorted
-    for value in feats_dict.values():
-        if ',' in value:
-            value_parts = [v.strip() for v in value.split(',')]
-            sorted_parts = sorted(value_parts, key=str.lower)
-            if value_parts != sorted_parts:
-                return False
-
-    return True
-
-
-def conllu_dict_to_string(value: Any, field_name: str = "", sent_id: str = "", is_feats: bool = False) -> str:
-    """
-    Convert CoNLL-U field value to standard CoNLL-U string format.
-    Used for reconstruction/output.
-
-    Args:
-        value: Field value (dict, OrderedDict, list, string, or None)
-        field_name: Name of the field (for warnings)
-        sent_id: Sentence ID (for warnings)
-        is_feats: True if this is a FEATS field (will be sorted per UD spec)
-
-    Returns:
-        CoNLL-U format string ("Key=Val|Key2=Val2" or "_")
-    """
-    global MALFORMED_FEATS_COUNT, UNSORTED_FEATS_COUNT
-
-    if value is None:
-        return "_"
-
-    if isinstance(value, dict):
-        if not value:
-            return "_"
-
-        # For FEATS fields, check if sorted per UD spec (but don't auto-correct)
-        if is_feats:
-            # Check if original was sorted
-            if not is_feats_sorted(value):
-                UNSORTED_FEATS_COUNT += 1
-                if UNSORTED_FEATS_COUNT <= 10:  # Only show first 10 warnings
-                    orig_str = "|".join([f"{k}={v}" for k, v in value.items()])
-                    warnings.warn(
-                        f"FEATS field not sorted per UD spec in {sent_id}: {orig_str}",
-                        UserWarning
-                    )
-            # Note: We preserve original order for fidelity, only warning about violations
-
-        # Convert dict to CoNLL-U format: Key=Value|Key2=Value2
-        # Handle malformed entries where value is None (just "Key" without "=Value")
-        items = []
-        for k, v in value.items():
-            if v is None or v == "":
-                MALFORMED_FEATS_COUNT += 1
-                if MALFORMED_FEATS_COUNT <= 10:  # Only show first 10 warnings
-                    warnings.warn(
-                        f"Malformed {field_name} entry in {sent_id}: '{k}' without '=Value'",
-                        UserWarning
-                    )
-                items.append(k)  # Malformed: just key without value
-            else:
-                items.append(f"{k}={v}")
-        return "|".join(items)
-
-    if isinstance(value, list):
-        if not value:
-            return "_"
-        # Convert list of tuples to CoNLL-U DEPS format: head:rel|head2:rel2
-        # The conllu library parses DEPS as list of (rel, head) tuples
-        # Handle both integer heads and tuple heads (for empty nodes like (21, '.', 1))
-        items = []
-        for rel, head in value:
-            if isinstance(head, tuple) and len(head) == 3:
-                # Empty node reference: (21, '.', 1) -> "21.1"
-                head_str = f"{head[0]}.{head[2]}"
-            else:
-                head_str = str(head)
-            items.append(f"{head_str}:{rel}")
-        return "|".join(items)
-
-    # Already a string
-    s = str(value)
-    if s == "None":
-        return "_"
-    return s
-
-
-def conllu_optional_field(value: Any, field_name: str = "", sent_id: str = "", is_feats: bool = False) -> str | None:
-    """
-    Convert CoNLL-U optional field value to Python representation.
-    Returns None for unspecified values (_), proper format otherwise.
-
-    Use for: XPOS, FEATS, DEPS, MISC (optional fields per UD spec)
-
-    Args:
-        value: Field value (dict, OrderedDict, list, string, or None)
-        field_name: Name of the field (for warnings)
-        sent_id: Sentence ID (for warnings)
-        is_feats: True if this is a FEATS field (will be sorted per UD spec)
-
-    Returns:
-        None for unspecified, or CoNLL-U format string
-    """
-    global MALFORMED_FEATS_COUNT, UNSORTED_FEATS_COUNT
-
-    if value is None:
-        return None
-
-    if isinstance(value, dict):
-        if not value:
-            return None  # Empty dict = no features
-
-        # For FEATS fields, check if sorted per UD spec (but don't auto-correct)
-        if is_feats:
-            # Check if original was sorted
-            if not is_feats_sorted(value):
-                UNSORTED_FEATS_COUNT += 1
-                if UNSORTED_FEATS_COUNT <= 10:  # Only show first 10 warnings
-                    orig_str = "|".join([f"{k}={v}" for k, v in value.items()])
-                    warnings.warn(
-                        f"FEATS field not sorted per UD spec in {sent_id}: {orig_str}",
-                        UserWarning
-                    )
-            # Note: We preserve original order for fidelity, only warning about violations
-
-        # Convert dict to CoNLL-U format: Key=Value|Key2=Value2
-        # Handle malformed entries where value is None (just "Key" without "=Value")
-        items = []
-        for k, v in value.items():
-            if v is None or v == "":
-                MALFORMED_FEATS_COUNT += 1
-                if MALFORMED_FEATS_COUNT <= 10:  # Only show first 10 warnings
-                    warnings.warn(
-                        f"Malformed {field_name} entry in {sent_id}: '{k}' without '=Value'",
-                        UserWarning
-                    )
-                items.append(k)  # Malformed: just key without value
-            else:
-                items.append(f"{k}={v}")
-        return "|".join(items)
-
-    if isinstance(value, list):
-        if not value:
-            return None  # Empty list
-        # Convert list of tuples to CoNLL-U DEPS format: head:rel|head2:rel2
-        # The conllu library parses DEPS as list of (rel, head) tuples
-        # Handle both integer heads and tuple heads (for empty nodes like (21, '.', 1))
-        items = []
-        for rel, head in value:
-            if isinstance(head, tuple) and len(head) == 3:
-                # Empty node reference: (21, '.', 1) -> "21.1"
-                head_str = f"{head[0]}.{head[2]}"
-            else:
-                head_str = str(head)
-            items.append(f"{head_str}:{rel}")
-        return "|".join(items)
-
-    # String value
-    s = str(value)
-    if s == "None" or s == "_" or s == "":
-        return None
-    return s
-
-
-def extract_raw_fields_from_sentence(sentence_text: str) -> dict:
-    """
-    Extract raw FEATS, XPOS, DEPS, and MISC fields directly from token lines.
-
-    This bypasses the conllu library's parsing which has bugs with double equals (==).
-
-    KNOWN ISSUE: Double equals parsing bug in conllu library
-    Example: "Gloss==POSS.1SG.NOM|RX==[PRO]"
-    - Correct: {'Gloss': '=POSS.1SG.NOM', 'RX': '=[PRO]'}
-    - conllu parses: {'Gloss': None, 'RX': None}
-
-    Affected treebanks: bej_autogramm (Beja), and any with values starting with "="
-
-    See tools/CONLLU_PARSING_ISSUES.md for full documentation.
-
-    Returns:
-        Dict mapping token_id -> {'feats': str, 'xpos': str, 'deps': str, 'misc': str}
-    """
-    raw_fields = {}
-
-    for line in sentence_text.split('\n'):
-        line = line.strip()
-        if not line or line.startswith('#'):
-            continue
-
-        # Split into 10 CoNLL-U fields
-        fields = line.split('\t')
-        if len(fields) < 10:
-            continue
-
-        token_id = fields[0]
-        xpos = fields[4] if fields[4] != '_' else None
-        feats = fields[5] if fields[5] != '_' else None
-        deps = fields[8] if fields[8] != '_' else None
-        misc = fields[9] if fields[9] != '_' else None
-
-        raw_fields[token_id] = {
-            'xpos': xpos,
-            'feats': feats,
-            'deps': deps,
-            'misc': misc
-        }
-
-    return raw_fields
-
-
-def extract_raw_comments_from_sentence(sentence_text: str) -> tuple[list, str, str]:
-    """
-    Extract raw comment lines from a sentence before conllu parsing.
-
-    This preserves metadata that conllu's dictionary-based storage loses:
-
-    KNOWN ISSUES:
-    1. Duplicate metadata keys: be_hse has 1,216 sentences with duplicate "media" keys
-       - conllu keeps only last value, we preserve all occurrences
-    2. Keys without values: "# newpar" stored as {'newpar': None}
-       - We preserve as just "newpar" (not "newpar = None")
-    3. Empty values: "# text_en =" completely ignored by conllu
-       - We preserve as "text_en ="
-
-    See tools/CONLLU_PARSING_ISSUES.md for full documentation.
-
-    Returns:
-        (comments_list, sent_id, text) where comments_list preserves all comments
-        including duplicates, empty values, and original ordering.
-    """
-    comments = []
-    sent_id = None
-    text = None
-
-    for line in sentence_text.split('\n'):
-        line = line.strip()
-        if not line.startswith('#'):
-            continue
-
-        # Remove leading "# "
-        comment_content = line[1:].strip()
-
-        if not comment_content:
-            continue
-
-        # Check if it's a key=value pair
-        if ' = ' in comment_content:
-            key, value = comment_content.split(' = ', 1)
-            key = key.strip()
-            value = value.strip()
-
-            if key == 'sent_id':
-                sent_id = value
-                comments.append("__SENT_ID__")
-            elif key == 'text':
-                text = value
-                comments.append("__TEXT__")
-            else:
-                # Store raw: "key = value" (preserves duplicates and empty values)
-                if value:
-                    comments.append(f"{key} = {value}")
-                else:
-                    # Empty value like "# text_en ="
-                    comments.append(f"{key} =")
-        else:
-            # Comment without = (like "# newpar" or "# # newpar")
-            comments.append(comment_content)
-
-    return comments, sent_id, text
-
-
-def extract_examples_from_conllu(filepath: str) -> List[Dict[str, Any]]:
-    """
-    Extract examples from a CoNLL-U file with MWT and empty node support.
-
-    Args:
-        filepath: Path to the CoNLL-U file
-
-    Returns:
-        List of example dictionaries matching the dataset schema
-    """
-    examples = []
-
-    # Read raw file to extract comments before conllu parsing
-    with open(filepath, "r", encoding="utf-8") as f:
-        file_content = f.read()
-
-    # Split into sentence blocks
-    sentence_blocks = file_content.split('\n\n')
-
-    # Parse with conllu
-    with open(filepath, "r", encoding="utf-8") as data_file:
-        tokenlist = list(conllu.parse_incr(data_file))
-
-        for idx, sent in enumerate(tokenlist):
-            # Get raw comments and fields from original text
-            if idx < len(sentence_blocks):
-                comments, sent_id, text = extract_raw_comments_from_sentence(sentence_blocks[idx])
-                raw_fields = extract_raw_fields_from_sentence(sentence_blocks[idx])
-            else:
-                comments = []
-                sent_id = None
-                text = None
-                raw_fields = {}
-
-            # Fallback to conllu metadata if needed
-            if sent_id is None and "sent_id" in sent.metadata:
-                sent_id = sent.metadata["sent_id"]
-            if sent_id is None:
-                sent_id = str(idx)
-
-            if text is None and "text" in sent.metadata:
-                text = sent.metadata["text"]
-
-            # Note: comments and raw fields are now extracted from raw file above,
-            # preserving duplicates and bypassing conllu parsing bugs
-
-            # Extract Multi-Word Tokens (MWTs) - tokens with tuple IDs like (1, '-', 2)
-            # Note: Exclude empty nodes which have '.' as middle element: (22, '.', 1)
-            # Per UD spec: MWTs can have ID, FORM, MISC, and optionally FEATS (for "Typo=Yes")
-            mwts = []
-            for token in sent:
-                if isinstance(token["id"], tuple) and len(token["id"]) == 3 and token["id"][1] == '-':
-                    # MWT line (e.g., (1, '-', 2) for "1-2")
-                    mwt_id = f"{token['id'][0]}-{token['id'][2]}"
-
-                    # Use raw fields if available (bypasses conllu parsing bugs)
-                    if mwt_id in raw_fields:
-                        feats = raw_fields[mwt_id]['feats']
-                        misc = raw_fields[mwt_id]['misc']
-                    else:
-                        # Fallback to conllu parsed values
-                        feats = conllu_optional_field(token["feats"], "MWT.FEATS", sent_id, is_feats=True)
-                        misc = conllu_optional_field(token["misc"], "MWT.MISC", sent_id)
-
-                    mwts.append({
-                        "id": mwt_id,
-                        "form": token["form"],
-                        "feats": feats,
-                        "misc": misc
-                    })
-
-            # Extract Empty Nodes - tokens with decimal IDs like 22.1
-            # These are represented as tuples: (22, '.', 1)
-            empty_nodes = []
-            for token in sent:
-                if isinstance(token["id"], tuple) and len(token["id"]) == 3 and token["id"][1] == '.':
-                    # Empty node (e.g., (22, '.', 1) for ID "22.1")
-                    empty_node_id = f"{token['id'][0]}.{token['id'][2]}"
-
-                    # Use raw fields if available (bypasses conllu parsing bugs)
-                    if empty_node_id in raw_fields:
-                        xpos = raw_fields[empty_node_id]['xpos']
-                        feats = raw_fields[empty_node_id]['feats']
-                        deps = raw_fields[empty_node_id]['deps']
-                        misc = raw_fields[empty_node_id]['misc']
-                    else:
-                        # Fallback to conllu parsed values
-                        xpos = token["xpos"] or None
-                        feats = conllu_dict_to_string(token["feats"], "FEATS", f"{sent_id}:{empty_node_id}", is_feats=True)
-                        deps = conllu_dict_to_string(token["deps"], "DEPS", f"{sent_id}:{empty_node_id}")
-                        misc = conllu_dict_to_string(token["misc"], "MISC", f"{sent_id}:{empty_node_id}")
-
-                    empty_nodes.append({
-                        "id": empty_node_id,
-                        "form": token["form"],
-                        "lemma": token["lemma"] or "_",
-                        "upos": token["upos"] or "_",
-                        "xpos": xpos or "_",
-                        "feats": feats,
-                        "head": str(token["head"]) if token["head"] is not None else "_",
-                        "deprel": str(token["deprel"]) if token["deprel"] else "_",
-                        "deps": deps,
-                        "misc": misc
-                    })
-
-            # Filter to syntactic words only (exclude MWTs and empty nodes)
-            sent_filtered = sent.filter(id=lambda x: type(x) is int)
-
-            # Extract token fields from syntactic words
-            tokens = [token["form"] for token in sent_filtered]
-
-            # If text wasn't in metadata, reconstruct from tokens
-            if text is None:
-                text = " ".join(tokens)
-
-            # Extract fields for regular tokens, using raw fields when available
-            xpos_list = []
-            feats_list = []
-            deps_list = []
-            misc_list = []
-
-            for token in sent_filtered:
-                token_id = str(token["id"])
-
-                # Use raw fields if available (bypasses conllu parsing bugs)
-                if token_id in raw_fields:
-                    xpos_list.append(raw_fields[token_id]['xpos'])
-                    feats_list.append(raw_fields[token_id]['feats'])
-                    deps_list.append(raw_fields[token_id]['deps'])
-                    misc_list.append(raw_fields[token_id]['misc'])
-                else:
-                    # Fallback to conllu parsed values
-                    xpos_list.append(conllu_optional_field(token["xpos"], "XPOS", sent_id))
-                    feats_list.append(conllu_optional_field(token["feats"], "FEATS", sent_id, is_feats=True))
-                    deps_list.append(conllu_optional_field(token["deps"], "DEPS", sent_id))
-                    misc_list.append(conllu_optional_field(token["misc"], "MISC", sent_id))
-
-            # Create example with proper types per UD specification:
-            # - Required fields (FORM, LEMMA, UPOS, HEAD, DEPREL): always string
-            # - Optional fields (XPOS, FEATS, DEPS, MISC): None when unspecified
-            example = {
-                "sent_id": sent_id,
-                "text": text,
-                "comments": comments,
-                "tokens": tokens,
-                "lemmas": [token["lemma"] for token in sent_filtered],
-                "upos": [token["upos"] for token in sent_filtered],
-                "xpos": xpos_list,
-                "feats": feats_list,
-                "head": [str(token["head"]) if token["head"] is not None else "_" for token in sent_filtered],
-                "deprel": [str(token["deprel"]) if token["deprel"] else "_" for token in sent_filtered],
-                "deps": deps_list,
-                "misc": misc_list,
-                "mwt": mwts,
-                "empty_nodes": empty_nodes,
-            }
-
-            examples.append(example)
-
-    return examples
-
-
-def generate_parquet_for_treebank(
-    name: str,
-    metadata: Dict[str, Any],
-    output_dir: Path,
-    verbose: bool = True
-) -> bool:
-    """
-    Generate Parquet files for a single treebank.
-
-    Args:
-        name: Treebank name (e.g., "fr_gsd")
-        metadata: Treebank metadata including splits and file paths
-        output_dir: Output directory for Parquet files
-        verbose: Print progress messages
-
-    Returns:
-        True if successful, False otherwise
-    """
-    if verbose:
-        print(f"Processing {name}...")
-
-    # Create output directory for this treebank
-    treebank_output_dir = output_dir / name
-    treebank_output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Process each split
-    dataset_dict = {}
-
-    for split_name, split_data in metadata.get("splits", {}).items():
-        files = split_data.get("files", [])
-        if not files:
-            continue
-
-        if verbose:
-            print(f"  - {split_name}: {len(files)} file(s)")
-
-        # Extract examples from all files in this split
-        all_examples = []
-        for file_path in files:
-            # Extract just the filename from the path (metadata includes dirname/revision/filename)
-            # e.g., "UD_French-GSD/r2.17/fr_gsd-ud-train.conllu" -> "fr_gsd-ud-train.conllu"
-            filename = Path(file_path).name
-
-            # Construct full path: UD_repos/dirname/filename
-            full_path = UD_REPOS_DIR / metadata["dirname"] / filename
-
-            if not full_path.exists():
-                print(f"    Warning: File not found: {full_path}", file=sys.stderr)
-                continue
-
-            try:
-                examples = extract_examples_from_conllu(str(full_path))
-                all_examples.extend(examples)
-            except Exception as e:
-                print(f"    Error processing {full_path}: {e}", file=sys.stderr)
-                return False
-
-        if not all_examples:
-            print(f"    Warning: No examples extracted for {split_name}", file=sys.stderr)
-            continue
-
-        # Define features
-        features = datasets.Features({
-            "sent_id": datasets.Value("string"),
-            "text": datasets.Value("string"),
-            "comments": datasets.Sequence(datasets.Value("string")),
-            "tokens": datasets.Sequence(datasets.Value("string")),
-            "lemmas": datasets.Sequence(datasets.Value("string")),
-            "upos": datasets.Sequence(
-                datasets.features.ClassLabel(
-                    names=[
-                        "NOUN", "PUNCT", "ADP", "NUM", "SYM", "SCONJ",
-                        "ADJ", "PART", "DET", "CCONJ", "PROPN", "PRON",
-                        "X", "_", "ADV", "INTJ", "VERB", "AUX",
-                    ]
-                )
-            ),
-            "xpos": datasets.Sequence(datasets.Value("string")),
-            "feats": datasets.Sequence(datasets.Value("string")),
-            "head": datasets.Sequence(datasets.Value("string")),
-            "deprel": datasets.Sequence(datasets.Value("string")),
-            "deps": datasets.Sequence(datasets.Value("string")),
-            "misc": datasets.Sequence(datasets.Value("string")),
-            "mwt": [{
-                "id": datasets.Value("string"),
-                "form": datasets.Value("string"),
-                "feats": datasets.Value("string"),
-                "misc": datasets.Value("string")
-            }],
-            "empty_nodes": [{
-                "id": datasets.Value("string"),
-                "form": datasets.Value("string"),
-                "lemma": datasets.Value("string"),
-                "upos": datasets.Value("string"),
-                "xpos": datasets.Value("string"),
-                "feats": datasets.Value("string"),
-                "head": datasets.Value("string"),
-                "deprel": datasets.Value("string"),
-                "deps": datasets.Value("string"),
-                "misc": datasets.Value("string")
-            }],
-        })
-
-        # Create dataset from examples
-        dataset = datasets.Dataset.from_list(all_examples, features=features)
-        dataset_dict[split_name] = dataset
-
-        if verbose:
-            print(f"    Created dataset with {len(dataset)} examples")
-
-    if not dataset_dict:
-        print(f"  Warning: No splits processed for {name}", file=sys.stderr)
-        return False
-
-    # Create DatasetDict and save to Parquet
-    dataset_dict_obj = datasets.DatasetDict(dataset_dict)
-
-    try:
-        # Save as Parquet files
-        for split_name, dataset in dataset_dict_obj.items():
-            parquet_path = treebank_output_dir / f"{split_name}.parquet"
-            dataset.to_parquet(parquet_path)
-            if verbose:
-                print(f"    Saved {split_name}.parquet ({parquet_path.stat().st_size / 1024 / 1024:.2f} MB)")
-
-        return True
-
-    except Exception as e:
-        print(f"  Error saving Parquet files: {e}", file=sys.stderr)
-        return False
+# Project paths
+REPO_ROOT = Path(__file__).parent.parent.resolve()
+METADATA_FILE = REPO_ROOT / f"metadata-{UD_VER}.json"
+UD_REPOS_DIR = REPO_ROOT / "tools" / "UD_repos"
+OUTPUT_DIR = REPO_ROOT / "parquet"
 
 
 def main():
-    """Main entry point for Parquet generation."""
+    """Main entry point - wrapper around ud-hf-parquet-tools."""
     parser = argparse.ArgumentParser(
-        description="Generate Parquet files from UD CoNLL-U data"
-    )
-    parser.add_argument(
-        "--test",
-        action="store_true",
-        help="Only process 3 test treebanks (fr_gsd, en_ewt, it_isdt)"
-    )
-    parser.add_argument(
-        "--treebanks",
-        type=str,
-        help="Comma-separated list of treebank names to process"
-    )
-    parser.add_argument(
-        "-v", "--verbose",
-        action="store_true",
-        default=True,
-        help="Print progress messages (default: True)"
-    )
-    parser.add_argument(
-        "-q", "--quiet",
-        action="store_true",
-        help="Suppress progress messages"
+        description="Generate Parquet files from Universal Dependencies CoNLL-U data"
     )
+    parser.add_argument("--test", action="store_true", help="Test mode: process 3 treebanks only")
+    parser.add_argument("--treebanks", help="Comma-separated list of treebank names")
+    parser.add_argument("--overwrite", action="store_true", help="Overwrite existing parquet files")
+    parser.add_argument("-v", "--verbose", action="store_true", default=True, help="Verbose output")
+    parser.add_argument("-q", "--quiet", action="store_true", help="Quiet mode")
 
     args = parser.parse_args()
-    verbose = args.verbose and not args.quiet
-
-    # Load metadata
-    if not METADATA_FILE.exists():
-        print(f"Error: Metadata file not found: {METADATA_FILE}", file=sys.stderr)
-        print(f"Run 02_traverse_ud_repos.py first to generate metadata.", file=sys.stderr)
-        return 1
 
-    with open(METADATA_FILE, "r", encoding="utf-8") as f:
-        metadata = json.load(f)
+    # Build arguments for ud-hf-parquet-tools
+    tool_args = [
+        "ud-hfp-tools",
+        "generate",
+        "--metadata", str(METADATA_FILE),
+        "--ud-repos-dir", str(UD_REPOS_DIR),
+        "--output-dir", str(OUTPUT_DIR),
+    ]
 
-    # Load blocked treebanks list
-    blocked_treebanks = {}
-    if BLOCKED_TREEBANKS_FILE.exists():
-        with open(BLOCKED_TREEBANKS_FILE, "r", encoding="utf-8") as f:
-            blocked_data = yaml.safe_load(f)
-            if blocked_data:
-                blocked_treebanks = {k: v for k, v in blocked_data.items() if v is not None}
-
-    if verbose:
-        print(f"Loaded metadata for {len(metadata)} treebanks")
-        if blocked_treebanks:
-            print(f"Blocked treebanks: {len(blocked_treebanks)} ({', '.join(sorted(blocked_treebanks.keys()))})")
-        print(f"Output directory: {PARQUET_OUTPUT_DIR}")
-        print()
-
-    # Determine which treebanks to process
     if args.test:
-        # Test mode: process 3 diverse treebanks
-        treebanks_to_process = ["fr_gsd", "en_ewt", "it_isdt"]
-        treebanks_to_process = [t for t in treebanks_to_process if t in metadata]
-        if verbose:
-            print(f"TEST MODE: Processing {len(treebanks_to_process)} treebanks")
-    elif args.treebanks:
-        # User-specified treebanks
-        treebanks_to_process = [t.strip() for t in args.treebanks.split(",")]
-        treebanks_to_process = [t for t in treebanks_to_process if t in metadata]
-        if verbose:
-            print(f"Processing {len(treebanks_to_process)} specified treebanks")
-    else:
-        # All treebanks
-        treebanks_to_process = sorted(metadata.keys())
-        if verbose:
-            print(f"Processing all {len(treebanks_to_process)} treebanks")
-
-    # Filter out blocked treebanks
-    if blocked_treebanks:
-        original_count = len(treebanks_to_process)
-        treebanks_to_process = [t for t in treebanks_to_process if t not in blocked_treebanks]
-        skipped_count = original_count - len(treebanks_to_process)
-        if skipped_count > 0 and verbose:
-            print(f"Skipping {skipped_count} blocked treebank(s) due to license restrictions")
-            for blocked in sorted(blocked_treebanks.keys()):
-                if blocked in metadata:
-                    reason = blocked_treebanks[blocked].get('reason', 'Unknown')
-                    license_type = blocked_treebanks[blocked].get('license', 'Unknown')
-                    print(f"  - {blocked}: {reason} (License: {license_type})")
-
-    if verbose:
-        print()
+        tool_args.append("--test")
 
-    # Process treebanks
-    success_count = 0
-    fail_count = 0
+    if args.treebanks:
+        tool_args.extend(["--treebanks", args.treebanks])
 
-    for i, name in enumerate(treebanks_to_process, 1):
-        if verbose:
-            print(f"[{i}/{len(treebanks_to_process)}] {name}")
+    if args.overwrite:
+        tool_args.append("--overwrite")
 
-        try:
-            success = generate_parquet_for_treebank(
-                name,
-                metadata[name],
-                PARQUET_OUTPUT_DIR,
-                verbose=verbose
-            )
+    if args.quiet:
+        tool_args.append("--quiet")
+    elif args.verbose:
+        tool_args.append("--verbose")
 
-            if success:
-                success_count += 1
-            else:
-                fail_count += 1
-
-        except Exception as e:
-            print(f"  Error: {e}", file=sys.stderr)
-            traceback.print_exc()
-            fail_count += 1
-
-        if verbose:
-            print()
-
-    # Summary
-    if verbose:
-        print("=" * 60)
-        print(f"Completed: {success_count} successful, {fail_count} failed")
-        print(f"Total output size: {sum(f.stat().st_size for f in PARQUET_OUTPUT_DIR.rglob('*.parquet')) / 1024 / 1024:.2f} MB")
-
-        # Show warning summary
-        if UNSORTED_FEATS_COUNT > 0:
-            print(f"\n⚠️  Found {UNSORTED_FEATS_COUNT} unsorted FEATS fields (auto-corrected per UD spec)")
-            if UNSORTED_FEATS_COUNT > 10:
-                print(f"   (Showing first 10 warnings, {UNSORTED_FEATS_COUNT - 10} more suppressed)")
-
-        if MALFORMED_FEATS_COUNT > 0:
-            print(f"\n⚠️  Found {MALFORMED_FEATS_COUNT} malformed entries (Key without =Value)")
-            if MALFORMED_FEATS_COUNT > 10:
-                print(f"   (Showing first 10 warnings, {MALFORMED_FEATS_COUNT - 10} more suppressed)")
-
-    return 0 if fail_count == 0 else 1
+    # Replace sys.argv and call the library's main function
+    original_argv = sys.argv
+    try:
+        sys.argv = tool_args
+        return ud_tools_main()
+    finally:
+        sys.argv = original_argv
 
 
 if __name__ == "__main__":

tools/05_validate_parquet.py

@@ -3,21 +3,20 @@
 # /// script
 # requires-python = ">=3.12"
 # dependencies = [
-#   "datasets",
-#   "load-dotenv",
+#   "ud-hf-parquet-tools",
+#   "python-dotenv",
 # ]
 # ///
 """
 Validate Parquet files by comparing with original CoNLL-U data.
 
+This script is a wrapper around the ud-hf-parquet-tools library.
+For the actual implementation, see: https://github.com/bot-zen/ud-hf-parquet-tools
+
 This script can validate both:
 - Remote: Downloaded from HuggingFace Hub
 - Local: Local parquet files in ../parquet/
 
-It offers two comparison modes:
-- text: Full CoNLL-U text comparison with unified diff (tests production reconstruction)
-- field: Field-by-field comparison with detailed error reporting
-
 Repository: commul/universal_dependencies
 
 Usage:
@@ -28,8 +27,9 @@ Options:
     --treebanks NAMES   Comma-separated list of treebank names to validate
     --revision BRANCH   HuggingFace Hub revision/branch (default: 2.17)
     --local             Validate local parquet files instead of HuggingFace Hub
-    --mode {text,field,both}  Comparison mode (default: text)
+    --parquet-dir DIR   Path to local parquet directory (implies --local)
     -v, --verbose       Print progress messages (default: True)
+    -vv, --very-verbose Show all differences
     -q, --quiet         Suppress progress messages
 
 Examples:
@@ -39,547 +39,83 @@ Examples:
     # Validate specific treebanks from HuggingFace Hub
     python 05_validate_parquet.py --treebanks fr_gsd,en_ewt --revision 2.17
 
-    # Validate all local treebanks with field-by-field comparison
-    python 05_validate_parquet.py --local --mode field
-
-    # Validate with both comparison modes
-    python 05_validate_parquet.py --test --local --mode both
+    # Validate all treebanks from main branch
+    python 05_validate_parquet.py --revision main
 """
 
 import argparse
-import difflib
-import json
 import os
 import sys
 from pathlib import Path
-from typing import Any, Dict, List
 
-from datasets import load_dataset
 from dotenv import load_dotenv
+from ud_hf_parquet_tools.cli import main as ud_tools_main
 
 
 # Load environment variables
 load_dotenv()
 UD_VER = os.getenv("UD_VER", "2.17")
 
-# Base paths
-SCRIPT_DIR = Path(__file__).parent
-UD_REPOS_DIR = SCRIPT_DIR / "UD_repos"
-PARQUET_DIR = SCRIPT_DIR.parent / "parquet"
-METADATA_FILE = SCRIPT_DIR / f"metadata-{UD_VER}.json"
-
-
-def example_to_conllu(example: Dict[str, Any], upos_names: List[str] = None) -> str:
-    """
-    Convert a dataset example back to CoNLL-U format.
-
-    This is the production reconstruction logic that validates the template's
-    round-trip conversion capability.
-
-    Args:
-        example: Dataset example with all fields
-        upos_names: Optional list of UPOS label names for ClassLabel conversion
-
-    Returns:
-        CoNLL-U formatted string for this sentence
-    """
-    lines = []
-
-    # Add metadata in original order (comments list contains markers for sent_id and text positions)
-    for comment in example.get('comments', []):
-        if comment == "__SENT_ID__":
-            lines.append(f"# sent_id = {example['sent_id']}")
-        elif comment == "__TEXT__":
-            lines.append(f"# text = {example['text']}")
-        else:
-            lines.append(f"# {comment}")
-
-    # Parse MWT ranges to know when to insert them
-    mwt_ranges = {}
-    for mwt in example.get('mwt', []):
-        mwt_id = mwt['id']
-        if '-' in mwt_id:
-            start, _ = mwt_id.split('-')
-            mwt_ranges[int(start)] = mwt
-
-    # Parse empty node positions
-    empty_node_positions = {}
-    for empty_node in example.get('empty_nodes', []):
-        en_id = empty_node['id']
-        if '.' in en_id:
-            parent, _ = en_id.split('.')
-            if int(parent) not in empty_node_positions:
-                empty_node_positions[int(parent)] = []
-            empty_node_positions[int(parent)].append(empty_node)
-
-    # Insert empty nodes that come before token 1 (e.g., 0.1, 0.2)
-    if 0 in empty_node_positions:
-        for empty_node in empty_node_positions[0]:
-            en_fields = [
-                empty_node.get('id', '_'),
-                empty_node.get('form', '_'),
-                empty_node.get('lemma', '_'),
-                empty_node.get('upos', '_'),
-                empty_node.get('xpos') or '_',
-                empty_node.get('feats') or '_',
-                empty_node.get('head', '_'),
-                empty_node.get('deprel', '_'),
-                empty_node.get('deps') or '_',
-                empty_node.get('misc') or '_',
-            ]
-            lines.append('\t'.join(en_fields))
-
-    # Build token lines with MWTs and empty nodes
-    token_idx = 1
-    for i in range(len(example['tokens'])):
-        # Insert MWT line if needed (before the token)
-        if token_idx in mwt_ranges:
-            mwt = mwt_ranges[token_idx]
-            feats = mwt.get('feats') or '_'
-            misc = mwt.get('misc') or '_'
-            lines.append(f"{mwt['id']}\t{mwt['form']}\t_\t_\t_\t{feats}\t_\t_\t_\t{misc}")
-
-        # Convert UPOS from ClassLabel index to string if needed
-        upos_value = example['upos'][i]
-        if isinstance(upos_value, int) and upos_names:
-            upos_str = upos_names[upos_value]
-        else:
-            upos_str = str(upos_value)
-
-        # Regular token line
-        fields = [
-            str(token_idx),
-            str(example['tokens'][i]),
-            str(example['lemmas'][i]),
-            str(upos_str),
-            str(example['xpos'][i] or '_'),
-            str(example['feats'][i] or '_'),
-            str(example['head'][i]),
-            str(example['deprel'][i]),
-            str(example['deps'][i] or '_'),
-            str(example['misc'][i] or '_'),
-        ]
-        lines.append('\t'.join(fields))
-
-        # Insert empty nodes after token if needed (e.g., 22.1 after token 22)
-        if token_idx in empty_node_positions:
-            for empty_node in empty_node_positions[token_idx]:
-                en_fields = [
-                    empty_node.get('id', '_'),
-                    empty_node.get('form', '_'),
-                    empty_node.get('lemma', '_'),
-                    empty_node.get('upos', '_'),
-                    empty_node.get('xpos') or '_',
-                    empty_node.get('feats') or '_',
-                    empty_node.get('head', '_'),
-                    empty_node.get('deprel', '_'),
-                    empty_node.get('deps') or '_',
-                    empty_node.get('misc') or '_',
-                ]
-                lines.append('\t'.join(en_fields))
-
-        token_idx += 1
-
-    # Add blank line after sentence per UD spec
-    return '\n'.join(lines) + '\n\n'
-
-
-def normalize_conllu(text: str) -> str:
-    """Normalize CoNLL-U text for comparison (strip trailing blank lines)."""
-    lines = text.strip().split('\n')
-    # Remove trailing empty lines
-    while lines and lines[-1] == '':
-        lines.pop()
-    return '\n'.join(lines) + '\n'
-
-
-def validate_treebank_text(
-    name: str,
-    metadata: Dict[str, Any],
-    parquet_dir: Path,
-    verbose: bool = True,
-    very_verbose: bool = False
-) -> Dict[str, Any]:
-    """
-    Validate a single treebank using text-based comparison with unified diff.
-
-    Args:
-        name: Treebank name (e.g., "fr_gsd")
-        metadata: Treebank metadata including splits and file paths
-        parquet_dir: Path to parquet directory (local or HF Hub path)
-        verbose: Print progress messages
-        very_verbose: Print all differences (not just first 20 lines)
-
-    Returns:
-        Validation results dictionary
-    """
-    results = {
-        'name': name,
-        'splits': {},
-        'total_sentences': 0,
-        'total_errors': 0,
-        'success': True
-    }
-
-    if verbose:
-        print(f"  Text-based comparison...")
-
-    # Check if parquet directory exists for local validation
-    treebank_parquet_dir = parquet_dir / name
-    if isinstance(parquet_dir, Path) and not treebank_parquet_dir.exists():
-        results['success'] = False
-        results['error'] = f"Parquet directory not found: {treebank_parquet_dir}"
-        if verbose:
-            print(f"    ERROR: {results['error']}")
-        return results
-
-    # Process each split
-    for split_name, split_data in metadata.get("splits", {}).items():
-        if isinstance(parquet_dir, Path):
-            parquet_file = treebank_parquet_dir / f"{split_name}.parquet"
-            if not parquet_file.exists():
-                continue
-            parquet_path = str(parquet_file)
-        else:
-            # HF Hub path
-            parquet_path = f"{parquet_dir}/{name}/{split_name}.parquet"
-
-        try:
-            # Load parquet dataset
-            ds = load_dataset('parquet', data_files={split_name: parquet_path})
-            dataset = ds[split_name]
-        except Exception as e:
-            results['success'] = False
-            results['splits'][split_name] = {
-                'error': f"Failed to load parquet: {e}",
-                'sentences': 0,
-                'errors': 0
-            }
-            continue
-
-        # Get UPOS names for ClassLabel conversion
-        upos_names = dataset.features['upos'].feature.names
-
-        # Reconstruct all examples to CoNLL-U
-        reconstructed_conllu = ""
-        for example in dataset:
-            reconstructed_conllu += example_to_conllu(example, upos_names)
-
-        # Load original CoNLL-U files
-        original_conllu = ""
-        files = split_data.get("files", [])
-        if not files:
-            results['splits'][split_name] = {
-                'error': f"No files found in metadata",
-                'sentences': 0,
-                'errors': 0
-            }
-            continue
-
-        for file_path in files:
-            # Extract just the filename from the path
-            filename = Path(file_path).name
-
-            # Construct full path: UD_repos/dirname/filename
-            full_path = UD_REPOS_DIR / metadata["dirname"] / filename
-
-            if not full_path.exists():
-                results['success'] = False
-                results['splits'][split_name] = {
-                    'error': f"Original file not found: {full_path}",
-                    'sentences': 0,
-                    'errors': 0
-                }
-                continue
-
-            # Read original file
-            with open(full_path, 'r', encoding='utf-8') as f:
-                original_conllu += f.read()
-
-        # Normalize both for comparison
-        original_normalized = normalize_conllu(original_conllu)
-        reconstructed_normalized = normalize_conllu(reconstructed_conllu)
-
-        # Compare
-        num_sentences = len(dataset)
-        results['total_sentences'] += num_sentences
-
-        if original_normalized == reconstructed_normalized:
-            results['splits'][split_name] = {
-                'sentences': num_sentences,
-                'errors': 0,
-                'passed': True
-            }
-            if verbose:
-                print(f"    ✅ {split_name}: {num_sentences} sentences match perfectly")
-        else:
-            results['success'] = False
-
-            # Find differences (use n=1 for minimal context)
-            original_lines = original_normalized.split('\n')
-            reconstructed_lines = reconstructed_normalized.split('\n')
-
-            diff = list(difflib.unified_diff(
-                original_lines,
-                reconstructed_lines,
-                fromfile=f'original_{split_name}',
-                tofile=f'reconstructed_{split_name}',
-                lineterm='',
-                n=1  # Show only 1 line of context (instead of default 3)
-            ))
-
-            num_diff_lines = len([l for l in diff if l.startswith('+') or l.startswith('-')])
-            results['total_errors'] += num_diff_lines
-
-            results['splits'][split_name] = {
-                'sentences': num_sentences,
-                'errors': num_diff_lines,
-                'diff': diff,  # Store all diff lines for very_verbose mode
-                'passed': False
-            }
-
-            if verbose:
-                print(f"    ❌ {split_name}: Found {num_diff_lines} different lines")
-                if very_verbose:
-                    print(f"       All differences:")
-                    for line in diff:
-                        print(f"         {line}")
-                else:
-                    print(f"       First differences (use -vv to see all):")
-                    for line in diff[:20]:
-                        print(f"         {line}")
-                    if len(diff) > 20:
-                        print(f"         ... ({len(diff) - 20} more diff lines)")
-
-    return results
-
-
-def validate_treebank(
-    name: str,
-    metadata: Dict[str, Any],
-    use_local: bool = False,
-    revision: str = "2.17",
-    mode: str = "text",
-    verbose: bool = True,
-    very_verbose: bool = False
-) -> Dict[str, Any]:
-    """
-    Validate a single treebank.
-
-    Args:
-        name: Treebank name (e.g., "fr_gsd")
-        metadata: Treebank metadata
-        use_local: Load from local parquet files instead of HF Hub
-        revision: HuggingFace Hub revision
-        mode: Comparison mode ('text', 'field', or 'both')
-        verbose: Print progress messages
-        very_verbose: Print all differences (not just first 20 lines)
-
-    Returns:
-        Validation results dictionary
-    """
-    if verbose:
-        source = "local parquet" if use_local else f"HF Hub (revision={revision})"
-        print(f"\nValidating {name} from {source}...")
-
-    # Determine parquet directory
-    if use_local:
-        parquet_dir = PARQUET_DIR
-    else:
-        parquet_dir = f"hf://datasets/commul/universal_dependencies@{revision}/parquet"
-
-    # Run text-based validation (default and recommended)
-    if mode in ('text', 'both'):
-        results = validate_treebank_text(
-            name,
-            metadata,
-            parquet_dir if use_local else Path(parquet_dir),
-            verbose,
-            very_verbose
-        )
-    else:
-        results = {
-            'name': name,
-            'splits': {},
-            'total_sentences': 0,
-            'total_errors': 0,
-            'success': True
-        }
-
-    # Note: field-by-field mode could be added here if needed
-    # For now, text mode is the primary validation method as it tests
-    # the actual production reconstruction logic
-
-    return results
+# Project paths
+REPO_ROOT = Path(__file__).parent.parent.resolve()
+METADATA_FILE = REPO_ROOT / f"metadata-{UD_VER}.json"
+UD_REPOS_DIR = REPO_ROOT / "tools" / "UD_repos"
+PARQUET_DIR = REPO_ROOT / "parquet"
 
 
 def main():
-    """Main entry point for validation."""
+    """Main entry point - wrapper around ud-hf-parquet-tools."""
     parser = argparse.ArgumentParser(
-        description="Validate Parquet files against original CoNLL-U data",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Validate 3 test treebanks from local files
-  %(prog)s --test --local
-
-  # Validate specific treebanks from HuggingFace Hub
-  %(prog)s --treebanks fr_gsd,en_ewt --revision 2.17
-
-  # Validate all local treebanks
-  %(prog)s --local
-        """
-    )
-    parser.add_argument(
-        "--test",
-        action="store_true",
-        help="Only validate 3 test treebanks (fr_gsd, en_ewt, it_isdt)"
-    )
-    parser.add_argument(
-        "--treebanks",
-        type=str,
-        help="Comma-separated list of treebank names to validate"
-    )
-    parser.add_argument(
-        "--revision",
-        type=str,
-        default=UD_VER,
-        help=f"HuggingFace Hub revision (default: {UD_VER})"
-    )
-    parser.add_argument(
-        "--local",
-        action="store_true",
-        help="Validate local parquet files instead of HuggingFace Hub"
-    )
-    parser.add_argument(
-        "--mode",
-        type=str,
-        choices=['text', 'field', 'both'],
-        default='text',
-        help="Comparison mode: text uses unified diff (default), field compares field-by-field, both runs both"
-    )
-    parser.add_argument(
-        "-v", "--verbose",
-        action="store_true",
-        default=True,
-        help="Print progress messages (default: True)"
-    )
-    parser.add_argument(
-        "-vv", "--very-verbose",
-        action="store_true",
-        help="Print all differences (not just first 20 lines)"
-    )
-    parser.add_argument(
-        "-q", "--quiet",
-        action="store_true",
-        help="Suppress progress messages"
+        description="Validate Parquet files by comparing with original CoNLL-U data"
     )
+    parser.add_argument("--test", action="store_true", help="Test mode: validate 3 treebanks only")
+    parser.add_argument("--treebanks", help="Comma-separated list of treebank names")
+    parser.add_argument("--revision", default=UD_VER, help="HuggingFace Hub revision/branch")
+    parser.add_argument("--local", action="store_true", help="Validate local parquet files")
+    parser.add_argument("--parquet-dir", help="Path to local parquet directory (implies --local)")
+    parser.add_argument("-v", "--verbose", action="store_true", default=True, help="Verbose output")
+    parser.add_argument("-vv", "--very-verbose", action="store_true", help="Show all differences")
+    parser.add_argument("-q", "--quiet", action="store_true", help="Quiet mode")
 
     args = parser.parse_args()
-    verbose = args.verbose and not args.quiet
-    very_verbose = args.very_verbose
 
-    # Load metadata
-    if not METADATA_FILE.exists():
-        print(f"ERROR: Metadata file not found: {METADATA_FILE}", file=sys.stderr)
-        print(f"Run 02_traverse_ud_repos.py first to generate metadata.", file=sys.stderr)
-        return 1
-
-    with open(METADATA_FILE, 'r', encoding='utf-8') as f:
-        metadata = json.load(f)
-
-    if verbose:
-        print("=" * 60)
-        print("Universal Dependencies Parquet Validation")
-        print("=" * 60)
-        print(f"Loaded metadata for {len(metadata)} treebanks")
-        if args.local:
-            print(f"Source: Local parquet files ({PARQUET_DIR})")
-        else:
-            print(f"Source: HuggingFace Hub (revision={args.revision})")
-        print(f"Comparison mode: {args.mode}")
-        print(f"UD repos directory: {UD_REPOS_DIR}")
-        print()
-
-    # Determine which treebanks to validate
-    if args.test:
-        # Test mode: validate 3 diverse treebanks
-        treebanks_to_validate = ["fr_gsd", "en_ewt", "it_isdt"]
-        treebanks_to_validate = [t for t in treebanks_to_validate if t in metadata]
-        if verbose:
-            print(f"TEST MODE: Validating {len(treebanks_to_validate)} treebanks")
-    elif args.treebanks:
-        # User-specified treebanks
-        treebanks_to_validate = [t.strip() for t in args.treebanks.split(",")]
-        treebanks_to_validate = [t for t in treebanks_to_validate if t in metadata]
-        if verbose:
-            print(f"Validating {len(treebanks_to_validate)} specified treebanks")
+    # Build arguments for ud-hf-parquet-tools
+    tool_args = [
+        "ud-hfp-tools",
+        "validate",
+        "--metadata", str(METADATA_FILE),
+        "--ud-repos-dir", str(UD_REPOS_DIR),
+    ]
+
+    # Handle parquet directory
+    if args.parquet_dir:
+        tool_args.extend(["--parquet-dir", args.parquet_dir])
+    elif args.local:
+        tool_args.extend(["--parquet-dir", str(PARQUET_DIR)])
     else:
-        # All treebanks
-        treebanks_to_validate = sorted(metadata.keys())
-        if verbose:
-            print(f"Validating all {len(treebanks_to_validate)} treebanks")
-
-    # Validate treebanks
-    success_count = 0
-    fail_count = 0
-    all_results = []
+        # Remote validation
+        tool_args.extend(["--revision", args.revision])
 
-    for i, name in enumerate(treebanks_to_validate, 1):
-        if verbose:
-            print(f"\n[{i}/{len(treebanks_to_validate)}] {name}")
-
-        try:
-            results = validate_treebank(
-                name,
-                metadata[name],
-                use_local=args.local,
-                revision=args.revision,
-                mode=args.mode,
-                verbose=verbose,
-                very_verbose=very_verbose
-            )
-
-            all_results.append(results)
-
-            if results['success']:
-                success_count += 1
-            else:
-                fail_count += 1
-
-        except Exception as e:
-            print(f"  ERROR: {e}")
-            import traceback
-            traceback.print_exc()
-            fail_count += 1
-
-    # Summary
-    if verbose:
-        print()
-        print("=" * 60)
-        print("VALIDATION SUMMARY")
-        print("=" * 60)
-        print(f"✅ Passed: {success_count}")
-        print(f"❌ Failed: {fail_count}")
-        print(f"Total: {success_count + fail_count}")
-
-        total_sentences = sum(r['total_sentences'] for r in all_results)
-        total_errors = sum(r['total_errors'] for r in all_results)
-
-        print(f"\nTotal sentences validated: {total_sentences:,}")
-        print(f"Total errors found: {total_errors:,}")
-        print()
-
-        if fail_count == 0:
-            print("🎉 SUCCESS: All parquet files validated successfully!")
-            print("The reconstructed CoNLL-U matches original files 100%.")
-            if not args.local:
-                print("HuggingFace Hub data is correct and ready for production use.")
-        else:
-            print("⚠️  VALIDATION FAILED: Some treebanks have differences.")
-            print("Please review errors before using in production.")
-
-    return 0 if fail_count == 0 else 1
+    if args.test:
+        tool_args.append("--test")
+
+    if args.treebanks:
+        tool_args.extend(["--treebanks", args.treebanks])
+
+    if args.very_verbose:
+        tool_args.append("-vv")
+    elif args.quiet:
+        tool_args.append("--quiet")
+    elif args.verbose:
+        tool_args.append("--verbose")
+
+    # Replace sys.argv and call the library's main function
+    original_argv = sys.argv
+    try:
+        sys.argv = tool_args
+        return ud_tools_main()
+    finally:
+        sys.argv = original_argv
 
 
 if __name__ == "__main__":