Disentangle tools/README.md and ADDING_NEW_UD_VERSION.md

**tools/README.md:**
- Rewrote as concise quick reference for experienced developers
- Focus on commands, not explanations
- Added "Quick Start" section with complete workflow
- Documented all pipeline scripts (00-05)
- Added directory structure diagram
- Included configuration examples
- Added common operations and troubleshooting
- References ADDING_NEW_UD_VERSION.md for detailed guide

**ADDING_NEW_UD_VERSION.md:**
- Maintained as comprehensive guide for new contributors
- Updated all outdated script references:
- 02_traverse_ud_repos.py → 02_generate_metadata.py
- 03_fill_universal_dependencies_tamplate.py → 03_generate_README.py
- Removed all references to universal_dependencies.py (no longer exists)
- Added explanations for each step ("What is...?", "Why...?")
- Kept troubleshooting section with detailed solutions
- Kept timeline estimates and checklist
- References tools/README.md for technical details
- Updated to reflect v2.0 architecture:
- Parquet-only format (no Python script loader)
- External ud-hf-parquet-tools library
- Blocked treebanks handling

**Key improvements:**
- No duplication between files
- Clear separation of concerns (quick ref vs. guide)
- All references to current architecture
- Cross-references between documents

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

ADDING_NEW_UD_VERSION.md

@@ -2,12 +2,15 @@
 
 This guide explains how to add a new Universal Dependencies release (e.g., UD 2.18, 2.19, etc.) to the `commul/universal_dependencies` HuggingFace dataset.
 
+**Quick reference:** See [tools/README.md](tools/README.md) for concise commands and script documentation.
+
 ## Prerequisites
 
 - Git repository cloned and up to date
-- Python environment with dependencies installed:
+- Python 3.12+ with `uv` installed
+- Dependencies installed:
   ```bash
-  pip install -r requirements.txt  # or use uv
+  pip install ud-hf-parquet-tools pyyaml python-dotenv jinja2
   ```
 - Access to push to `commul/universal_dependencies` on HuggingFace Hub
 - `huggingface-cli` installed and authenticated:
