# Migration Guide: v1.x → v2.0

This guide helps you migrate from Universal Dependencies dataset loader v1.x to v2.0.

## What's New in v2.0

**Architecture Changes:**
- **Parquet format**: Native support with datasets >=4.0.0 (5-10x faster loading)
- **No Python script**: Dataset no longer requires `trust_remote_code=True`
- **External helper library**: CoNLL-U processing utilities moved to [`ud-hf-parquet-tools`](https://github.com/bot-zen/ud-hf-parquet-tools)

**Data Changes:**
- **MWT bug fix**: Token sequences now correctly exclude Multi-Word Token surface forms
- **MWT field added**: New structured `mwt` field with Multi-Word Token information
- **Enhanced metadata**: Includes `num_fused` (MWT counts) in statistics

## Quick Start

### For Users with datasets >=4.0.0

No code changes needed! Parquet files load automatically:

```python
from datasets import load_dataset

# v2.0: Works seamlessly with datasets >=4.0.0
dataset = load_dataset("commul/universal_dependencies", "fr_gsd")
# Automatically uses Parquet format (fast, secure)
```

### For Users with datasets <4.0.0

**Option 1: Upgrade datasets (Recommended)**

```bash
pip install --upgrade "datasets>=4.0.0"
```

**Option 2: Continue using v1.x**

```python
# v1.x: Requires trust_remote_code
dataset = load_dataset("commul/universal_dependencies", "fr_gsd", trust_remote_code=True, revision="v1.0")
```

## Breaking Changes

### 1. Token Sequences Now Exclude MWT Forms

**Impact:** Token counts and sequences have changed for treebanks with Multi-Word Tokens (MWTs).

**What Changed:**
- v1.x incorrectly included MWT surface forms in token sequences
- v2.0 correctly excludes them, matching UD guidelines

**Example (French "des" → "de" + "les"):**

```python
# v1.x (BUGGY):
{
    "tokens": ["Elle", "des", "de", "les", "pommes", "."],  # WRONG: "des" included
    "lemmas": ["elle", "_", "de", "le", "pomme", "."],
    "upos": ["PRON", "_", "ADP", "DET", "NOUN", "PUNCT"],
}

# v2.0 (CORRECT):
{
    "tokens": ["Elle", "de", "les", "pommes", "."],  # CORRECT: only syntactic words
    "lemmas": ["elle", "de", "le", "pomme", "."],
    "upos": ["PRON", "ADP", "DET", "NOUN", "PUNCT"],
    "mwt": [{"id": "2-3", "form": "des", "misc": ""}],  # MWT info preserved
}
```

**Affected Treebanks (50+):**

Languages with common MWTs include:
- **French** (fr_*): du, au, des, aux (~2-5% of tokens)
- **Italian** (it_*): del, della, nel, alla (~1-3%)
- **Portuguese** (pt_*): do, da, no, pelo (~2-4%)
- **Spanish** (es_*): del, al (~0.5-1%)
- **Arabic** (ar_*): various clitics (~1-2%)
- **German** (de_*): zum, vom, am (~0.1-0.5%)
- **Catalan** (ca_*): del, al, pels (~1-2%)
- **Indonesian** (id_*): reduplications (~0.1%)

**Action Required:**

If your code assumes specific token counts or positions:

```python
# v1.x code that might break:
def get_third_token(example):
    return example["tokens"][2]  # May return different token in v2.0

# Migration fix:
def get_third_syntactic_word(example):
    # v2.0: This is now correct - gets the 3rd syntactic word
    return example["tokens"][2]

def get_third_surface_token(example):
    # v2.0: If you need surface forms, reconstruct from MWTs
    tokens = example["tokens"][:]
    mwts = example["mwt"]

    # Insert MWT forms at appropriate positions
    for mwt in reversed(mwts):  # Process in reverse to maintain indices
        start, end = map(int, mwt["id"].split("-"))
        tokens[start-1:end] = [mwt["form"]]

    return tokens[2]
```

### 2. New Schema Field: `mwt`

**Impact:** Dataset schema now includes an `mwt` field.

**What Changed:**
- Added: `mwt` field containing structured MWT information
- Schema: `[{"id": "1-2", "form": "surface_form", "misc": "metadata"}]`
- Empty list for treebanks without MWTs

**Example Usage:**

```python
from datasets import load_dataset

dataset = load_dataset("commul/universal_dependencies", "fr_gsd", split="train")

# Access MWT information
for example in dataset:
    if example["mwt"]:  # Has MWTs
        for mwt in example["mwt"]:
            print(f"MWT {mwt['id']}: {mwt['form']}")
            # Extract range
            start, end = map(int, mwt["id"].split("-"))
            syntactic_words = example["tokens"][start-1:end]
            print(f"  → {' + '.join(syntactic_words)}")

# Output example:
# MWT 2-3: des
#   → de + les
```

**Research Use Cases:**

```python
# Count MWTs per treebank
def count_mwts(dataset):
    return sum(len(ex["mwt"]) for ex in dataset)

# Analyze MWT patterns
def analyze_mwt_patterns(dataset):
    patterns = {}
    for ex in dataset:
        for mwt in ex["mwt"]:
            form = mwt["form"]
            patterns[form] = patterns.get(form, 0) + 1
    return patterns

fr_gsd = load_dataset("commul/universal_dependencies", "fr_gsd", split="train")
print(analyze_mwt_patterns(fr_gsd))
# Output: {'des': 1234, 'du': 987, 'au': 654, 'aux': 321, ...}
```

### 3. Requires datasets >=4.0.0

**Impact:** The Python script loader is deprecated (datasets >=4.0.0 policy).

**What Changed:**
- v1.x: Uses Python script with `trust_remote_code=True`
- v2.0: Uses Parquet format (no remote code execution)

**Security Benefit:**
- No arbitrary code execution from dataset loading
- Parquet files are data-only, sandboxed
- Aligns with HuggingFace security policies

**Migration:**

```bash
# Check your datasets version
python -c "import datasets; print(datasets.__version__)"

# Upgrade if needed
pip install --upgrade "datasets>=4.0.0"
```

If you cannot upgrade datasets:

```python
# Use v1.x with revision pinning
dataset = load_dataset(
    "commul/universal_dependencies",
    "fr_gsd",
    trust_remote_code=True,
    revision="v1.0"  # Pin to v1.x
)
```

## Helper Functions Moved to External Library

**Important:** Helper functions for CoNLL-U processing are now in a separate package.

### What Moved

The following functions are **no longer part of the dataset**:
- `parse_feats()`, `parse_misc()`, `parse_deps()` - Parse CoNLL-U field strings
- `write_conllu()`, `example_to_conllu()` - Export data to CoNLL-U format
- Various internal conversion utilities

### How to Access Helper Functions

If you need CoNLL-U processing utilities, install the external library:

```bash
pip install ud-hf-parquet-tools
```

Then import from the package:

```python
from datasets import load_dataset
from ud_hf_parquet_tools import parse_feats, parse_misc, write_conllu

# Load dataset
ds = load_dataset("commul/universal_dependencies", "en_ewt", split="train")

# Parse optional fields
sentence = ds[0]
for i, token in enumerate(sentence['tokens']):
    feats = parse_feats(sentence['feats'][i])  # Returns dict or {}
    misc = parse_misc(sentence['misc'][i])      # Returns dict or {}
    print(f"{token}: UPOS={sentence['upos'][i]}, feats={feats}, misc={misc}")

# Export back to CoNLL-U format
write_conllu(ds, "output.conllu")
```

**Library Documentation:** https://github.com/bot-zen/ud-hf-parquet-tools

### If You Don't Need Helper Functions

Most users only need the dataset itself and can work directly with the fields:

```python
from datasets import load_dataset

ds = load_dataset("commul/universal_dependencies", "en_ewt", split="train")

# Access data directly
sentence = ds[0]
print(f"Tokens: {sentence['tokens']}")
print(f"POS tags: {sentence['upos']}")
print(f"Dependencies: {sentence['deprel']}")

# FEATS and MISC are strings in CoNLL-U format
print(f"Features (raw): {sentence['feats'][0]}")  # e.g., "Case=Nom|Number=Sing"
print(f"Misc (raw): {sentence['misc'][0]}")       # e.g., "SpaceAfter=No"

# Parse manually if needed (simple cases)
feats_str = sentence['feats'][0]
if feats_str:
    feats_dict = dict(kv.split('=') for kv in feats_str.split('|'))
    print(f"Features (parsed): {feats_dict}")
```

## New Features in v2.0

### 1. Parquet Format (5-10x Faster Loading)

```python
# v1.x: Downloads CoNLL-U, parses on-the-fly (~10-30 seconds)
dataset = load_dataset("commul/universal_dependencies", "fr_gsd", trust_remote_code=True)

# v2.0: Loads pre-processed Parquet (~1-3 seconds)
dataset = load_dataset("commul/universal_dependencies", "fr_gsd")
```

**Benefits:**
- Much faster loading (especially for large treebanks)
- Lower memory usage
- Better compression
- Native support in datasets >=4.0.0

### 2. Multi-Word Token (MWT) Information

```python
dataset = load_dataset("commul/universal_dependencies", "fr_gsd", split="train")

# Find sentences with MWTs
sentences_with_mwts = [ex for ex in dataset if ex["mwt"]]
print(f"Sentences with MWTs: {len(sentences_with_mwts)}/{len(dataset)}")

# Analyze MWT complexity
complex_mwts = [ex for ex in dataset if any(
    int(mwt["id"].split("-")[1]) - int(mwt["id"].split("-")[0]) > 2
    for mwt in ex["mwt"]
)]
print(f"Sentences with 3+ word MWTs: {len(complex_mwts)}")
```

### 3. Enhanced Metadata

```python
# Load dataset info
from datasets import load_dataset_builder

builder = load_dataset_builder("commul/universal_dependencies", "fr_gsd")
info = builder.info

# Now includes MWT statistics
print(info.description)  # Contains num_fused counts
```

## Verification Steps

### 1. Verify Token Counts Match UD Stats

```python
from datasets import load_dataset
import json

# Load dataset and metadata
dataset = load_dataset("commul/universal_dependencies", "fr_gsd", split="train")

# Count syntactic words
word_count = sum(len(ex["tokens"]) for ex in dataset)

# Load metadata (if available)
with open("metadata.json") as f:
    metadata = json.load(f)

expected_words = int(metadata["fr_gsd"]["splits"]["train"]["num_words"])
print(f"Dataset words: {word_count}")
print(f"Expected words: {expected_words}")
print(f"Match: {word_count == expected_words}")

# This should be True in v2.0 (was False in v1.x for MWT treebanks)
```

### 2. Verify MWT Extraction

```python
# Count MWTs
mwt_count = sum(len(ex["mwt"]) for ex in dataset)

expected_mwts = int(metadata["fr_gsd"]["splits"]["train"]["num_fused"])
print(f"Dataset MWTs: {mwt_count}")
print(f"Expected MWTs: {expected_mwts}")
print(f"Match: {mwt_count == expected_mwts}")
```

### 3. Compare v1.x vs v2.0 Output

```python
# Load both versions (if v1.x still available)
v1 = load_dataset("commul/universal_dependencies", "en_ewt", split="test[:10]", revision="v1.0", trust_remote_code=True)
v2 = load_dataset("commul/universal_dependencies", "en_ewt", split="test[:10]")

# English-EWT has no MWTs, so should be identical except for new field
for i in range(10):
    assert v1[i]["tokens"] == v2[i]["tokens"], f"Example {i} differs"
    assert v2[i]["mwt"] == [], f"Example {i} has unexpected MWTs"

print("✓ English-EWT unchanged (no MWTs)")

# French-GSD has MWTs, so v2.0 will differ
v1_fr = load_dataset("commul/universal_dependencies", "fr_gsd", split="test[:10]", revision="v1.0", trust_remote_code=True)
v2_fr = load_dataset("commul/universal_dependencies", "fr_gsd", split="test[:10]")

# v1.x token count includes MWTs (WRONG)
v1_token_count = sum(len(ex["tokens"]) for ex in v1_fr)

# v2.0 token count excludes MWTs (CORRECT)
v2_token_count = sum(len(ex["tokens"]) for ex in v2_fr)

print(f"v1.x French token count: {v1_token_count} (includes MWT forms)")
print(f"v2.0 French token count: {v2_token_count} (syntactic words only)")
print(f"Difference: {v1_token_count - v2_token_count} MWT forms removed")
```

## Common Issues

### Issue 1: "Dataset script not supported" Error

**Error:**
```
RuntimeError: Dataset scripts are no longer supported
```

**Cause:** Using datasets >=4.0.0 with v1.x loader

**Solution:**
```bash
pip install --upgrade "datasets>=4.0.0"
# Then use v2.0 (Parquet-based)
```

### Issue 2: Token Count Mismatch

**Issue:** Your code expects specific token counts that changed in v2.0

**Solution:** Update your code to use `num_words` from metadata instead of `num_tokens`

```python
# v1.x: Used num_tokens (WRONG for MWT treebanks)
expected_count = metadata["splits"]["train"]["num_tokens"]

# v2.0: Use num_words (CORRECT)
expected_count = metadata["splits"]["train"]["num_words"]
```

### Issue 3: MWT Field Not Found (v1.x Code)

**Issue:** Old code doesn't handle the new `mwt` field

**Solution:** Gracefully handle the field or upgrade

```python
# Backwards compatible code
tokens = example["tokens"]
mwts = example.get("mwt", [])  # Empty list if not present
```

### Issue 4: Helper Function Import Errors

**Error:**
```python
from universal_dependencies import parse_feats
# ImportError: No module named 'universal_dependencies'
```

**Cause:** Helper functions moved to separate library

**Solution:**
```bash
# Install the helper library
pip install ud-hf-parquet-tools

# Update imports
from ud_hf_parquet_tools import parse_feats, parse_misc, write_conllu
```

Or work with raw strings directly (see "If You Don't Need Helper Functions" section above).

## Support

If you encounter issues during migration:

1. Check the [CHANGELOG.md](CHANGELOG.md) for detailed changes
2. Review the [README.md](README.md) for updated examples
3. Helper library documentation: https://github.com/bot-zen/ud-hf-parquet-tools
4. Report issues at: https://huggingface.co/datasets/commul/universal_dependencies/discussions

## Summary

**Key Takeaways:**

✅ **v2.0 is more correct:** Fixes critical MWT bug
✅ **v2.0 is faster:** Parquet format is 5-10x quicker
✅ **v2.0 is more secure:** No remote code execution
✅ **v2.0 adds features:** MWT information now available
✅ **v2.0 is modular:** Helper functions available as separate library

**Migration Checklist:**

- [ ] Upgrade to datasets >=4.0.0
- [ ] Test your code with v2.0 data
- [ ] Update token count expectations (if using MWT treebanks)
- [ ] Update any hard-coded token indices (if applicable)
- [ ] If using helper functions: Install `ud-hf-parquet-tools` and update imports
- [ ] If exporting to CoNLL-U: Use `write_conllu()` from `ud-hf-parquet-tools`
- [ ] Utilize new MWT field for research (optional)

**Estimated Migration Time:**
- Basic usage: 15-30 minutes
- With helper functions: +10 minutes (install library, update imports)

**Resources:**
- Dataset repository: https://huggingface.co/datasets/commul/universal_dependencies
- Helper library: https://github.com/bot-zen/ud-hf-parquet-tools
- CHANGELOG: [CHANGELOG.md](CHANGELOG.md)