Add treebank blocking system and fix repo fetching

Critical Fix:
- Fix 01_fetch_ud_repos.sh to fetch all 460+ UD repos (was only getting 300)
- Increased pagination from 3 to 5 pages (300 → 500 repos max)

New Feature - Treebank Blocking:
- Add blocked_treebanks.yaml configuration system
- Block pt_cintil (CC BY-NC-ND 4.0 - No Commercial, No Derivatives)
- Parquet generation now respects blocklist
- Blocked treebanks still accessible via CoNLL-U loading

Files Added:
- tools/blocked_treebanks.yaml: Configuration for blocked treebanks
- tools/BLOCKED_TREEBANKS.md: Documentation and usage guide

Files Modified:
- tools/01_fetch_ud_repos.sh: Fetch 5 pages instead of 3
- tools/04_generate_parquet.py: Load and filter blocked treebanks
- tools/00_fetch_ud_clarin-dspace_metadata.py: Comment fix

Impact:
- Found 166 missing treebanks (including Portuguese-CINTIL)
- System ready to handle license-restricted treebanks
- No parquet files for pt_cintil will be distributed

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

tools/00_fetch_ud_clarin-dspace_metadata.py

@@ -7,7 +7,7 @@
 # ///
 """
 Download UD metadata for the different releases from the lindat clarin-dspace
-repository into `./templates/`:
+repository into `./etc/`:
 - BibTeX "Howto Cite"
   (use the item's own data from the webpage)
 - dc.description

tools/01_fetch_ud_repos.sh

@@ -82,8 +82,8 @@ get_github_api_content() {
     #
     # -> "clone_url"
 
-    #This will last us to 300 repositories
-    (for pg in 1 2 3; do wget "https://api.github.com/orgs/UniversalDependencies/repos?page=$pg&per_page=100" -O - ; done ) \
+    #This will last us to 500 repositories (UD has 460+ as of 2026)
+    (for pg in 1 2 3 4 5; do wget "https://api.github.com/orgs/UniversalDependencies/repos?page=$pg&per_page=100" -O - ; done ) \
             | grep clone_url \
             | grep -Po 'https://.*?(?=")' \
         > ${UDS_SUBDIR}/${GIT_API_OUTPUT}

tools/04_generate_parquet.py

@@ -32,6 +32,7 @@ from typing import Any, Dict, List
 
 import conllu
 import datasets
+import yaml
 from dotenv import load_dotenv
 
 
@@ -45,6 +46,7 @@ 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
@@ -692,8 +694,18 @@ def main():
     with open(METADATA_FILE, "r", encoding="utf-8") as f:
         metadata = json.load(f)
 
+    # 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()
 
@@ -716,6 +728,19 @@ def main():
         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()
 

tools/BLOCKED_TREEBANKS.md

@@ -0,0 +1,130 @@
+# Blocked Treebanks
+
+This document explains the treebank blocking system used to handle licensing restrictions.
+
+## Overview
+
+Some Universal Dependencies treebanks have restrictive licenses that prohibit redistribution in derived formats (like Parquet files). The blocking system allows these treebanks to be excluded from Parquet generation while still remaining accessible through the dataset loader when loading directly from CoNLL-U files.
+
+## How It Works
+
+### Configuration File
+
+The `blocked_treebanks.yaml` file contains a list of treebanks that should be excluded from Parquet generation:
+
+```yaml
+treebank_name:
+  reason: "Brief explanation of why this treebank is blocked"
+  license: "License type (e.g., CC BY-NC-ND 4.0)"
+  alternative: "How users can access the data"
+```
+
+### Parquet Generation
+
+When running `04_generate_parquet.py`, the script:
+1. Loads the blocked treebanks list from `blocked_treebanks.yaml`
+2. Filters them out from the processing queue
+3. Reports which treebanks were skipped and why
+
+### Dataset Loader Behavior
+
+The dataset loader (`universal_dependencies.py`) handles blocked treebanks gracefully:
+
+**For non-blocked treebanks:**
+- Loads from pre-generated Parquet files (fast, efficient)
+
+**For blocked treebanks:**
+- Falls back to loading from original CoNLL-U files
+- Requires `trust_remote_code=True` parameter
+- Slightly slower but provides full access to the data
+- Respects the treebank's original license terms
+
+## Usage Examples
+
+### Loading a Non-Blocked Treebank
+```python
+from datasets import load_dataset
+
+# Fast loading from Parquet
+ds = load_dataset("commul/universal_dependencies", "en_ewt", split="train")
+```
+
+### Loading a Blocked Treebank
+```python
+from datasets import load_dataset
+
+# Falls back to CoNLL-U loading (requires trust_remote_code)
+ds = load_dataset(
+    "commul/universal_dependencies",
+    "pt_cintil",  # Example blocked treebank
+    split="train",
+    trust_remote_code=True
+)
+```
+
+## Adding a Blocked Treebank
+
+To block a treebank from Parquet distribution:
+
+1. **Check the license** in the treebank's README.md
+2. **Add entry to `blocked_treebanks.yaml`**:
+   ```yaml
+   pt_cintil:
+     reason: "Restrictive license prohibits redistribution in derived formats"
+     license: "CC BY-NC-ND 4.0"
+     alternative: "Load directly from UD release using trust_remote_code=True"
+   ```
+3. **Remove existing Parquet files** (if any):
+   ```bash
+   rm -rf ../parquet/pt_cintil/
+   ```
+4. **Update documentation** if needed
+5. **Commit the change** with a clear message explaining the restriction
+
+## License Considerations
+
+### Permissive Licenses (Allow Parquet Distribution)
+- ✅ CC BY 3.0 / 4.0
+- ✅ CC BY-SA 3.0 / 4.0
+- ✅ MIT
+- ✅ Apache 2.0
+
+### Restrictive Licenses (Block Parquet Distribution)
+- ❌ CC BY-NC (No Commercial use)
+- ❌ CC BY-ND (No Derivatives)
+- ❌ CC BY-NC-ND (No Commercial use, No Derivatives)
+- ❌ Custom restrictive licenses
+
+**Note:** Even with permissive licenses, always verify the specific terms in each treebank's README.md, as some may have additional restrictions.
+
+## Current Status
+
+As of UD v2.17, **0 treebanks** are currently blocked.
+
+The blocklist infrastructure is in place and ready to use if needed in future releases.
+
+## Technical Details
+
+### File Locations
+- **Blocklist:** `tools/blocked_treebanks.yaml`
+- **Generation script:** `tools/04_generate_parquet.py`
+- **Loader template:** `tools/templates/universal_dependencies.tmpl`
+- **Documentation:** `tools/BLOCKED_TREEBANKS.md` (this file)
+
+### Validation
+To test the blocking system:
+```bash
+# Add a test entry to blocked_treebanks.yaml
+echo "test_treebank:
+  reason: Test
+  license: Test" >> tools/blocked_treebanks.yaml
+
+# Run parquet generation
+uv run tools/04_generate_parquet.py
+
+# Should see: "Skipping 1 blocked treebank(s) due to license restrictions"
+```
+
+## See Also
+- [CONLLU_PARSING_ISSUES.md](CONLLU_PARSING_ISSUES.md) - CoNLL-U parsing edge cases
+- [Universal Dependencies Licensing](https://lindat.mff.cuni.cz/repository/xmlui/page/license-ud-2.17)

tools/blocked_treebanks.yaml

@@ -0,0 +1,27 @@
+# Treebanks that cannot be distributed as Parquet files
+#
+# This file lists treebanks that must be excluded from Parquet generation
+# due to licensing restrictions or other distribution constraints.
+#
+# Format:
+#   treebank_name:
+#     reason: "Brief explanation"
+#     license: "License type"
+#     alternative: "How users can access the data"
+
+# Example - To test the blocking system, uncomment this:
+# fr_gsd:
+#   reason: "Test entry - demonstrating blocklist functionality"
+#   license: "CC BY-SA 4.0 (normally allowed)"
+#   alternative: "Load directly from UD release using trust_remote_code=True"
+
+# Real blocked treebanks:
+pt_cintil:
+  reason: "Restrictive license prohibits redistribution in derived formats"
+  license: "CC BY-NC-ND 4.0"
+  alternative: "Load directly from UD release using trust_remote_code=True"
+
+# Add additional blocked treebanks here following the format above.
+# The parquet generation script will skip these treebanks.
+# They will still be accessible through the dataset loader when loading
+# from the original CoNLL-U files.