@@ -18,7 +21,12 @@ This guide explains how to add a new Universal Dependencies release (e.g., UD 2.
 
 ## Overview
 
-Each UD version (2.7, 2.8, ..., 2.17, 2.18, ...) has its own git branch. The loader version (v2.0) is consistent across branches. When a new UD release is published, you create a new branch and run the pipeline to generate dataset files.
+Each UD version (2.7, 2.8, ..., 2.17, 2.18, ...) has its own git branch. The dataset uses Parquet format (v2.0 architecture) for all versions. When a new UD release is published, you create a new branch and run the generation pipeline.
+
+**Architecture:**
+- **No Python script loader**: Dataset uses Parquet files only (datasets >=4.0.0)
+- **External tools**: Helper functions in separate `ud-hf-parquet-tools` library
+- **Blocked treebanks**: Some treebanks excluded due to license restrictions
 
 ## Step-by-Step Guide
 
@@ -31,7 +39,7 @@ For this example, we'll add **UD 2.18** (replace with actual version).
 ### 2. Create New Branch
 
 ```bash
-# Ensure you're on the latest main/template branch
+# Ensure you're on the latest main branch
 git checkout main
 git pull origin main
 
@@ -44,270 +52,359 @@ git pull origin 2.17
 git checkout -b 2.18
 ```
 
+**Why branching?** Each UD version is maintained independently, allowing users to load specific versions via `revision="2.18"`.
+
 ### 3. Update Environment Configuration
 
 ```bash
 cd tools
 
-# Create or update .env file
-echo "UD_VER=2.18" > .env
+# Set the version number
+export NEW_VER=2.18
+echo "UD_VER=${NEW_VER}" > .env
 
 # Verify
 cat .env
 # Output: UD_VER=2.18
 ```
 
-### 4. Fetch Metadata for New Version
+**What is .env?** Environment file that all scripts read to determine which UD version to process.
+
+### 4. Fetch Metadata from LINDAT/CLARIN
 
 ```bash
-# Fetch citation and description from LINDAT/CLARIN
-python 00_fetch_ud_clarin-dspace_metadata.py
+# Fetch citation and description
+./00_fetch_ud_clarin-dspace_metadata.py -o
 
 # This creates:
 # - etc/citation-2.18
 # - etc/description-2.18
 ```
 
-**Note:** You may need to update the LINDAT handle ID in the script if the UD project uses a new handle for this release. Check the [UD release page](https://universaldependencies.org/) for the correct handle.
+**Before running**, update the script to add the new version's handle ID:
+
+1. Open `00_fetch_ud_clarin-dspace_metadata.py`
+2. Find the `url_postfixes` dictionary
+3. Add entry for new version:
+   ```python
+   "2.18": "11234/1-XXXX",  # Check UD website for correct handle
+   ```
+
+**Where to find handle?** Visit the [UD release page](https://universaldependencies.org/) and check the LINDAT citation link.
 
 ### 5. Fetch Language Codes and Flags
 
 ```bash
-# Fetch codes_and_flags.yaml for new version
-./00_fetch_ud_codes_and_flags.sh
+# Fetch language metadata
+./00_fetch_ud_codes_and_flags.sh -o
 
 # This creates:
 # - etc/codes_and_flags-2.18.yaml
-# - etc/codes_and_flags-latest.yaml (symlink)
+# - etc/codes_and_flags-latest.yaml (updated symlink)
 ```
 
-**Note:** You may need to update the git commit hash mapping in the script if a new UD version is released.
+**Before running**, update the script with the docs-automation commit hash:
+
+1. Open `00_fetch_ud_codes_and_flags.sh`
+2. Find the `VER_MAPPING` associative array
+3. Add entry:
+   ```bash
+   VER_MAPPING["2.18"]="<git-commit-hash-for-2.18>"
+   ```
+
+**How to find hash?** Check the [UD docs-automation releases](https://github.com/UniversalDependencies/docs/releases) for the commit tagged with the version.
 
-### 6. Fetch UD Repositories
+### 6. Discover UD Repositories
 
 ```bash
-# This discovers all UD repositories on GitHub
+# Generate list of all UD repositories
 ./01_fetch_ud_repos.sh
 
 # This creates:
-# - .UD_submodules_add.commands
+# - .UD_submodules_add.commands (list of git submodule add commands)
+```
+
+**What does this do?** Queries GitHub API for all repositories in the UniversalDependencies organization and generates commands to add them as submodules.
+
+### 7. Fetch UD Repositories as Submodules
 
-# The script will tell you to run commands in UD_repos/
-# Follow those instructions:
+```bash
 cd UD_repos
 
-# Initialize git if not already done
+# Initialize git repository (if first time)
 git init
 
-# Add submodules (this may take a while - 289 repositories)
+# Add all UD repositories as submodules
 bash ../.UD_submodules_add.commands
 
-# Checkout the new release tag (e.g., r2.18)
-git submodule foreach 'git fetch --tags && git checkout r2.18 && touch .tag-r2.18'
+# Checkout the new release tag in all submodules
+git submodule foreach "git fetch --tags && git checkout r${NEW_VER} && touch .tag-r${NEW_VER}"
+
+# Create branch and commit
+git checkout -b ${NEW_VER}
+git add -A
+git commit -m "Add UD ${NEW_VER} repositories"
 
 cd ..
 ```
 
 **Expected time:** 30-60 minutes depending on network speed.
 
-### 7. Traverse Repositories and Extract Metadata
+**What are .tag-r{VER} files?** Marker files that `02_generate_metadata.py` checks to ensure a repository has the correct version tag.
 
+**Troubleshooting:** If some repositories don't have the tag:
 ```bash
-# Extract metadata from all treebanks
-python 02_traverse_ud_repos.py
+git submodule foreach "git fetch --tags && (git checkout r${NEW_VER} || git checkout main) && touch .tag-r${NEW_VER}"
+```
+
+### 8. Extract Metadata from Treebanks
+
+```bash
+# Generate metadata from all treebank directories
+./02_generate_metadata.py -o
 
 # This creates:
-# - metadata-2.18.json (contains info for all 339+ treebanks)
+# - metadata-2.18.json (contains info for all treebanks)
 
 # Verify the output
-ls -lh metadata-2.18.json
+ls -lh metadata-${NEW_VER}.json
 # Should be ~200-300 KB
 
 # Quick check: count treebanks
-python -c "import json; print(len(json.load(open('metadata-2.18.json'))))"
-# Should be 339+ (may increase with new treebanks)
+python -c "import json; print(len(json.load(open('metadata-${NEW_VER}.json'))))"
+# Should be 339+ (number increases with new treebanks)
 ```
 
-### 8. Generate Dataset Loader Script
+**What does this script do?**
+- Reads README files from each treebank
+- Extracts summaries, licenses, genres
+- Collects statistics from stats.xml
+- Identifies available splits (train/dev/test)
+- Checks `blocked_treebanks.yaml` for license restrictions
+- Adds "blocked" property to metadata
+
+**Expected time:** 5-10 minutes
+
+### 9. Generate Dataset Card (README)
 
 ```bash
-# Generate universal_dependencies-2.18 from template
-python 03_fill_universal_dependencies_tamplate.py
+# Generate HuggingFace dataset card
+./03_generate_README.py -o
 
 # This creates:
-# - universal_dependencies-2.18 (Python loader script)
-# - README-2.18 (dataset card)
+# - README-2.18 (dataset card for HuggingFace)
 
-# Verify files were created
-ls -lh universal_dependencies-2.18 README-2.18
+# Verify file was created
+ls -lh README-${NEW_VER}
 ```
 
-### 9. Generate Parquet Files
+**What does this do?** Renders `templates/README.tmpl` with metadata, citation, and description to create the HuggingFace dataset card.
+
+### 10. Review Blocked Treebanks
+
+Before generating Parquet files, review the blocked treebanks:
 
 ```bash
-# Test with a few treebanks first
-python 04_generate_parquet.py --test
+# Check blocked treebanks list
+cat blocked_treebanks.yaml
+
+# Example entry:
+# pt_cintil:
+#   reason: "Restrictive license prohibits redistribution in derived formats"
+#   license: "CC BY-NC-SA 4.0"
+```
+
+**Why block treebanks?** Some treebanks have licenses (e.g., CC BY-NC-SA) that prohibit redistribution in modified formats like Parquet.
+
+**See also:** [tools/BLOCKED_TREEBANKS.md](tools/BLOCKED_TREEBANKS.md)
 
-# If successful, generate for all treebanks (takes 2-4 hours)
-python 04_generate_parquet.py
+### 11. Generate Parquet Files
+
+```bash
+# Test with 3 treebanks first
+uv run ./04_generate_parquet.py --test
+
+# If successful, generate all treebanks (takes 2-4 hours)
+uv run ./04_generate_parquet.py
 
 # This creates:
-# - parquet/{treebank_name}/{split}.parquet for all 339+ treebanks
+# - ../parquet/{treebank_name}/{split}.parquet for all treebanks
 
 # Verify output
 du -sh ../parquet/
 # Should be ~50-80 GB total
 ```
 
-**Optional:** Run on a subset first to verify correctness:
+**What does this do?** Wrapper script that calls the `ud-hf-parquet-tools` library to convert CoNLL-U files to Parquet format.
+
+**Options:**
+- `--test`: Generate only 3 treebanks (quick test)
+- `--overwrite`: Regenerate existing files
+- `--blocked-treebanks`: Path to YAML file with blocked treebanks
+
+**Expected time:** 2-4 hours for all treebanks
+
+### 12. Validate Parquet Files
+
 ```bash
-python 04_generate_parquet.py --treebanks "en_ewt,fr_gsd,de_gsd"
+# Test validation on 3 treebanks
+uv run ./05_validate_parquet.py --local --test
+
+# Full validation (optional, takes ~30-60 minutes)
+uv run ./05_validate_parquet.py --local --mode text -vv > /tmp/parquet-check.log
+
+# Check for errors (excluding metadata comments)
+grep -E "         [+-]" /tmp/parquet-check.log | grep -vE "         [+-]#"
 ```
 
-### 10. Copy Files to Repository Root
+**What does this do?** Compares Parquet output to original CoNLL-U to verify 100% data fidelity.
+
+**Expected output:** No differences except in comment metadata (which may vary slightly).
+
+### 13. Copy Files to Repository Root
 
 ```bash
-# Copy generated files to root
 cd ..  # Back to repository root
 
-cp tools/universal_dependencies-2.18 universal_dependencies.py
-cp tools/README-2.18 README.md
-cp tools/metadata-2.18.json metadata.json
+# Copy generated files
+cp tools/README-${NEW_VER} README.md
+cp tools/metadata-${NEW_VER}.json metadata.json
 
 # Verify files are in place
-ls -lh universal_dependencies.py README.md metadata.json
+ls -lh README.md metadata.json parquet/
 ```
 
-### 11. Test the Dataset Loader
+**Why copy to root?** HuggingFace Hub expects these files at the repository root for the dataset to work.
 
-```bash
-# Test loading with Python script (for backwards compatibility testing)
-python -c "
-from datasets import load_dataset
-import sys
-sys.path.insert(0, '.')
+### 14. Test Dataset Loading
 
-# Test a small treebank
-ds = load_dataset('./universal_dependencies.py', 'en_pronouns', split='test')
-print(f'Loaded {len(ds)} examples')
-print(f'Features: {list(ds.features.keys())}')
-print(f'MWT field present: {\"mwt\" in ds.features}')
-"
+Test that the dataset loads correctly:
 
+```bash
 # Test loading from Parquet
 python -c "
 from datasets import load_dataset
 
-# Test Parquet loading
-ds = load_dataset('parquet', data_files='parquet/en_ewt/train.parquet')
-print(f'Loaded {len(ds[\"train\"])} examples from Parquet')
+# Test a small treebank
+ds = load_dataset('parquet', data_files='parquet/en_pronouns/test.parquet')
+print(f'Loaded {len(ds[\"train\"])} examples')
+print(f'Features: {list(ds[\"train\"].features.keys())}')
+print(f'MWT field present: {\"mwt\" in ds[\"train\"].features}')
 "
 ```
 
-### 12. Commit Changes to Git
+**Expected output:**
+```
+Loaded X examples
+Features: ['sent_id', 'text', 'comments', 'tokens', 'lemmas', 'upos', 'xpos', 'feats', 'head', 'deprel', 'deps', 'misc', 'mwt', 'empty_nodes']
+MWT field present: True
+```
+
+### 15. Commit Changes to Git
 
 ```bash
 # Add generated files
-git add universal_dependencies.py
-git add README.md
-git add metadata.json
-git add tools/metadata-2.18.json
-git add tools/universal_dependencies-2.18
-git add tools/README-2.18
-git add tools/etc/citation-2.18
-git add tools/etc/description-2.18
-git add tools/etc/codes_and_flags-2.18.yaml
+git add README.md metadata.json parquet/
+git add tools/metadata-${NEW_VER}.json
+git add tools/README-${NEW_VER}
+git add tools/etc/citation-${NEW_VER}
+git add tools/etc/description-${NEW_VER}
+git add tools/etc/codes_and_flags-${NEW_VER}.yaml
 git add tools/.env
 
 # Commit with descriptive message
-git commit -m "Add UD 2.18 data with loader v2.0
+git commit -m "Add UD ${NEW_VER} data with Parquet format
 
-- Generated from Universal Dependencies 2.18 release
+- Generated from Universal Dependencies ${NEW_VER} release
 - 339+ treebanks across 186+ languages
-- Includes Parquet files for efficient loading
-- Loader version: 2.0.0
-- MWT support and bug fixes included
+- Parquet format for efficient loading (datasets >=4.0.0)
+- Blocked treebanks excluded per license restrictions
+- Helper functions available in ud-hf-parquet-tools library
 
 Generated files:
-- universal_dependencies.py (loader script)
 - README.md (dataset card)
 - metadata.json (treebank metadata)
-- Parquet files in parquet/ directory"
+- parquet/ directory with all treebank splits"
 
 # Tag the commit
-git tag -a ud2.18-loader-v2.0 -m "UD 2.18 with Loader v2.0"
+git tag -a ud${NEW_VER} -m "Universal Dependencies ${NEW_VER} release"
 
 # Push branch and tags
-git push origin 2.18
+git push origin ${NEW_VER}
 git push origin --tags
 ```
 
-### 13. Validate Parquet Files
+### 16. Upload to HuggingFace Hub
 
-```bash
-# Test validation on 3 treebanks first
-python 05_validate_parquet.py --test
+**Option A: Using git-lfs (Recommended)**
+
+If you've cloned the HuggingFace repository with git-lfs:
 
-# If successful, validate all treebanks (optional, takes ~30-60 minutes)
-python 05_validate_parquet.py
+```bash
+# Add HF Hub as remote (if not already)
+git remote add hf https://huggingface.co/datasets/commul/universal_dependencies
 
-# This validates:
-# - Data loads correctly from HuggingFace Hub
-# - All fields round-trip correctly
-# - MWT information is preserved
-# - Token sequences exclude MWT forms (v2.0 bug fix)
+# Push to HuggingFace
+git push hf ${NEW_VER}
+git push hf --tags
 ```
 
-### 14. Upload to HuggingFace Hub
+**Option B: Using huggingface-cli**
 
 ```bash
-# Upload Parquet files to HuggingFace (this may take several hours)
-# Note: If using git-lfs, commit and push instead:
-git add parquet/
-git commit -m "Add Parquet files for all treebanks"
-git push origin 2.18
-
-# Alternative: Use huggingface-cli (if not using git-lfs)
-huggingface-cli upload commul/universal_dependencies ./parquet --repo-type dataset --revision 2.18
-
-# Upload main files
-huggingface-cli upload commul/universal_dependencies ./universal_dependencies.py --repo-type dataset --revision 2.18
-huggingface-cli upload commul/universal_dependencies ./README.md --repo-type dataset --revision 2.18
-huggingface-cli upload commul/universal_dependencies ./metadata.json --repo-type dataset --revision 2.18
-
-# Alternatively, push everything at once (if you have the repo cloned with git-lfs)
-# git push hf 2.18
+# Upload entire directory
+huggingface-cli upload commul/universal_dependencies . --repo-type dataset --revision ${NEW_VER}
 ```
 
 **Expected upload time:** 2-6 hours depending on network speed and HuggingFace server load.
 
-### 15. Verify on HuggingFace Hub
+**Tip:** Run uploads during off-peak hours for better performance.
+
+### 17. Verify on HuggingFace Hub
 
 Visit: https://huggingface.co/datasets/commul/universal_dependencies
 
-1. Check that branch `2.18` exists in the "Branches" dropdown
-2. Verify files are present:
-   - `universal_dependencies.py`
-   - `README.md`
+**Checklist:**
+1. ✅ Branch `2.18` exists in the "Branches" dropdown
+2. ✅ Files are present:
+   - `README.md` (dataset card)
    - `metadata.json`
    - `parquet/` directory with subdirectories
+3. ✅ Dataset card displays correctly
+4. ✅ Files section shows parquet files
 
-3. Test loading:
-   ```python
-   from datasets import load_dataset
+**Test loading:**
+```python
+from datasets import load_dataset
 
-   # Load from new version
-   ds = load_dataset("commul/universal_dependencies", "en_ewt", revision="2.18")
-   print(ds)
-   ```
+# Load from new version
+ds = load_dataset("commul/universal_dependencies", "en_ewt", revision="2.18")
+print(ds)
+```
+
+**Expected output:**
+```
+DatasetDict({
+    train: Dataset({
+        features: ['sent_id', 'text', 'comments', 'tokens', 'lemmas', ...],
+        num_rows: 12544
+    })
+    dev: Dataset({...})
+    test: Dataset({...})
+})
+```
+
+### 18. Update Main Branch (Optional)
 
-### 16. Update Dataset Card (Optional)
+If this is now the latest version:
 
-If this is now the latest version, you may want to update the dataset card to mention it:
+```bash
+git checkout main
+git merge ${NEW_VER}
+git push origin main
+```
 
-1. Edit README.md to add "Latest version: 2.18" at the top
-2. Update version badges if any
-3. Commit and push
+This makes the new version the default when users don't specify a revision.
 
 ## Troubleshooting
 
@@ -321,15 +418,25 @@ cd tools/UD_repos
 git submodule foreach 'git fetch --tags && (git checkout r2.18 || git checkout main) && touch .tag-r2.18'
 ```
 
+This falls back to `main` branch for repositories without the tag.
+
 ### Issue: Metadata extraction fails for a treebank
 
 **Problem:** A treebank is malformed or missing expected files.
 
+**Symptoms:**
+```
+ITEM DELETED - no summary: UD_Language-Treebank
+ITEM DELETED - no files  : UD_Language-Treebank
+ITEM DELETED - no license: UD_Language-Treebank
+```
+
 **Solution:**
-- Check the specific treebank in `UD_repos/UD_{Language}-{Treebank}/`
-- Verify it has `.conllu` files and `stats.xml`
-- Skip problematic treebanks by editing `02_traverse_ud_repos.py` if necessary
-- Report issues to the UD project
+1. Check the specific treebank in `tools/UD_repos/UD_{Language}-{Treebank}/`
+2. Verify it has `.conllu` files and `stats.xml`
+3. Check if README has required metadata
+4. If persistently broken, report to UD project
+5. Treebank will be automatically excluded from dataset
 
 ### Issue: Parquet generation fails for a treebank
 
@@ -337,69 +444,103 @@ git submodule foreach 'git fetch --tags && (git checkout r2.18 || git checkout m
 
 **Solution:**
 ```bash
-# Generate Parquet in batches to isolate the problem
-python 04_generate_parquet.py --treebanks "en_ewt"  # Test one at a time
-
-# Check logs for specific error
-# Fix the problematic CoNLL-U file or skip it temporarily
+# Isolate the problem by generating one treebank at a time
+uv run ./04_generate_parquet.py --treebanks "en_ewt"
+
+# Check error message for details
+# Common issues:
+# - Malformed CoNLL-U syntax
+# - Encoding problems
+# - Invalid character in fields
 ```
 
+**Report issues:** See [CONLLU_PARSING.md](https://github.com/bot-zen/ud-hf-parquet-tools/blob/main/CONLLU_PARSING.md) in ud-hf-parquet-tools for known parsing edge cases.
+
 ### Issue: HuggingFace upload is very slow
 
 **Problem:** Large Parquet files + network latency.
 
 **Solution:**
 - Use a machine with better network connection
-- Upload during off-peak hours
-- Use `--num-workers` flag if available:
-  ```bash
-  huggingface-cli upload commul/universal_dependencies ./parquet --repo-type dataset --revision 2.18 --num-workers 4
-  ```
+- Upload during off-peak hours (e.g., nighttime UTC)
+- Consider parallel uploads if using huggingface-cli
+
+### Issue: Out of disk space
+
+**Problem:** Parquet files take ~50-80 GB.
+
+**Solution:**
+- Ensure you have at least 100 GB free space
+- Generate Parquet files on a machine with larger disk
+- Clean up old UD versions: `rm -rf tools/UD_repos/` after uploading
+
+### Issue: Script dependencies not found
+
+**Problem:** ImportError or ModuleNotFoundError.
+
+**Solution:**
+```bash
+# Install required packages
+pip install ud-hf-parquet-tools pyyaml python-dotenv jinja2
+
+# Or use uv to manage dependencies automatically
+uv run --script ./script.py
+```
 
 ## Checklist
 
 Before marking the release as complete:
 
-- [ ] All metadata files generated (`metadata-2.18.json`, `citation-2.18`, `description-2.18`)
-- [ ] Universal dependencies script generated (`universal_dependencies-2.18`)
-- [ ] README generated (`README-2.18`)
-- [ ] Parquet files generated for all treebanks
-- [ ] Files copied to repository root
-- [ ] Tested loading from Python script
-- [ ] Tested loading from Parquet
-- [ ] Committed to git with proper message
-- [ ] Tagged with `ud2.18-loader-v2.0`
+- [ ] `.env` file updated with new version
+- [ ] Metadata files generated (`citation-{VER}`, `description-{VER}`, `codes_and_flags-{VER}.yaml`)
+- [ ] All UD repositories fetched and checked out to correct tag
+- [ ] `metadata-{VER}.json` generated with blocked treebank info
+- [ ] `README-{VER}` generated
+- [ ] Parquet files generated for all non-blocked treebanks
+- [ ] Parquet files validated (spot check)
+- [ ] Files copied to repository root (`README.md`, `metadata.json`, `parquet/`)
+- [ ] Tested loading from Parquet files
+- [ ] Committed to git with descriptive message
+- [ ] Tagged with `ud{VER}`
 - [ ] Pushed to origin
 - [ ] Uploaded to HuggingFace Hub
-- [ ] Verified on HuggingFace Hub
-- [ ] Tested loading from HuggingFace Hub
+- [ ] Verified dataset loads from HF Hub
+- [ ] (Optional) Updated main branch if latest version
 
 ## Timeline Estimate
 
-| Step | Time | Can be Parallelized? |
-|------|------|---------------------|
-| 1-5: Setup & metadata | 5-10 min | No |
-| 6: Fetch repositories | 30-60 min | No |
-| 7: Extract metadata | 10-20 min | No |
-| 8: Generate script | 1-2 min | No |
-| 9: Generate Parquet | 2-4 hours | Yes (by treebank) |
-| 10-12: Commit to git | 5-10 min | No |
-| 13: Upload to HF Hub | 2-6 hours | Partially |
-| 14-15: Verify & update | 10-20 min | No |
-| **Total** | **~5-11 hours** | |
+| Step | Time | Notes |
+|------|------|-------|
+| 1-5: Setup & metadata | 10-15 min | Manual edits required |
+| 6-7: Fetch repositories | 30-60 min | Network-dependent |
+| 8-9: Generate metadata/README | 5-10 min | Fast |
+| 10-12: Generate & validate Parquet | 2-4 hours | CPU-intensive |
+| 13-15: Commit to git | 10-15 min | Fast |
+| 16: Upload to HF Hub | 2-6 hours | Network-dependent |
+| 17-18: Verify & update | 10-20 min | Fast |
+| **Total** | **~5-11 hours** | Can parallelize some steps |
 
-**Recommendation:** Start the process in the morning so uploads can complete during the day.
+**Recommendation:** Start the process in the morning. Long-running steps (repository fetch, Parquet generation, upload) can run unattended.
 
 ## Notes
 
-- The loader version (v2.0) is already in the templates, so new UD versions automatically get the latest loader features.
-- Each UD version branch is independent - you can maintain multiple versions simultaneously.
-- Old branches (2.7-2.17) can be upgraded to v2.0 loader using the same process (just checkout the old branch and regenerate files).
-- The `main` branch can serve as a template or point to the latest version.
+- **No Python script loader:** v2.0 architecture uses Parquet files only (no `universal_dependencies.py`)
+- **Helper functions external:** CoNLL-U utilities available in `ud-hf-parquet-tools` library
+- **Blocked treebanks:** Some treebanks excluded due to license restrictions (see `blocked_treebanks.yaml`)
+- **Branch independence:** Each UD version branch is self-contained
+- **Version pinning:** Users can load specific versions via `revision="2.18"`
+
+## Reference Documentation
+
+- **Quick reference:** [tools/README.md](tools/README.md) - Script documentation and common operations
+- **Blocked treebanks:** [tools/BLOCKED_TREEBANKS.md](tools/BLOCKED_TREEBANKS.md) - License restrictions
+- **Migration guide:** [MIGRATION.md](MIGRATION.md) - v1.x to v2.0 migration
+- **Parquet tools:** https://github.com/bot-zen/ud-hf-parquet-tools - External library for CoNLL-U processing
+- **CoNLL-U parsing:** https://github.com/bot-zen/ud-hf-parquet-tools/blob/main/CONLLU_PARSING.md - Parsing edge cases
 
 ## Support
 
 For issues:
-- Universal Dependencies data issues → [UD GitHub Issues](https://github.com/UniversalDependencies/docs/issues)
-- Loader/tooling issues → Your repository issues
-- HuggingFace Hub issues → [HuggingFace Community Forums](https://discuss.huggingface.co/)
+- **UD data issues** → [UD GitHub Issues](https://github.com/UniversalDependencies/docs/issues)
+- **Tooling issues** → Your repository issues or [ud-hf-parquet-tools issues](https://github.com/bot-zen/ud-hf-parquet-tools/issues)
+- **HuggingFace Hub issues** → [HuggingFace Community Forums](https://discuss.huggingface.co/)

tools/README.md

@@ -1,129 +1,185 @@
-# README
-
-## Add a new version
-
-Use `NEW_VER` as the placeholder in the steps below (for example `2.17`). Keep
-commands idempotent by running scripts with the `-o/--override` flag whenever a
-file already exists.
-
-1. **Start new branch ${NEW_VER}**
-   ```
-   git checkout -b ${NEW_VER}
-   ```
-
-2. **Add PID info**
-   - Edit `.env` and set `UD_VER=NEW_VER`:
-     ```
-     NEW_VER=2.17
-     echo "UD_VER=${NEW_VER}" > .env
-     ```
-   - In `00_fetch_ud_clarin-dspace_metadata.py`, add a new entry to the
-     `url_postfixes` dict, e.g.
-     ```
-     "2.17": "11234/1-6000",  # <treebanks/languages>, released <date>
-     ```
-   - Fetch the metadata artefacts:
-     ```
-     ./00_fetch_ud_clarin-dspace_metadata.py -o
-     ```
-
-3. **Add/update docs-commit mapping**
-   - In `00_fetch_ud_codes_and_flags.sh`, append the git hash for the new
-     release to `VER_MAPPING`, e.g.
-     ```
-     VER_MAPPING["2.17"]="bea0c0e56c64cad41e60f479a8eca87dc571113f"
-     ```
-   - Refresh the codes/flags map and fetch the repositories list:
-     ```
-     ./00_fetch_ud_codes_and_flags.sh -o
-     ./01_fetch_ud_repos.sh
-     ```
-   - Commit the newly generated and changed files:
-     ```
-     git commit -m "Add PID,docs-commit info for new version" \
-        tools/00_fetch_ud_clarin-dspace_metadata.py tools/00_fetch_ud_codes_and_flags.sh
-
-     git add etc/codes_and_flags-${NEW_VER}.yaml
-     git commit -m"Add etc/codes_and_flags-${NEW_VER}.yaml" \
-        etc/codes_and_flags-${NEW_VER}.yaml
-
-     git commit -m"Bump to ${NEW_VER}: etc/codes_and_flags-latest.yaml" \
-        etc/codes_and_flags-latest.yaml
-     ```
-
-4. **Create the NEW_VER repositories branch**
-   ```
-   cd UD_repos/                      # change into the directory with all UD data
-   git checkout -b ${NEW_VER}
-   . .UD_submodules_add.commands     # update/initialise submodules
-   git add -u                        # add new content (!check for new directories/content)
-   # FIXME:
-   git submodule foreach git status | grep -v .tag- | grep -v Entering | grep -v HEAD | grep -v Untracked | grep -v '<file>' | grep -v nothing | grep -v master
-   git commit -m "Bump to ${NEW_VER}"
-   cd ..
-   ```
-
-5. **Regenerate metadata and README**
-   ```
-   ./02_generate_metadata.py -o
-   ./03_generate_README.py -o
-   ```
-   Review the generated files (`README-${NEW_VER}`, `metadata-${NEW_VER}.json`)
-   before committing.
-
-6. **Generate and check parquet files**
-   (Update blocked_treebanks.yaml - if necessary. See BLOCKED_TREEBANKS.md)
-   ```
-   uv run tools/04_generate_parquet.py
-
-   uv run tools/05_validate_parquet.py --local --mode text -vv > /tmp/parquet-check.log
-   # Check for differences outside the metadata headers:
-   grep -E "         [+-]" /tmp/parquet-check.log | grep -vE "         [+-]#"
-   ```
-
-7. **Commit and sync artefacts**
-   ```
-   git add README-${NEW_VER} metadata-${NEW_VER}.json
-   git commit -m "Add README-${NEW_VER} metadata-${NEW_VER}.json"
-
-   cp README-${NEW_VER} ../README.md
-   cp metadata-${NEW_VER}.json ../metadata.json
-   git add ../parquet
-   git commit -m "Bump to ${NEW_VER}: README.md metadata.json parquet/" ../README.md ../metadata.json
-
-   git checkout main
-   git merge ${NEW_VER}
-   git push origin ${NEW_VER}
-   git push origin main
-   ```
-   Adjust the final push commands if your workflow requires pull requests or
-   protected branches.
-
-
-## Overview of files and directories
-1. **00 (./etc/)**
-   - `00_fetch_ud_clarin-dspace_metadata.py`
-     Download `./etc/citation-VER` and `./etc/description-VER` UD metadata files for
-     the different releases from the lindat clarin-dspace repository.
-
-   - `00_fetch_ud_codes_and_flags.sh`
-     Download `./etc/codes_and_flags.yaml`, a yaml file mapping UD (long) language
-     names to metadata from UD `docs-automation` at GitHub.
-
-2. **01**
-   - Identify all relevant UD repositories from GitHub:
-     * https://github.com/UniversalDependencies/
-     and generate a list of submodules to add to a (newly created) repository in the
-     subdirectory `./UD_Repos/`.
-
-3. **02**
-   - Collect relevant metadata from local UD directories:
-     - extract the '# Summary' from the beginning and machine readable
-       metadata from the end of the README.{md,txt} file
-   - use the UD directory name for collecting metadata from the
-     codes_and_flags.yaml file
-   - collect {dev,train,test}.conllu files.
-
-4. **03**
-   Use `./templates/README.tmpl` to generate:
-     - `README-${UD_VER}` (dataset card for HuggingFace)
+# tools/ Directory
+
+Quick reference for the Universal Dependencies dataset generation pipeline.
+
+## Quick Start: Add New UD Version
+
+```bash
+# Set version
+export NEW_VER=2.18
+cd tools
+echo "UD_VER=${NEW_VER}" > .env
+
+# Fetch metadata
+./00_fetch_ud_clarin-dspace_metadata.py -o
+./00_fetch_ud_codes_and_flags.sh -o
+./01_fetch_ud_repos.sh
+
+# Initialize repositories
+cd UD_repos
+git init
+bash ../.UD_submodules_add.commands
+git submodule foreach "git fetch --tags && git checkout r${NEW_VER} && touch .tag-r${NEW_VER}"
+cd ..
+
+# Generate files
+./02_generate_metadata.py -o
+./03_generate_README.py -o
+uv run ./04_generate_parquet.py
+uv run ./05_validate_parquet.py --local --test
+
+# Sync to root
+cp README-${NEW_VER} ../README.md
+cp metadata-${NEW_VER}.json ../metadata.json
+git add ../parquet ../README.md ../metadata.json
+```
+
+**For detailed instructions, see:** [ADDING_NEW_UD_VERSION.md](../ADDING_NEW_UD_VERSION.md)
+
+## Pipeline Scripts
+
+### 00 - Fetch Metadata
+
+**00_fetch_ud_clarin-dspace_metadata.py**
+- Downloads citation and description from LINDAT/CLARIN repository
+- Creates: `etc/citation-{VER}`, `etc/description-{VER}`
+- Update `url_postfixes` dict for new versions
+
+**00_fetch_ud_codes_and_flags.sh**
+- Downloads language codes and flags from UD docs-automation
+- Creates: `etc/codes_and_flags-{VER}.yaml`, `etc/codes_and_flags-latest.yaml`
+- Update `VER_MAPPING` for new versions
+
+### 01 - Fetch Repositories
+
+**01_fetch_ud_repos.sh**
+- Discovers all UD repositories on GitHub
+- Creates: `.UD_submodules_add.commands`
+- Run commands in `UD_repos/` directory to fetch all treebanks
+
+### 02 - Generate Metadata
+
+**02_generate_metadata.py**
+- Extracts metadata from local UD directories
+- Collects: summaries, licenses, splits, statistics, blocked status
+- Creates: `metadata-{VER}.json`
+- Reads: `blocked_treebanks.yaml` for license restrictions
+
+### 03 - Generate README
+
+**03_generate_README.py**
+- Renders Jinja2 template with metadata
+- Creates: `README-{VER}` (HuggingFace dataset card)
+- Uses: `templates/README.tmpl`, `metadata-{VER}.json`, `etc/citation-{VER}`, `etc/description-{VER}`
+
+### 04 - Generate Parquet
+
+**04_generate_parquet.py**
+- Wrapper script calling `ud-hf-parquet-tools` library
+- Converts CoNLL-U files to Parquet format
+- Creates: `../parquet/{treebank}/{split}.parquet`
+- Options: `--test`, `--overwrite`, `--blocked-treebanks`
+
+### 05 - Validate Parquet
+
+**05_validate_parquet.py**
+- Wrapper script calling `ud-hf-parquet-tools` library
+- Validates Parquet files against CoNLL-U source
+- Options: `--local`, `--test`, `--mode text`
+
+## Directory Structure
+
+```
+tools/
+├── 00_fetch_ud_clarin-dspace_metadata.py   # Fetch citation/description
+├── 00_fetch_ud_codes_and_flags.sh          # Fetch language metadata
+├── 01_fetch_ud_repos.sh                    # Discover UD repos
+├── 02_generate_metadata.py                 # Extract treebank metadata
+├── 03_generate_README.py                   # Generate dataset card
+├── 04_generate_parquet.py                  # Generate Parquet files
+├── 05_validate_parquet.py                  # Validate Parquet files
+├── blocked_treebanks.yaml                  # License-restricted treebanks
+├── etc/
+│   ├── citation-{VER}                      # Generated citations
+│   ├── description-{VER}                   # Generated descriptions
+│   └── codes_and_flags-{VER}.yaml          # Language metadata
+├── templates/
+│   └── README.tmpl                         # Jinja2 template for dataset card
+├── metadata-{VER}.json                     # Generated metadata (output)
+├── README-{VER}                            # Generated dataset card (output)
+└── UD_repos/                               # Git submodules (created by 01)
+    ├── UD_{Language}-{Treebank}/           # Individual treebanks
+    └── .UD_submodules_add.commands         # Generated submodule commands
+```
+
+## Configuration
+
+**Environment Variables (.env)**
+```bash
+UD_VER=2.17  # Current UD version
+```
+
+**Blocked Treebanks (blocked_treebanks.yaml)**
+```yaml
+pt_cintil:
+  reason: "Restrictive license prohibits redistribution in derived formats"
+  license: "CC BY-NC-SA 4.0"
+  url: "https://github.com/UniversalDependencies/UD_Portuguese-CINTIL"
+```
+
+## Dependencies
+
+- Python 3.12+
+- `uv` (for running scripts with dependencies)
+- `ud-hf-parquet-tools` (for parquet generation/validation)
+- Git with submodules support
+
+Install dependencies:
+```bash
+pip install ud-hf-parquet-tools pyyaml python-dotenv jinja2
+```
+
+## Common Operations
+
+**Test on subset:**
+```bash
+uv run ./04_generate_parquet.py --test  # Tests 3 treebanks
+uv run ./05_validate_parquet.py --test  # Validates 3 treebanks
+```
+
+**Force regeneration:**
+```bash
+./02_generate_metadata.py -o            # Override existing
+./03_generate_README.py -o
+uv run ./04_generate_parquet.py --overwrite
+```
+
+**Skip blocked treebanks:**
+```bash
+uv run ./04_generate_parquet.py --blocked-treebanks blocked_treebanks.yaml
+```
+
+## Troubleshooting
+
+**Script not found:**
+- Scripts use `#!/usr/bin/env -S uv run --script` shebang
+- Make executable: `chmod +x *.py *.sh`
+- Or run with: `uv run --script ./script.py`
+
+**Missing dependencies:**
+```bash
+pip install ud-hf-parquet-tools
+```
+
+**Submodule checkout fails:**
+```bash
+cd UD_repos
+git submodule foreach 'git fetch --tags && (git checkout r2.17 || git checkout main)'
+```
+
+## Documentation
+
+- **Comprehensive guide:** [ADDING_NEW_UD_VERSION.md](../ADDING_NEW_UD_VERSION.md)
+- **Blocked treebanks:** [BLOCKED_TREEBANKS.md](BLOCKED_TREEBANKS.md)
+- **Migration guide:** [MIGRATION.md](../MIGRATION.md)
+- **Parquet tools:** https://github.com/bot-zen/ud-hf-parquet-tools