Add scripts and ud-tools from UDD-v0.1

- Add scripts: convert_to_ud.py, fetch_data.py, statistics.py, upload_to_hf.py
- Add ud-tools: validation module for Universal Dependencies format
- Add .gitignore for __pycache__

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

.gitignore

@@ -0,0 +1 @@
+__pycache__/

scripts/convert_to_ud.py

@@ -0,0 +1,525 @@
+"""
+Convert sentences to Universal Dependencies format compatible with HuggingFace.
+Structure follows: https://huggingface.co/datasets/commul/universal_dependencies/viewer/vi_vtb
+Uses underthesea dependency_parse for proper annotations.
+"""
+
+import json
+from os.path import dirname, expanduser, join
+
+from underthesea import dependency_parse, pos_tag
+
+# Map Vietnamese POS tags to Universal POS tags
+# Based on: https://universaldependencies.org/u/pos/
+UPOS_MAP = {
+    'N': 'NOUN',      # Noun
+    'Np': 'PROPN',    # Proper noun
+    'Nc': 'NOUN',     # Classifier noun
+    'Nu': 'NOUN',     # Unit noun
+    'V': 'VERB',      # Verb
+    'A': 'ADJ',       # Adjective
+    'P': 'PRON',      # Pronoun
+    'R': 'ADV',       # Adverb
+    'L': 'DET',       # Determiner/Quantifier
+    'M': 'NUM',       # Numeral
+    'E': 'ADP',       # Preposition
+    'C': 'CCONJ',     # Coordinating conjunction
+    'CC': 'CCONJ',    # Coordinating conjunction
+    'SC': 'SCONJ',    # Subordinating conjunction
+    'I': 'INTJ',      # Interjection
+    'T': 'PART',      # Particle
+    'B': 'X',         # Foreign word
+    'Y': 'X',         # Abbreviation
+    'S': 'SYM',       # Symbol
+    'X': 'X',         # Other
+    'CH': 'PUNCT',    # Punctuation
+    'Ny': 'NOUN',     # Noun (variant)
+}
+
+# Vietnamese auxiliary verbs that should be tagged as AUX
+# Based on UD Vietnamese validation data (data.json)
+AUX_WORDS = {
+    'bị', 'chưa thể', 'chắc chắn', 'có thể', 'có vẻ', 'cần',
+    'giả', 'không thể', 'là', 'muốn', 'nghĩa là', 'nhằm',
+    'nên', 'phải', 'quyết', 'thôi', 'thể', 'xong', 'được', 'định'
+}
+
+# Vietnamese determiners - words that should be DET when used as 'det' relation
+DET_WORDS = {
+    'các', 'những', 'mọi', 'mỗi', 'từng', 'bất kỳ', 'một', 'hai', 'ba',
+    'này', 'đó', 'kia', 'ấy', 'nọ', 'nào', 'đấy', 'cái', 'con', 'chiếc',
+    'người', 'cả', 'phá tán'  # Words that appear as det in the data
+}
+
+# Words that can be ADV when used as 'advmod'
+ADV_WORDS = {
+    'không', 'chưa', 'đã', 'đang', 'sẽ', 'còn', 'vẫn', 'cũng', 'rất',
+    'quá', 'lắm', 'hơn', 'nhất', 'luôn', 'thường', 'hay', 'ít', 'nhiều',
+    'tự', 'một cách', 'được', 'không thể', 'lại', 'cá biệt', 'dân sự'
+}
+
+# Invalid deprels that need to be mapped to valid ones
+DEPREL_MAP = {
+    'acomp': 'xcomp',  # Adjectival complement -> open clausal complement
+    'nmod:comp': 'nmod',  # Invalid subtype
+    'nmod:agent': 'obl:agent',  # Agent should be obl not nmod
+    'nmod:with': 'nmod',  # Invalid subtype
+    'nmod:about': 'nmod',  # Invalid subtype -> nmod
+    'compound:number': 'nummod',  # Number compounds should be nummod
+    'compound:nmod': 'compound',  # Invalid subtype
+    'obl:pcomp': 'obl',  # Invalid subtype -> obl
+}
+
+
+def to_upos(tag, token=None):
+    """Convert Vietnamese POS tag to Universal POS tag."""
+    # Check if token is an auxiliary verb (case insensitive)
+    if token:
+        token_lower = token.lower()
+        if token_lower in AUX_WORDS:
+            return 'AUX'
+        # Also check if lowercased token matches
+        for aux in AUX_WORDS:
+            if token_lower == aux.lower():
+                return 'AUX'
+    return UPOS_MAP.get(tag, 'X')
+
+
+def fix_syntax_errors(tokens, upos, head, deprel):
+    """
+    Post-process to fix common UD SYNTAX validation errors.
+    Returns fixed (upos, deprel) lists.
+    Run multiple passes to handle dependencies between fixes.
+    """
+    n = len(tokens)
+    upos = list(upos)
+    deprel = list(deprel)
+    head = [int(h) for h in head]
+
+    # First pass: fix leaf nodes (aux/mark/case/punct should not have children)
+    # Need multiple passes to handle chains of leaf nodes
+    for _ in range(5):  # Multiple passes to handle chains
+        changed = False
+        for i in range(n):
+            rel = deprel[i]
+
+            # Leaf nodes should not have children - redirect children to parent
+            # Include subtypes like aux:pass, mark:pcomp, etc.
+            # Also include det, nummod, clf which should be leaves
+            if rel.split(':')[0] in ('aux', 'cop', 'mark', 'case', 'punct', 'det', 'nummod', 'clf'):
+                has_children = any(head[j] == i + 1 for j in range(n))
+                if has_children:
+                    my_head = head[i]
+                    for j in range(n):
+                        if head[j] == i + 1:
+                            head[j] = my_head
+                            changed = True
+        if not changed:
+            break
+
+    for i in range(n):
+        token_lower = tokens[i].lower()
+        rel = deprel[i]
+        pos = upos[i]
+
+        # Fix 0: Map invalid deprels to valid ones
+        if rel in DEPREL_MAP:
+            deprel[i] = DEPREL_MAP[rel]
+            rel = deprel[i]
+
+        # Fix 1: rel-upos-det - 'det' (including subtypes) should be DET or PRON
+        if rel.startswith('det') and pos not in ('DET', 'PRON'):
+            # Force all 'det' relations to have DET or PRON UPOS
+            upos[i] = 'DET'
+
+        # Fix 2: rel-upos-advmod - 'advmod' (including subtypes) should be ADV
+        if rel.startswith('advmod') and pos != 'ADV':
+            # For advmod, always prefer changing UPOS to ADV
+            upos[i] = 'ADV'
+
+        # Fix 2b: rel-upos-nummod - 'nummod' should be NUM
+        if rel.startswith('nummod') and upos[i] != 'NUM':
+            # If token is clearly not a number (e.g., VERB), change relation instead
+            if upos[i] == 'VERB':
+                deprel[i] = 'acl'  # Adjectival clause for verbs
+                rel = 'acl'  # Update local variable too
+            elif upos[i] == 'ADJ':
+                deprel[i] = 'amod'  # Adjectival modifier
+                rel = 'amod'
+            else:
+                upos[i] = 'NUM'
+
+        # Fix 3: rel-upos-mark - 'mark' (including subtypes) should not be AUX
+        if rel.startswith('mark') and pos == 'AUX':
+            upos[i] = 'SCONJ'
+
+        # Fix 3b: rel-upos-punct - 'punct' must be PUNCT, and PUNCT must have 'punct' deprel
+        if rel == 'punct' and pos != 'PUNCT':
+            # Change relation to something appropriate based on POS
+            if pos in ('VERB', 'NOUN', 'ADJ'):
+                deprel[i] = 'dep'  # Use generic dependency
+            else:
+                upos[i] = 'PUNCT'
+
+        # Fix 3b2: upos-rel-punct - PUNCT must have 'punct' deprel
+        if pos == 'PUNCT' and rel != 'punct':
+            deprel[i] = 'punct'
+            rel = 'punct'
+
+        # Fix 3c: rel-upos-case - 'case' should be ADP, not ADJ, AUX or PROPN
+        if rel == 'case' and pos in ('ADJ', 'AUX', 'PROPN', 'NOUN', 'VERB'):
+            upos[i] = 'ADP'
+
+        # Fix 3d: rel-upos-cc - 'cc' should be CCONJ or SCONJ
+        if rel == 'cc' and pos not in ('CCONJ', 'SCONJ'):
+            upos[i] = 'CCONJ'
+
+        # Fix 3e: rel-upos-aux - 'aux' should be AUX, but only for valid auxiliaries
+        is_valid_aux = token_lower in AUX_WORDS or any(token_lower == aux.lower() for aux in AUX_WORDS)
+        if rel.startswith('aux'):
+            if is_valid_aux:
+                upos[i] = 'AUX'
+                pos = 'AUX'
+            else:
+                # Not a valid auxiliary - change relation to advcl or xcomp
+                if pos == 'VERB' or upos[i] == 'VERB':
+                    deprel[i] = 'advcl'
+                    upos[i] = 'VERB'
+                elif pos == 'ADP' or upos[i] == 'ADP':
+                    deprel[i] = 'mark'
+                    upos[i] = 'ADP'
+                else:
+                    deprel[i] = 'xcomp'
+                rel = deprel[i]
+                pos = upos[i]
+        # Also fix AUX UPOS that's not a valid auxiliary (MORPHO aux-lemma)
+        elif pos == 'AUX' and not is_valid_aux:
+            upos[i] = 'VERB'  # Default to VERB for non-aux
+            pos = 'VERB'
+
+        # Fix 3f: rel-upos-cop - 'cop' should be AUX or PRON/DET, only 'là' is valid copula
+        if rel == 'cop':
+            if token_lower != 'là':
+                # Not a valid copula, change to xcomp
+                deprel[i] = 'xcomp'
+                rel = 'xcomp'
+            elif pos not in ('AUX', 'PRON', 'DET'):
+                upos[i] = 'AUX'
+
+        # Fix 4: obl-should-be-nmod - when parent is nominal, use nmod
+        if rel.startswith('obl') and head[i] > 0:
+            parent_idx = head[i] - 1
+            if parent_idx < n and upos[parent_idx] in ('NOUN', 'PROPN', 'PRON'):
+                # Preserve subtype if exists
+                if ':' in rel:
+                    deprel[i] = 'nmod:' + rel.split(':')[1]
+                else:
+                    deprel[i] = 'nmod'
+
+        # Fix 5: (handled in first pass above)
+
+    # Fix 5b: right-to-left relations - flat/conj/appos must be left-to-right
+    for i in range(n):
+        rel = deprel[i]
+        base_rel = rel.split(':')[0]
+        if base_rel in ('flat', 'conj', 'appos') and head[i] > 0:
+            parent_idx = head[i] - 1
+            if parent_idx > i:  # Parent comes after child (wrong direction)
+                # Change to compound which allows both directions
+                if ':' in rel:
+                    deprel[i] = 'compound:' + rel.split(':')[1]
+                else:
+                    deprel[i] = 'compound'
+
+    # Fix 5c: Apply DEPREL_MAP again to catch any newly created invalid deprels
+    for i in range(n):
+        if deprel[i] in DEPREL_MAP:
+            deprel[i] = DEPREL_MAP[deprel[i]]
+
+    # Fix 5d: Final check for nummod with wrong UPOS
+    for i in range(n):
+        if deprel[i].startswith('nummod') and upos[i] != 'NUM':
+            if upos[i] == 'VERB':
+                deprel[i] = 'acl'
+            elif upos[i] == 'ADJ':
+                deprel[i] = 'amod'
+            elif upos[i] == 'NOUN':
+                deprel[i] = 'nmod'
+            else:
+                upos[i] = 'NUM'
+
+    # Fix 6: too-many-subjects - add :outer subtype for multiple subjects
+    # Group all subject types (nsubj, csubj) by predicate
+    predicates = {}
+    for i in range(n):
+        base_rel = deprel[i].split(':')[0]
+        if base_rel in ('nsubj', 'csubj') and head[i] > 0:
+            pred_idx = head[i]
+            if pred_idx not in predicates:
+                predicates[pred_idx] = []
+            predicates[pred_idx].append((i, base_rel))
+
+    for pred_idx, subj_list in predicates.items():
+        if len(subj_list) > 1:
+            # Sort by position to keep first subject as main
+            subj_list.sort(key=lambda x: x[0])
+            # Mark all but the first as :outer (only nsubj:outer is valid, not csubj:outer)
+            for idx, base_rel in subj_list[1:]:
+                if ':outer' not in deprel[idx]:
+                    # csubj:outer is not a valid UD relation, use nsubj:outer instead
+                    deprel[idx] = 'nsubj:outer'
+
+    # Fix 7: too-many-objects - add :pass or compound for multiple objects
+    predicates_obj = {}
+    for i in range(n):
+        if deprel[i] == 'obj' and head[i] > 0:
+            pred_idx = head[i]
+            if pred_idx not in predicates_obj:
+                predicates_obj[pred_idx] = []
+            predicates_obj[pred_idx].append(i)
+
+    for pred_idx, obj_indices in predicates_obj.items():
+        if len(obj_indices) > 1:
+            # Mark subsequent objects as compound
+            for idx in obj_indices[1:]:
+                # Check if it's adjacent to previous - likely compound
+                if idx > 0 and obj_indices[0] == idx - 1:
+                    deprel[idx] = 'compound'
+                else:
+                    deprel[idx] = 'iobj'
+
+    # Fix 8: punct-is-nonproj - attach punctuation to avoid non-projectivity
+    # Try to find the best attachment point that doesn't cross other edges
+    for i in range(n):
+        if upos[i] == 'PUNCT':
+            # Try candidates in order: previous token, next token, then expand outward
+            candidates = []
+            if i > 0:
+                candidates.append(i)  # Previous token (1-based)
+            if i + 1 < n:
+                candidates.append(i + 2)  # Next token (1-based)
+
+            # Expand to find more candidates
+            for dist in range(2, n):
+                if i - dist >= 0:
+                    candidates.append(i - dist + 1)  # 1-based
+                if i + dist < n:
+                    candidates.append(i + dist + 1)  # 1-based
+
+            # Find best attachment that doesn't cause crossing
+            best_head = candidates[0] if candidates else 1
+            for cand in candidates:
+                test_head = list(head)
+                test_head[i] = cand
+                if not punct_causes_crossing(i, cand - 1, test_head, n):
+                    best_head = cand
+                    break
+
+            head[i] = best_head
+
+    return upos, [str(h) for h in head], deprel
+
+
+def punct_causes_crossing(punct_idx, new_head_idx, head, n):
+    """Check if attaching punct to new_head causes any edge crossing."""
+    if new_head_idx < 0 or new_head_idx >= n:
+        return False
+
+    p_low, p_high = min(punct_idx, new_head_idx), max(punct_idx, new_head_idx)
+
+    # Check all other edges for crossing with this punct edge
+    for j in range(n):
+        if j == punct_idx:
+            continue
+        if head[j] > 0 and head[j] != punct_idx + 1:  # j has a head and it's not punct
+            j_head = head[j] - 1
+            if j_head < 0 or j_head >= n:
+                continue
+            j_low, j_high = min(j, j_head), max(j, j_head)
+
+            # Check if edges cross (one endpoint inside, one outside)
+            # Edges cross if: (p_low < j_low < p_high < j_high) or (j_low < p_low < j_high < p_high)
+            if (p_low < j_low < p_high < j_high) or (j_low < p_low < j_high < p_high):
+                return True
+
+    return False
+
+
+def compute_space_after(text, tokens):
+    """Compute SpaceAfter=No for tokens based on original text."""
+    misc = []
+    pos = 0
+    for i, token in enumerate(tokens):
+        # Find token in text
+        token_start = text.find(token, pos)
+        if token_start == -1:
+            # Token not found, assume space after
+            misc.append("_")
+            continue
+
+        token_end = token_start + len(token)
+        pos = token_end
+
+        # Check if there's a space after this token
+        if token_end < len(text):
+            next_char = text[token_end]
+            if next_char in ' \t\n':
+                misc.append("_")
+            else:
+                misc.append("SpaceAfter=No")
+        else:
+            # End of text
+            misc.append("_")
+
+    return misc
+
+
+def load_sentences(filepath):
+    """Load sentences from sentences.txt"""
+    sentences = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                parts = line.split("\t", 1)
+                if len(parts) == 2:
+                    sentences.append(parts[1])
+    return sentences
+
+
+def convert_to_ud_format(sentences):
+    """Convert sentences to UD format using dependency_parse."""
+    data = []
+
+    for idx, text in enumerate(sentences, 1):
+        if idx % 100 == 0:
+            print(f"  Processing sentence {idx}/{len(sentences)}...")
+
+        sent_id = f"s{idx}"
+
+        try:
+            # Use dependency_parse for tokens, heads, and deprels
+            parsed = dependency_parse(text)
+            # parsed is list of (token, head, deprel)
+
+            tokens = [t[0] for t in parsed]
+            head = [str(t[1]) for t in parsed]
+            deprel = [t[2] for t in parsed]
+
+            # Get POS tags
+            tagged = pos_tag(text)
+            # Align POS tags with dependency tokens
+            if len(tagged) == len(tokens):
+                xpos = [t[1] for t in tagged]  # Original Vietnamese tags
+                upos = [to_upos(t[1], t[0]) for t in tagged]  # Universal tags with token
+            else:
+                # Fallback: use 'X' for unknown
+                xpos = ['X'] * len(tokens)
+                upos = ['X'] * len(tokens)
+
+        except Exception as e:
+            print(f"  Error parsing sentence {idx}: {e}")
+            # Fallback to pos_tag only
+            tagged = pos_tag(text)
+            tokens = [t[0] for t in tagged]
+            xpos = [t[1] for t in tagged]
+            upos = [to_upos(t[1], t[0]) for t in tagged]
+            head = ["0"] * len(tokens)
+            deprel = ["dep"] * len(tokens)
+            if len(tokens) > 0:
+                deprel[0] = "root"
+
+        # Apply syntax fixes
+        upos, head, deprel = fix_syntax_errors(tokens, upos, head, deprel)
+
+        # Create other fields
+        n = len(tokens)
+        lemmas = [t.lower() for t in tokens]  # Vietnamese: lemma = lowercase token
+        feats = ["_"] * n
+        deps = ["_"] * n
+        misc = compute_space_after(text, tokens)  # Compute SpaceAfter
+
+        row = {
+            "sent_id": sent_id,
+            "text": text,
+            "comments": [f"# sent_id = {sent_id}", f"# text = {text}"],
+            "tokens": tokens,
+            "lemmas": lemmas,
+            "upos": upos,
+            "xpos": xpos,
+            "feats": feats,
+            "head": head,
+            "deprel": deprel,
+            "deps": deps,
+            "misc": misc,
+            "mwt": [],
+            "empty_nodes": []
+        }
+        data.append(row)
+
+    return data
+
+
+def save_jsonl(data, filepath):
+    """Save data as JSONL format."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        for row in data:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def save_conllu(data, filepath):
+    """Save data as CoNLL-U format."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        for row in data:
+            f.write(f"# sent_id = {row['sent_id']}\n")
+            f.write(f"# text = {row['text']}\n")
+            for i in range(len(row['tokens'])):
+                # ID FORM LEMMA UPOS XPOS FEATS HEAD DEPREL DEPS MISC
+                line = "\t".join([
+                    str(i + 1),
+                    row['tokens'][i],
+                    row['lemmas'][i],
+                    row['upos'][i],
+                    row['xpos'][i],
+                    row['feats'][i],
+                    row['head'][i],
+                    row['deprel'][i],
+                    row['deps'][i],
+                    row['misc'][i]
+                ])
+                f.write(line + "\n")
+            f.write("\n")
+
+
+def main():
+    source_folder = expanduser("~/Downloads/UD_Vietnamese-UUD-v0.1")
+    sentences_file = join(source_folder, "sentences.txt")
+
+    print("Loading sentences...")
+    sentences = load_sentences(sentences_file)
+    print(f"Loaded {len(sentences)} sentences")
+
+    print("Converting to UD format...")
+    data = convert_to_ud_format(sentences)
+
+    # Save as JSONL (for HuggingFace)
+    jsonl_file = join(source_folder, "train.jsonl")
+    save_jsonl(data, jsonl_file)
+    print(f"Saved JSONL to: {jsonl_file}")
+
+    # Save as CoNLL-U (standard UD format)
+    conllu_file = join(source_folder, "train.conllu")
+    save_conllu(data, conllu_file)
+    print(f"Saved CoNLL-U to: {conllu_file}")
+
+    # Print sample
+    print("\nSample row:")
+    sample = data[0]
+    print(f"  sent_id: {sample['sent_id']}")
+    print(f"  text: {sample['text'][:60]}...")
+    print(f"  tokens: {sample['tokens'][:5]}...")
+    print(f"  upos: {sample['upos'][:5]}...")
+
+
+if __name__ == "__main__":
+    main()

scripts/fetch_data.py

@@ -0,0 +1,115 @@
+"""
+Fetch data from HuggingFace dataset undertheseanlp/UTS_VLC
+- Get documents from law dataset
+- Segment sentences using underthesea
+- Get first 3000 sentences
+"""
+
+import re
+from os.path import dirname, join
+
+from datasets import load_dataset
+
+from underthesea import sent_tokenize, text_normalize
+
+
+def clean_text(text):
+    """Remove markdown formatting and clean text."""
+    # Normalize Unicode using underthesea
+    text = text_normalize(text)
+    # Remove markdown headers
+    text = re.sub(r'^#+\s+', '', text, flags=re.MULTILINE)
+    # Remove bold/italic markers
+    text = re.sub(r'\*+', '', text)
+    # Remove horizontal rules
+    text = re.sub(r'^-+$', '', text, flags=re.MULTILINE)
+    # Remove links
+    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+    # Remove multiple newlines
+    text = re.sub(r'\n{2,}', '\n', text)
+    # Remove leading/trailing whitespace per line
+    lines = [line.strip() for line in text.split('\n')]
+    text = '\n'.join(lines)
+    return text
+
+
+def is_valid_sentence(sent):
+    """Check if sentence is valid for UD annotation."""
+    sent = sent.strip()
+    # Remove trailing list markers like "1." or "a)"
+    sent = re.sub(r'\n\d+\.$', '', sent)
+    sent = re.sub(r'\n[a-z]\)$', '', sent)
+    sent = sent.strip()
+
+    if not sent:
+        return False, sent
+    # Too short
+    if len(sent) < 20:
+        return False, sent
+    # Too long
+    if len(sent) > 300:
+        return False, sent
+    # Skip headers (all caps, or starts with "Điều", "Chương", etc.)
+    if re.match(r'^(QUỐC HỘI|CỘNG HÒA|Độc lập|Phần thứ|Chương [IVX]+|MỤC \d+)', sent):
+        return False, sent
+    # Skip article titles
+    if re.match(r'^(Điều \d+|Khoản \d+|Mục \d+)', sent):
+        return False, sent
+    # Skip if mostly uppercase
+    if sum(1 for c in sent if c.isupper()) > len(sent) * 0.5:
+        return False, sent
+    # Skip if starts with special markers
+    if sent.startswith(('English:', 'Số hiệu:', 'Ngày hiệu lực:', '---', '|')):
+        return False, sent
+    # Must contain Vietnamese characters
+    if not re.search(r'[àáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ]', sent, re.IGNORECASE):
+        return False, sent
+    # Skip if ends with just a number (incomplete sentence)
+    if re.search(r'\n\d+$', sent):
+        return False, sent
+    return True, sent
+
+
+def fetch_and_process():
+    # Load dataset from HuggingFace
+    print("Loading dataset from HuggingFace...")
+    ds = load_dataset("undertheseanlp/UTS_VLC", split="2026")
+
+    # Segment sentences from all documents until we have 3000
+    print("Segmenting sentences...")
+    all_sentences = []
+    for idx, doc in enumerate(ds):
+        content = doc["content"]
+        content = clean_text(content)
+        sentences = sent_tokenize(content)
+        for sent in sentences:
+            sent = sent.strip()
+            is_valid, cleaned_sent = is_valid_sentence(sent)
+            if is_valid:
+                all_sentences.append(cleaned_sent)
+        if len(all_sentences) >= 3000:
+            print(f"Processed {idx + 1} documents")
+            break
+
+    # Get first 3000 sentences
+    sentences_3000 = all_sentences[:3000]
+    print(f"Total sentences collected: {len(sentences_3000)}")
+
+    # Save to output file
+    output_dir = dirname(dirname(__file__))
+    output_file = join(output_dir, "sentences.txt")
+
+    with open(output_file, "w", encoding="utf-8") as f:
+        for i, sent in enumerate(sentences_3000, 1):
+            f.write(f"{i}\t{sent}\n")
+
+    print(f"Saved to: {output_file}")
+
+    # Print sample
+    print("\nSample sentences:")
+    for i, sent in enumerate(sentences_3000[:5], 1):
+        print(f"  {i}. {sent[:80]}...")
+
+
+if __name__ == "__main__":
+    fetch_and_process()

scripts/statistics.py

@@ -0,0 +1,182 @@
+"""
+Statistics for UD Vietnamese Dataset (UDD-v0.1)
+"""
+
+from collections import Counter
+from os.path import dirname, join
+
+
+def parse_conllu(filepath):
+    """Parse CoNLL-U file and return sentences."""
+    sentences = []
+    current_sentence = {
+        'tokens': [],
+        'upos': [],
+        'deprel': [],
+        'head': [],
+        'metadata': {}
+    }
+
+    with open(filepath, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                if current_sentence['tokens']:
+                    sentences.append(current_sentence)
+                    current_sentence = {
+                        'tokens': [],
+                        'upos': [],
+                        'deprel': [],
+                        'head': [],
+                        'metadata': {}
+                    }
+            elif line.startswith('#'):
+                # Metadata
+                if '=' in line:
+                    key, value = line[2:].split('=', 1)
+                    current_sentence['metadata'][key.strip()] = value.strip()
+            else:
+                parts = line.split('\t')
+                if len(parts) >= 10:
+                    # Skip multi-word tokens (e.g., 1-2)
+                    if '-' in parts[0] or '.' in parts[0]:
+                        continue
+                    current_sentence['tokens'].append(parts[1])
+                    current_sentence['upos'].append(parts[3])
+                    current_sentence['head'].append(parts[6])
+                    current_sentence['deprel'].append(parts[7])
+
+    # Add last sentence if exists
+    if current_sentence['tokens']:
+        sentences.append(current_sentence)
+
+    return sentences
+
+
+def compute_statistics(sentences):
+    """Compute statistics from parsed sentences."""
+    stats = {}
+
+    # Basic counts
+    stats['num_sentences'] = len(sentences)
+    stats['num_tokens'] = sum(len(s['tokens']) for s in sentences)
+
+    # Sentence length statistics
+    sent_lengths = [len(s['tokens']) for s in sentences]
+    stats['avg_sent_length'] = sum(sent_lengths) / len(sent_lengths) if sent_lengths else 0
+    stats['min_sent_length'] = min(sent_lengths) if sent_lengths else 0
+    stats['max_sent_length'] = max(sent_lengths) if sent_lengths else 0
+
+    # UPOS distribution
+    all_upos = []
+    for s in sentences:
+        all_upos.extend(s['upos'])
+    stats['upos_counts'] = Counter(all_upos)
+
+    # DEPREL distribution
+    all_deprel = []
+    for s in sentences:
+        all_deprel.extend(s['deprel'])
+    stats['deprel_counts'] = Counter(all_deprel)
+
+    # Tree depth statistics
+    depths = []
+    for s in sentences:
+        max_depth = compute_tree_depth(s['head'])
+        depths.append(max_depth)
+    stats['avg_tree_depth'] = sum(depths) / len(depths) if depths else 0
+    stats['max_tree_depth'] = max(depths) if depths else 0
+
+    # Root relation counts
+    root_upos = []
+    for s in sentences:
+        for i, (upos, deprel) in enumerate(zip(s['upos'], s['deprel'])):
+            if deprel == 'root':
+                root_upos.append(upos)
+    stats['root_upos_counts'] = Counter(root_upos)
+
+    return stats
+
+
+def compute_tree_depth(heads):
+    """Compute maximum depth of dependency tree."""
+    n = len(heads)
+    if n == 0:
+        return 0
+
+    depths = [0] * n
+
+    def get_depth(idx):
+        if depths[idx] > 0:
+            return depths[idx]
+        head = int(heads[idx])
+        if head == 0:
+            depths[idx] = 1
+        else:
+            depths[idx] = get_depth(head - 1) + 1
+        return depths[idx]
+
+    for i in range(n):
+        try:
+            get_depth(i)
+        except (RecursionError, IndexError):
+            depths[i] = 1
+
+    return max(depths) if depths else 0
+
+
+def print_statistics(stats):
+    """Print statistics in a nice format."""
+    print("=" * 60)
+    print("UD Vietnamese Dataset (UDD-v0.1) Statistics")
+    print("=" * 60)
+
+    print("\n## Basic Statistics")
+    print(f"  Sentences:         {stats['num_sentences']:,}")
+    print(f"  Tokens:            {stats['num_tokens']:,}")
+    print(f"  Avg sent length:   {stats['avg_sent_length']:.2f}")
+    print(f"  Min sent length:   {stats['min_sent_length']}")
+    print(f"  Max sent length:   {stats['max_sent_length']}")
+    print(f"  Avg tree depth:    {stats['avg_tree_depth']:.2f}")
+    print(f"  Max tree depth:    {stats['max_tree_depth']}")
+
+    print("\n## UPOS Distribution")
+    print(f"  {'Tag':<10} {'Count':>8} {'Percent':>8}")
+    print("  " + "-" * 28)
+    total_tokens = stats['num_tokens']
+    for tag, count in stats['upos_counts'].most_common():
+        pct = count / total_tokens * 100
+        print(f"  {tag:<10} {count:>8,} {pct:>7.2f}%")
+
+    print("\n## DEPREL Distribution")
+    print(f"  {'Relation':<20} {'Count':>8} {'Percent':>8}")
+    print("  " + "-" * 38)
+    for rel, count in stats['deprel_counts'].most_common():
+        pct = count / total_tokens * 100
+        print(f"  {rel:<20} {count:>8,} {pct:>7.2f}%")
+
+    print("\n## Root UPOS Distribution")
+    print(f"  {'UPOS':<10} {'Count':>8} {'Percent':>8}")
+    print("  " + "-" * 28)
+    total_roots = sum(stats['root_upos_counts'].values())
+    for tag, count in stats['root_upos_counts'].most_common():
+        pct = count / total_roots * 100
+        print(f"  {tag:<10} {count:>8,} {pct:>7.2f}%")
+
+    print("\n" + "=" * 60)
+
+
+def main():
+    # Find train.conllu file
+    base_dir = dirname(dirname(__file__))
+    conllu_file = join(base_dir, 'train.conllu')
+
+    print(f"Reading: {conllu_file}")
+    sentences = parse_conllu(conllu_file)
+
+    stats = compute_statistics(sentences)
+    print_statistics(stats)
+
+
+if __name__ == "__main__":
+    main()

scripts/upload_to_hf.py

@@ -0,0 +1,80 @@
+"""
+Upload UD dataset to HuggingFace Hub.
+Dataset: undertheseanlp/UDD-v0.1
+
+Usage:
+    export $(cat .env | xargs) && python upload_to_hf.py
+"""
+
+import json
+import os
+from os.path import expanduser, join
+
+from datasets import Dataset, DatasetDict
+from huggingface_hub import HfApi, login
+
+
+def load_jsonl(filepath):
+    """Load JSONL file."""
+    data = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            data.append(json.loads(line))
+    return data
+
+
+def main():
+    # Login with token from environment
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        print("Logging in with HF_TOKEN...")
+        login(token=token)
+    else:
+        print("Warning: HF_TOKEN not set. Using cached credentials.")
+
+    source_folder = expanduser("~/Downloads/UD_Vietnamese-UUD-v0.1")
+    jsonl_file = join(source_folder, "train.jsonl")
+    readme_file = join(source_folder, "README.md")
+
+    print("Loading data...")
+    data = load_jsonl(jsonl_file)
+    print(f"Loaded {len(data)} sentences")
+
+    # Create HuggingFace Dataset
+    print("Creating HuggingFace Dataset...")
+    dataset = Dataset.from_list(data)
+
+    # Create DatasetDict with train split
+    dataset_dict = DatasetDict({
+        "train": dataset
+    })
+
+    print(f"Dataset: {dataset_dict}")
+    print(f"Features: {dataset.features}")
+
+    # Push to HuggingFace Hub
+    repo_id = "undertheseanlp/UDD-v0.1"
+    print(f"\nPushing to HuggingFace Hub: {repo_id}")
+
+    dataset_dict.push_to_hub(
+        repo_id,
+        private=False,
+        commit_message="Update: 1000 sentences from Vietnamese Legal Corpus"
+    )
+
+    # Upload README.md
+    print("Uploading README.md...")
+    api = HfApi()
+    api.upload_file(
+        path_or_fileobj=readme_file,
+        path_in_repo="README.md",
+        repo_id=repo_id,
+        repo_type="dataset",
+        commit_message="Add README with dataset card"
+    )
+
+    print(f"\nDone! Dataset available at: https://huggingface.co/datasets/{repo_id}")
+
+
+if __name__ == "__main__":
+    main()

ud-tools/requirements.txt

@@ -0,0 +1,2 @@
+udapi>=0.5.0
+regex>=2020.09.27

ud-tools/udtools/LICENSE.txt

@@ -0,0 +1,339 @@
+GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {description}
+    Copyright (C) {year}  {fullname}
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  {signature of Ty Coon}, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

ud-tools/udtools/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include  tests  *.*

ud-tools/udtools/README.md

@@ -0,0 +1,249 @@
+# UD Tools
+
+This package contains Python tools for [Universal Dependencies](https://universaldependencies.org/):
+
+* The official UD/CoNLL-U validator
+* The official UD parsing scorer from the CoNLL (2017, 2018) and IWPT (2020, 2021) shared tasks
+
+## The official UD/CoNLL-U validator
+
+Reads a CoNLL-U file and verifies that it complies with the UD specification. For more details on UD validation, visit
+[the description](https://universaldependencies.org/contributing/validation.html) on the UD website.
+
+The most up-to-date version of the validator always resides in the master branch of the
+[tools](https://github.com/UniversalDependencies/tools) repository on GitHub. It is possible to run the script
+`validate.py` from your local copy of the repository even without installing the `udtools` package via pip.
+Nevertheless, you will need a few third-party modules the validator depends on. You can install them like this:
+`pip install -r requirements.txt`.
+
+If the root folder of the tools repository is in your system `PATH`, you do not have to be in that folder when
+launching the script:
+
+```
+cat la_proiel-ud-train.conllu | python validate.py --lang la --max-err=0
+```
+
+You can run `python validate.py --help` for a list of available options.
+
+### Invoking validation from your Python program
+
+To use the validator from your Python code, first install `udtools` (possibly after creating and activating a virtual
+environment). This should give you access to a fairly recent version of the validator but it will not necessarily be
+the authoritative version, as it may lack some modifications of the language-specific data.
+`pip install --upgrade udtools`
+
+```python
+from udtools import Validator
+
+validator = Validator(lang='la')
+state = validator.validate_files(['la_proiel-ud-train.conllu', 'la_proiel-ud-dev.conllu', 'la_proiel-ud-test.conllu'])
+print(state)
+```
+
+The state is an object with various pieces of information collected during the validation run. Its string
+representation is a summary of the warnings and errors found, as well as the string "*** PASSED ***" or
+"*** FAILED ***". You can also use the state in a boolean context (condition), where “passed” evaluates as `True` and
+“failed” as `False`. Note however that the default behavior of the validator is still to print errors and warnings to
+STDERR as soon as they are detected. To suppress printing, add `output=None` to the arguments when constructing the
+validator. (The default value of this argument is `sys.stderr`. You could also set it to `sys.stdout` or to a handle
+of a file open for writing.)
+
+```python
+from udtools import Validator
+
+validator = Validator(lang='la', output=None)
+state = validator.validate_files(['la_proiel-ud-train.conllu', 'la_proiel-ud-dev.conllu', 'la_proiel-ud-test.conllu'])
+if state:
+    print('Yay!')
+else:
+    print('Oh no ☹')
+```
+
+Alternatively, you could simulate supplying the `--quiet` option as if it came from the command line:
+
+```python
+import sys
+from udtools.argparser import parse_args_validator
+from udtools import Validator
+
+sys.argv = ['validate.py', '--lang=la', '--quiet']
+args = parse_args_validator()
+validator = Validator(lang='la', args=args)
+state = validator.validate_files(['la_proiel-ud-train.conllu', 'la_proiel-ud-dev.conllu', 'la_proiel-ud-test.conllu'])
+if state:
+    print('Yay!')
+else:
+    print('Oh no ☹')
+```
+
+Instead of printing the errors to STDERR as soon as they are found, you can have them saved in the validation state
+and later process them the way you prefer. Note that if you use the argparser approach from the previous example, the
+number of incidents saved (per category) is limited by default. This is to save your memory if you do not need to keep
+the errors (some treebanks have hundreds of thousands of errors and warnings). By setting `--max-store=0`, this limit
+is turned off. However, the default limit is set in the argparser, so if you use the simpler approach with
+`output=None` and you do not invoke the argparser for other reasons, no limit will be imposed.
+
+```python
+from udtools import Validator
+
+validator = Validator(lang='la', output=None)
+state = validator.validate_files(['la_proiel-ud-train.conllu', 'la_proiel-ud-dev.conllu', 'la_proiel-ud-test.conllu'])
+# Take only errors, skip warnings.
+all_errors = [x for x in state.error_tracker if x.is_error()]
+all_errors.sort(key=lambda incident: incident.testid)
+for error in all_errors:
+    print(error)
+```
+
+### Entry points
+
+The validator has several other entry points in addition to `validate_files()`:
+
+* `validate_file()` takes just one file name (path), reads that file and tests its validity. If the file name is '-',
+  it is interpreted as reading from STDIN. Note that `validate_files()` calls `validate_file()` for each file in turn,
+  then it also calls `validate_end()` to perform checks that can only be done after the whole treebank has been read.
+  If you call directly `validate_file()`, you should take care of calling `validate_end()` yourself.
+  * `validate_end()` takes just the state from the validation performed so far, and checks that the observations saved
+    in the state are not in conflict.
+* `validate_file_handle()` takes the object associated with an open file (or `sys.stdin`). Otherwise it is analogous
+  to `validate_file()` (and is in fact called from `validate_file()`).
+* `validate_sentence()` takes a list of CoNLL-U lines corresponding to one sentence, including the sentence-terminating
+  empty line. When called from `validate_file_handle()`, it will have at most one empty line and this will be the last
+  line in the list, as it is how the file reader detected the sentence end. However, the method is aware that other
+  callers could supply lists with empty lines in the middle, and it will report an error if this happens.
+
+All the `validate_*()` methods mentioned above return a `State` object. All of them can optionally take a `State` from
+previous runs as an argument (named `state`), in which case they will base their decisions on this state, and save
+their observations in it, too.
+
+The validator uses data files with specifications of feature values, lemmas of auxiliaries etc. for each language.
+These files change more often than the validator code itself, so it is likely that your pip-installed `udtools` does
+not have the most up-to-date version. Therefore, you may want to have a local copy of the tools repository, regularly
+update it by calling `git pull`, and tell the validator where to load the data files from (instead of its installation
+location):
+
+```python
+validator = Validator(lang='la', datapath='/my/copy/of/ud/tools/data')
+```
+
+### Printing incidents in JSON
+
+Instead of prose error messages suitable for human users, you can print the error descriptions in JSON so it can be
+easily read and processed by an external application.
+
+```python
+from udtools import Validator
+
+validator = Validator(lang='la', output=None)
+state = validator.validate_files(['la_proiel-ud-train.conllu', 'la_proiel-ud-dev.conllu', 'la_proiel-ud-test.conllu'])
+incidents = sorted(state.error_tracker, key=lambda incident: incident.testid)
+print('[')
+print(',\n'.join([incident.json() for incident in incidents]))
+print(']')
+```
+
+### Selecting only some tests
+
+UD defines several
+[levels of validity](https://universaldependencies.org/contributing/validation-rules.html#levels-of-validity)
+of CoNLL-U files. By default, validity on the highest level 5 is required; this is the level that UD treebanks must
+pass in order to be released as part of Universal Dependencies. It is possible to request a lower level of validity,
+for example, only the backbone file structure can be checked, omitting any linguistic checks of the annotation
+guidelines. When invoking `validate.py` from the command line, the numeric option `--level` (e.g., `--level 1`)
+tells the validator to skip tests on levels 2 and above. The same argument can be given directly to the constructor
+of the `Validator` class. The lowest level is not specific to individual languages, so we can give the generic
+language "ud" instead.
+
+```python
+validator = Validator(lang='ud', level=1)
+```
+
+One may want to filter the tests along various other dimensions: errors only (skipping warnings); selected test classes
+(FORMAT, MORPHO, SYNTAX, ENHANCED, METADATA etc.); individual test ids (e.g., `obl-should-be-nmod`). It is always
+possible to do what we showed above, i.e., collecting all incidents, then processing them and showing only the selected
+ones. However, this approach has its drawbacks: We waste time by running tests whose results we do not want to see;
+for large treebanks it is not practical to postpone showing first results until the whole treebank is processed; and
+it may be also quite heavy to keep all unnecessary incidents in memory.
+
+You may try to get around this by implementing your own alternative to `validate_sentence()` and call individual tests
+directly. There are some dangers though, which you should consider first:
+
+* The tests are not documented at present, so you have to consult the source code. The relevant functions are methods
+  of `Validator` and their names start with `check_` (as opposed to `validate_`, which signals the better documented
+  entry points). Note that one `check_` method may generate multiple different incident types, whose ids are not
+  reflected in the name of the method; and a few incidents can even occur outside any `check_` method (e.g., directly
+  in a `validate_` method).
+* The interface is far from stable. Names of methods may change at any time, as well as the types of incidents they
+  generate, the arguments they expect, their return values (if any) or side effects. Some checks only look at
+  individual cells in the CoNLL-U tabular format, others expect the fully built tree structure.
+* There are dependencies among the tests. Some `check_` methods can be run safely only if other `check_` methods have
+  been run previously and did not encounter errors.
+
+### Adding your own tests
+
+You may want to add language-specific consistency tests beyond what the official validator can do (e.g., ensuring that
+all personal pronouns have a non-empty value of the `Person` feature), or even treebank/project-specific tests (e.g.,
+all tokens should have a valid `Ref` attribute in MISC). One way of doing this would be to derive your own validator
+class based on `udtools.Validator`.
+
+```python
+from udtools import Validator
+from udtools.incident import TestClass, Error
+
+class MyValidator(Validator):
+
+    def validate_sentence(self, lines, state=None):
+        state = super().validate_sentence(lines, state)
+        self.check_my_own_stuff(state, lines)
+        return state
+
+    def check_my_own_stuff(self, state, lines):
+        for line in lines:
+            if re.match(r'40\t', line):
+                Error(
+                    state=state, config=self.incfg,
+                    level=1,
+                    testclass=TestClass.FORMAT,
+                    testid='id-40',
+                    message="Node ID 40 is not allowed in this treebank."
+                ).confirm()
+
+validator = MyValidator(lang='la')
+state = validator.validate_files(['la_proiel-ud-train.conllu', 'la_proiel-ud-dev.conllu', 'la_proiel-ud-test.conllu'])
+print(state)
+```
+
+
+
+## The official UD parsing scorer
+
+Reads two CoNLL-U files: gold standard (annotated manually) and system output (predicted by a parsing model). Both
+files must be valid at least at level 2, and their underlying text must be compatible, i.e., it can differ in
+whitespace but not in other characters. The scorer evaluates similarity of the system output to the gold standard
+by computing several metrics that were defined in the UD parsing shared tasks (CoNLL 2017 & 2018, IWPT 2020 & 2021).
+
+To load two files and evaluate their similarity without enhanced dependencies (i.e., in the style of the CoNLL shared
+tasks), you can do the following.
+
+```python
+from udtools.udeval import load_conllu_file, evaluate, build_evaluation_table
+
+gold_ud = load_conllu_file('gold.conllu')
+system_ud = load_conllu_file('system.conllu')
+evaluation = evaluate(gold_ud, system_ud)
+results = build_evaluation_table(evaluation, verbose=True)
+print(results)
+```
+
+To use the command line interface and arguments, you can use `parse_args_scorer()` as shown below. If you supply
+`--help` as the only argument, you will get the description of the options available.
+
+```python
+from udtools.argparser import parse_args_scorer
+from udtools.udeval import evaluate_wrapper, build_evaluation_table
+
+args = parse_args_scorer()
+evaluation = evaluate_wrapper(args)
+results = build_evaluation_table(evaluation, args.verbose, args.counts, args.enhanced)
+print(results)
+```

ud-tools/udtools/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "udtools"
+version = "0.2.7"
+authors = [
+  { name="Filip Ginter" },
+  { name="Sampo Pyysalo" },
+  { name="Daniel Zeman" },
+  { name="Milan Straka" },
+  { name="Martin Popel" },
+  { name="Gosse Bouma" },
+  { name="John Bauer" },
+  { name="Arianna Masciolini" },
+  { name="Ludovica Pannitto" },
+]
+maintainers = [
+  { name="Daniel Zeman", email="zeman@ufal.mff.cuni.cz" },
+]
+description = "Python tools for Universal Dependencies"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["udapi>=0.5.0", "regex>=2020.09.27"]
+classifiers = [
+  "Development Status :: 2 - Pre-Alpha",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+license = "GPL-2.0-or-later"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://universaldependencies.org/"
+Issues = "https://github.com/UniversalDependencies/tools/issues"
+
+[project.scripts]
+udvalidate = "udtools.cli:main"
+udeval = "udtools.cli:main_eval"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+udtools = ["data/*.json"]
+

ud-tools/udtools/src/udtools/__init__.py

@@ -0,0 +1,11 @@
+"""
+udtools.
+
+Python tools for Universal Dependencies.
+"""
+
+__version__ = "0.2.7"
+__author__ = 'Daniel Zeman'
+__credits__ = 'Universal Dependencies community'
+
+from .validator import Validator

ud-tools/udtools/src/udtools/argparser.py

@@ -0,0 +1,144 @@
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+import sys
+import argparse
+
+
+#==============================================================================
+# Argument processing for validate.py.
+#==============================================================================
+
+
+def build_argparse_validator():
+    opt_parser = argparse.ArgumentParser(description="CoNLL-U validation script. Python 3 is needed to run it!")
+
+    io_group = opt_parser.add_argument_group("Input / output options")
+    io_group.add_argument('-q', '--quiet',
+                          dest='quiet', action="store_true", default=False,
+                          help="""Do not print anything (errors, warnings, summary).
+                          Exit with 0 on pass, non-zero on fail.""")
+    io_group.add_argument('--no-warnings',
+                          dest='no_warnings', action='store_true', default=False,
+                          help="""Print only errors but no warnings.
+                          The final summary will still include the number of warnings, although they were not printed.""")
+    io_group.add_argument('-e', '--exclude',
+                          nargs='+',
+                          help="""One or more ids of tests whose incidents should not be printed.
+                          For example: --exclude missing-sent-id invalid-sent-id.
+                          The tests will still be performed and resulting incidents counted in the final summary.""")
+    io_group.add_argument('-i', '--include-only',
+                          nargs='+',
+                          help="""One or more ids of tests whose incidents should be printed.
+                          For example: --include-only missing-sent-id invalid-sent-id.
+                          Any other incidents will not be printed.
+                          The tests will still be performed and resulting incidents counted in the final summary.""")
+    io_group.add_argument('--max-err',
+                          action='store', type=int, default=20,
+                          help="""How many incidents to print per test class? 0 for all.
+                          Default: %(default)d.""")
+    io_group.add_argument('input',
+                          nargs='*',
+                          help="""Input file name(s), or "-" or nothing for standard input.""")
+
+    test_group = opt_parser.add_argument_group("Test configuration options")
+    test_group.add_argument('--lang',
+                            action='store', required=True, default=None,
+                            help="""Which langauge are we checking (ISO 639 code)?
+                            Determines the language-specific lists of features,
+                            auxiliaries, relation subtypes etc. This is a required
+                            argument. Use "ud" as the value if you only want to
+                            test the universal part of the UD guidelines.""")
+    test_group.add_argument('--level',
+                            action='store', type=int, default=5, dest="level",
+                            help="""Level 1: Test only CoNLL-U backbone.
+                            Level 2: UD format.
+                            Level 3: UD contents.
+                            Level 4: Language-specific labels.
+                            Level 5 (default): Language-specific contents.""")
+    test_group.add_argument('--coref',
+                            action='store_true', default=False, dest='check_coref',
+                            help='Test coreference and entity-related annotation in MISC.')
+    return opt_parser
+
+
+
+def parse_args_validator(args=None):
+    """
+    Creates an instance of the ArgumentParser and parses the command line
+    arguments.
+
+    Parameters
+    ----------
+    args : list of strings, optional
+        If not supplied, the argument parser will read sys.args instead.
+        Otherwise the caller can supply list such as ['--lang', 'en'].
+
+    Returns
+    -------
+    args : argparse.Namespace
+        Values of individual arguments can be accessed as object properties
+        (using the dot notation). It is possible to convert it to a dict by
+        calling vars(args).
+    """
+    opt_parser = build_argparse_validator()
+    args = opt_parser.parse_args(args=args)
+    # Level of validation.
+    if args.level < 1:
+        print(f'Option --level must not be less than 1; changing from {args.level} to 1',
+              file=sys.stderr)
+        args.level = 1
+    # No language-specific tests for levels 1-3.
+    # Anyways, any Feature=Value pair should be allowed at level 3 (because it may be language-specific),
+    # and any word form or lemma can contain spaces (because language-specific guidelines may allow it).
+    # We can also test language 'ud' on level 4; then it will require that no language-specific features are present.
+    if args.level < 4:
+        args.lang = 'ud'
+    if args.input == []:
+        args.input.append('-')
+    return args
+
+
+#==============================================================================
+# Argument processing for eval.py.
+#==============================================================================
+
+
+
+def parse_args_scorer(args=None):
+    """
+    Creates an instance of the ArgumentParser and parses the command line
+    arguments.
+
+    Parameters
+    ----------
+    args : list of strings, optional
+        If not supplied, the argument parser will read sys.args instead.
+        Otherwise the caller can supply list such as ['--lang', 'en'].
+
+    Returns
+    -------
+    args : argparse.Namespace
+        Values of individual arguments can be accessed as object properties
+        (using the dot notation). It is possible to convert it to a dict by
+        calling vars(args).
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument('gold_file', type=str,
+                        help='Name of the CoNLL-U file with the gold data.')
+    parser.add_argument('system_file', type=str,
+                        help='Name of the CoNLL-U file with the predicted data.')
+    parser.add_argument('--verbose', '-v', default=False, action='store_true',
+                        help='Print all metrics.')
+    parser.add_argument('--counts', '-c', default=False, action='store_true',
+                        help='Print raw counts of correct/gold/system/aligned words instead of precision/recall/F1 for all metrics.')
+    parser.add_argument('--no-enhanced', dest='enhanced', action='store_false', default=True,
+                        help='Turn off evaluation of enhanced dependencies.')
+    parser.add_argument('--enhancements', type=str, default='0',
+                        help='Level of enhancements in the gold data (see guidelines) 0=all (default), 1=no gapping, 2=no shared parents, 3=no shared dependents 4=no control, 5=no external arguments, 6=no lemma info, combinations: 12=both 1 and 2 apply, etc.')
+    parser.add_argument('--no-empty-nodes', default=False,
+                        help='Empty nodes have been collapsed (needed to correctly evaluate enhanced/gapping). Raise exception if an empty node is encountered.')
+    parser.add_argument('--multiple-roots-okay', default=False, action='store_true',
+                        help='A single sentence can have multiple nodes with HEAD=0.')
+    args = parser.parse_args(args=args)
+    return args

ud-tools/udtools/src/udtools/cli.py

@@ -0,0 +1,49 @@
+#! /usr/bin/env python3
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+# 2025-08-31: Refactoring by @AngledLuffa
+# 2025-09: Refactoring by @harisont and @ellepannitto
+import sys
+from udtools.argparser import parse_args_validator, parse_args_scorer
+from udtools.validator import Validator
+from udtools.udeval import evaluate_wrapper, build_evaluation_table
+
+
+
+#==============================================================================
+# The main function.
+#==============================================================================
+
+
+
+def main():
+    args = parse_args_validator()
+    validator = Validator(lang=args.lang, level=args.level, max_store=10, args=args)
+    state = validator.validate_files(args.input)
+    # Summarize the warnings and errors.
+    summary = str(state)
+    if not args.quiet:
+        print(summary, file=sys.stderr)
+    if state.passed():
+        return 0
+    else:
+        return 1
+
+
+
+def main_eval():
+    # Parse arguments
+    args = parse_args_scorer()
+
+    # Evaluate
+    evaluation = evaluate_wrapper(args)
+    results = build_evaluation_table(evaluation, args.verbose, args.counts, args.enhanced)
+    print(results)
+    return 0
+
+
+
+if __name__=="__main__":
+    errcode = main()
+    sys.exit(errcode)

ud-tools/udtools/src/udtools/data.py

@@ -0,0 +1,403 @@
+import os.path
+# According to https://stackoverflow.com/questions/1832893/python-regex-matching-unicode-properties,
+# the regex module has the same API as re but it can check Unicode character properties using \p{}
+# as in Perl.
+#import re
+import regex as re
+import json
+
+
+
+class Data:
+    """
+    The Data class holds various dictionaries of tags, auxiliaries, regular
+    expressions etc. needed for detailed testing, especially for language-
+    specific constraints.
+    """
+    def __init__(self, datapath=None):
+        if datapath:
+            self.datapath = datapath
+        else:
+            # The folder where this module resides.
+            THISDIR = os.path.dirname(os.path.realpath(os.path.abspath(__file__)))
+            # If this module was imported directly from the root folder of the
+            # tools repository, the data folder should be a first-level subfolder
+            # there. Otherwise, the module is taken from installed udtools and
+            # the data is a subfolder here.
+            self.datapath = os.path.join(THISDIR, '..', '..', '..', 'data')
+            if not os.path.exists(self.datapath):
+                self.datapath = os.path.join(THISDIR, 'data')
+        # Universal part of speech tags in the UPOS column. Just a set.
+        # For consistency, they are also read from a file. But these tags do
+        # not change, so they could be even hard-coded here.
+        self.upos = set()
+        # Morphological features in the FEATS column.
+        # Key: language code; value: feature-value-UPOS data from feats.json.
+        self.feats = {}
+        # Universal dependency relation types (without subtypes) in the DEPREL
+        # column. For consistency, they are also read from a file. but these
+        # labels do not change, so they could be even hard-coded here.
+        self.udeprel = set()
+        # Dependency relation types in the DEPREL column.
+        # Key: language code; value: deprel data from deprels.json.
+        # Cached processed version: key: language code; value: set of deprels.
+        self.deprel = {}
+        self.cached_deprel_for_language = {}
+        # Enhanced dependency relation types in the DEPS column.
+        # Key: language code; value: edeprel data from edeprels.json.
+        # Cached processed version: key: language code; value: set of edeprels.
+        self.edeprel = {}
+        self.cached_edeprel_for_language = {}
+        # Auxiliary (and copula) lemmas in the LEMMA column.
+        # Key: language code; value: auxiliary/copula data from data.json.
+        # Cached processed versions: key: language code; value: list of lemmas.
+        self.auxcop = {}
+        self.cached_aux_for_language = {}
+        self.cached_cop_for_language = {}
+        # Tokens with spaces in the FORM and LEMMA columns.
+        # Key: language code; value: data from tospace.json.
+        self.tospace = {}
+        # Load language-specific data from external JSON files.
+        self.load()
+        # For each of the language-specific lists, we can generate an
+        # explanation for the user in case they use something that is not on
+        # the list. The explanation will be printed only once but the explain
+        # function may be called thousand times, so let us cache the output to
+        # reduce the time waste a little.
+        self._explanation_feats = {}
+        self._explanation_deprel = {}
+        self._explanation_edeprel = {}
+        self._explanation_aux = {}
+        self._explanation_cop = {}
+        self._explanation_tospace = {}
+
+    def get_feats_for_language(self, lcode):
+        """
+        Searches the previously loaded database of feature-value-UPOS combinations.
+        Returns the data for a given language code, organized in dictionaries.
+        Returns an empty dict if there are no data for the given language code.
+        """
+        ###!!! If lcode is 'ud', we should permit all universal feature-value pairs,
+        ###!!! regardless of language-specific documentation.
+        # Do not crash if the user asks for an unknown language.
+        if not lcode in self.feats:
+            return {}
+        return self.feats[lcode]
+
+    def get_deprel_for_language(self, lcode):
+        """
+        Searches the previously loaded database of dependency relation labels.
+        Returns the set of permitted deprels for a given language code. Also
+        saves the result in self so that next time it can be fetched quickly
+        (once we loaded the data, we do not expect them to change).
+        """
+        if lcode in self.cached_deprel_for_language:
+            return self.cached_deprel_for_language[lcode]
+        deprelset = set()
+        # If lcode is 'ud', we should permit all universal dependency relations,
+        # regardless of language-specific documentation.
+        if lcode == 'ud':
+            deprelset = self.udeprel
+        elif lcode in self.deprel:
+            for r in self.deprel[lcode]:
+                if self.deprel[lcode][r]['permitted'] > 0:
+                    deprelset.add(r)
+        self.cached_deprel_for_language[lcode] = deprelset
+        return deprelset
+
+    def get_edeprel_for_language(self, lcode):
+        """
+        Searches the previously loaded database of enhanced case markers.
+        Returns the set of permitted edeprels for a given language code. Also
+        saves the result in self so that next time it can be fetched quickly
+        (once we loaded the data, we do not expect them to change).
+        """
+        if lcode in self.cached_edeprel_for_language:
+            return self.cached_edeprel_for_language[lcode]
+        basic_deprels = self.get_deprel_for_language(lcode)
+        edeprelset = basic_deprels | {'ref'}
+        for bdeprel in basic_deprels:
+            if re.match(r"^[nc]subj(:|$)", bdeprel):
+                edeprelset.add(bdeprel+':xsubj')
+        if lcode in self.edeprel:
+            for c in self.edeprel[lcode]:
+                for deprel in self.edeprel[lcode][c]['extends']:
+                    for bdeprel in basic_deprels:
+                        if bdeprel == deprel or re.match(r"^"+deprel+':', bdeprel):
+                            edeprelset.add(bdeprel+':'+c)
+        self.cached_edeprel_for_language[lcode] = edeprelset
+        return edeprelset
+
+    def get_auxcop_for_language(self, lcode):
+        """
+        Searches the previously loaded database of auxiliary/copula lemmas.
+        Returns the AUX and COP lists for a given language code. Also saves
+        the result in self so that next time it can be fetched quickly (once
+        we loaded the data, we do not expect them to change).
+        """
+        if lcode in self.cached_aux_for_language and lcode in self.cached_cop_for_language:
+            return self.cached_aux_for_language[lcode], self.cached_cop_for_language[lcode]
+        # If any of the functions of the lemma is other than cop.PRON, it counts as an auxiliary.
+        # If any of the functions of the lemma is cop.*, it counts as a copula.
+        auxlist = []
+        coplist = []
+        lemmalist = self.auxcop.get(lcode, {}).keys()
+        auxlist = [x for x in lemmalist
+                   if len([y for y in self.auxcop[lcode][x]['functions']
+                    if y['function'] != 'cop.PRON']) > 0]
+        coplist = [x for x in lemmalist
+                   if len([y for y in self.auxcop[lcode][x]['functions']
+                    if re.match(r"^cop\.", y['function'])]) > 0]
+        self.cached_aux_for_language[lcode] = auxlist
+        self.cached_cop_for_language[lcode] = coplist
+        return auxlist, coplist
+
+    def get_aux_for_language(self, lcode):
+        """
+        An entry point for get_auxcop_for_language() that returns only the aux
+        list. It either takes the cached list (if available), or calls
+        get_auxcop_for_language().
+        """
+        if lcode in self.cached_aux_for_language:
+            return self.cached_aux_for_language[lcode]
+        auxlist, coplist = self.get_auxcop_for_language(lcode)
+        return auxlist
+
+    def get_cop_for_language(self, lcode):
+        """
+        An entry point for get_auxcop_for_language() that returns only the cop
+        list. It either takes the cached list (if available), or calls
+        get_auxcop_for_language().
+        """
+        if lcode in self.cached_cop_for_language:
+            return self.cached_cop_for_language[lcode]
+        auxlist, coplist = self.get_auxcop_for_language(lcode)
+        return coplist
+
+    def get_tospace_for_language(self, lcode):
+        """
+        Searches the previously loaded database of regular expressions describing
+        permitted tokens with spaces. Returns the expressions for a given language code.
+        """
+        # Do not crash if the user asks for an unknown language.
+        if not lcode in self.tospace:
+            return None
+        return self.tospace[lcode]
+
+    def explain_feats(self, lcode):
+        """
+        Returns explanation message for features of a particular language.
+        To be called after language-specific features have been loaded.
+        """
+        if lcode in self._explanation_feats:
+            return self._explanation_feats[lcode]
+        featset = self.get_feats_for_language(lcode)
+        # Prepare a global message about permitted features and values. We will add
+        # it to the first error message about an unknown feature. Note that this
+        # global information pertains to the default validation language and it
+        # should not be used with code-switched segments in alternative languages.
+        msg = ''
+        if not lcode in self.feats:
+            msg += f"No feature-value pairs have been permitted for language [{lcode}].\n"
+            msg += "They can be permitted at the address below (if the language has an ISO code and is registered with UD):\n"
+            msg += "https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_feature.pl\n"
+        else:
+            # Identify feature values that are permitted in the current language.
+            for f in featset:
+                for e in featset[f]['errors']:
+                    msg += f"ERROR in _{lcode}/feat/{f}.md: {e}\n"
+            res = set()
+            for f in featset:
+                if featset[f]['permitted'] > 0:
+                    for v in featset[f]['uvalues']:
+                        res.add(f+'='+v)
+                    for v in featset[f]['lvalues']:
+                        res.add(f+'='+v)
+            sorted_documented_features = sorted(res)
+            msg += f"The following {len(sorted_documented_features)} feature values are currently permitted in language [{lcode}]:\n"
+            msg += ', '.join(sorted_documented_features) + "\n"
+            msg += "If a language needs a feature that is not documented in the universal guidelines, the feature must\n"
+            msg += "have a language-specific documentation page in a prescribed format.\n"
+            msg += "See https://universaldependencies.org/contributing_language_specific.html for further guidelines.\n"
+            msg += "All features including universal must be specifically turned on for each language in which they are used.\n"
+            msg += "See https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_feature.pl for details.\n"
+        self._explanation_feats[lcode] = msg
+        return msg
+
+    def explain_deprel(self, lcode):
+        """
+        Returns explanation message for deprels of a particular language.
+        To be called after language-specific deprels have been loaded.
+        """
+        if lcode in self._explanation_deprel:
+            return self._explanation_deprel[lcode]
+        deprelset = self.get_deprel_for_language(lcode)
+        # Prepare a global message about permitted relation labels. We will add
+        # it to the first error message about an unknown relation. Note that this
+        # global information pertains to the default validation language and it
+        # should not be used with code-switched segments in alternative languages.
+        msg = ''
+        if len(deprelset) == 0:
+            msg += f"No dependency relation types have been permitted for language [{lcode}].\n"
+            msg += "They can be permitted at the address below (if the language has an ISO code and is registered with UD):\n"
+            msg += "https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_deprel.pl\n"
+        else:
+            # Identify dependency relations that are permitted in the current language.
+            # If there are errors in documentation, identify the erroneous doc file.
+            # Note that data.deprel[lcode] may not exist even though we have a non-empty
+            # set of relations, if lcode is 'ud'.
+            if lcode in self.deprel:
+                for r in self.deprel[lcode]:
+                    file = re.sub(r':', r'-', r)
+                    if file == 'aux':
+                        file = 'aux_'
+                    for e in self.deprel[lcode][r]['errors']:
+                        msg += f"ERROR in _{lcode}/dep/{file}.md: {e}\n"
+            sorted_documented_relations = sorted(deprelset)
+            msg += f"The following {len(sorted_documented_relations)} relations are currently permitted in language [{lcode}]:\n"
+            msg += ', '.join(sorted_documented_relations) + "\n"
+            msg += "If a language needs a relation subtype that is not documented in the universal guidelines, the relation\n"
+            msg += "must have a language-specific documentation page in a prescribed format.\n"
+            msg += "See https://universaldependencies.org/contributing_language_specific.html for further guidelines.\n"
+            msg += "Documented dependency relations can be specifically turned on/off for each language in which they are used.\n"
+            msg += "See https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_deprel.pl for details.\n"
+        self._explanation_deprel[lcode] = msg
+        return msg
+
+    def explain_edeprel(self, lcode):
+        """
+        Returns explanation message for edeprels of a particular language.
+        To be called after language-specific edeprels have been loaded.
+        """
+        if lcode in self._explanation_edeprel:
+            return self._explanation_edeprel[lcode]
+        edeprelset = self.get_edeprel_for_language(lcode)
+        # Prepare a global message about permitted relation labels. We will add
+        # it to the first error message about an unknown relation. Note that this
+        # global information pertains to the default validation language and it
+        # should not be used with code-switched segments in alternative languages.
+        msg = ''
+        if len(edeprelset) == 0:
+            msg += f"No enhanced dependency relation types (case markers) have been permitted for language [{lcode}].\n"
+            msg += "They can be permitted at the address below (if the language has an ISO code and is registered with UD):\n"
+            msg += "https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_edeprel.pl\n"
+        else:
+            # Identify dependency relations that are permitted in the current language.
+            # If there are errors in documentation, identify the erroneous doc file.
+            # Note that data.deprel[lcode] may not exist even though we have a non-empty
+            # set of relations, if lcode is 'ud'.
+            sorted_case_markers = sorted(edeprelset)
+            msg += f"The following {len(sorted_case_markers)} enhanced relations are currently permitted in language [{lcode}]:\n"
+            msg += ', '.join(sorted_case_markers) + "\n"
+            msg += "See https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_edeprel.pl for details.\n"
+        self._explanation_deprel[lcode] = msg
+        return msg
+
+    def explain_aux(self, lcode):
+        """
+        Returns explanation message for auxiliaries of a particular language.
+        To be called after language-specific auxiliaries have been loaded.
+        """
+        if lcode in self._explanation_aux:
+            return self._explanation_aux[lcode]
+        auxdata = self.get_aux_for_language(lcode)
+        # Prepare a global message about permitted auxiliary lemmas. We will add
+        # it to the first error message about an unknown auxiliary. Note that this
+        # global information pertains to the default validation language and it
+        # should not be used with code-switched segments in alternative languages.
+        msg = ''
+        if len(auxdata) == 0:
+            msg += f"No auxiliaries have been documented at the address below for language [{lcode}].\n"
+            msg += f"https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_auxiliary.pl?lcode={lcode}\n"
+        else:
+            # Identify auxiliaries that are permitted in the current language.
+            msg += f"The following {len(auxdata)} auxiliaries are currently documented in language [{lcode}]:\n"
+            msg += ', '.join(auxdata) + "\n"
+            msg += f"See https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_auxiliary.pl?lcode={lcode} for details.\n"
+        self._explanation_aux[lcode] = msg
+        return msg
+
+    def explain_cop(self, lcode):
+        """
+        Returns explanation message for copulas of a particular language.
+        To be called after language-specific copulas have been loaded.
+        """
+        if lcode in self._explanation_cop:
+            return self._explanation_cop[lcode]
+        copdata = self.get_cop_for_language(lcode)
+        # Prepare a global message about permitted copula lemmas. We will add
+        # it to the first error message about an unknown copula. Note that this
+        # global information pertains to the default validation language and it
+        # should not be used with code-switched segments in alternative languages.
+        msg = ''
+        if len(copdata) == 0:
+            msg += f"No copulas have been documented at the address below for language [{lcode}].\n"
+            msg += f"https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_auxiliary.pl?lcode={lcode}\n"
+        else:
+            # Identify auxiliaries that are permitted in the current language.
+            msg += f"The following {len(copdata)} copulas are currently documented in language [{lcode}]:\n"
+            msg += ', '.join(copdata) + "\n"
+            msg += f"See https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_auxiliary.pl?lcode={lcode} for details.\n"
+        self._explanation_cop[lcode] = msg
+        return msg
+
+    def explain_tospace(self, lcode):
+        """
+        Returns explanation message for tokens with spaces of a particular language.
+        To be called after language-specific tokens with spaces have been loaded.
+        """
+        if lcode in self._explanation_tospace:
+            return self._explanation_tospace[lcode]
+        # Prepare a global message about permitted features and values. We will add
+        # it to the first error message about an unknown token with space. Note that
+        # this global information pertains to the default validation language and it
+        # should not be used with code-switched segments in alternative languages.
+        msg = ''
+        if not lcode in self.tospace:
+            msg += f"No tokens with spaces have been permitted for language [{lcode}].\n"
+            msg += "They can be permitted at the address below (if the language has an ISO code and is registered with UD):\n"
+            msg += "https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_token_with_space.pl\n"
+        else:
+            msg += f"Only tokens and lemmas matching the following regular expression are currently permitted to contain spaces in language [{lcode}]:\n"
+            msg += self.tospace[lcode][0]
+            msg += "\nOthers can be permitted at the address below (if the language has an ISO code and is registered with UD):\n"
+            msg += "https://quest.ms.mff.cuni.cz/udvalidator/cgi-bin/unidep/langspec/specify_token_with_space.pl\n"
+        self._explanation_tospace[lcode] = msg
+        return msg
+
+    def load(self):
+        """
+        Loads the external validation data such as permitted feature-value
+        combinations, and stores them in self. The source JSON files are
+        supposed to be in the data subfolder of the folder where the script
+        lives.
+        """
+        with open(os.path.join(self.datapath, 'upos.json'), 'r', encoding='utf-8') as f:
+            contents = json.load(f)
+        upos_list = contents['upos']
+        self.upos = set(upos_list)
+        with open(os.path.join(self.datapath, 'feats.json'), 'r', encoding='utf-8') as f:
+            contents = json.load(f)
+        self.feats = contents['features']
+        with open(os.path.join(self.datapath, 'udeprels.json'), 'r', encoding='utf-8') as f:
+            contents = json.load(f)
+        udeprel_list = contents['udeprels']
+        self.udeprel = set(udeprel_list)
+        with open(os.path.join(self.datapath, 'deprels.json'), 'r', encoding='utf-8') as f:
+            contents = json.load(f)
+        self.deprel = contents['deprels']
+        with open(os.path.join(self.datapath, 'edeprels.json'), 'r', encoding='utf-8') as f:
+            contents = json.load(f)
+        self.edeprel = contents['edeprels']
+        with open(os.path.join(self.datapath, 'data.json'), 'r', encoding='utf-8') as f:
+            contents = json.load(f)
+        self.auxcop = contents['auxiliaries']
+        with open(os.path.join(self.datapath, 'tospace.json'), 'r', encoding='utf-8') as f:
+            contents = json.load(f)
+        # There is one or more regular expressions for each language in the file.
+        # If there are multiple expressions, combine them in one and compile it.
+        self.tospace = {}
+        for l in contents['expressions']:
+            combination = '('+'|'.join(sorted(list(contents['expressions'][l])))+')'
+            compilation = re.compile(combination)
+            self.tospace[l] = (combination, compilation)

ud-tools/udtools/src/udtools/incident.py

@@ -0,0 +1,240 @@
+from dataclasses import dataclass
+from enum import Enum
+from json import JSONEncoder
+
+jenc = JSONEncoder()
+
+
+
+class TestClass(Enum):
+    INTERNAL = 0
+    UNICODE = 1
+    FORMAT = 2
+    MORPHO = 3
+    SYNTAX = 4
+    ENHANCED = 5
+    COREF = 6
+    METADATA = 7
+
+    def __str__(self):
+        return self.name
+
+    def __lt__(self, other):
+        return self.value < other.value
+
+
+
+class IncidentType(Enum):
+    ERROR = 1
+    WARNING = 0
+
+    def __str__(self):
+        return self.name
+
+    def __lt__(self, other):
+        return self.value < other.value
+
+
+
+@dataclass(order=True)
+class Reference:
+    """
+    Points to a position in the source file. Each incident (error or warning)
+    has always a main anchor (reference) that is reported with the error.
+    However, some errors may also relate to additional positions in the file,
+    which can be then given as a list of Reference objects. As a minimum,
+    a reference indicates the line number. If there were multiple input files,
+    it should also indicate the file name, as line numbers reset when new file
+    starts. Optionally, references can also indicate the sentence and node ids
+    (if pointing to a node) to facilitate locating the target. Finally, the
+    reference can include a comment which explain its relation to the incident.
+    """
+    filename: str
+    lineno: int
+    sentid: str = ''
+    nodeid: str = ''
+    comment: str = ''
+
+    def json(self):
+        """
+        Returns the reference description in JSON format so it can be passed to
+        external applications easily.
+        """
+        jsonlist = []
+        jsonlist.append(f'"filename": {jenc.encode(str(self.filename))}')
+        jsonlist.append(f'"lineno": "{str(self.lineno)}"')
+        jsonlist.append(f'"sentid": {jenc.encode(str(self.sentid))}')
+        jsonlist.append(f'"nodeid": "{str(self.nodeid)}"')
+        jsonlist.append(f'"comment": {jenc.encode(self.comment)}')
+        return '{' + ', '.join(jsonlist) + '}'
+
+
+
+class Incident:
+    """
+    Instances of this class describe individual errors or warnings in the input
+    file.
+    """
+    # We can modify the class-level defaults before a batch of similar tests.
+    # Then we do not have to repeat the shared parameters for each test.
+    default_level = 1
+    default_testclass = TestClass.FORMAT
+    default_testid = 'generic-error'
+    default_message = 'No error description provided.'
+    default_lineno = None
+    def __init__(self, state, config, level=None, testclass=None, testid=None, message=None, lineno=None, nodeid=None, explanation='', references=[]):
+        self.state = state
+        self.config = config
+
+        # Validation level to which the incident belongs. Integer 1-5.
+        self.level = self.default_level if level == None else level
+        # Thematic area to which the incident belongs: Format, Meta, Morpho,
+        # Syntax, Enhanced, Coref, Warning.
+        self.testclass = self.default_testclass if testclass == None else testclass
+        # Identifier of the test that lead to the incident. Short string.
+        self.testid = self.default_testid if testid == None else testid
+        # Verbose description of the error for the user. It does not have to be
+        # identical for all errors with the same testid because it can contain
+        # instance-specific data (e.g. the word form).
+        self.message = self.default_message if message == None else message
+        # Additional more verbose information. To be printed with the first
+        # incident of a given type.
+        self.explanation = explanation
+        # File name. The default is the file from which we are reading right
+        # now ('-' if reading from STDIN).
+        self.filename = state.get_current_file_name()
+        # Line number. The default is the most recently read line as recorded
+        # in the state; but in most cases we need to get the number
+        # during instantiation, as the most recently read line is the last line
+        # of the sentence, and the error was found on one of the words of the
+        # sentence.
+        self.lineno = lineno if lineno != None else self.default_lineno if self.default_lineno != None else state.current_line
+        if self.lineno < 0:
+            self.lineno = state.sentence_line
+        # Current (most recently read) sentence id.
+        self.sentid = state.sentence_id
+        # ID of the node on which the error occurred (if it pertains to one node).
+        self.nodeid = nodeid
+        # Additional references to nodes or other input lines, if needed.
+        # List of Reference objects. Note that the main anchor is not included
+        # in the list; it is described directly in filename, lineno, sentid and
+        # nodeid parameters.
+        self.references = references
+
+    def json(self):
+        """
+        Returns the incident description in JSON format so it can be passed to
+        external applications easily.
+        """
+        jsonlist = []
+        jsonlist.append(f'"level": "{self.level}"')
+        jsonlist.append(f'"type": "{str(self.get_type())}"')
+        jsonlist.append(f'"testclass": "{str(self.testclass)}"')
+        jsonlist.append(f'"testid": "{str(self.testid)}"')
+        jsonlist.append(f'"filename": {jenc.encode(str(self.filename))}')
+        jsonlist.append(f'"lineno": "{str(self.lineno)}"')
+        jsonlist.append(f'"sentid": {jenc.encode(str(self.sentid))}')
+        jsonlist.append(f'"nodeid": "{str(self.nodeid)}"')
+        jsonlist.append(f'"message": {jenc.encode(str(self.message))}')
+        jsonlist.append(f'"explanation": {jenc.encode(str(self.explanation))}')
+        refjson = '[' + ', '.join([x.json() for x in self.references]) + ']'
+        jsonlist.append(f'"references": {refjson}')
+        return '{' + ', '.join(jsonlist) + '}'
+
+    def _count_me(self):
+        self.state.error_counter[self.get_type()][self.testclass] += 1
+        # Return 0 if we are not over max_err.
+        # Return 1 if we just crossed max_err (meaning we may want to print an explanation).
+        # Return 2 if we exceeded max_err by more than 1.
+        if 'max_err' in self.config and self.config['max_err'] > 0 and self.state.error_counter[self.get_type()][self.testclass] > self.config['max_err']:
+            if self.state.error_counter[self.get_type()][self.testclass] == self.config['max_err'] + 1:
+                return 1
+            else:
+                return 2
+        else:
+            return 0
+
+    def _store_me(self):
+        # self.state.error_tracker is a list of incidents.
+        if 'max_store' in self.config and self.config['max_store'] > 0 and len(self.state.error_tracker) >= self.config['max_store']:
+            return # we cannot store more incidents
+        self.state.error_tracker.append(self)
+
+    def __str__(self):
+        # If we are here, the error message should really be printed.
+        # Address of the incident.
+        address = f'Line {self.lineno} Sent {self.sentid}'
+        # Insert file name if there are several input files.
+        if 'report_filename' in self.config and self.config['report_filename']:
+            address = f'File {self.filename} ' + address
+        # Classification of the incident.
+        levelclassid = f'L{self.level} {self.testclass_to_report()} {self.testid}'
+        # Message (+ explanation, if this is the first error of its kind).
+        message = self.message
+        if self.explanation and self.explanation not in self.state.explanation_printed:
+            message += "\n\n" + self.explanation + "\n"
+            self.state.explanation_printed.add(self.explanation)
+        return f'[{address}]: [{levelclassid}] {message}'
+
+    def __lt__(self, other):
+        return self.lineno < other.lineno
+
+    def confirm(self):
+        """
+        An Incident object is typically created at the time we know the incident
+        (error or warning) really occurred. However, sometimes it is useful to
+        prepare the object when we observe one necessary condition, and then
+        wait whether we also encounter the other necessary conditions. Once we
+        know that all conditions have been met, we should call this method. It
+        will take care of registering the incident, reporting it, adjusting
+        error counters etc. In the typical situation, one calls .confirm()
+        immediately after one constructs the Incident object.
+        """
+        # Even if we should be quiet, at least count the error.
+        too_many = self._count_me()
+        self._store_me()
+        # Check if this incident should be printed, and if so, print it.
+        if not self.config['output'] or 'quiet' in self.config and self.config['quiet']:
+            return
+        if 'no_warnings' in self.config and self.config['no_warnings'] and self.is_warning():
+            return
+        if 'exclude' in self.config and self.testid in self.config['exclude']:
+            return
+        if 'include_only' in self.config and self.testid not in self.config['include_only']:
+            return
+        # Suppress error messages of a type of which we have seen too many.
+        if too_many > 0:
+            if too_many == 1:
+                print(f'...suppressing further messages regarding {str(self.get_type())}/{str(self.testclass)}', file=self.config['output'])
+            return # suppressed
+        print(str(self), file=self.config['output'])
+
+    def get_type(self):
+        """ This method must be overridden in derived classes. """
+        raise NotImplementedError()
+
+    def is_error(self):
+        return self.get_type() == IncidentType.ERROR
+
+    def is_warning(self):
+        return self.get_type() == IncidentType.WARNING
+
+    def testclass_to_report(self):
+        """ This method must be overridden in derived classes. """
+        raise NotImplementedError()
+
+
+
+class Error(Incident):
+    def get_type(self):
+        return IncidentType.ERROR
+    def testclass_to_report(self):
+        return str(self.testclass)
+
+
+
+class Warning(Incident):
+    def get_type(self):
+        return IncidentType.WARNING
+    def testclass_to_report(self):
+        return 'WARNING'

ud-tools/udtools/src/udtools/level1.py

@@ -0,0 +1,623 @@
+#! /usr/bin/env python3
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+import unicodedata
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    import udtools.src.udtools.utils as utils
+    from udtools.src.udtools.incident import Incident, Error, TestClass
+except ModuleNotFoundError:
+    import udtools.utils as utils
+    from udtools.incident import Incident, Error, TestClass
+
+
+
+# Constants for the column indices
+COLCOUNT=10
+ID,FORM,LEMMA,UPOS,XPOS,FEATS,HEAD,DEPREL,DEPS,MISC=range(COLCOUNT)
+COLNAMES='ID,FORM,LEMMA,UPOS,XPOS,FEATS,HEAD,DEPREL,DEPS,MISC'.split(',')
+
+
+
+class Level1:
+#==============================================================================
+# Level 1 tests. Only CoNLL-U backbone. Values can be empty or non-UD.
+#==============================================================================
+
+
+    def check_sentence_lines(self, state):
+        """
+        Low-level tests of a block of input lines that should represent one
+        sentence. If we are validating a file or treebank, the block was
+        probably obtained by reading lines from the file until the next empty
+        line. But it is also possible that the caller is an annotation tool,
+        which wants to validate one sentence in isolation.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_lines : list(str)
+            List of lines in the sentence (comments and tokens), including
+            final empty line. The lines are not expected to include the final
+            newline character.
+            First we expect an optional block (zero or more lines) of comments,
+            i.e., lines starting with '#'. Then we expect a non-empty block
+            (one or more lines) of nodes, empty nodes, and multiword tokens.
+            Finally, we expect exactly one empty line.
+        current_line : int
+            The number of the most recently read line from the input file
+            (1-based).
+
+        Writes to state
+        ----------------
+        comment_start_line : int
+            The line number (relative to input file, 1-based) of the first line
+            in the current sentence, including comments if any.
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+
+        Incidents
+        ---------
+        misplaced-comment
+        pseudo-empty-line
+        extra-empty-line
+        empty-sentence
+        invalid-line
+        missing-empty-line
+        + those issued by check_unicode_normalization()
+
+        Returns
+        -------
+        ok : bool
+            Is it OK to run subsequent checks? It can be OK even after some
+            less severe errors.
+        """
+        Incident.default_level = 1
+        Incident.default_testclass = TestClass.FORMAT
+        # When we arrive here, state.current_line points to the last line of the
+        # sentence, that is, the terminating empty line (if the input is valid).
+        lines = state.current_lines
+        n_lines = len(lines)
+        state.comment_start_line = state.current_line - n_lines + 1
+        state.sentence_line = state.comment_start_line # temporarily, until we find the first token
+        seen_non_comment = False # once we see non-comment, no further comments allowed
+        seen_token_node = False # at least one such line per sentence required
+        last_line_is_empty = False
+        ok = True # is it ok to run subsequent tests? It can be ok even after some less severe errors.
+        for i in range(n_lines):
+            lineno = state.comment_start_line + i
+            line = lines[i]
+            self.check_unicode_normalization(state, line, lineno)
+            # Comment lines.
+            if line and line[0] == '#':
+                # We will really validate sentence ids later. But now we want to remember
+                # everything that looks like a sentence id and use it in the error messages.
+                # Line numbers themselves may not be sufficient if we are reading multiple
+                # files from a pipe.
+                match = utils.crex.sentid.fullmatch(line)
+                if match:
+                    state.sentence_id = match.group(1)
+                if seen_non_comment:
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testid='misplaced-comment',
+                        message='Spurious comment line. Comments are only allowed before a sentence.'
+                    ).confirm()
+                    ok = False
+            else:
+                if not seen_non_comment:
+                    state.sentence_line = state.comment_start_line + i
+                seen_non_comment = True
+                # Token/node lines.
+                if line and line[0].isdigit():
+                    seen_token_node = True
+                # Empty line (end of sentence).
+                elif not line or utils.is_whitespace(line):
+                    # Lines consisting of space/tab characters are non-empty and invalid,
+                    # so we will report an error but otherwise we will treat them as empty
+                    # lines to prevent confusing subsequent errors.
+                    if utils.is_whitespace(line):
+                        Error(
+                            state=state, config=self.incfg, lineno=lineno,
+                            testid='pseudo-empty-line',
+                            message='Spurious line that appears empty but is not; there are whitespace characters.'
+                        ).confirm()
+                    # If the input lines were read from the input stream, there
+                    # will be at most one empty line and it will be the last line
+                    # (because it triggered returning a sentence). However, the
+                    # list of lines may come from other sources (any user can
+                    # ask for validation of their list of lines) and then we may
+                    # encounter empty lines anywhere.
+                    if i != n_lines-1:
+                        Error(
+                            state=state, config=self.incfg, lineno=lineno,
+                            testid='extra-empty-line',
+                            message='Spurious empty line that is not the last line of a sentence.'
+                        ).confirm()
+                        ok = False
+                    else:
+                        last_line_is_empty = True
+                        if not seen_token_node:
+                            Error(
+                                state=state, config=self.incfg, lineno=lineno,
+                                testid='empty-sentence',
+                                message='Sentence must not be empty. Only one empty line is expected after every sentence.'
+                            ).confirm()
+                            ok = False
+                # A line which is neither a comment nor a token/word, nor empty. That's bad!
+                else:
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testid='invalid-line',
+                        message=f"Spurious line: '{line}'. All non-empty lines should start with a digit or the # character."
+                    ).confirm()
+                    ok = False
+        # If the last line is not empty (e.g. because the file ended prematurely),
+        # it is an error.
+        if not last_line_is_empty:
+            Error(
+                state=state, config=self.incfg, lineno=state.current_line,
+                testid='missing-empty-line',
+                message='Missing empty line after the sentence.'
+            ).confirm()
+            ok = seen_token_node
+        return ok
+
+
+    def check_sentence_columns(self, state):
+        """
+        Low-level tests of the token/node lines of one sentence. The lines
+        should have been already checked by check_sentence_lines() and all
+        should start with a digit. We will split them to columns (cells),
+        check that there is the expected number of columns and that they are
+        not empty.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_lines : list(str)
+            List of lines in the sentence (comments and tokens), including
+            final empty line. The lines are not expected to include the final
+            newline character.
+        comment_start_line : int
+            The line number (relative to input file, 1-based) of the first line
+            in the current sentence, including comments if any.
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+
+        Writes to state
+        ----------------
+        current_token_node_table : list(list(str))
+            The list of multiword token lines / regular node lines / empty node
+            lines, each split to fields (columns).
+
+        Incidents
+        ---------
+        number-of-columns
+        + those issued by check_whitespace()
+
+        Returns
+        -------
+        ok : bool
+            Is it OK to run subsequent checks? It can be OK even after some
+            less severe errors.
+        """
+        Incident.default_level = 1
+        Incident.default_testclass = TestClass.FORMAT
+        n_comment_lines = state.sentence_line-state.comment_start_line
+        n_lines = len(state.current_lines)
+        # Normally we should exclude the last line because it is the empty line
+        # terminating the sentence. But if the empty line is missing (which is
+        # an error that we reported elsewhere), we must keep the last line.
+        range_end = n_lines-1 if (not state.current_lines[-1] or utils.is_whitespace(state.current_lines[-1])) else n_lines
+        token_lines = state.current_lines[n_comment_lines:range_end]
+        n_token_lines = len(token_lines)
+        token_lines_fields = [] # List of token/word lines of the current sentence, converted from string to list of fields.
+        ok = True # is it ok to run subsequent tests? It can be ok even after some less severe errors.
+        for i in range(n_token_lines):
+            lineno = state.sentence_line + i
+            line = token_lines[i]
+            cols = line.split("\t")
+            token_lines_fields.append(cols)
+            # If there is an unexpected number of columns, do not test their contents.
+            # Maybe the contents belongs to a different column. And we could see
+            # an exception if a column value is missing.
+            if len(cols) == COLCOUNT:
+                # Low-level tests, mostly universal constraints on whitespace in fields, also format of the ID field.
+                self.check_whitespace(state, cols, lineno)
+            else:
+                Error(
+                    state=state, config=self.incfg, lineno=lineno,
+                    testid='number-of-columns',
+                    message=f'The line has {len(cols)} columns but {COLCOUNT} are expected.'
+                ).confirm()
+                ok = False
+        state.current_token_node_table = token_lines_fields
+        return ok
+
+
+
+#------------------------------------------------------------------------------
+# Level 1 tests applicable to a single line independently of the others.
+#------------------------------------------------------------------------------
+
+
+
+    def check_unicode_normalization(self, state, text, lineno):
+        """
+        Tests that letters composed of multiple Unicode characters (such as a base
+        letter plus combining diacritics) conform to NFC normalization (canonical
+        decomposition followed by canonical composition).
+
+        Parameters
+        ----------
+        text : str
+            The input line to be tested. If the line consists of TAB-separated
+            fields (token line), errors reports will specify the field where the
+            error occurred. Otherwise (comment line), the error report will not be
+            localized.
+
+        Incidents
+        ---------
+        unicode-normalization
+        """
+        normalized_text = unicodedata.normalize('NFC', text)
+        if text != normalized_text:
+            # Find the first unmatched character and include it in the report.
+            firsti = -1
+            firstj = -1
+            inpfirst = ''
+            inpsecond = ''
+            nfcfirst = ''
+            tcols = text.split("\t")
+            ncols = normalized_text.split("\t")
+            for i in range(len(tcols)):
+                for j in range(len(tcols[i])):
+                    if tcols[i][j] != ncols[i][j]:
+                        firsti = i
+                        firstj = j
+                        inpfirst = unicodedata.name(tcols[i][j])
+                        nfcfirst = unicodedata.name(ncols[i][j])
+                        if j+1 < len(tcols[i]):
+                            inpsecond = unicodedata.name(tcols[i][j+1])
+                        break
+                if firsti >= 0:
+                    break
+            if len(tcols) > 1:
+                testmessage = f"Unicode not normalized: {COLNAMES[firsti]}.character[{firstj}] is {inpfirst}, should be {nfcfirst}."
+            else:
+                testmessage = f"Unicode not normalized: character[{firstj}] is {inpfirst}, should be {nfcfirst}."
+            explanation_second = f" In this case, your next character is {inpsecond}." if inpsecond else ''
+            Error(
+                state=state, config=self.incfg, lineno=lineno,
+                level=1,
+                testclass=TestClass.UNICODE,
+                testid='unicode-normalization',
+                message=testmessage,
+                explanation=f"This error usually does not mean that {inpfirst} is an invalid character. Usually it means that this is a base character followed by combining diacritics, and you should replace them by a single combined character.{explanation_second} You can fix normalization errors using the normalize_unicode.pl script from the tools repository."
+            ).confirm()
+
+
+
+    def check_whitespace(self, state, cols, lineno):
+        """
+        Checks that columns are not empty and do not contain whitespace characters
+        except for patterns that could be allowed at level 4. Applies to all types
+        of TAB-containing lines: nodes / words, mwt ranges, empty nodes.
+
+        Parameters
+        ----------
+        cols : list
+            The values of the columns on the current node / token line.
+
+        Incidents
+        ---------
+        invalid-whitespace-mwt
+        invalid-whitespace
+        empty-column
+        leading-whitespace
+        trailing-whitespace
+        repeated-whitespace
+        """
+        Incident.default_level = 1
+        Incident.default_testclass = TestClass.FORMAT
+        Incident.default_lineno = lineno
+        # Some whitespace may be permitted in FORM, LEMMA and MISC but not elsewhere.
+        # Multi-word tokens may have whitespaces in MISC but not in FORM or LEMMA.
+        # If it contains a space, it does not make sense to treat it as a MWT.
+        ismwt = utils.is_multiword_token(cols)
+        for col_idx in range(COLCOUNT):
+            if col_idx >= len(cols):
+                break # this has been already reported in next_sentence()
+            if ismwt and col_idx in (FORM, LEMMA) and utils.crex.ws.search(cols[col_idx]):
+                Error(
+                    state=state, config=self.incfg,
+                    testid='invalid-whitespace-mwt',
+                    message=f"White space not allowed in multi-word token '{cols[col_idx]}'. If it contains a space, it is not a single surface token."
+                ).confirm()
+            # These columns must not have whitespace.
+            elif col_idx in (ID, UPOS, XPOS, FEATS, HEAD, DEPREL, DEPS) and utils.crex.ws.search(cols[col_idx]):
+                Error(
+                    state=state, config=self.incfg,
+                    testid='invalid-whitespace',
+                    message=f"White space not allowed in column {COLNAMES[col_idx]}: '{cols[col_idx]}'."
+                ).confirm()
+            # Only perform the following tests if we have not found and reported a space above.
+            else:
+                # Must never be empty
+                if not cols[col_idx]:
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='empty-column',
+                        message=f"Empty value in column {COLNAMES[col_idx]}: '{cols[col_idx]}'."
+                    ).confirm()
+                else:
+                    # Must never have leading/trailing/repeated whitespace.
+                    # This will be only reported for columns that allow whitespace in general.
+                    if cols[col_idx][0].isspace():
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='leading-whitespace',
+                            message=f"Leading whitespace not allowed in column {COLNAMES[col_idx]}: '{cols[col_idx]}'."
+                        ).confirm()
+                    if cols[col_idx][-1].isspace():
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='trailing-whitespace',
+                            message=f"Trailing whitespace not allowed in column {COLNAMES[col_idx]}: '{cols[col_idx]}'."
+                        ).confirm()
+                    # Must never contain two consecutive whitespace characters
+                    if utils.crex.ws2.search(cols[col_idx]):
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='repeated-whitespace',
+                            message=f"Two or more consecutive whitespace characters not allowed in column {COLNAMES[col_idx]}: '{cols[col_idx]}'."
+                        ).confirm()
+
+
+
+#------------------------------------------------------------------------------
+# Level 1 tests applicable to the whole sentence.
+#------------------------------------------------------------------------------
+
+
+
+    def check_id_sequence(self, state):
+        """
+        Validates that the ID sequence is correctly formed.
+        Besides reporting the errors, it also returns False to the caller so it can
+        avoid building a tree from corrupt IDs.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_token_node_table : list(list(str))
+            The list of multiword token lines / regular node lines / empty node
+            lines, each split to fields (columns).
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+
+        Incidents
+        ---------
+        invalid-word-id
+        invalid-word-interval
+        misplaced-word-interval
+        misplaced-empty-node
+        word-id-sequence
+        reversed-word-interval
+        word-interval-out
+
+        Returns
+        -------
+        ok : bool
+            Is it OK to run subsequent checks? It can be OK even after some
+            less severe errors.
+        """
+        ok = True
+        Incident.default_level = 1
+        Incident.default_testclass = TestClass.FORMAT
+        words=[]
+        tokens=[]
+        current_word_id, next_empty_id = 0, 1
+        for i in range(len(state.current_token_node_table)):
+            lineno = state.sentence_line + i
+            cols = state.current_token_node_table[i]
+            # Check for the format of the ID value. (ID must not be empty.)
+            if not (utils.is_word(cols) or utils.is_empty_node(cols) or utils.is_multiword_token(cols)):
+                Error(
+                    state=state, config=self.incfg, lineno=lineno,
+                    testid='invalid-word-id',
+                    message=f"Unexpected ID format '{cols[ID]}'."
+                ).confirm()
+                ok = False
+                continue
+            if not utils.is_empty_node(cols):
+                next_empty_id = 1    # reset sequence
+            if utils.is_word(cols):
+                t_id = int(cols[ID])
+                current_word_id = t_id
+                words.append(t_id)
+                # Not covered by the previous interval?
+                if not (tokens and tokens[-1][0] <= t_id and tokens[-1][1] >= t_id):
+                    tokens.append((t_id, t_id, lineno)) # nope - let's make a default interval for it
+            elif utils.is_multiword_token(cols):
+                match = utils.crex.mwtid.fullmatch(cols[ID]) # Check the interval against the regex
+                if not match: # This should not happen. The function utils.is_multiword_token() would then not return True.
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testid='invalid-word-interval',
+                        message=f"Spurious word interval definition: '{cols[ID]}'."
+                    ).confirm()
+                    ok = False
+                    continue
+                beg, end = int(match.group(1)), int(match.group(2))
+                if not ((not words and beg >= 1) or (words and beg >= words[-1] + 1)):
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testid='misplaced-word-interval',
+                        message='Multiword range not before its first word.'
+                    ).confirm()
+                    ok = False
+                    continue
+                tokens.append((beg, end, lineno))
+            elif utils.is_empty_node(cols):
+                word_id, empty_id = (int(i) for i in utils.parse_empty_node_id(cols))
+                if word_id != current_word_id or empty_id != next_empty_id:
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testid='misplaced-empty-node',
+                        message=f'Empty node id {cols[ID]}, expected {current_word_id}.{next_empty_id}'
+                    ).confirm()
+                    ok = False
+                next_empty_id += 1
+                # Interaction of multiword tokens and empty nodes if there is an empty
+                # node between the first word of a multiword token and the previous word:
+                # This sequence is correct: 4 4.1 5-6 5 6
+                # This sequence is wrong:   4 5-6 4.1 5 6
+                if word_id == current_word_id and tokens and word_id < tokens[-1][0]:
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testid='misplaced-empty-node',
+                        message=f"Empty node id {cols[ID]} must occur before multiword token {tokens[-1][0]}-{tokens[-1][1]}."
+                    ).confirm()
+                    ok = False
+        # Now let's do some basic sanity checks on the sequences.
+        # Expected sequence of word IDs is 1, 2, ...
+        expstrseq = ','.join(str(x) for x in range(1, len(words) + 1))
+        wrdstrseq = ','.join(str(x) for x in words)
+        if wrdstrseq != expstrseq:
+            Error(
+                state=state, config=self.incfg, lineno=-1,
+                testid='word-id-sequence',
+                message=f"Words do not form a sequence. Got '{wrdstrseq}'. Expected '{expstrseq}'."
+            ).confirm()
+            ok = False
+        # Check elementary sanity of word intervals.
+        # Remember that these are not just multi-word tokens. Here we have intervals even for single-word tokens (b=e)!
+        for (b, e, lineno) in tokens:
+            if e < b: # end before beginning
+                Error(
+                    state=state, config=self.incfg, lineno=lineno,
+                    testid='reversed-word-interval',
+                    message=f'Spurious token interval {b}-{e}'
+                ).confirm()
+                ok = False
+                continue
+            if b < 1 or e > len(words): # out of range
+                Error(
+                    state=state, config=self.incfg, lineno=lineno,
+                    testid='word-interval-out',
+                    message=f'Spurious token interval {b}-{e} (out of range)'
+                ).confirm()
+                ok = False
+                continue
+        return ok
+
+
+
+    def check_token_range_overlaps(self, state):
+        """
+        Checks that the word ranges for multiword tokens do not overlap.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_token_node_table : list(list(str))
+            The list of multiword token lines / regular node lines / empty node
+            lines, each split to fields (columns).
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+
+        Incidents
+        ---------
+        invalid-word-interval
+        overlapping-word-intervals
+
+        Returns
+        -------
+        ok : bool
+            Is it OK to run subsequent checks? It can be OK even after some
+            less severe errors.
+        """
+        ok = True
+        Incident.default_level = 1
+        Incident.default_testclass = TestClass.FORMAT
+        covered = set()
+        for i in range(len(state.current_token_node_table)):
+            lineno = state.sentence_line + i
+            cols = state.current_token_node_table[i]
+            if not utils.is_multiword_token(cols):
+                continue
+            m = utils.crex.mwtid.fullmatch(cols[ID])
+            if not m: # This should not happen. The function utils.is_multiword_token() would then not return True.
+                Error(
+                    state=state, config=self.incfg, lineno=lineno,
+                    testid='invalid-word-interval',
+                    message=f"Spurious word interval definition: '{cols[ID]}'."
+                ).confirm()
+                continue
+            start, end = m.groups()
+            start, end = int(start), int(end)
+            # Do not test if start >= end: This was already tested above in check_id_sequence().
+            if covered & set(range(start, end+1)):
+                Error(
+                    state=state, config=self.incfg, lineno=lineno,
+                    testid='overlapping-word-intervals',
+                    message=f'Range overlaps with others: {cols[ID]}'
+                ).confirm()
+                ok = False
+            covered |= set(range(start, end+1))
+        return ok
+
+
+
+#------------------------------------------------------------------------------
+# Level 1 tests applicable to the whole input file.
+#------------------------------------------------------------------------------
+
+
+
+    def check_newlines(self, state, inp):
+        """
+        Checks that the input file consistently uses linux-style newlines (LF
+        only, not CR LF like in Windows). To be run on the input file handle
+        after the whole input has been read.
+
+        Incidents
+        ---------
+        non-unix-newline
+        """
+        if inp.newlines and inp.newlines != '\n':
+            Error(
+                state=state, config=self.incfg,
+                level=1,
+                testclass=TestClass.FORMAT,
+                lineno=state.current_line,
+                testid='non-unix-newline',
+                message='Only the unix-style LF line terminator is allowed.'
+            ).confirm()

ud-tools/udtools/src/udtools/level2.py

@@ -0,0 +1,1288 @@
+#! /usr/bin/env python3
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+# According to https://stackoverflow.com/questions/1832893/python-regex-matching-unicode-properties,
+# the regex module has the same API as re but it can check Unicode character properties using \p{}
+# as in Perl.
+#import re
+import regex as re
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    import udtools.src.udtools.utils as utils
+    from udtools.src.udtools.incident import Incident, Error, TestClass, Reference
+    from udtools.src.udtools.level1 import Level1
+except ModuleNotFoundError:
+    import udtools.utils as utils
+    from udtools.incident import Incident, Error, TestClass, Reference
+    from udtools.level1 import Level1
+
+
+
+# Constants for the column indices
+COLCOUNT=10
+ID,FORM,LEMMA,UPOS,XPOS,FEATS,HEAD,DEPREL,DEPS,MISC=range(COLCOUNT)
+COLNAMES='ID,FORM,LEMMA,UPOS,XPOS,FEATS,HEAD,DEPREL,DEPS,MISC'.split(',')
+
+
+
+class Level2(Level1):
+#==============================================================================
+# Level 2 tests. Tree structure, universal tags and deprels. Note that any
+# well-formed Feature=Value pair is allowed (because it could be language-
+# specific) and any word form or lemma can contain spaces (because language-
+# specific guidelines may permit it).
+#==============================================================================
+
+
+
+#------------------------------------------------------------------------------
+# Level 2 tests applicable to a single line independently of the others.
+#------------------------------------------------------------------------------
+
+
+
+    def check_mwt_empty_vals(self, state, cols, line):
+        """
+        Checks that a multi-word token has _ empty values in all fields except MISC.
+        This is required by UD guidelines although it is not a problem in general,
+        therefore a level 2 test.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        cols : list
+            The values of the columns on the current node / token line.
+        line : int
+            Number of the line where the node occurs in the file.
+
+        Incidents
+        ---------
+        mwt-nonempty-field
+        """
+        assert utils.is_multiword_token(cols), 'internal error'
+        for col_idx in range(LEMMA, MISC): # all columns except the first two (ID, FORM) and the last one (MISC)
+            # Exception: The feature Typo=Yes may occur in FEATS of a multi-word token.
+            if col_idx == FEATS and cols[col_idx] == 'Typo=Yes':
+                pass
+            elif cols[col_idx] != '_':
+                Error(
+                    state=state, config=self.incfg,
+                    lineno=line,
+                    level=2,
+                    testclass=TestClass.FORMAT,
+                    testid='mwt-nonempty-field',
+                    message=f"A multi-word token line must have '_' in the column {COLNAMES[col_idx]}. Now: '{cols[col_idx]}'."
+                ).confirm()
+
+
+
+
+    def check_empty_node_empty_vals(self, state, cols, line):
+        """
+        Checks that an empty node has _ empty values in HEAD and DEPREL. This is
+        required by UD guidelines but not necessarily by CoNLL-U, therefore
+        a level 2 test.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        cols : list
+            The values of the columns on the current node / token line.
+        line : int
+            Number of the line where the node occurs in the file.
+
+        Incidents
+        ---------
+        empty-node-nonempty-field
+        """
+        assert utils.is_empty_node(cols), 'internal error'
+        for col_idx in (HEAD, DEPREL):
+            if cols[col_idx]!= '_':
+                Error(
+                    state=state, config=self.incfg,
+                    lineno=line,
+                    level=2,
+                    testclass=TestClass.FORMAT,
+                    testid='empty-node-nonempty-field',
+                    message=f"An empty node must have '_' in the column {COLNAMES[col_idx]}. Now: '{cols[col_idx]}'."
+                ).confirm()
+
+
+
+    def check_upos(self, state, cols, line):
+        """
+        Checks that the UPOS field contains one of the 17 known tags.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        cols : list
+            The values of the columns on the current node / token line.
+        line : int
+            Number of the line where the node occurs in the file.
+
+        Incidents
+        ---------
+        unknown-upos
+        """
+        if utils.is_empty_node(cols) and cols[UPOS] == '_':
+            return
+        # Just in case, we still match UPOS against the regular expression that
+        # checks general character constraints. However, the list of UPOS, loaded
+        # from a JSON file, should conform to the regular expression.
+        if not utils.crex.upos.fullmatch(cols[UPOS]) or cols[UPOS] not in self.data.upos:
+            Error(
+                state=state, config=self.incfg,
+                lineno=line,
+                level=2,
+                testclass=TestClass.MORPHO,
+                testid='unknown-upos',
+                message=f"Unknown UPOS tag: '{cols[UPOS]}'."
+            ).confirm()
+
+
+
+    def check_feats_format(self, state, cols, line):
+        """
+        Checks general constraints on feature-value format: Permitted characters in
+        feature name and value, features must be sorted alphabetically, features
+        cannot be repeated etc.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        cols : list
+            The values of the columns on the current node / token line.
+        line : int
+            Number of the line where the node occurs in the file.
+
+        Incidents
+        ---------
+        unsorted-features
+        invalid-feature
+        repeated-feature-value
+        unsorted-feature-values
+        invalid-feature-value
+        repeated-feature
+
+        Returns
+        -------
+        safe : bool
+            There were no errors or the errors are not so severe that we should
+            refrain from loading the sentence into Udapi.
+        """
+        Incident.default_lineno = line
+        Incident.default_level = 2
+        Incident.default_testclass = TestClass.MORPHO
+        feats = cols[FEATS]
+        if feats == '_':
+            return True
+        utils.features_present(state, line)
+        feat_list = feats.split('|')
+        if [f.lower() for f in feat_list] != sorted(f.lower() for f in feat_list):
+            Error(
+                state=state, config=self.incfg,
+                testid='unsorted-features',
+                message=f"Morphological features must be sorted: '{feats}'."
+            ).confirm()
+        attr_set = set() # I'll gather the set of features here to check later that none is repeated.
+        # Subsequent higher-level tests could fail if a feature is not in the
+        # Feature=Value format. If that happens, we will return False and the caller
+        # can skip the more fragile tests.
+        safe = True
+        for f in feat_list:
+            match = utils.crex.featval.fullmatch(f)
+            if match is None:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='invalid-feature',
+                    message=f"Spurious morphological feature: '{f}'. Should be of the form Feature=Value and must start with [A-Z] and only contain [A-Za-z0-9]."
+                ).confirm()
+                attr_set.add(f) # to prevent misleading error "Repeated features are disallowed"
+                safe = False
+            else:
+                # Check that the values are sorted as well
+                attr = match.group(1)
+                attr_set.add(attr)
+                values = match.group(2).split(',')
+                if len(values) != len(set(values)):
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='repeated-feature-value',
+                        message=f"Repeated feature values are disallowed: '{feats}'"
+                    ).confirm()
+                if [v.lower() for v in values] != sorted(v.lower() for v in values):
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='unsorted-feature-values',
+                        message=f"If a feature has multiple values, these must be sorted: '{f}'"
+                    ).confirm()
+                for v in values:
+                    if not utils.crex.val.fullmatch(v):
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='invalid-feature-value',
+                            message=f"Spurious value '{v}' in '{f}'. Must start with [A-Z0-9] and only contain [A-Za-z0-9]."
+                        ).confirm()
+                    # Level 2 tests character properties and canonical order but not that the f-v pair is known.
+        if len(attr_set) != len(feat_list):
+            Error(
+                state=state, config=self.incfg,
+                testid='repeated-feature',
+                message=f"Repeated features are disallowed: '{feats}'."
+            ).confirm()
+        return safe
+
+
+
+    def check_deprel_format(self, state, cols, line):
+        """
+        Checks general constraints on valid characters in DEPREL. Furthermore,
+        if the general character format is OK, checks that the main relation
+        type (udeprel) is defined in UD. Subtypes, if any, are ignored. This is
+        a level 2 test and it does not consult language-specific lists. It will
+        not report an error even if a main deprel is forbidden in a language.
+        This method checks the DEPREL column but not DEPS.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        cols : list
+            The values of the columns on the current node / token line.
+        line : int
+            Number of the line where the node occurs in the file.
+
+        Incidents
+        ---------
+        invalid-deprel
+        unknown-deprel
+        """
+        Incident.default_level = 2
+        Incident.default_lineno = line
+        if utils.is_multiword_token(cols):
+            return
+        # Empty nodes must have '_' in DEPREL but that has been already checked
+        # in check_empty_node_empty_vals().
+        if utils.is_empty_node(cols):
+            return
+        if not utils.crex.deprel.fullmatch(cols[DEPREL]):
+            Error(
+                state=state, config=self.incfg,
+                testclass=TestClass.SYNTAX,
+                testid='invalid-deprel',
+                message=f"Invalid DEPREL value '{cols[DEPREL]}'. Only lowercase English letters or a colon are expected."
+            ).confirm()
+        else:
+            # At this level, ignore the language-specific lists and use
+            # language 'ud' instead.
+            deprelset = self.data.get_deprel_for_language('ud')
+            # Test only the universal part if testing at universal level.
+            deprel = utils.lspec2ud(cols[DEPREL])
+            if deprel not in deprelset:
+                Error(
+                    state=state, config=self.incfg,
+                    testclass=TestClass.SYNTAX,
+                    testid='unknown-udeprel',
+                    message=f"Unknown main DEPREL type: '{deprel}'."
+                ).confirm()
+
+
+
+    def check_deps_format(self, state, cols, line):
+        """
+        Checks that DEPS is correctly formatted and that there are no
+        self-loops in DEPS (longer cycles are allowed in enhanced graphs but
+        self-loops are not).
+
+        For each relation in DEPS, it also checks the general constraints on
+        valid characters in DEPS. If the general character format is OK, checks
+        that the main relation type of each relation in DEPS is on the list of
+        main deprel types defined in UD. If there is a subtype, it is ignored.
+        This is a level 2 test and it does not consult language-specific lists.
+        It will not report an error even if a main deprel is forbidden in the
+        language.
+
+        This function must be run on raw DEPS before it is fed into Udapi because
+        it checks the order of relations, which is not guaranteed to be preserved
+        in Udapi. On the other hand, we assume that it is run after
+        check_id_references() and only if DEPS is parsable and the head indices
+        in it are OK.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        cols : list
+            The values of the columns on the current node / token line.
+        line : int
+            Number of the line where the node occurs in the file.
+
+        Incidents
+        ---------
+        unsorted-deps
+        unsorted-deps-2
+        repeated-deps
+        deps-self-loop
+        invalid-edeprel
+        unknown-eudeprel
+        """
+        Incident.default_level = 2
+        Incident.default_lineno = line
+        if utils.is_multiword_token(cols):
+            return
+        if cols[DEPS] == '_':
+            return
+        # Remember whether there is at least one difference between the basic
+        # tree and the enhanced graph in the entire dataset.
+        if cols[DEPS] != '_' and cols[DEPS] != cols[HEAD]+':'+cols[DEPREL]:
+            state.seen_enhancement = line
+        # We should have called check_id_references() before (and only come
+        # here if that check succeeded); since utils.deps_list() is called
+        # there, it should be now guaranteed that the contents of DEPS is
+        # parsable.
+        edeps = utils.deps_list(cols)
+        heads = [utils.nodeid2tuple(h) for h, d in edeps]
+        if heads != sorted(heads):
+            Error(
+                state=state, config=self.incfg,
+                testclass=TestClass.FORMAT,
+                testid='unsorted-deps',
+                message=f"DEPS not sorted by head index: '{cols[DEPS]}'."
+            ).confirm()
+        else:
+            lasth = None
+            lastd = None
+            for h, d in edeps:
+                if h == lasth:
+                    if d < lastd:
+                        Error(
+                            state=state, config=self.incfg,
+                            testclass=TestClass.FORMAT,
+                            testid='unsorted-deps-2',
+                            message=f"DEPS pointing to head '{h}' not sorted by relation type: '{cols[DEPS]}'."
+                        ).confirm()
+                    elif d == lastd:
+                        Error(
+                            state=state, config=self.incfg,
+                            testclass=TestClass.FORMAT,
+                            testid='repeated-deps',
+                            message=f"DEPS contain multiple instances of the same relation '{h}:{d}'."
+                        ).confirm()
+                lasth = h
+                lastd = d
+        id_ = utils.nodeid2tuple(cols[ID])
+        if id_ in heads:
+            Error(
+                state=state, config=self.incfg,
+                testclass=TestClass.ENHANCED,
+                testid='deps-self-loop',
+                message=f"Self-loop in DEPS for '{cols[ID]}'"
+            ).confirm()
+        # At this level, ignore the language-specific lists and use language
+        # 'ud' instead.
+        deprelset = self.data.get_deprel_for_language('ud')
+        deprelset.add('ref')
+        for head, deprel in edeps:
+            if not utils.crex.edeprel.fullmatch(deprel):
+                Error(
+                    state=state, config=self.incfg,
+                    testclass=TestClass.ENHANCED,
+                    testid='invalid-edeprel',
+                    message=f"Invalid enhanced relation type: '{cols[DEPS]}'."
+                ).confirm()
+            else:
+                # Test only the universal part if testing at universal level.
+                udeprel = utils.lspec2ud(deprel)
+                if not udeprel in deprelset:
+                    Error(
+                        state=state, config=self.incfg,
+                        testclass=TestClass.ENHANCED,
+                        testid='unknown-eudeprel',
+                        message=f"Unknown main relation type '{udeprel}' in '{head}:{deprel}'."
+                    ).confirm()
+
+
+
+    def check_misc(self, state, cols, line):
+        """
+        In general, the MISC column can contain almost anything. However, if there
+        is a vertical bar character, it is interpreted as the separator of two
+        MISC attributes, which may or may not have the form of attribute=value pair.
+        In general it is not forbidden that the same attribute appears several times
+        with different values, but this should not happen for selected attributes
+        that are described in the UD documentation.
+
+        This function must be run on raw MISC before it is fed into Udapi because
+        Udapi is not prepared for some of the less recommended usages of MISC.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        cols : list
+            The values of the columns on the current node / token line.
+        line : int
+            Number of the line where the node occurs in the file.
+
+        Incidents
+        ---------
+        empty-misc
+        empty-misc-key
+        misc-extra-space
+        misc-attr-typo
+        repeated-misc
+        """
+        Incident.default_lineno = line
+        Incident.default_level = 2
+        Incident.default_testclass = TestClass.FORMAT
+        if cols[MISC] == '_':
+            return
+        misc = [ma.split('=', 1) for ma in cols[MISC].split('|')]
+        mamap = {}
+        for ma in misc:
+            if ma[0] == '':
+                if len(ma) == 1:
+                    Warning(
+                        state=state, config=self.incfg,
+                        testid='empty-misc',
+                        message="Empty attribute in MISC; possible misinterpreted vertical bar?"
+                    ).confirm()
+                else:
+                    Warning(
+                        state=state, config=self.incfg,
+                        testid='empty-misc-key',
+                        message=f"Empty MISC attribute name in '{ma[0]}={ma[1]}'."
+                    ).confirm()
+            # We do not warn about MISC items that do not contain '='.
+            # But the remaining error messages below assume that ma[1] exists.
+            if len(ma) == 1:
+                ma.append('')
+            if re.match(r"^\s", ma[0]):
+                Warning(
+                    state=state, config=self.incfg,
+                    testid='misc-extra-space',
+                    message=f"MISC attribute name starts with space in '{ma[0]}={ma[1]}'."
+                ).confirm()
+            elif re.search(r"\s$", ma[0]):
+                Warning(
+                    state=state, config=self.incfg,
+                    testid='misc-extra-space',
+                    message=f"MISC attribute name ends with space in '{ma[0]}={ma[1]}'."
+                ).confirm()
+            elif re.match(r"^\s", ma[1]):
+                Warning(
+                    state=state, config=self.incfg,
+                    testid='misc-extra-space',
+                    message=f"MISC attribute value starts with space in '{ma[0]}={ma[1]}'."
+                ).confirm()
+            elif re.search(r"\s$", ma[1]):
+                Warning(
+                    state=state, config=self.incfg,
+                    testid='misc-extra-space',
+                    message=f"MISC attribute value ends with space in '{ma[0]}={ma[1]}'."
+                ).confirm()
+            if re.match(r"^(SpaceAfter|Lang|Translit|LTranslit|Gloss|LId|LDeriv|Ref)$", ma[0]):
+                mamap.setdefault(ma[0], 0)
+                mamap[ma[0]] = mamap[ma[0]] + 1
+            elif re.match(r"^\s*(spaceafter|lang|translit|ltranslit|gloss|lid|lderiv|ref)\s*$", ma[0], re.IGNORECASE):
+                Warning(
+                    state=state, config=self.incfg,
+                    testid='misc-attr-typo',
+                    message=f"Possible typo (case or spaces) in MISC attribute '{ma[0]}={ma[1]}'."
+                ).confirm()
+        for a in list(mamap):
+            if mamap[a] > 1:
+                Error(
+                    state=state, config=self.incfg,
+                    testclass=TestClass.FORMAT, # this one is real error
+                    testid='repeated-misc',
+                    message=f"MISC attribute '{a}' not supposed to occur twice"
+                ).confirm()
+
+
+
+#------------------------------------------------------------------------------
+# Level 2 tests applicable to the whole sentence.
+#------------------------------------------------------------------------------
+
+
+
+    def check_id_references(self, state):
+        """
+        Verifies that HEAD and DEPS reference existing IDs. If this function does
+        not return True, most of the other tests should be skipped for the current
+        sentence (in particular anything that considers the tree structure).
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_token_node_table : list(list(str))
+            The list of multiword token lines / regular node lines / empty node
+            lines, each split to fields (columns).
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+
+        Incidents
+        ---------
+        invalid-head
+        unknown-head
+        invalid-deps
+        invalid-ehead
+        unknown-ehead
+
+        Returns
+        -------
+        ok : bool
+            Is it OK to run subsequent checks? It can be OK even after some
+            less severe errors.
+        """
+        ok = True
+        Incident.default_level = 2
+        Incident.default_testclass = TestClass.FORMAT
+        ids = set([cols[ID] for cols in state.current_token_node_table if utils.is_word(cols) or utils.is_empty_node(cols)])
+        for i in range(len(state.current_token_node_table)):
+            lineno = state.sentence_line + i
+            cols = state.current_token_node_table[i]
+            if utils.is_multiword_token(cols):
+                continue
+            # Test the basic HEAD only for non-empty nodes.
+            # We have checked elsewhere that it is empty for empty nodes.
+            if not utils.is_empty_node(cols):
+                match = utils.crex.head.fullmatch(cols[HEAD])
+                if match is None:
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testid='invalid-head',
+                        message=f"Invalid HEAD: '{cols[HEAD]}'."
+                    ).confirm()
+                    ok = False
+                if not (cols[HEAD] in ids or cols[HEAD] == '0'):
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testclass=TestClass.SYNTAX,
+                        testid='unknown-head',
+                        message=f"Undefined HEAD (no such ID): '{cols[HEAD]}'."
+                    ).confirm()
+                    ok = False
+            try:
+                deps = utils.deps_list(cols)
+            except ValueError:
+                # Similar errors have probably been reported earlier.
+                Error(
+                    state=state, config=self.incfg, lineno=lineno,
+                    testid='invalid-deps',
+                    message=f"Failed to parse DEPS: '{cols[DEPS]}'."
+                ).confirm()
+                ok = False
+                continue
+            for head, deprel in deps:
+                match = utils.crex.ehead.fullmatch(head)
+                if match is None:
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testid='invalid-ehead',
+                        message=f"Invalid enhanced head reference: '{head}'."
+                    ).confirm()
+                    ok = False
+                if not (head in ids or head == '0'):
+                    Error(
+                        state=state, config=self.incfg, lineno=lineno,
+                        testclass=TestClass.ENHANCED,
+                        testid='unknown-ehead',
+                        message=f"Undefined enhanced head reference (no such ID): '{head}'."
+                    ).confirm()
+                    ok = False
+        return ok
+
+
+
+    def check_tree(self, state):
+        """
+        Takes the list of non-comment lines (line = list of columns) describing
+        a sentence. Returns an array with line number corresponding to each tree
+        node. In case of fatal problems (missing HEAD etc.) returns None
+        (and reports the error, unless it is something that should have been
+        reported earlier).
+
+        We will assume that this function is called only if both ID and HEAD
+        values have been found valid for all tree nodes, including the sequence
+        of IDs and the references from HEAD to existing IDs.
+
+        This function originally served to build a data structure that would
+        describe the tree and make it accessible during subsequent tests. Now we
+        use the Udapi data structures instead but we still have to call this
+        function first because it will survive and report ill-formed input. In
+        such a case, the Udapi data structure will not be built and Udapi-based
+        tests will be skipped.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_token_node_table : list(list(str))
+            The list of multiword token lines / regular node lines / empty node
+            lines, each split to fields (columns).
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+
+        Incidents
+        ---------
+        head-self-loop
+        multiple-roots
+        non-tree
+
+        Returns
+        -------
+        ok : bool
+            Is it OK to run subsequent checks? It can be OK even after some
+            less severe errors.
+        """
+        Incident.default_level = 2
+        Incident.default_testclass = TestClass.SYNTAX
+        children = {} # int(node id) -> set of children
+        n_words = 0
+        for i in range(len(state.current_token_node_table)):
+            lineno = state.sentence_line + i
+            cols = state.current_token_node_table[i]
+            if not utils.is_word(cols):
+                continue
+            n_words += 1
+            # ID and HEAD values have been validated before and this function would
+            # not be called if they were not OK. So we can now safely convert them
+            # to integers.
+            id_ = int(cols[ID])
+            head = int(cols[HEAD])
+            if head == id_:
+                Error(
+                    state=state, config=self.incfg, lineno=lineno,
+                    testid='head-self-loop',
+                    message=f'HEAD == ID for {cols[ID]}'
+                ).confirm()
+                return False
+            # Incrementally build the set of children of every node.
+            children.setdefault(head, set()).add(id_)
+        word_ids = list(range(1, n_words+1))
+        # Check that there is just one node with the root relation.
+        children_0 = sorted(children.get(0, []))
+        if len(children_0) > 1:
+            references = [Reference(filename=state.current_file_name,
+                                    lineno=state.sentence_line + i,
+                                    sentid=state.sentence_id,
+                                    nodeid=i)
+                          for i in children_0]
+            Error(
+                state=state, config=self.incfg, lineno=state.sentence_line,
+                testid='multiple-roots',
+                message=f"Multiple root words: {children_0}",
+                references=references
+            ).confirm()
+            return False
+        # Return None if there are any cycles. Otherwise we could not later ask
+        # Udapi to built a data structure representing the tree.
+        # Presence of cycles is equivalent to presence of unreachable nodes.
+        projection = set()
+        node_id = 0
+        nodes = list((node_id,))
+        while nodes:
+            node_id = nodes.pop()
+            children_id = sorted(children.get(node_id, []))
+            for child in children_id:
+                if child in projection:
+                    continue # skip cycles
+                projection.add(child)
+                nodes.append(child)
+        unreachable = set(word_ids) - projection
+        if unreachable:
+            str_unreachable = ','.join(str(w) for w in sorted(unreachable))
+            Error(
+                state=state, config=self.incfg, lineno=state.sentence_line,
+                testid='non-tree',
+                message=f'Non-tree structure. Words {str_unreachable} are not reachable from the root 0.'
+            ).confirm()
+            return False
+        return True
+
+
+
+
+    def check_deps_all_or_none(self, state):
+        """
+        Checks that enhanced dependencies are present if they were present in
+        another sentence, and absent if they were absent in another sentence.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_token_node_table : list(list(str))
+            The list of multiword token lines / regular node lines / empty node
+            lines, each split to fields (columns).
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+
+        Incidents
+        ---------
+        edeps-only-sometimes
+        """
+        egraph_exists = False # enhanced deps are optional
+        for i in range(len(state.current_token_node_table)):
+            cols = state.current_token_node_table[i]
+            if utils.is_multiword_token(cols):
+                continue
+            if utils.is_empty_node(cols) or cols[DEPS] != '_':
+                egraph_exists = True
+        # We are currently testing the existence of enhanced graphs separately for each sentence.
+        # However, we should not allow that one sentence has a connected egraph and another
+        # has no enhanced dependencies. Such inconsistency could come as a nasty surprise
+        # to the users.
+        Incident.default_lineno = state.sentence_line
+        Incident.default_level = 2
+        Incident.default_testclass = TestClass.ENHANCED
+        if egraph_exists:
+            if not state.seen_enhanced_graph:
+                state.seen_enhanced_graph = state.sentence_line
+                if state.seen_tree_without_enhanced_graph:
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='edeps-only-sometimes',
+                        message=f"Enhanced graph must be empty because we saw empty DEPS on line {state.seen_tree_without_enhanced_graph}"
+                    ).confirm()
+        else:
+            if not state.seen_tree_without_enhanced_graph:
+                state.seen_tree_without_enhanced_graph = state.sentence_line
+                if state.seen_enhanced_graph:
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='edeps-only-sometimes',
+                        message=f"Enhanced graph cannot be empty because we saw non-empty DEPS on line {state.seen_enhanced_graph}"
+                    ).confirm()
+
+
+
+    def check_egraph_connected(self, state, nodes):
+        """
+        Takes the list of nodes (including empty nodes). If there are enhanced
+        dependencies in DEPS, builds the enhanced graph and checks that it is
+        rooted and connected.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        nodes : list of udapi.core.node.Node objects
+            List of nodes in the sentence, including empty nodes, sorted by word
+            order.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        unconnected-egraph
+        """
+        egraph_exists = False # enhanced deps are optional
+        egraph = {'0': {'children': set()}}
+        nodeids = set()
+        for node in nodes:
+            parents = [x['parent'] for x in node.deps]
+            if node.is_empty() or len(parents) > 0:
+                egraph_exists = True
+            nodeids.add(str(node.ord))
+            # The graph may already contain a record for the current node if one of
+            # the previous nodes is its child. If it doesn't, we will create it now.
+            egraph.setdefault(str(node.ord), {})
+            egraph[str(node.ord)].setdefault('children', set())
+            # Incrementally build the set of children of every node.
+            for p in parents:
+                egraph.setdefault(str(p.ord), {})
+                egraph[str(p.ord)].setdefault('children', set()).add(str(node.ord))
+        # If there is no trace of enhanced annotation, there are no requirements
+        # on the enhanced graph.
+        if not egraph_exists:
+            return
+        # Check that the graph is rooted and connected. The UD guidelines do not
+        # license unconnected graphs. Projection of the technical root (ord '0')
+        # must contain all nodes.
+        projection = set()
+        node_id = '0'
+        projnodes = list((node_id,))
+        while projnodes:
+            node_id = projnodes.pop()
+            for child in egraph[node_id]['children']:
+                if child in projection:
+                    continue # skip cycles
+                projection.add(child)
+                projnodes.append(child)
+        unreachable = nodeids - projection
+        if unreachable:
+            sur = sorted(unreachable)
+            Error(
+                state=state, config=self.incfg,
+                lineno=state.current_node_linenos[sur[0]],
+                level=2,
+                testclass=TestClass.ENHANCED,
+                testid='unconnected-egraph',
+                message=f"Enhanced graph is not connected. Nodes {sur} are not reachable from any root"
+            ).confirm()
+            return None
+
+
+
+#------------------------------------------------------------------------------
+# Level 2 tests of sentence metadata.
+#------------------------------------------------------------------------------
+
+
+
+    def check_sent_id(self, state):
+        """
+        Checks that sentence id exists, is well-formed and unique.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_lines : list(str)
+            List of lines in the sentence (comments and tokens), including
+            final empty line. The lines are not expected to include the final
+            newline character.
+            First we expect an optional block (zero or more lines) of comments,
+            i.e., lines starting with '#'. Then we expect a non-empty block
+            (one or more lines) of nodes, empty nodes, and multiword tokens.
+            Finally, we expect exactly one empty line.
+        comment_start_line : int
+            The line number (relative to input file, 1-based) of the first line
+            in the current sentence, including comments if any.
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+        known_sent_ids : set
+            Sentence ids already seen in this treebank.
+
+        Writes to state
+        ----------------
+        known_sent_ids : set
+            Sentence ids already seen in this treebank.
+
+        Incidents
+        ---------
+            invalid-sent-id
+            missing-sent-id
+            multiple-sent-id
+            non-unique-sent-id
+            slash-in-sent-id
+        """
+        Incident.default_level = 2
+        Incident.default_testclass = TestClass.METADATA
+        Incident.default_lineno = -1 # use the first line after the comments
+        n_comment_lines = state.sentence_line-state.comment_start_line
+        comments = state.current_lines[0:n_comment_lines]
+        matched = []
+        for c in comments:
+            match = utils.crex.sentid.fullmatch(c)
+            if match:
+                matched.append(match)
+            else:
+                if c.startswith('# sent_id') or c.startswith('#sent_id'):
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='invalid-sent-id',
+                        message=f"Spurious sent_id line: '{c}' should look like '# sent_id = xxxxx' where xxxxx is not whitespace. Forward slash reserved for special purposes."
+                    ).confirm()
+        if not matched:
+            Error(
+                state=state, config=self.incfg,
+                testid='missing-sent-id',
+                message='Missing the sent_id attribute.'
+            ).confirm()
+        elif len(matched) > 1:
+            Error(
+                state=state, config=self.incfg,
+                testid='multiple-sent-id',
+                message='Multiple sent_id attributes.'
+            ).confirm()
+        else:
+            # Uniqueness of sentence ids should be tested treebank-wide, not just file-wide.
+            # For that to happen, all three files should be tested at once.
+            sid = matched[0].group(1)
+            if sid in state.known_sent_ids:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='non-unique-sent-id',
+                    message=f"Non-unique sent_id attribute '{sid}'."
+                ).confirm()
+            if sid.count('/') > 1 or (sid.count('/') == 1 and self.lang != 'ud'):
+                Error(
+                    state=state, config=self.incfg,
+                    testid='slash-in-sent-id',
+                    message=f"The forward slash is reserved for special use in parallel treebanks: '{sid}'"
+                ).confirm()
+            state.known_sent_ids.add(sid)
+
+
+
+    def check_parallel_id(self, state):
+        """
+        The parallel_id sentence-level comment is used after sent_id of
+        sentences that are parallel translations of sentences in other
+        treebanks. Like sent_id, it must be well-formed and unique. Unlike
+        sent_id, it is optional. Sentences that do not have it are not
+        parallel.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_lines : list(str)
+            List of lines in the sentence (comments and tokens), including
+            final empty line. The lines are not expected to include the final
+            newline character.
+            First we expect an optional block (zero or more lines) of comments,
+            i.e., lines starting with '#'. Then we expect a non-empty block
+            (one or more lines) of nodes, empty nodes, and multiword tokens.
+            Finally, we expect exactly one empty line.
+        comment_start_line : int
+            The line number (relative to input file, 1-based) of the first line
+            in the current sentence, including comments if any.
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+        known_parallel_ids : set
+            Parallel sentence ids already seen in this treebank.
+        parallel_id_lastalt : dict
+        parallel_id_lastpart : dict
+
+        Writes to state
+        ----------------
+        known_parallel_ids : set
+            Parallel sentence ids already seen in this treebank.
+        parallel_id_lastalt : dict
+        parallel_id_lastpart : dict
+
+        Incidents
+        ---------
+            invalid-parallel-id
+            multiple-parallel-id
+            non-unique-parallel-id
+            parallel-id-alt
+            parallel-id-part
+        """
+        Incident.default_level = 2
+        Incident.default_testclass = TestClass.METADATA
+        Incident.default_lineno = -1 # use the first line after the comments
+        n_comment_lines = state.sentence_line-state.comment_start_line
+        comments = state.current_lines[0:n_comment_lines]
+        matched = []
+        for c in comments:
+            match = utils.crex.parallelid.fullmatch(c)
+            if match:
+                matched.append(match)
+            else:
+                if c.startswith('# parallel_id') or c.startswith('#parallel_id'):
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='invalid-parallel-id',
+                        message=f"Spurious parallel_id line: '{c}' should look like '# parallel_id = corpus/sentence' where corpus is [a-z]+ and sentence is [-0-9a-z]. Optionally, '/alt[1-9][0-9]*' and/or 'part[1-9][0-9]*' may follow."
+                    ).confirm()
+        if len(matched) > 1:
+            Error(
+                state=state, config=self.incfg,
+                testid='multiple-parallel-id',
+                message='Multiple parallel_id attributes.'
+            ).confirm()
+        elif matched:
+            # Uniqueness of parallel ids should be tested treebank-wide, not just file-wide.
+            # For that to happen, all three files should be tested at once.
+            pid = matched[0].group(1)
+            if pid in state.known_parallel_ids:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='non-unique-parallel-id',
+                    message=f"Non-unique parallel_id attribute '{pid}'."
+                ).confirm()
+            else:
+                # Additional tests when pid has altN or partN.
+                # Do them only if the whole pid is unique.
+                sid = matched[0].group(2) + '/' + matched[0].group(3)
+                alt = None
+                part = None
+                altpart = matched[0].group(4)
+                if altpart:
+                    apmatch = re.fullmatch(r"(?:alt([0-9]+))?(?:part([0-9]+))?", altpart)
+                    if apmatch:
+                        alt = apmatch.group(1)
+                        part = apmatch.group(2)
+                        if alt:
+                            alt = int(alt)
+                        if part:
+                            part = int(part)
+                if sid in state.parallel_id_lastalt:
+                    if state.parallel_id_lastalt[sid] == None and alt != None or state.parallel_id_lastalt[sid] != None and alt == None:
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='parallel-id-alt',
+                            message=f"Some instances of parallel sentence '{sid}' have the 'alt' suffix while others do not."
+                        ).confirm()
+                    elif alt != None and alt != state.parallel_id_lastalt[sid] + 1:
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='parallel-id-alt',
+                            message=f"The alt suffix of parallel sentence '{sid}' should be {state.parallel_id_lastalt[sid]}+1 but it is {alt}."
+                        ).confirm()
+                elif alt != None and alt != 1:
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='parallel-id-alt',
+                        message=f"The alt suffix of parallel sentence '{sid}' should be 1 but it is {alt}."
+                    ).confirm()
+                state.parallel_id_lastalt[sid] = alt
+                if sid in state.parallel_id_lastpart:
+                    if state.parallel_id_lastpart[sid] == None and part != None or state.parallel_id_lastpart[sid] != None and part == None:
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='parallel-id-part',
+                            message=f"Some instances of parallel sentence '{sid}' have the 'part' suffix while others do not."
+                        ).confirm()
+                    elif part != None and part != state.parallel_id_lastpart[sid] + 1:
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='parallel-id-part',
+                            message=f"The part suffix of parallel sentence '{sid}' should be {state.parallel_id_lastpart[sid]}+1 but it is {part}."
+                        ).confirm()
+                elif part != None and part != 1:
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='parallel-id-part',
+                        message=f"The part suffix of parallel sentence '{sid}' should be 1 but it is {part}."
+                    ).confirm()
+                state.parallel_id_lastpart[sid] = part
+            state.known_parallel_ids.add(pid)
+
+
+
+    def check_text_meta(self, state):
+        """
+        Checks metadata other than sentence id, that is, document breaks, paragraph
+        breaks and sentence text (which is also compared to the sequence of the
+        forms of individual tokens, and the spaces vs. SpaceAfter=No in MISC).
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_lines : list(str)
+            List of lines in the sentence (comments and tokens), including
+            final empty line. The lines are not expected to include the final
+            newline character.
+            First we expect an optional block (zero or more lines) of comments,
+            i.e., lines starting with '#'. Then we expect a non-empty block
+            (one or more lines) of nodes, empty nodes, and multiword tokens.
+            Finally, we expect exactly one empty line.
+        comment_start_line : int
+            The line number (relative to input file, 1-based) of the first line
+            in the current sentence, including comments if any.
+        current_token_node_table : list(list(str))
+            The list of multiword token lines / regular node lines / empty node
+            lines, each split to fields (columns).
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+        known_parallel_ids : set
+            Parallel sentence ids already seen in this treebank.
+        parallel_id_lastalt : dict
+        parallel_id_lastpart : dict
+
+        Writes to state
+        ----------------
+        known_parallel_ids : set
+            Parallel sentence ids already seen in this treebank.
+        parallel_id_lastalt : dict
+        parallel_id_lastpart : dict
+
+        Incidents
+        ---------
+        multiple-newdoc
+        multiple-newpar
+        spaceafter-newdocpar
+        missing-text
+        multiple-text
+        text-trailing-whitespace
+        nospaceafter-yes
+        spaceafter-value
+        spaceafter-empty-node
+        spaceafter-mwt-node
+        text-form-mismatch
+        missing-spaceafter
+        text-extra-chars
+        """
+        Incident.default_level = 2
+        Incident.default_testclass = TestClass.METADATA
+        Incident.default_lineno = -1 # use the first line after the comments
+        n_comment_lines = state.sentence_line-state.comment_start_line
+        comments = state.current_lines[0:n_comment_lines]
+        newdoc_matched = []
+        newpar_matched = []
+        text_matched = []
+        for c in comments:
+            newdoc_match = utils.crex.newdoc.fullmatch(c)
+            if newdoc_match:
+                newdoc_matched.append(newdoc_match)
+            newpar_match = utils.crex.newpar.fullmatch(c)
+            if newpar_match:
+                newpar_matched.append(newpar_match)
+            text_match = utils.crex.text.fullmatch(c)
+            if text_match:
+                text_matched.append(text_match)
+        if len(newdoc_matched) > 1:
+            Error(
+                state=state, config=self.incfg,
+                testid='multiple-newdoc',
+                message='Multiple newdoc attributes.'
+            ).confirm()
+        if len(newpar_matched) > 1:
+            Error(
+                state=state, config=self.incfg,
+                testid='multiple-newpar',
+                message='Multiple newpar attributes.'
+            ).confirm()
+        if (newdoc_matched or newpar_matched) and state.spaceafterno_in_effect:
+            Error(
+                state=state, config=self.incfg,
+                testid='spaceafter-newdocpar',
+                message='New document or paragraph starts when the last token of the previous sentence says SpaceAfter=No.'
+            ).confirm()
+        if not text_matched:
+            Error(
+                state=state, config=self.incfg,
+                testid='missing-text',
+                message='Missing the text attribute.'
+            ).confirm()
+        elif len(text_matched) > 1:
+            Error(
+                state=state, config=self.incfg,
+                testid='multiple-text',
+                message='Multiple text attributes.'
+            ).confirm()
+        else:
+            stext = text_matched[0].group(1)
+            if stext[-1].isspace():
+                Error(
+                    state=state, config=self.incfg,
+                    testid='text-trailing-whitespace',
+                    message='The text attribute must not end with whitespace.'
+                ).confirm()
+            # Validate the text against the SpaceAfter attribute in MISC.
+            skip_words = set()
+            mismatch_reported = 0 # do not report multiple mismatches in the same sentence; they usually have the same cause
+            for iline in range(len(state.current_token_node_table)):
+                cols = state.current_token_node_table[iline]
+                if 'NoSpaceAfter=Yes' in cols[MISC]: # I leave this without the split("|") to catch all
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='nospaceafter-yes',
+                        message="'NoSpaceAfter=Yes' should be replaced with 'SpaceAfter=No'."
+                    ).confirm()
+                if len([x for x in cols[MISC].split('|') if re.match(r"^SpaceAfter=", x) and x != 'SpaceAfter=No']) > 0:
+                    Error(
+                        state=state, config=self.incfg,
+                        lineno=state.sentence_line+iline,
+                        testid='spaceafter-value',
+                        message="Unexpected value of the 'SpaceAfter' attribute in MISC. Did you mean 'SpacesAfter'?"
+                    ).confirm()
+                if utils.is_empty_node(cols):
+                    if 'SpaceAfter=No' in cols[MISC]: # I leave this without the split("|") to catch all
+                        Error(
+                            state=state, config=self.incfg,
+                            lineno=state.sentence_line+iline,
+                            testid='spaceafter-empty-node',
+                            message="'SpaceAfter=No' cannot occur with empty nodes."
+                        ).confirm()
+                    continue
+                elif utils.is_multiword_token(cols):
+                    beg, end = cols[ID].split('-')
+                    begi, endi = int(beg), int(end)
+                    # If we see a multi-word token, add its words to an ignore-set – these will be skipped, and also checked for absence of SpaceAfter=No.
+                    for i in range(begi, endi+1):
+                        skip_words.add(str(i))
+                elif cols[ID] in skip_words:
+                    if 'SpaceAfter=No' in cols[MISC]:
+                        Error(
+                            state=state, config=self.incfg,
+                            lineno=state.sentence_line+iline,
+                            testid='spaceafter-mwt-node',
+                            message="'SpaceAfter=No' cannot occur with words that are part of a multi-word token."
+                        ).confirm()
+                    continue
+                else:
+                    # Err, I guess we have nothing to do here. :)
+                    pass
+                # So now we have either a multi-word token or a word which is also a token in its entirety.
+                if not stext.startswith(cols[FORM]):
+                    if not mismatch_reported:
+                        extra_message = ''
+                        if len(stext) >= 1 and stext[0].isspace():
+                            extra_message = ' (perhaps extra SpaceAfter=No at previous token?)'
+                        Error(
+                            state=state, config=self.incfg,
+                            lineno=state.sentence_line+iline,
+                            testid='text-form-mismatch',
+                            message=f"Mismatch between the text attribute and the FORM field. Form[{cols[ID]}] is '{cols[FORM]}' but text is '{stext[:len(cols[FORM])+20]}...'"+extra_message
+                        ).confirm()
+                        mismatch_reported = 1
+                else:
+                    stext = stext[len(cols[FORM]):] # eat the form
+                    # Remember if SpaceAfter=No applies to the last word of the sentence.
+                    # This is not prohibited in general but it is prohibited at the end of a paragraph or document.
+                    if 'SpaceAfter=No' in cols[MISC].split("|"):
+                        state.spaceafterno_in_effect = True
+                    else:
+                        state.spaceafterno_in_effect = False
+                        if (stext) and not stext[0].isspace():
+                            Error(
+                                state=state, config=self.incfg,
+                                lineno=state.sentence_line+iline,
+                                testid='missing-spaceafter',
+                                message=f"'SpaceAfter=No' is missing in the MISC field of node {cols[ID]} because the text is '{utils.shorten(cols[FORM]+stext)}'."
+                            ).confirm()
+                        stext = stext.lstrip()
+            if stext:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='text-extra-chars',
+                    message=f"Extra characters at the end of the text attribute, not accounted for in the FORM fields: '{stext}'"
+                ).confirm()

ud-tools/udtools/src/udtools/level3.py

@@ -0,0 +1,1157 @@
+#! /usr/bin/env python3
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+# According to https://stackoverflow.com/questions/1832893/python-regex-matching-unicode-properties,
+# the regex module has the same API as re but it can check Unicode character properties using \p{}
+# as in Perl.
+#import re
+import regex as re
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    import udtools.src.udtools.utils as utils
+    from udtools.src.udtools.incident import Incident, Error, Warning, TestClass
+    from udtools.src.udtools.level2 import Level2
+except ModuleNotFoundError:
+    import udtools.utils as utils
+    from udtools.incident import Incident, Error, Warning, TestClass
+    from udtools.level2 import Level2
+
+
+
+class Level3(Level2):
+#==============================================================================
+# Level 3 tests. Annotation content vs. the guidelines (only universal tests).
+#==============================================================================
+
+
+    def check_required_feature(self, state, feats, required_feature, required_value, incident):
+        """
+        In general, the annotation of morphological features is optional, although
+        highly encouraged. However, if the treebank does have features, then certain
+        features become required. This function will check the presence of a feature
+        and if it is missing, an error will be reported only if at least one feature
+        has been already encountered. Otherwise the error will be remembered and it
+        may be reported afterwards if any feature is encountered later.
+
+        Parameters
+        ----------
+        feats : udapi.core.dualdict.DualDict object
+            The feature-value set to be tested whether they contain the required one.
+        required_feature : str
+            The name of the required feature.
+        required_value : str
+            The required value of the feature. Multivalues are not supported (they
+            are just a string value containing one or more commas). If
+            required_value is None or an empty string, it means that we require any
+            non-empty value of required_feature.
+        incident : Incident object
+            The message that should be printed if the error is confirmed.
+        """
+        ok = True
+        if required_value:
+            if feats[required_feature] != required_value:
+                ok = False
+        else:
+            if feats[required_feature] == '':
+                ok = False
+        if not ok:
+            if state.seen_morpho_feature:
+                incident.confirm()
+            else:
+                if not incident.testid in state.delayed_feature_errors:
+                    state.delayed_feature_errors[incident.testid] = {'occurrences': []}
+                state.delayed_feature_errors[incident.testid]['occurrences'].append({'incident': incident})
+
+
+    def check_expected_features(self, state, node):
+        """
+        Certain features are expected to occur with certain UPOS or certain values
+        of other features. This function issues warnings instead of errors, as
+        features are in general optional and language-specific. Even the warnings
+        are issued only if the treebank has features. Note that the expectations
+        tested here are considered (more or less) universal. Checking that a given
+        feature-value pair is compatible with a particular UPOS is done using
+        language-specific lists at level 4.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        pron-det-without-prontype
+        verbform-fin-without-mood
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 3
+        Incident.default_testclass = TestClass.MORPHO
+        if node.upos in ['PRON', 'DET']:
+            self.check_required_feature(state, node.feats, 'PronType', None, Warning(
+                state=state, config=self.incfg,
+                testid='pron-det-without-prontype',
+                message=f"The word '{utils.formtl(node)}' is tagged '{node.upos}' but it lacks the 'PronType' feature"
+            ))
+        # See https://github.com/UniversalDependencies/docs/issues/1155 for
+        # complaints about this warning.
+        if node.feats['VerbForm'] == 'Fin' and node.feats['Mood'] == '':
+            Warning(
+                state=state, config=self.incfg,
+                testid='verbform-fin-without-mood',
+                message=f"Finite verb '{utils.formtl(node)}' lacks the 'Mood' feature"
+            ).confirm()
+        # We have to exclude AUX from the following test because they could be
+        # nonverbal and Mood could be their lexical feature
+        # (see https://github.com/UniversalDependencies/docs/issues/1147).
+        # Update: Lithuanian seems to need Mood=Nec with participles. Turning the test off.
+        #elif node.feats['Mood'] != '' and node.feats['VerbForm'] != 'Fin' and not (node.upos == 'AUX' and node.feats['VerbForm'] == ''):
+        #    Warning(
+        #        state=state, config=self.incfg,
+        #        testid='mood-without-verbform-fin',
+        #        message=f"Non-empty 'Mood' feature at a word that is not finite verb ('{utils.formtl(node)}')"
+        #    ).confirm()
+
+
+
+    def check_zero_root(self, state, node):
+        """
+        Checks that DEPREL is "root" iff HEAD is 0.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The node whose incoming relation will be validated. This function
+            operates on both regular and empty nodes. Make sure to call it for
+            empty nodes, too!
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        0-is-not-root
+        root-is-not-0
+        enhanced-0-is-not-root
+        enhanced-root-is-not-0
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 3
+        Incident.default_testclass = TestClass.SYNTAX
+        if not node.is_empty():
+            if node.parent.ord == 0 and node.udeprel != 'root':
+                Error(
+                    state=state, config=self.incfg,
+                    testid='0-is-not-root',
+                    message="DEPREL must be 'root' if HEAD is 0."
+                ).confirm()
+            if node.parent.ord != 0 and node.udeprel == 'root':
+                Error(
+                    state=state, config=self.incfg,
+                    testid='root-is-not-0',
+                    message="DEPREL cannot be 'root' if HEAD is not 0."
+                ).confirm()
+        # In the enhanced graph, test both regular and empty roots.
+        for edep in node.deps:
+            if edep['parent'].ord == 0 and utils.lspec2ud(edep['deprel']) != 'root':
+                Error(
+                    state=state, config=self.incfg,
+                    testclass=TestClass.ENHANCED,
+                    testid='enhanced-0-is-not-root',
+                    message="Enhanced relation type must be 'root' if head is 0."
+                ).confirm()
+            if edep['parent'].ord != 0 and utils.lspec2ud(edep['deprel']) == 'root':
+                Error(
+                    state=state, config=self.incfg,
+                    testclass=TestClass.ENHANCED,
+                    testid='enhanced-root-is-not-0',
+                    message="Enhanced relation type cannot be 'root' if head is not 0."
+                ).confirm()
+
+
+
+    def check_upos_vs_deprel(self, state, node):
+        """
+        For certain relations checks that the dependent word belongs to an expected
+        part-of-speech category. Occasionally we may have to check the children of
+        the node, too.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        fixed-without-extpos
+        rel-upos-det
+        rel-upos-nummod
+        rel-upos-advmod
+        rel-upos-expl
+        rel-upos-aux
+        rel-upos-cop
+        rel-upos-case
+        rel-upos-mark
+        rel-upos-cc
+        rel-upos-punct
+        upos-rel-punct
+        rel-upos-fixed
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 3
+        Incident.default_testclass = TestClass.SYNTAX
+        # Occasionally a word may be marked by the feature ExtPos as acting as
+        # a part of speech different from its usual one (which is given in UPOS).
+        # Typical examples are words that head fixed multiword expressions (the
+        # whole expression acts like a word of that alien part of speech), but
+        # ExtPos may be used also on single words whose external POS is altered.
+        upos = node.upos
+        # Nodes with a fixed child may need ExtPos to signal the part of speech of
+        # the whole fixed expression.
+        if node.feats['ExtPos']:
+            upos = node.feats['ExtPos']
+        # This is a level 3 test, we will check only the universal part of the relation.
+        deprel = node.udeprel
+        childrels = set([x.udeprel for x in node.children])
+        # It is recommended that the head of a fixed expression always has ExtPos,
+        # even if it does not need it to pass the tests in this function.
+        if 'fixed' in childrels and not node.feats['ExtPos']:
+            fixed_forms = [node.form] + [x.form for x in node.children if x.udeprel == 'fixed']
+            str_fixed_forms = ' '.join(fixed_forms)
+            Warning(
+                state=state, config=self.incfg,
+                testid='fixed-without-extpos',
+                message=f"Fixed expression '{str_fixed_forms}' does not have the 'ExtPos' feature"
+            ).confirm()
+        # Certain relations are reserved for nominals and cannot be used for verbs.
+        # Nevertheless, they can appear with adjectives or adpositions if they are promoted due to ellipsis.
+        # Unfortunately, we cannot enforce this test because a word can be cited
+        # rather than used, and then it can take a nominal function even if it is
+        # a verb, as in this Upper Sorbian sentence where infinitives are appositions:
+        # [hsb] Z werba danci "rejować" móže substantiw nastać danco "reja", adjektiw danca "rejowanski" a adwerb dance "rejowansce", ale tež z substantiwa martelo "hamor" móže nastać werb marteli "klepać z hamorom", adjektiw martela "hamorowy" a adwerb martele "z hamorom".
+        # Determiner can alternate with a pronoun.
+        if deprel == 'det' and not re.match(r"^(DET|PRON)", upos):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-det',
+                message=f"'det' should be 'DET' or 'PRON' but it is '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        # Nummod is for "number phrases" only. This could be interpreted as NUM only,
+        # but some languages treat some cardinal numbers as NOUNs, and in
+        # https://github.com/UniversalDependencies/docs/issues/596,
+        # we concluded that the validator will tolerate them.
+        if deprel == 'nummod' and not re.match(r"^(NUM|NOUN|SYM)$", upos):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-nummod',
+                message=f"'nummod' should be 'NUM' but it is '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        # Advmod is for adverbs, perhaps particles but not for prepositional phrases or clauses.
+        # Nevertheless, we should allow adjectives because they can be used as adverbs in some languages.
+        # https://github.com/UniversalDependencies/docs/issues/617#issuecomment-488261396
+        # Bohdan reports that some DET can modify adjectives in a way similar to ADV.
+        # I am not sure whether advmod is the best relation for them but the alternative
+        # det is not much better, so maybe we should not enforce it. Adding DET to the tolerated UPOS tags.
+        if deprel == 'advmod' and not re.match(r"^(ADV|ADJ|CCONJ|DET|PART|SYM)", upos) and not 'goeswith' in childrels:
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-advmod',
+                message=f"'advmod' should be 'ADV' but it is '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        # Known expletives are pronouns. Determiners and particles are probably acceptable, too.
+        if deprel == 'expl' and not re.match(r"^(PRON|DET|PART)$", upos):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-expl',
+                message=f"'expl' should normally be 'PRON' but it is '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        # Auxiliary verb/particle must be AUX.
+        if deprel == 'aux' and not re.match(r"^(AUX)", upos):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-aux',
+                message=f"'aux' should be 'AUX' but it is '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        # Copula is an auxiliary verb/particle (AUX) or a pronoun (PRON|DET).
+        if deprel == 'cop' and not re.match(r"^(AUX|PRON|DET|SYM)", upos):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-cop',
+                message=f"'cop' should be 'AUX' or 'PRON'/'DET' but it is '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        # Case is normally an adposition, maybe particle.
+        # However, there are also secondary adpositions and they may have the original POS tag:
+        # NOUN: [cs] pomocí, prostřednictvím
+        # VERB: [en] including
+        # Interjection can also act as case marker for vocative, as in Sanskrit: भोः भगवन् / bhoḥ bhagavan / oh sir.
+        if deprel == 'case' and re.match(r"^(PROPN|ADJ|PRON|DET|NUM|AUX)", upos):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-case',
+                message=f"'case' should not be '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        # Mark is normally a conjunction or adposition, maybe particle but definitely not a pronoun.
+        ###!!! February 2022: Temporarily allow mark+VERB ("regarding"). In the future, it should be banned again
+        ###!!! by default (and case+VERB too), but there should be a language-specific list of exceptions.
+        ###!!! In 2024 I wanted to re-enable the test because people could use the
+        ###!!! newly approved ExtPos feature to signal that "regarding" is acting
+        ###!!! as a function word, but Amir was opposed to the idea that ExtPos would
+        ###!!! now be required also for single-word expressions.
+        if deprel == 'mark' and re.match(r"^(NOUN|PROPN|ADJ|PRON|DET|NUM|AUX|INTJ)", upos):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-mark',
+                message=f"'mark' should not be '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        # Cc is a conjunction, possibly an adverb or particle.
+        if deprel == 'cc' and re.match(r"^(NOUN|PROPN|ADJ|PRON|DET|NUM|VERB|AUX|INTJ)", upos):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-cc',
+                message=f"'cc' should not be '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        if deprel == 'punct' and upos != 'PUNCT':
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-punct',
+                message=f"'punct' must be 'PUNCT' but it is '{upos}' ('{utils.formtl(node)}')"
+            ).confirm()
+        if upos == 'PUNCT' and not re.match(r"^(punct|root)", deprel):
+            Error(
+                state=state, config=self.incfg,
+                testid='upos-rel-punct',
+                message=f"'PUNCT' must be 'punct' but it is '{node.deprel}' ('{utils.formtl(node)}')"
+            ).confirm()
+        if upos == 'PROPN' and (deprel == 'fixed' or 'fixed' in childrels):
+            Error(
+                state=state, config=self.incfg,
+                testid='rel-upos-fixed',
+                message=f"'fixed' should not be used for proper nouns ('{utils.formtl(node)}')."
+            ).confirm()
+
+
+
+    def check_flat_foreign(self, state, node):
+        """
+        flat:foreign is an optional subtype of flat. It is used to connect two words
+        in a code-switched segment of foreign words if the annotators did not want
+        to provide the analysis according to the source language. If flat:foreign
+        is used, both the parent and the child should have the Foreign=Yes feature
+        and their UPOS tag should be X.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        flat-foreign-upos-feats
+        """
+        Incident.default_level = 3
+        Incident.default_testclass = TestClass.MORPHO
+        if node.deprel != 'flat:foreign':
+            return
+        parent = node.parent
+        if node.upos != 'X' or str(node.feats) != 'Foreign=Yes':
+            Warning(
+                state=state, config=self.incfg,
+                lineno=state.current_node_linenos[str(node.ord)],
+                nodeid=node.ord,
+                testid='flat-foreign-upos-feats',
+                message="The child of a flat:foreign relation should have UPOS X and Foreign=Yes (but no other features)."
+            ).confirm()
+        if parent.upos != 'X' or str(parent.feats) != 'Foreign=Yes':
+            Warning(
+                state=state, config=self.incfg,
+                lineno=state.current_node_linenos[str(parent.ord)],
+                nodeid=parent.ord,
+                testid='flat-foreign-upos-feats',
+                message="The parent of a flat:foreign relation should have UPOS X and Foreign=Yes (but no other features)."
+            ).confirm()
+
+
+
+    def check_left_to_right_relations(self, state, node):
+        """
+        Certain UD relations must always go left-to-right (in the logical order,
+        meaning that parent precedes child, disregarding that some languages have
+        right-to-left writing systems).
+        Here we currently check the rule for the basic dependencies.
+        The same should also be tested for the enhanced dependencies!
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        right-to-left-conj
+        right-to-left-fixed
+        right-to-left-flat
+        right-to-left-goeswith
+        right-to-left-appos
+        """
+        # According to the v2 guidelines, apposition should also be left-headed, although the definition of apposition may need to be improved.
+        if node.udeprel in ['conj', 'fixed', 'flat', 'goeswith', 'appos']:
+            ichild = node.ord
+            iparent = node.parent.ord
+            if ichild < iparent:
+                # We must recognize the relation type in the test id so we can manage exceptions for legacy treebanks.
+                # For conj, flat, and fixed the requirement was introduced already before UD 2.2.
+                # For appos and goeswith the requirement was introduced before UD 2.4.
+                # The designation "right-to-left" is confusing in languages with right-to-left writing systems.
+                # We keep it in the testid but we make the testmessage more neutral.
+                Error(
+                    state=state, config=self.incfg,
+                    lineno=state.current_node_linenos[str(node.ord)],
+                    nodeid=node.ord,
+                    level=3,
+                    testclass=TestClass.SYNTAX,
+                    testid=f"right-to-left-{node.udeprel}",
+                    message=f"Parent of relation '{node.deprel}' must precede the child in the word order."
+                ).confirm()
+
+
+
+    def check_single_subject(self, state, node):
+        """
+        No predicate should have more than one subject.
+        An xcomp dependent normally has no subject, but in some languages the
+        requirement may be weaker: it could have an overt subject if it is
+        correferential with a particular argument of the matrix verb. Hence we do
+        not check zero subjects of xcomp dependents at present.
+        Furthermore, in some situations we must allow multiple subjects. If a clause
+        acts as a nonverbal predicate of another clause, then we must attach two
+        subjects to the predicate of the inner clause: one is the predicate of the
+        inner clause, the other is the predicate of the outer clause. This could in
+        theory be recursive but in practice it isn't. As of UD 2.10, an amendment
+        of the guidelines says that the inner predicate of the predicate clause
+        should govern both subjects even if there is a copula (previously such
+        cases were an exception from the UD approach that copulas should not be
+        heads); however, the outer subjects should be attached as [nc]subj:outer.
+        See https://universaldependencies.org/changes.html#multiple-subjects.
+        See also issue 34 (https://github.com/UniversalDependencies/tools/issues/34).
+        Strictly speaking, :outer is optional because it is a subtype, and some
+        treebanks may want to avoid it. For example, in Coptic Scriptorium, there
+        is only one occurrence in dev, one in test, and none in train, so it would
+        be impossible to train a parser that gets it right. For that reason, it is
+        possible to replace the :outer subtype with Subject=Outer in MISC. The MISC
+        attribute is just a directive for the validator and no parser is expected
+        to predict it.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        too-many-subjects
+        """
+
+        def is_inner_subject(node):
+            """
+            Takes a node (udapi.core.node.Node). Tells whether the node's deprel is
+            nsubj or csubj without the :outer subtype. Alternatively, instead of the
+            :outer subtype, the node could have Subject=Outer in MISC.
+            """
+            if not re.search(r'subj', node.udeprel):
+                return False
+            if re.match(r'^[nc]subj:outer$', node.deprel):
+                return False
+            if node.misc['Subject'] == 'Outer':
+                return False
+            return True
+
+        subjects = [x for x in node.children if is_inner_subject(x)]
+        subject_ids = [x.ord for x in subjects]
+        subject_forms = [utils.formtl(x) for x in subjects]
+        subject_references = utils.create_references(subjects, state, 'Subject')
+        if len(subjects) > 1:
+            Error(
+                state=state, config=self.incfg,
+                lineno=state.current_node_linenos[str(node.ord)],
+                nodeid=node.ord,
+                level=3,
+                testclass=TestClass.SYNTAX,
+                testid='too-many-subjects',
+                message=f"Multiple subjects {str(subject_ids)} ({str(subject_forms)[1:-1]}) under the predicate '{utils.formtl(node)}' not subtyped as ':outer'.",
+                explanation="Outer subjects are allowed if a clause acts as the predicate of another clause.",
+                references=subject_references
+            ).confirm()
+
+
+
+    def check_single_object(self, state, node):
+        """
+        No predicate should have more than one direct object (number of indirect
+        objects is unlimited). Theoretically, ccomp should be understood as a
+        clausal equivalent of a direct object, but we do not have an indirect
+        equivalent, so it seems better to tolerate additional ccomp at present.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        too-many-objects
+        """
+        objects = [x for x in node.children if x.udeprel == 'obj']
+        object_ids = [x.ord for x in objects]
+        object_forms = [utils.formtl(x) for x in objects]
+        object_references = utils.create_references(objects, state, 'Object')
+        if len(objects) > 1:
+            Error(
+                state=state, config=self.incfg,
+                lineno=state.current_node_linenos[str(node.ord)],
+                nodeid=node.ord,
+                level=3,
+                testclass=TestClass.SYNTAX,
+                testid='too-many-objects',
+                message=f"Multiple direct objects {str(object_ids)} ({str(object_forms)[1:-1]}) under the predicate '{utils.formtl(node)}'.",
+                references=object_references
+            ).confirm()
+
+
+
+    def check_nmod_obl(self, state, node):
+        """
+        The difference between nmod and obl is that the former modifies a
+        nominal while the latter modifies a predicate of a clause. Typically
+        the parent of nmod will be NOUN, PROPN or PRON; the parent of obl is
+        usually a VERB, sometimes ADJ or ADV. However, nominals can also be
+        predicates and then they may take obl dependents:
+            I am the leader of the group (nmod)
+            I am the leader on Mondays (obl)
+        This function tries to detect at least some cases where the nominal
+        is not a predicate and thus cannot take obl dependents.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        obl-should-be-nmod
+        """
+        if node.udeprel == 'obl' and node.parent.upos in ['NOUN', 'PROPN', 'PRON']:
+            # If the parent itself has certain deprels, we know that it is just
+            # a nominal and not a predicate. This will reveal some erroneous
+            # obliques but not all, because we will not recognize some non-
+            # predicative nominals, and even for the predicative ones, some
+            # dependents might be better analyzed as nmod.
+            if node.parent.udeprel in ['nsubj', 'obj', 'iobj', 'obl', 'vocative', 'dislocated', 'expl', 'nmod']:
+                # For the moment (2025-09-20), I am making this a warning only.
+                # But I suppose that it will became an error in the future.
+                Error(
+                    state=state, config=self.incfg,
+                    lineno=state.current_node_linenos[str(node.ord)],
+                    nodeid=node.ord,
+                    level=3,
+                    testclass=TestClass.SYNTAX,
+                    testid='obl-should-be-nmod',
+                    message=f"The parent (node [{node.parent.ord}] '{utils.formtl(node.parent)}') is a nominal (and not a predicate), hence the relation should be 'nmod', not 'obl'.",
+                    references=utils.create_references([node.parent], state, 'Parent')
+                ).confirm()
+
+
+
+    def check_orphan(self, state, node):
+        """
+        The orphan relation is used to attach an unpromoted orphan to the promoted
+        orphan in gapping constructions. A common error is that the promoted orphan
+        gets the orphan relation too. The parent of orphan is typically attached
+        via a conj relation, although some other relations are plausible too.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        orphan-parent
+        """
+        # This is a level 3 test, we will check only the universal part of the relation.
+        if node.udeprel == 'orphan':
+            # We include advcl because gapping (or something very similar) can also
+            # occur in subordinate clauses: "He buys companies like my mother [does] vegetables."
+            # In theory, a similar pattern could also occur with reparandum.
+            # A similar pattern also occurs with acl, e.g. in Latvian:
+            # viņš ēd tos ābolus, ko pirms tam [ēda] tārpi ('he eats the same apples, which were [eaten] by worms before that')
+            # Other clausal heads (ccomp, csubj) may be eligible as well, e.g. in Latvian
+            # (see also issue 635 2019-09-19):
+            # atjēdzos, ka bez angļu valodas nekur [netikšu] '[I] realised, that [I will get] nowhere without English'
+            # 2023-04-14: Reclassifying the test as warning only. Due to promotion,
+            # the parent of orphan may receive many other relations. See issue 635
+            # for details and a Latin example.
+            if not re.match(r"^(conj|parataxis|root|csubj|ccomp|advcl|acl|reparandum)$", node.parent.udeprel):
+                Warning(
+                    state=state, config=self.incfg,
+                    lineno=state.current_node_linenos[str(node.ord)],
+                    nodeid=node.ord,
+                    level=3,
+                    testclass=TestClass.SYNTAX,
+                    testid='orphan-parent',
+                    message=f"The parent of 'orphan' should normally be 'conj' but it is '{node.parent.udeprel}'.",
+                    references=utils.create_references([node.parent], state, 'Parent')
+                ).confirm()
+
+
+
+    def check_functional_leaves(self, state, node):
+        """
+        Most of the time, function-word nodes should be leaves. This function
+        checks for known exceptions and warns in the other cases.
+        (https://universaldependencies.org/u/overview/syntax.html#function-word-modifiers)
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        leaf-mark-case
+        leaf-aux-cop
+        leaf-det
+        leaf-clf
+        leaf-cc
+        leaf-fixed
+        leaf-goeswith
+        leaf-punct
+        """
+        # This is a level 3 test, we will check only the universal part of the relation.
+        deprel = node.udeprel
+        if deprel in ['case', 'mark', 'cc', 'aux', 'cop', 'det', 'clf', 'fixed', 'goeswith', 'punct']:
+            idparent = node.ord
+            pdeprel = deprel
+            pfeats = node.feats
+            for child in node.children:
+                idchild = child.ord
+                Incident.default_lineno = state.current_node_linenos[str(idchild)]
+                Incident.default_level = 3
+                Incident.default_testclass = TestClass.SYNTAX
+                cdeprel = child.udeprel
+                # The guidelines explicitly say that negation can modify any function word
+                # (see https://universaldependencies.org/u/overview/syntax.html#function-word-modifiers).
+                # We cannot recognize negation simply by deprel; we have to look at the
+                # part-of-speech tag and the Polarity feature as well.
+                cupos = child.upos
+                cfeats = child.feats
+                if pdeprel != 'punct' and cdeprel == 'advmod' and re.match(r"^(PART|ADV)$", cupos) and cfeats['Polarity'] == 'Neg':
+                    continue
+                # Punctuation should not depend on function words if it can be projectively
+                # attached to a content word. But sometimes it cannot. Czech example:
+                # "Budou - li však zbývat , ukončíme" (lit. "will - if however remain , we-stop")
+                # "však" depends on "ukončíme" while "budou" and "li" depend nonprojectively
+                # on "zbývat" (which depends on "ukončíme"). "Budou" is aux and "li" is mark.
+                # Yet the hyphen must depend on one of them because any other attachment would
+                # be non-projective. Here we assume that if the parent of a punctuation node
+                # is attached nonprojectively, punctuation can be attached to it to avoid its
+                # own nonprojectivity.
+                if node.is_nonprojective() and cdeprel == 'punct':
+                    continue
+                # Auxiliaries, conjunctions and case markers will tollerate a few special
+                # types of modifiers.
+                # Punctuation should normally not depend on a functional node. However,
+                # it is possible that a functional node such as auxiliary verb is in
+                # quotation marks or brackets ("must") and then these symbols should depend
+                # on the functional node. We temporarily allow punctuation here, until we
+                # can detect precisely the bracket situation and disallow the rest.
+                # According to the guidelines
+                # (https://universaldependencies.org/u/overview/syntax.html#function-word-modifiers),
+                # mark can have a limited set of adverbial/oblique dependents, while the same
+                # is not allowed for nodes attached as case. Nevertheless, there are valid
+                # objections against this (see https://github.com/UniversalDependencies/docs/issues/618)
+                # and we may want to revisit the guideline in UD v3. For the time being,
+                # we make the validator more benevolent to 'case' too. (If we now force people
+                # to attach adverbials higher, information will be lost and later reversal
+                # of the step will not be possible.)
+                # Coordinating conjunctions usually depend on a non-first conjunct, i.e.,
+                # on a node whose deprel is 'conj'. However, there are paired conjunctions
+                # such as "both-and", "either-or". Here the first part is attached to the
+                # first conjunct. Since some function nodes (mark, case, aux, cop) can be
+                # coordinated, we must allow 'cc' children under these nodes, too. However,
+                # we do not want to allow 'cc' under another 'cc'. (Still, 'cc' can have
+                # a 'conj' dependent. In "and/or", "or" will depend on "and" as 'conj'.)
+                if re.match(r"^(mark|case)$", pdeprel) and not re.match(r"^(advmod|obl|goeswith|fixed|reparandum|conj|cc|punct)$", cdeprel):
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='leaf-mark-case',
+                        message=f"'{pdeprel}' not expected to have children ({idparent}:{node.form}:{pdeprel} --> {idchild}:{child.form}:{cdeprel})"
+                    ).confirm()
+                if re.match(r"^(aux|cop)$", pdeprel) and not re.match(r"^(goeswith|fixed|reparandum|conj|cc|punct)$", cdeprel):
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='leaf-aux-cop',
+                        message=f"'{pdeprel}' not expected to have children ({idparent}:{node.form}:{pdeprel} --> {idchild}:{child.form}:{cdeprel})"
+                    ).confirm()
+                # Classifiers must be allowed under demonstrative determiners according to the clf guidelines.
+                # People have identified various constructions where the restriction
+                # on children of det dependents may have to be relaxed even if not
+                # mentioned directly in the universal guidelines.
+                # https://universaldependencies.org/workgroups/newdoc/children_of_determiners.html
+                # Latvian: There are compound determiners, composed of a PART and a head PRON.
+                # They are not fixed, so they need a separate exception for the compound deprel.
+                # (Laura, https://github.com/UniversalDependencies/docs/issues/1059#issuecomment-2413484624)
+                # Hebrew: Demonstrative pronouns have their own determiners, as in “the men the these” = “these men”.
+                # It is also parallel to how adjectival modification works in Modern Hebrew.
+                # Maybe determiners under demonstratives could be allowed in some languages but not the others?
+                # (Daniel, https://github.com/UniversalDependencies/docs/issues/1059#issuecomment-2400694043)
+                # Classical Armenian: Case marker may be repeated both at a noun and at its demonstrative.
+                # We probably should allow demonstratives to have their own case child, but ideally we should
+                # not allow it for all determiners in all languages because it opens the door for errors
+                # (currently there are such errors in Chinese data). ###!!! For now I am allowing it everywhere.
+                # (Petr, https://github.com/UniversalDependencies/docs/issues/1059#issuecomment-2441260051)
+                # Spoken data:
+                # There is a lot of fillers ("euh"), tagged INTJ and attached as discourse
+                # "to the most relevant nearby unit" (that is the guideline). The most
+                # relevant nearby unit may be a determiner. Similarly, parentheticals
+                # should be attached as parataxis to the most relevant unit, and again
+                # the unit is not necessarily a clause. For example, Latvian:
+                # "tādā godīgā iestādē ieperinājušies daži (tikai daži!) zagļi"
+                # “a few (only a few!) thieves have nested in such an honest institution”
+                # (Laura, https://github.com/UniversalDependencies/docs/issues/1059#issuecomment-2438448236)
+                # Several treebanks have problems with possessive determiners, which
+                # are referential and can thus take dependents such as appos, acl:relcl, even nmod.
+                # Joakim thinks that such possessives should be nmod rather than det,
+                # but that's not how many of us understand the UD guidelines. For now,
+                # the test should be thus relaxed if the determiner has Poss=Yes.
+                # Flavio also argued that certain multiword det expressions should be
+                # connected by flat:redup (rather than fixed), which is why flat should
+                # be another exception.
+                if re.match(r"^(det)$", pdeprel) and not re.match(r"^(det|case|advmod|obl|clf|goeswith|fixed|flat|compound|reparandum|discourse|parataxis|conj|cc|punct)$", cdeprel) and not (pfeats['Poss'] == 'Yes' and re.match(r"^(appos|acl|nmod)$", cdeprel)):
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='leaf-det',
+                        message=f"'{pdeprel}' not expected to have children ({idparent}:{node.form}:{pdeprel} --> {idchild}:{child.form}:{cdeprel})"
+                    ).confirm()
+                if re.match(r"^(clf)$", pdeprel) and not re.match(r"^(advmod|obl|goeswith|fixed|reparandum|conj|cc|punct)$", cdeprel):
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='leaf-clf',
+                        message=f"'{pdeprel}' not expected to have children ({idparent}:{node.form}:{pdeprel} --> {idchild}:{child.form}:{cdeprel})"
+                    ).confirm()
+                if re.match(r"^(cc)$", pdeprel) and not re.match(r"^(goeswith|fixed|reparandum|conj|punct)$", cdeprel):
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='leaf-cc',
+                        message=f"'{pdeprel}' not expected to have children ({idparent}:{node.form}:{pdeprel} --> {idchild}:{child.form}:{cdeprel})"
+                    ).confirm()
+                # Fixed expressions should not be nested, i.e., no chains of fixed relations.
+                # As they are supposed to represent functional elements, they should not have
+                # other dependents either, with the possible exception of conj.
+                # We also allow a punct child, at least temporarily, because of fixed
+                # expressions that have a hyphen in the middle (e.g. Russian "вперед-назад").
+                # It would be better to keep these expressions as one token. But sometimes
+                # the tokenizer is out of control of the UD data providers and it is not
+                # practical to retokenize.
+                elif pdeprel == 'fixed' and not re.match(r"^(goeswith|reparandum|conj|punct)$", cdeprel):
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='leaf-fixed',
+                        message=f"'{pdeprel}' not expected to have children ({idparent}:{node.form}:{pdeprel} --> {idchild}:{child.form}:{cdeprel})"
+                    ).confirm()
+                # Goeswith cannot have any children, not even another goeswith.
+                elif pdeprel == 'goeswith':
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='leaf-goeswith',
+                        message=f"'{pdeprel}' not expected to have children ({idparent}:{node.form}:{pdeprel} --> {idchild}:{child.form}:{cdeprel})"
+                    ).confirm()
+                # Punctuation can exceptionally have other punct children if an exclamation
+                # mark is in brackets or quotes. It cannot have other children.
+                elif pdeprel == 'punct' and cdeprel != 'punct':
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='leaf-punct',
+                        message=f"'{pdeprel}' not expected to have children ({idparent}:{node.form}:{pdeprel} --> {idchild}:{child.form}:{cdeprel})"
+                    ).confirm()
+
+
+
+    def check_fixed_span(self, state, node):
+        """
+        Like with goeswith, the fixed relation should not in general skip words that
+        are not part of the fixed expression. Unlike goeswith however, there can be
+        an intervening punctuation symbol. Moreover, the rule that fixed expressions
+        cannot be discontiguous has been challenged with examples from Swedish and
+        Coptic, see https://github.com/UniversalDependencies/docs/issues/623.
+        Hence, the test was turned off 2019-04-13. I am re-activating it 2023-09-03
+        as just a warning.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        fixed-gap
+        """
+        fxchildren = [c for c in node.children if c.udeprel == 'fixed']
+        if fxchildren:
+            fxlist = sorted([node] + fxchildren)
+            fxrange = [n for n in node.root.descendants if n.ord >= node.ord and n.ord <= fxchildren[-1].ord]
+            # All nodes between me and my last fixed child should be either fixed or punct.
+            fxgap = [n for n in fxrange if n.udeprel != 'punct' and n not in fxlist]
+            if fxgap:
+                fxordlist = [n.ord for n in fxlist]
+                fxexpr = ' '.join([(n.form if n in fxlist else '*') for n in fxrange])
+                Warning(
+                    state=state, config=self.incfg,
+                    lineno=state.current_node_linenos[str(node.ord)],
+                    nodeid=node.ord,
+                    level=3,
+                    testclass=TestClass.SYNTAX,
+                    testid='fixed-gap',
+                    message=f"Gaps in fixed expression {str(fxordlist)} '{fxexpr}'"
+                ).confirm()
+
+
+    def check_goeswith_span(self, state, node):
+        """
+        The relation 'goeswith' is used to connect word parts that are separated
+        by whitespace and should be one word instead. We assume that the relation
+        goes left-to-right, which is checked elsewhere. Here we check that the
+        nodes really were separated by whitespace. If there is another node in the
+        middle, it must be also attached via 'goeswith'. The parameter id refers to
+        the node whose goeswith children we test.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        goeswith-gap
+        goeswith-nospace
+        goeswith-missing-typo
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 3
+        Incident.default_testclass = TestClass.SYNTAX
+        gwchildren = [c for c in node.children if c.udeprel == 'goeswith']
+        if gwchildren:
+            gwlist = sorted([node] + gwchildren)
+            gwrange = [n for n in node.root.descendants if n.ord >= node.ord and n.ord <= gwchildren[-1].ord]
+            # All nodes between me and my last goeswith child should be goeswith too.
+            if gwlist != gwrange:
+                gwordlist = [n.ord for n in gwlist]
+                gwordrange = [n.ord for n in gwrange]
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='goeswith-gap',
+                    message=f"Gaps in goeswith group {str(gwordlist)} != {str(gwordrange)}."
+                ).confirm()
+            # Non-last node in a goeswith range must have a space after itself.
+            nospaceafter = [x for x in gwlist[:-1] if x.misc['SpaceAfter'] == 'No']
+            if nospaceafter:
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='goeswith-nospace',
+                    message="'goeswith' cannot connect nodes that are not separated by whitespace."
+                ).confirm()
+            # This is not about the span of the interrupted word, but since we already
+            # know that we are at the head of a goeswith word, let's do it here, too.
+            # Every goeswith parent should also have Typo=Yes. However, this is not
+            # required if the treebank does not have features at all.
+            incident = Error(
+                state=state, config=self.incfg,
+                nodeid=node.ord,
+                testclass=TestClass.MORPHO,
+                testid='goeswith-missing-typo',
+                message="Since the treebank has morphological features, 'Typo=Yes' must be used with 'goeswith' heads."
+            )
+            self.check_required_feature(state, node.feats, 'Typo', 'Yes', incident)
+
+
+
+    def check_goeswith_morphology_and_edeps(self, state, node):
+        """
+        If a node has the 'goeswith' incoming relation, it is a non-first part of
+        a mistakenly interrupted word. The lemma, upos tag and morphological features
+        of the word should be annotated at the first part, not here.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        goeswith-lemma
+        goeswith-upos
+        goeswith-feats
+        goeswith-edeps
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 3
+        Incident.default_testclass = TestClass.MORPHO
+        if node.udeprel == 'goeswith':
+            if node.lemma != '_':
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='goeswith-lemma',
+                    message="The lemma of a 'goeswith'-connected word must be annotated only at the first part."
+                ).confirm()
+            if node.upos != 'X':
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='goeswith-upos',
+                    message="The UPOS tag of a 'goeswith'-connected word must be annotated only at the first part; the other parts must be tagged 'X'."
+                ).confirm()
+            if str(node.feats) != '_':
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='goeswith-feats',
+                    message="The morphological features of a 'goeswith'-connected word must be annotated only at the first part."
+                ).confirm()
+            if str(node.raw_deps) != '_' and str(node.raw_deps) != str(node.parent.ord)+':'+node.deprel:
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testclass=TestClass.ENHANCED,
+                    testid='goeswith-edeps',
+                    message="A 'goeswith' dependent cannot have any additional dependencies in the enhanced graph."
+                ).confirm()
+
+
+
+    def check_projective_punctuation(self, state, node):
+        """
+        Punctuation is not supposed to cause nonprojectivity or to be attached
+        nonprojectively.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The tree node to be tested.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        punct-causes-nonproj
+        punct-is-nonproj
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 3
+        Incident.default_testclass = TestClass.SYNTAX
+        if node.udeprel == 'punct':
+            nonprojnodes = utils.get_caused_nonprojectivities(node)
+            if nonprojnodes:
+                nonprojids = [x.ord for x in nonprojnodes]
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='punct-causes-nonproj',
+                    message=f"Punctuation must not cause non-projectivity of nodes {nonprojids}",
+                    references=utils.create_references(nonprojnodes, state, 'Node made nonprojective')
+                ).confirm()
+            gapnodes = utils.get_gap(node)
+            if gapnodes:
+                gapids = [x.ord for x in gapnodes]
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='punct-is-nonproj',
+                    message=f"Punctuation must not be attached non-projectively over nodes {gapids}",
+                    references=utils.create_references(gapnodes, state, 'Node in gap')
+                ).confirm()
+
+
+
+    def check_enhanced_orphan(self, state, node):
+        """
+        Checks universally valid consequences of the annotation guidelines in the
+        enhanced representation. Currently tests only phenomena specific to the
+        enhanced dependencies; however, we should also test things that are
+        required in the basic dependencies (such as left-to-right coordination),
+        unless it is obvious that in enhanced dependencies such things are legal.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The node whose incoming relation will be validated. This function
+            operates on both regular and empty nodes. Make sure to call it for
+            empty nodes, too!
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        empty-node-after-eorphan
+        eorphan-after-empty-node
+        """
+        lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_lineno = lineno
+        Incident.default_level = 3
+        Incident.default_testclass = TestClass.ENHANCED
+        # Enhanced dependencies should not contain the orphan relation.
+        # However, all types of enhancements are optional and orphans are excluded
+        # only if this treebank addresses gapping. We do not know it until we see
+        # the first empty node.
+        if str(node.deps) == '_':
+            return
+        if node.is_empty():
+            if not state.seen_empty_node:
+                state.seen_empty_node = lineno
+                # Empty node itself is not an error. Report it only for the first time
+                # and only if an orphan occurred before it.
+                if state.seen_enhanced_orphan:
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='empty-node-after-eorphan',
+                        message=f"Empty node means that we address gapping and there should be no orphans in the enhanced graph; but we saw one on line {state.seen_enhanced_orphan}"
+                    ).confirm()
+        udeprels = set([utils.lspec2ud(edep['deprel']) for edep in node.deps])
+        if 'orphan' in udeprels:
+            if not state.seen_enhanced_orphan:
+                state.seen_enhanced_orphan = lineno
+            # If we have seen an empty node, then the orphan is an error.
+            if  state.seen_empty_node:
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='eorphan-after-empty-node',
+                    message=f"'orphan' not allowed in enhanced graph because we saw an empty node on line {state.seen_empty_node}"
+                ).confirm()

ud-tools/udtools/src/udtools/level4.py

@@ -0,0 +1,295 @@
+#! /usr/bin/env python3
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+# According to https://stackoverflow.com/questions/1832893/python-regex-matching-unicode-properties,
+# the regex module has the same API as re but it can check Unicode character properties using \p{}
+# as in Perl.
+#import re
+import regex as re
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    import udtools.src.udtools.utils as utils
+    from udtools.src.udtools.incident import Incident, Error, TestClass
+    from udtools.src.udtools.level3 import Level3
+except ModuleNotFoundError:
+    import udtools.utils as utils
+    from udtools.incident import Incident, Error, TestClass
+    from udtools.level3 import Level3
+
+
+
+class Level4(Level3):
+#==============================================================================
+# Level 4 tests. Language-specific formal tests. Now we can check in which
+# words spaces are permitted, and which Feature=Value pairs are defined.
+#==============================================================================
+
+
+
+    def check_words_with_spaces(self, state, node):
+        """
+        Checks a single line for disallowed whitespace.
+        Here we assume that all language-independent whitespace-related tests have
+        already been done on level 1, so we only check for words with spaces that
+        are explicitly allowed in a given language.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The node whose incoming relation will be validated. This function
+            operates on both regular and empty nodes. Make sure to call it for
+            empty nodes, too!
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        invalid-word-with-space
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 4
+        Incident.default_testclass = TestClass.FORMAT
+        # List of permited words with spaces is language-specific.
+        # The current token may be in a different language due to code switching.
+        tospacedata = self.data.get_tospace_for_language(self.lang)
+        lang = self.lang
+        altlang = utils.get_alt_language(node)
+        if altlang:
+            lang = altlang
+            tospacedata = self.data.get_tospace_for_language(altlang)
+        for column in ('FORM', 'LEMMA'):
+            word = node.form if column == 'FORM' else node.lemma
+            # Is there whitespace in the word?
+            if utils.crex.ws.search(word):
+                # Whitespace found. Does the word pass the regular expression that defines permitted words with spaces in this language?
+                if tospacedata:
+                    # For the purpose of this test, NO-BREAK SPACE is equal to SPACE.
+                    string_to_test = re.sub(r'\xA0', ' ', word)
+                    if not tospacedata[1].fullmatch(string_to_test):
+                        Error(
+                            state=state, config=self.incfg,
+                            nodeid=node.ord,
+                            testid='invalid-word-with-space',
+                            message=f"'{word}' in column {column} is not on the list of exceptions allowed to contain whitespace.",
+                            explanation=self.data.explain_tospace(lang)
+                        ).confirm()
+                else:
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='invalid-word-with-space',
+                        message=f"'{word}' in column {column} is not on the list of exceptions allowed to contain whitespace.",
+                        explanation=self.data.explain_tospace(lang)
+                    ).confirm()
+
+
+
+    def check_feature_values(self, state, node):
+        """
+        Checks that a feature-value pair is listed as approved. Feature lists are
+        language-specific. To disallow non-universal features, test on level 4 with
+        language 'ud'.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The node whose incoming relation will be validated. This function
+            operates on both regular and empty nodes. Make sure to call it for
+            empty nodes, too!
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        mwt-typo-repeated-at-word
+        feature-unknown
+        feature-not-permitted
+        feature-value-unknown
+        feature-upos-not-permitted
+        feature-value-upos-not-permitted
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 4
+        Incident.default_testclass = TestClass.MORPHO
+        if str(node.feats) == '_':
+            return True
+        # List of permited features is language-specific.
+        # The current token may be in a different language due to code switching.
+        default_lang = self.lang
+        default_featset = featset = self.data.get_feats_for_language(self.lang)
+        lang = default_lang
+        altlang = utils.get_alt_language(node)
+        if altlang:
+            lang = altlang
+            featset = self.data.get_feats_for_language(altlang)
+        for f in node.feats:
+            values = node.feats[f].split(',')
+            for v in values:
+                # Level 2 tested character properties and canonical order but not that the f-v pair is known.
+                # Level 4 also checks whether the feature value is on the list.
+                # If only universal feature-value pairs are allowed, test on level 4 with lang='ud'.
+                # The feature Typo=Yes is the only feature allowed on a multi-word token line.
+                # If it occurs there, it cannot be duplicated on the lines of the component words.
+                if f == 'Typo' and node.multiword_token:
+                    mwt = node.multiword_token
+                    if mwt.feats['Typo'] == 'Yes':
+                        Error(
+                            state=state, config=self.incfg,
+                            nodeid=node.ord,
+                            testid='mwt-typo-repeated-at-word',
+                            message=f"Feature Typo cannot occur at word [{node.ord}] if it already occurred at the corresponding multiword token [{mwt.ord_range}]."
+                        ).confirm()
+                # In case of code switching, the current token may not be in the default language
+                # and then its features are checked against a different feature set. An exception
+                # is the feature Foreign, which always relates to the default language of the
+                # corpus (but Foreign=Yes should probably be allowed for all UPOS categories in
+                # all languages).
+                effective_featset = featset
+                effective_lang = lang
+                if f == 'Foreign':
+                    # Revert to the default.
+                    effective_featset = default_featset
+                    effective_lang = default_lang
+                if effective_featset is not None:
+                    if f not in effective_featset:
+                        Error(
+                            state=state, config=self.incfg,
+                            nodeid=node.ord,
+                            testid='feature-unknown',
+                            message=f"Feature {f} is not documented for language [{effective_lang}] ('{utils.formtl(node)}', {f}={v}).",
+                            explanation=self.data.explain_feats(effective_lang)
+                        ).confirm()
+                    else:
+                        lfrecord = effective_featset[f]
+                        if lfrecord['permitted'] == 0:
+                            Error(
+                                state=state, config=self.incfg,
+                                nodeid=node.ord,
+                                testid='feature-not-permitted',
+                                message=f"Feature {f} is not permitted in language [{effective_lang}] ('{utils.formtl(node)}, {f}={v}').",
+                                explanation=self.data.explain_feats(effective_lang)
+                            ).confirm()
+                        else:
+                            values = lfrecord['uvalues'] + lfrecord['lvalues'] + lfrecord['unused_uvalues'] + lfrecord['unused_lvalues']
+                            if not v in values:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    nodeid=node.ord,
+                                    testid='feature-value-unknown',
+                                    message=f"Value {v} is not documented for feature {f} in language [{effective_lang}] ('{utils.formtl(node)}').",
+                                    explanation=self.data.explain_feats(effective_lang)
+                                ).confirm()
+                            elif not node.upos in lfrecord['byupos']:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    nodeid=node.ord,
+                                    testid='feature-upos-not-permitted',
+                                    message=f"Feature {f} is not permitted with UPOS {node.upos} in language [{effective_lang}] ('{utils.formtl(node)}').",
+                                    explanation=self.data.explain_feats(effective_lang)
+                                ).confirm()
+                            elif not v in lfrecord['byupos'][node.upos] or lfrecord['byupos'][node.upos][v]==0:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    nodeid=node.ord,
+                                    testid='feature-value-upos-not-permitted',
+                                    message=f"Value {v} of feature {f} is not permitted with UPOS {node.upos} in language [{effective_lang}] ('{utils.formtl(node)}').",
+                                    explanation=self.data.explain_feats(effective_lang)
+                                ).confirm()
+
+
+
+    def check_deprels(self, state, node):
+        """
+        Checks that a dependency relation label is listed as approved in the
+        given language. As a language-specific test, this function belongs to
+        level 4. This method currently checks udeprels both in the DEPREL
+        column and in the DEPS column.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The node whose incoming relation will be validated.
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        unknown-deprel
+        unknown-edeprel
+        """
+        Incident.default_lineno = state.current_node_linenos[str(node.ord)]
+        Incident.default_level = 4
+        Incident.default_testclass = TestClass.SYNTAX
+        # List of permited relations is language-specific.
+        # The current token may be in a different language due to code switching.
+        # Unlike with features and auxiliaries, with deprels it is less clear
+        # whether we want to switch the set of labels when the token belongs to
+        # another language. Especially with subtypes that are not so much language
+        # specific. For example, we may have allowed 'flat:name' for our language,
+        # the maintainers of the other language have not allowed it, and then we
+        # could not use it when the foreign language is active. (This actually
+        # happened in French GSD.) We will thus allow the union of the main and the
+        # alternative deprelset when both the parent and the child belong to the
+        # same alternative language. Otherwise, only the main deprelset is allowed.
+        mainlang = self.lang
+        naltlang = utils.get_alt_language(node)
+        # The basic relation should be tested on regular nodes but not on empty nodes.
+        if not node.is_empty():
+            paltlang = utils.get_alt_language(node.parent)
+            main_deprelset = self.data.get_deprel_for_language(mainlang)
+            alt_deprelset = set()
+            if naltlang != None and naltlang != mainlang and naltlang == paltlang:
+                alt_deprelset = self.data.get_deprel_for_language(naltlang)
+            # Test only the universal part if testing at universal level.
+            deprel = node.deprel
+            if deprel not in main_deprelset and deprel not in alt_deprelset:
+                Error(
+                    state=state, config=self.incfg,
+                    nodeid=node.ord,
+                    testid='unknown-deprel',
+                    message=f"Unknown DEPREL label: '{deprel}'",
+                    explanation=self.data.explain_deprel(mainlang)
+                ).confirm()
+        # If there are enhanced dependencies, test their deprels, too.
+        # We already know that the contents of DEPS is parsable (deps_list() was
+        # first called from check_id_references() and the head indices are OK).
+        # The order of enhanced dependencies was already checked in check_deps().
+        Incident.default_testclass = TestClass.ENHANCED
+        if str(node.deps) != '_':
+            main_edeprelset = self.data.get_edeprel_for_language(mainlang)
+            alt_edeprelset = self.data.get_edeprel_for_language(naltlang)
+            for edep in node.deps:
+                parent = edep['parent']
+                deprel = edep['deprel']
+                paltlang = utils.get_alt_language(parent)
+                if not (deprel in main_edeprelset or naltlang != None and naltlang != mainlang and naltlang == paltlang and deprel in alt_edeprelset):
+                    Error(
+                        state=state, config=self.incfg,
+                        nodeid=node.ord,
+                        testid='unknown-edeprel',
+                        message=f"Unknown enhanced relation type '{deprel}' in '{parent.ord}:{deprel}'",
+                        explanation=self.data.explain_edeprel(mainlang)
+                    ).confirm()

ud-tools/udtools/src/udtools/level5.py

@@ -0,0 +1,112 @@
+#! /usr/bin/env python3
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    import udtools.src.udtools.utils as utils
+    from udtools.src.udtools.incident import Error, TestClass
+    from udtools.src.udtools.level4 import Level4
+except ModuleNotFoundError:
+    import udtools.utils as utils
+    from udtools.incident import Error, TestClass
+    from udtools.level4 import Level4
+
+
+
+class Level5(Level4):
+#==============================================================================
+# Level 5 tests. Annotation content vs. the guidelines, language-specific.
+#==============================================================================
+
+
+
+    def check_auxiliary_verbs(self, state, node):
+        """
+        Verifies that the UPOS tag AUX is used only with lemmas that are known to
+        act as auxiliary verbs or particles in the given language.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The node whose incoming relation will be validated. This function
+            operates on both regular and empty nodes. Make sure to call it for
+            empty nodes, too!
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        aux-lemma
+        """
+        if node.upos == 'AUX' and node.lemma != '_':
+            lang = self.lang
+            altlang = utils.get_alt_language(node)
+            if altlang:
+                lang = altlang
+            auxlist = self.data.get_aux_for_language(lang)
+            if not auxlist or not node.lemma in auxlist:
+                Error(
+                    state=state, config=self.incfg,
+                    lineno=state.current_node_linenos[str(node.ord)],
+                    nodeid=node.ord,
+                    level=5,
+                    testclass=TestClass.MORPHO,
+                    testid='aux-lemma',
+                    message=f"'{utils.lemmatl(node)}' is not an auxiliary in language [{lang}]",
+                    explanation=self.data.explain_aux(lang)
+                ).confirm()
+
+
+
+    def check_copula_lemmas(self, state, node):
+        """
+        Verifies that the relation cop is used only with lemmas that are known to
+        act as copulas in the given language.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+        node : udapi.core.node.Node object
+            The node whose incoming relation will be validated. This function
+            operates on both regular and empty nodes. Make sure to call it for
+            empty nodes, too!
+
+        Reads from state
+        ----------------
+        current_node_linenos : dict(str: int)
+            Mapping from node ids (including empty nodes) to line numbers in
+            the input file.
+
+        Incidents
+        ---------
+        cop-lemma
+        """
+        if node.udeprel == 'cop' and node.lemma != '_':
+            lang = self.lang
+            altlang = utils.get_alt_language(node)
+            if altlang:
+                lang = altlang
+            coplist = self.data.get_cop_for_language(lang)
+            if not coplist or not node.lemma in coplist:
+                Error(
+                    state=state, config=self.incfg,
+                    lineno=state.current_node_linenos[str(node.ord)],
+                    nodeid=node.ord,
+                    level=5,
+                    testclass=TestClass.SYNTAX,
+                    testid='cop-lemma',
+                    message=f"'{utils.lemmatl(node)}' is not a copula in language [{lang}]",
+                    explanation=self.data.explain_cop(lang)
+                ).confirm()

ud-tools/udtools/src/udtools/level6.py

@@ -0,0 +1,798 @@
+#! /usr/bin/env python3
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+# According to https://stackoverflow.com/questions/1832893/python-regex-matching-unicode-properties,
+# the regex module has the same API as re but it can check Unicode character properties using \p{}
+# as in Perl.
+#import re
+import regex as re
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    import udtools.src.udtools.utils as utils
+    from udtools.src.udtools.incident import Incident, Error, Warning, TestClass
+    from udtools.src.udtools.level5 import Level5
+except ModuleNotFoundError:
+    import udtools.utils as utils
+    from udtools.incident import Incident, Error, Warning, TestClass
+    from udtools.level5 import Level5
+
+
+
+# Constants for the column indices
+COLCOUNT=10
+ID,FORM,LEMMA,UPOS,XPOS,FEATS,HEAD,DEPREL,DEPS,MISC=range(COLCOUNT)
+COLNAMES='ID,FORM,LEMMA,UPOS,XPOS,FEATS,HEAD,DEPREL,DEPS,MISC'.split(',')
+
+
+
+class Level6(Level5):
+#==============================================================================
+# Level 6 tests for annotation of coreference and named entities. This is
+# tested on demand only, as the requirements are not compulsory for UD
+# releases.
+#==============================================================================
+
+
+
+    def check_misc_entity(self, state):
+        """
+        Optionally checks the well-formedness of the MISC attributes that pertain
+        to coreference and named entities.
+
+        Parameters
+        ----------
+        state : udtools.state.State
+            The state of the validation run.
+
+        Reads from state
+        ----------------
+        current_lines : list(str)
+            List of lines in the sentence (comments and tokens), including
+            final empty line. The lines are not expected to include the final
+            newline character.
+            First we expect an optional block (zero or more lines) of comments,
+            i.e., lines starting with '#'. Then we expect a non-empty block
+            (one or more lines) of nodes, empty nodes, and multiword tokens.
+            Finally, we expect exactly one empty line.
+        comment_start_line : int
+            The line number (relative to input file, 1-based) of the first line
+            in the current sentence, including comments if any.
+        current_token_node_table : list(list(str))
+            The list of multiword token lines / regular node lines / empty node
+            lines, each split to fields (columns).
+        sentence_line : int
+            The line number (relative to input file, 1-based) of the first
+            node/token line in the current sentence.
+
+        Reads and writes to state
+        -------------------------
+        global_entity_attribute_string : str
+        entity_attribute_number : int
+        entity_attribute_index : dict
+        entity_types : dict
+        entity_ids_this_document : dict
+        entity_ids_other_documents : dict
+        open_entity_mentions : list
+        open_discontinuous_mentions : dict
+        entity_bridge_relations : dict
+        entity_split_antecedents : dict
+        entity_mention_spans : dict
+
+        Incidents
+        ---------
+        global-entity-mismatch
+        spurious-global-entity
+        entity-mwt
+        multiple-entity-statements
+        multiple-bridge-statements
+        multiple-splitante-statements
+        bridge-without-entity
+        splitante-without-entity
+        entity-without-global-entity
+        spurious-entity-statement
+        too-many-entity-attributes
+        spurious-entity-id
+        misplaced-mention-part
+        mention-attribute-mismatch
+        entity-across-newdoc
+        spurious-entity-type
+        spurious-mention-head
+        entity-type-mismatch
+        entity-identity-mismatch
+        ill-nested-entities
+        ill-nested-entities-warning
+        mention-head-out-of-range
+        same-span-entity-mentions
+        crossing-mentions-same-entity
+        spurious-bridge-statement
+        spurious-bridge-relation
+        misplaced-bridge-statement
+        repeated-bridge-relation
+        bridge-relation-mismatch
+        spurious-splitante-statement
+        spurious-splitante-relation
+        misplaced-splitante-statement
+        repeated-splitante-relation
+        only-one-split-antecedent
+        split-antecedent-mismatch
+        cross-sentence-mention
+        """
+        Incident.default_level = 6
+        Incident.default_testclass = TestClass.COREF
+        n_comment_lines = state.sentence_line-state.comment_start_line
+        comments = state.current_lines[0:n_comment_lines]
+        iline = 0
+        sentid = ''
+        for c in comments:
+            Incident.default_lineno = state.comment_start_line+iline
+            global_entity_match = utils.crex.global_entity.fullmatch(c)
+            newdoc_match = utils.crex.newdoc.fullmatch(c)
+            sentid_match = utils.crex.sentid.fullmatch(c)
+            if global_entity_match:
+                # As a global declaration, global.Entity is expected only once per file.
+                # However, we may be processing multiple files or people may have created
+                # the file by concatening smaller files, so we will allow repeated
+                # declarations iff they are identical to the first one.
+                if state.seen_global_entity:
+                    if global_entity_match.group(1) != state.global_entity_attribute_string:
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='global-entity-mismatch',
+                            message=f"New declaration of global.Entity '{global_entity_match.group(1)}' does not match the first declaration '{state.global_entity_attribute_string}' on line {state.seen_global_entity}."
+                        ).confirm()
+                else:
+                    state.seen_global_entity = state.comment_start_line + iline
+                    state.global_entity_attribute_string = global_entity_match.group(1)
+                    if not re.match(r"^[a-z]+(-[a-z]+)*$", state.global_entity_attribute_string):
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='spurious-global-entity',
+                            message=f"Cannot parse global.Entity attribute declaration '{state.global_entity_attribute_string}'."
+                        ).confirm()
+                    else:
+                        global_entity_attributes = state.global_entity_attribute_string.split('-')
+                        if not 'eid' in global_entity_attributes:
+                            Error(
+                                state=state, config=self.incfg,
+                                testid='spurious-global-entity',
+                                message=f"Global.Entity attribute declaration '{state.global_entity_attribute_string}' does not include 'eid'."
+                            ).confirm()
+                        elif global_entity_attributes[0] != 'eid':
+                            Error(
+                                state=state, config=self.incfg,
+                                testid='spurious-global-entity',
+                                message=f"Attribute 'eid' must come first in global.Entity attribute declaration '{state.global_entity_attribute_string}'."
+                            ).confirm()
+                        if not 'etype' in global_entity_attributes:
+                            Error(
+                                state=state, config=self.incfg,
+                                testid='spurious-global-entity',
+                                message=f"Global.Entity attribute declaration '{state.global_entity_attribute_string}' does not include 'etype'."
+                            ).confirm()
+                        elif global_entity_attributes[1] != 'etype':
+                            Error(
+                                state=state, config=self.incfg,
+                                testid='spurious-global-entity',
+                                message=f"Attribute 'etype' must come second in global.Entity attribute declaration '{state.global_entity_attribute_string}'."
+                            ).confirm()
+                        if not 'head' in global_entity_attributes:
+                            Error(
+                                state=state, config=self.incfg,
+                                testid='spurious-global-entity',
+                                message=f"Global.Entity attribute declaration '{state.global_entity_attribute_string}' does not include 'head'."
+                            ).confirm()
+                        elif global_entity_attributes[2] != 'head':
+                            Error(
+                                state=state, config=self.incfg,
+                                testid='spurious-global-entity',
+                                message=f"Attribute 'head' must come third in global.Entity attribute declaration '{state.global_entity_attribute_string}'."
+                            ).confirm()
+                        if 'other' in global_entity_attributes and global_entity_attributes[3] != 'other':
+                            Error(
+                                state=state, config=self.incfg,
+                                testid='spurious-global-entity',
+                                message=f"Attribute 'other', if present, must come fourth in global.Entity attribute declaration '{state.global_entity_attribute_string}'."
+                            ).confirm()
+                        # Fill the global dictionary that maps attribute names to list indices.
+                        i = 0
+                        for a in global_entity_attributes:
+                            if a in state.entity_attribute_index:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='spurious-global-entity',
+                                    message=f"Attribute '{a}' occurs more than once in global.Entity attribute declaration '{state.global_entity_attribute_string}'."
+                                ).confirm()
+                            else:
+                                state.entity_attribute_index[a] = i
+                            i += 1
+                        state.entity_attribute_number = len(global_entity_attributes)
+            elif newdoc_match:
+                for eid in state.entity_ids_this_document:
+                    state.entity_ids_other_documents[eid] = state.entity_ids_this_document[eid]
+                state.entity_ids_this_document = {}
+            elif sentid_match:
+                sentid = sentid_match.group(1)
+            iline += 1
+        for iline in range(len(state.current_token_node_table)):
+            cols = state.current_token_node_table[iline]
+            Incident.default_lineno = state.sentence_line+iline
+            # Add the current word to all currently open mentions. We will use it in error messages.
+            # Do this for regular and empty nodes but not for multi-word-token lines.
+            if not utils.is_multiword_token(cols):
+                for m in state.open_entity_mentions:
+                    m['span'].append(cols[ID])
+                    m['text'] += ' '+cols[FORM]
+                    m['length'] += 1
+            misc = cols[MISC].split('|')
+            entity = [x for x in misc if re.match(r"^Entity=", x)]
+            bridge = [x for x in misc if re.match(r"^Bridge=", x)]
+            splitante = [x for x in misc if re.match(r"^SplitAnte=", x)]
+            if utils.is_multiword_token(cols) and (len(entity)>0 or len(bridge)>0 or len(splitante)>0):
+                Error(
+                    state=state, config=self.incfg,
+                    testid='entity-mwt',
+                    message="Entity or coreference annotation must not occur at a multiword-token line."
+                ).confirm()
+                continue
+            if len(entity)>1:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='multiple-entity-statements',
+                    message=f"There can be at most one 'Entity=' statement in MISC but we have {str(misc)}."
+                ).confirm()
+                continue
+            if len(bridge)>1:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='multiple-bridge-statements',
+                    message=f"There can be at most one 'Bridge=' statement in MISC but we have {str(misc)}."
+                ).confirm()
+                continue
+            if len(splitante)>1:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='multiple-splitante-statements',
+                    message=f"There can be at most one 'SplitAnte=' statement in MISC but we have {str(misc)}."
+                ).confirm()
+                continue
+            if len(bridge)>0 and len(entity)==0:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='bridge-without-entity',
+                    message=f"The 'Bridge=' statement can only occur together with 'Entity=' in MISC but we have {str(misc)}."
+                ).confirm()
+                continue
+            if len(splitante)>0 and len(entity)==0:
+                Error(
+                    state=state, config=self.incfg,
+                    testid='splitante-without-entity',
+                    message=f"The 'SplitAnte=' statement can only occur together with 'Entity=' in MISC but we have {str(misc)}."
+                ).confirm()
+                continue
+            # There is at most one Entity (and only if it is there, there may be also one Bridge and/or one SplitAnte).
+            if len(entity)>0:
+                if not state.seen_global_entity:
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='entity-without-global-entity',
+                        message="No global.Entity comment was found before the first 'Entity' in MISC."
+                    ).confirm()
+                    continue
+                match = re.match(r"^Entity=((?:\([^( )]+(?:-[^( )]+)*\)?|[^( )]+\))+)$", entity[0])
+                if not match:
+                    Error(
+                        state=state, config=self.incfg,
+                        testid='spurious-entity-statement',
+                        message=f"Cannot parse the Entity statement '{entity[0]}'."
+                    ).confirm()
+                else:
+                    entity_string = match.group(1)
+                    # We cannot check the rest if we cannot identify the 'eid' attribute.
+                    if 'eid' not in state.entity_attribute_index:
+                        continue
+                    # Items of entities are pairs of [012] and a string.
+                    # 0 ... opening bracket; 1 ... closing bracket; 2 ... both brackets
+                    entities = []
+                    while entity_string:
+                        match = re.match(r"^\(([^( )]+(-[^( )]+)*)\)", entity_string)
+                        if match:
+                            entities.append((2, match.group(1)))
+                            entity_string = re.sub(r"^\([^( )]+(-[^( )]+)*\)", '', entity_string, count=1)
+                            continue
+                        match = re.match(r"^\(([^( )]+(-[^( )]+)*)", entity_string)
+                        if match:
+                            entities.append((0, match.group(1)))
+                            entity_string = re.sub(r"^\([^( )]+(-[^( )]+)*", '', entity_string, count=1)
+                            continue
+                        match = re.match(r"^([^( )]+)\)", entity_string)
+                        if match:
+                            entities.append((1, match.group(1)))
+                            entity_string = re.sub(r"^[^( )]+\)", '', entity_string, count=1)
+                            continue
+                        # If we pre-checked the string well, we should never arrive here!
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='internal-error',
+                            message='INTERNAL ERROR'
+                        ).confirm()
+                    # All 1 cases should precede all 0 cases.
+                    # The 2 cases can be either before the first 1 case, or after the last 0 case.
+                    seen0 = False
+                    seen1 = False
+                    seen2 = False
+                    # To be able to check validity of Bridge and SplitAnte, we will hash eids of mentions that start here.
+                    # To be able to check that no two mentions have the same span, we will hash start-end intervals for mentions that end here.
+                    starting_mentions = {}
+                    ending_mentions = {}
+                    for b, e in entities:
+                        # First get attributes, entity id, and if applicable, part of discontinuous mention.
+                        attributes = e.split('-')
+                        if b==0 or b==2:
+                            # Fewer attributes are allowed because trailing empty values can be omitted.
+                            # More attributes are not allowed.
+                            if len(attributes) > state.entity_attribute_number:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='too-many-entity-attributes',
+                                    message=f"Entity '{e}' has {len(attributes)} attributes while only {state.entity_attribute_number} attributes are globally declared."
+                                ).confirm()
+                            # The raw eid (bracket eid) may include an identification of a part of a discontinuous mention,
+                            # as in 'e155[1/2]'. This is fine for matching opening and closing brackets
+                            # because the closing bracket must contain it too. However, to identify the
+                            # cluster, we need to take the real id.
+                            beid = attributes[state.entity_attribute_index['eid']]
+                        else:
+                            # No attributes other than eid are expected at the closing bracket.
+                            if len(attributes) > 1:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='too-many-entity-attributes',
+                                    message=f"Entity '{e}' has {len(attributes)} attributes while only eid is expected at the closing bracket."
+                                ).confirm()
+                            beid = attributes[0]
+                        eid = beid
+                        ipart = 1
+                        npart = 1
+                        eidnpart = eid
+                        match = re.match(r"^(.+)\[([1-9]\d*)/([1-9]\d*)\]$", beid)
+                        if match:
+                            eid = match.group(1)
+                            ipart = int(match.group(2))
+                            npart = int(match.group(3))
+                            eidnpart = eid+'['+match.group(3)+']'
+                            # We should omit the square brackets if they would be [1/1].
+                            if ipart == 1 and npart == 1:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='spurious-entity-id',
+                                    message=f"Discontinuous mention must have at least two parts but it has one in '{beid}'."
+                                ).confirm()
+                            if ipart > npart:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='spurious-entity-id',
+                                    message=f"Entity id '{beid}' of discontinuous mention says the current part is higher than total number of parts."
+                                ).confirm()
+                        else:
+                            if re.match(r"[\[\]]", beid):
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='spurious-entity-id',
+                                    message=f"Entity id '{beid}' contains square brackets but does not have the form used in discontinuous mentions."
+                                ).confirm()
+
+                        #--------------------------------------------------------------------------------------------------------------------------------
+                        # The code that we will have to execute at single-node continuous parts and at the opening brackets of multi-node continuous parts.
+                        # We assume that we have already parsed beid and established whether this is a part of a discontinuous mention.
+                        def opening_bracket():
+                            attrstring_to_match = ''
+                            # If this is a part of a discontinuous mention, remember the attribute string.
+                            # At the beginning of each part, we will check that its attribute string is identical to the first part.
+                            if npart > 1:
+                                # We want to check that values of all attributes are same in all parts (except the eid which differs in the brackets).
+                                attributes_without_eid = [attributes[i] for i in range(len(attributes)) if i != state.entity_attribute_index['eid']]
+                                # For better readability of the error messages, reintroduce eid anyway, but without the brackets.
+                                attrstring_to_match = eid+'-'+('-'.join(attributes_without_eid))
+                                if ipart == 1:
+                                    # If this is the first part, create a new record for the mention in the global dictionary.
+                                    # We actually keep a stack of open mentions with the same eidnpart because they may be nested.
+                                    # The length and the span of the mention will be updated when we encounter the closing bracket of the current part.
+                                    discontinuous_mention = {'last_ipart': 1, 'npart': npart,
+                                                            'first_part_line': state.sentence_line+iline,
+                                                            'last_part_line': state.sentence_line+iline,
+                                                            'attributes': attrstring_to_match,
+                                                            'length': 0, 'span': []}
+                                    if eidnpart in state.open_discontinuous_mentions:
+                                        state.open_discontinuous_mentions[eidnpart].append(discontinuous_mention)
+                                    else:
+                                        state.open_discontinuous_mentions[eidnpart] = [discontinuous_mention]
+                                else:
+                                    if eidnpart in state.open_discontinuous_mentions:
+                                        discontinuous_mention = state.open_discontinuous_mentions[eidnpart][-1]
+                                        if ipart != discontinuous_mention['last_ipart']+1:
+                                            Error(
+                                                state=state, config=self.incfg,
+                                                testid='misplaced-mention-part',
+                                                message=f"Unexpected part of discontinuous mention '{beid}': last part was '{discontinuous_mention['last_ipart']}/{discontinuous_mention['npart']}' on line {discontinuous_mention['last_part_line']}."
+                                            ).confirm()
+                                            # We will update last_ipart at closing bracket, i.e., after the current part has been entirely processed.
+                                            # Otherwise nested discontinuous mentions might wrongly assess where they belong.
+                                        elif attrstring_to_match != discontinuous_mention['attributes']:
+                                            Error(
+                                                state=state, config=self.incfg,
+                                                testid='mention-attribute-mismatch',
+                                                message=f"Attribute mismatch of discontinuous mention: current part has '{attrstring_to_match}', first part '{discontinuous_mention['attributes']}' was at line {discontinuous_mention['first_part_line']}."
+                                            ).confirm()
+                                    else:
+                                        Error(
+                                            state=state, config=self.incfg,
+                                            testid='misplaced-mention-part',
+                                            message=f"Unexpected part of discontinuous mention '{beid}': this is part {ipart} but we do not have information about the previous parts."
+                                        ).confirm()
+                                        discontinuous_mention = {'last_ipart': ipart, 'npart': npart,
+                                                                'first_part_line': state.sentence_line+iline,
+                                                                'last_part_line': state.sentence_line+iline,
+                                                                'attributes': attrstring_to_match,
+                                                                'length': 0, 'span': []}
+                                        state.open_discontinuous_mentions[eidnpart] = [discontinuous_mention]
+                            # Check all attributes of the entity, except those that must be examined at the closing bracket.
+                            if eid in state.entity_ids_other_documents:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='entity-across-newdoc',
+                                    message=f"Same entity id should not occur in multiple documents; '{eid}' first seen on line {state.entity_ids_other_documents[eid]}, before the last newdoc."
+                                ).confirm()
+                            elif not eid in state.entity_ids_this_document:
+                                state.entity_ids_this_document[eid] = state.sentence_line+iline
+                            etype = ''
+                            identity = ''
+                            if 'etype' in state.entity_attribute_index and len(attributes) >= state.entity_attribute_index['etype']+1:
+                                etype = attributes[state.entity_attribute_index['etype']]
+                                # For etype values tentatively approved for CorefUD 1.0, see
+                                # https://github.com/ufal/corefUD/issues/13#issuecomment-1008447464
+                                if not re.match(r"^(person|place|organization|animal|plant|object|substance|time|number|abstract|event|other)?$", etype):
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='spurious-entity-type',
+                                        message=f"Spurious entity type '{etype}'."
+                                    ).confirm()
+                            if 'identity' in state.entity_attribute_index and len(attributes) >= state.entity_attribute_index['identity']+1:
+                                identity = attributes[state.entity_attribute_index['identity']]
+                            # Check the form of the head index now.
+                            # The value will be checked at the end of the mention,
+                            # when we know the mention length.
+                            head = 0
+                            if 'head' in state.entity_attribute_index and len(attributes) >= state.entity_attribute_index['head']+1:
+                                if not re.match(r"^[1-9][0-9]*$", attributes[state.entity_attribute_index['head']]):
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='spurious-mention-head',
+                                        message=f"Entity head index '{attributes[state.entity_attribute_index['head']]}' must be a non-zero-starting integer."
+                                    ).confirm()
+                                else:
+                                    head = int(attributes[state.entity_attribute_index['head']])
+                            # If this is the first mention of the entity, remember the values
+                            # of the attributes that should be identical at all mentions.
+                            if not eid in state.entity_types:
+                                state.entity_types[eid] = (etype, identity, state.sentence_line+iline)
+                            else:
+                                # All mentions of one entity (cluster) must have the same entity type.
+                                if etype != state.entity_types[eid][0]:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='entity-type-mismatch',
+                                        message=f"Entity '{eid}' cannot have type '{etype}' that does not match '{state.entity_types[eid][0]}' from the first mention on line {state.entity_types[eid][2]}."
+                                    ).confirm()
+                                # All mentions of one entity (cluster) must have the same identity (Wikipedia link or similar).
+                                if identity != state.entity_types[eid][1]:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='entity-identity-mismatch',
+                                        message=f"Entity '{eid}' cannot have identity '{identity}' that does not match '{state.entity_types[eid][1]}' from the first mention on line {state.entity_types[eid][2]}."
+                                    ).confirm()
+                            # Remember the line where (the current part of) the entity mention starts.
+                            mention = {'beid': beid, 'line': state.sentence_line+iline,
+                                       'span': [cols[ID]], 'text': cols[FORM],
+                                       'length': 1, 'head': head, 'attrstring': attrstring_to_match}
+                            state.open_entity_mentions.append(mention)
+                            # The set of mentions starting at the current line will be needed later when checking Bridge and SplitAnte statements.
+                            if ipart == 1:
+                                starting_mentions[eid] = True
+
+                        #--------------------------------------------------------------------------------------------------------------------------------
+                        # The code that we will have to execute at single-node continuous parts and at the closing brackets of multi-node continuous parts.
+                        def closing_bracket():
+                            # Find the corresponding opening bracket and extract the information we need to know.
+                            mention_length = 0
+                            mention_span = []
+                            head = 0
+                            opening_line = 0
+                            if len(state.open_entity_mentions)==0:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='ill-nested-entities',
+                                    message=f"Cannot close entity '{beid}' because there are no open entities."
+                                ).confirm()
+                                return
+                            else:
+                                # If the closing bracket does not occur where expected, it is currently only a warning.
+                                # We have crossing mention spans in CorefUD 1.0 and it has not been decided yet whether all of them should be illegal.
+                                ###!!! Note that this will not catch ill-nested mentions whose only intersection is one node. The bracketing will
+                                ###!!! not be a problem in such cases because one mention will be closed first, then the other will be opened.
+                                if beid != state.open_entity_mentions[-1]['beid']:
+                                    Warning(
+                                        state=state, config=self.incfg,
+                                        testclass=TestClass.COREF,
+                                        testid='ill-nested-entities-warning',
+                                        message=f"Entity mentions are not well nested: closing '{beid}' while the innermost open entity is '{state.open_entity_mentions[-1]['beid']}' from line {state.open_entity_mentions[-1]['line']}: {str(state.open_entity_mentions)}."
+                                    ).confirm()
+                                # Try to find and close the entity whether or not it was well-nested.
+                                for i in reversed(range(len(state.open_entity_mentions))):
+                                    if state.open_entity_mentions[i]['beid'] == beid:
+                                        mention_length = state.open_entity_mentions[i]['length']
+                                        mention_span = state.open_entity_mentions[i]['span']
+                                        head = state.open_entity_mentions[i]['head']
+                                        opening_line = state.open_entity_mentions[i]['line']
+                                        state.open_entity_mentions.pop(i)
+                                        break
+                                else:
+                                    # If we did not find the entity to close, then the warning above was not enough and we have to make it a validation error.
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='ill-nested-entities',
+                                        message=f"Cannot close entity '{beid}' because it was not found among open entities: {str(state.open_entity_mentions)}"
+                                    ).confirm()
+                                    return
+                            # If this is a part of a discontinuous mention, update the information about the whole mention.
+                            # We do this after reading the new part (and not when we see its opening bracket) so that nested
+                            # discontinuous mentions of the same entity are possible.
+                            if npart > 1:
+                                # Update the attributes that have to be updated after each part.
+                                if eidnpart in state.open_discontinuous_mentions:
+                                    discontinuous_mention = state.open_discontinuous_mentions[eidnpart][-1]
+                                    discontinuous_mention['last_ipart'] = ipart
+                                    discontinuous_mention['last_part_line'] = opening_line
+                                    discontinuous_mention['length'] += mention_length
+                                    discontinuous_mention['span'] += mention_span
+                                else:
+                                    # This should have been taken care of at the opening bracket.
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testclass=TestClass.INTERNAL,
+                                        testid='internal-error',
+                                        message="INTERNAL ERROR: at the closing bracket of a part of a discontinuous mention, still no record in state.open_discontinuous_mentions."
+                                    ).confirm()
+                                    discontinuous_mention = {'last_ipart': ipart, 'npart': npart,
+                                                            'first_part_line': opening_line,
+                                                            'last_part_line': opening_line,
+                                                            'attributes': '', 'length': mention_length,
+                                                            'span': mention_span}
+                                    state.open_discontinuous_mentions[eidnpart] = [discontinuous_mention]
+                                # Update mention_length and mention_span to reflect the whole span up to this point rather than just the last part.
+                                mention_length = state.open_discontinuous_mentions[eidnpart][-1]['length']
+                                mention_span = state.open_discontinuous_mentions[eidnpart][-1]['span']
+                            # We need to know the length (number of nodes) of the mention to check whether the head attribute is within limits.
+                            # We need to know the span (list of nodes) of the mention to check that no two mentions have the same span.
+                            # We only check these requirements after the last part of the discontinuous span (or after the single part of a continuous one).
+                            if ipart == npart:
+                                if mention_length < head:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='mention-head-out-of-range',
+                                        message=f"Entity mention head was specified as {head} on line {opening_line} but the mention has only {mention_length} nodes."
+                                    ).confirm()
+                                # Check that no two mentions have identical spans (only if this is the last part of a mention).
+                                ending_mention_key = str(opening_line)+str(mention_span)
+                                if ending_mention_key in ending_mentions:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='same-span-entity-mentions',
+                                        message=f"Entity mentions '{ending_mentions[ending_mention_key]}' and '{beid}' from line {opening_line} have the same span {str(mention_span)}."
+                                    ).confirm()
+                                else:
+                                    ending_mentions[ending_mention_key] = beid
+                                # Remember the span of the current mention so that we can later check whether it crosses the span of another mention.
+                                # Use the current sentence id to partially qualify the node ids. It will not work well for mentions that span multiple
+                                # sentences but we do not expect cross-sentence mentions to be frequent.
+                                myset = set(mention_span)
+                                # Check whether any other mention of the same entity has span that crosses the current one.
+                                if eid in state.entity_mention_spans:
+                                    if sentid in state.entity_mention_spans[eid]:
+                                        for m in state.entity_mention_spans[eid][sentid]:
+                                            ms = state.entity_mention_spans[eid][sentid][m]
+                                            if ms.intersection(myset) and not ms.issubset(myset) and not myset.issubset(ms):
+                                                Error(
+                                                    state=state, config=self.incfg,
+                                                    testid='crossing-mentions-same-entity',
+                                                    message=f"Mentions of entity '{eid}' have crossing spans: {m} vs. {str(mention_span)}."
+                                                ).confirm()
+                                    else:
+                                        state.entity_mention_spans[eid][sentid] = {}
+                                else:
+                                    state.entity_mention_spans[eid] = {}
+                                    state.entity_mention_spans[eid][sentid] = {}
+                                state.entity_mention_spans[eid][sentid][str(mention_span)] = myset
+                            # At the end of the last part of a discontinuous mention, remove the information about the mention.
+                            if npart > 1 and ipart == npart:
+                                if eidnpart in state.open_discontinuous_mentions:
+                                    if len(state.open_discontinuous_mentions[eidnpart]) > 1:
+                                        state.open_discontinuous_mentions[eidnpart].pop()
+                                    else:
+                                        state.open_discontinuous_mentions.pop(eidnpart)
+                        #--------------------------------------------------------------------------------------------------------------------------------
+
+                        # Now we know the beid, eid, as well as all other attributes.
+                        # We can check the well-nestedness of brackets.
+                        if b==0:
+                            if seen2 and not seen1:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='spurious-entity-statement',
+                                    message=f"If there are no closing entity brackets, single-node entity must follow all opening entity brackets in '{entity[0]}'."
+                                ).confirm()
+                            if seen0 and seen2:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='spurious-entity-statement',
+                                    message=f"Single-node entity must either precede all closing entity brackets or follow all opening entity brackets in '{entity[0]}'."
+                                ).confirm()
+                            seen0 = True
+                            seen2 = False
+                            opening_bracket()
+                        elif b==2:
+                            if seen1 and not seen0:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='spurious-entity-statement',
+                                    message=f"If there are no opening entity brackets, single-node entity must precede all closing entity brackets in '{entity[0]}'."
+                                ).confirm()
+                            seen2 = True
+                            opening_bracket()
+                            closing_bracket()
+                        else: # b==1
+                            if seen0:
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='spurious-entity-statement',
+                                    message=f"All closing entity brackets must precede all opening entity brackets in '{entity[0]}'."
+                                ).confirm()
+                            seen1 = True
+                            closing_bracket()
+                # Now we are done with checking the 'Entity=' statement.
+                # If there are also 'Bridge=' or 'SplitAnte=' statements, check them too.
+                if len(bridge) > 0:
+                    match = re.match(r"^Bridge=([^(< :>)]+<[^(< :>)]+(:[a-z]+)?(,[^(< :>)]+<[^(< :>)]+(:[a-z]+)?)*)$", bridge[0])
+                    if not match:
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='spurious-bridge-statement',
+                            message=f"Cannot parse the Bridge statement '{bridge[0]}'."
+                        ).confirm()
+                    else:
+                        bridges = match.group(1).split(',')
+                        # Hash src<tgt pairs and make sure they are not repeated.
+                        srctgt = {}
+                        for b in bridges:
+                            match = re.match(r"([^(< :>)]+)<([^(< :>)]+)(?::([a-z]+))?^$", b)
+                            if match:
+                                srceid = match.group(1)
+                                tgteid = match.group(2)
+                                relation = match.group(3) # optional
+                                bridgekey = srceid+'<'+tgteid
+                                if srceid == tgteid:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='spurious-bridge-relation',
+                                        message=f"Bridge must not point from an entity to itself: '{b}'."
+                                    ).confirm()
+                                if not tgteid in starting_mentions:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='misplaced-bridge-statement',
+                                        message=f"Bridge relation '{b}' must be annotated at the beginning of a mention of entity '{tgteid}'."
+                                    ).confirm()
+                                if bridgekey in srctgt:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='repeated-bridge-relation',
+                                        message=f"Bridge relation '{bridgekey}' must not be repeated in '{b}'."
+                                    ).confirm()
+                                else:
+                                    srctgt[bridgekey] = True
+                                # Check in the global dictionary whether this relation has been specified at another mention.
+                                if bridgekey in state.entity_bridge_relations:
+                                    if relation != state.entity_bridge_relations[bridgekey]['relation']:
+                                        Error(
+                                            state=state, config=self.incfg,
+                                            testid='bridge-relation-mismatch',
+                                            message=f"Bridge relation '{b}' type does not match '{state.entity_bridge_relations[bridgekey]['relation']}' specified earlier on line {state.entity_bridge_relations[bridgekey]['line']}."
+                                        ).confirm()
+                                else:
+                                    state.entity_bridge_relations[bridgekey] = {'relation': relation, 'line': state.sentence_line+iline}
+                if len(splitante) > 0:
+                    match = re.match(r"^SplitAnte=([^(< :>)]+<[^(< :>)]+(,[^(< :>)]+<[^(< :>)]+)*)$", splitante[0])
+                    if not match:
+                        Error(
+                            state=state, config=self.incfg,
+                            testid='spurious-splitante-statement',
+                            message=f"Cannot parse the SplitAnte statement '{splitante[0]}'."
+                        ).confirm()
+                    else:
+                        antecedents = match.group(1).split(',')
+                        # Hash src<tgt pairs and make sure they are not repeated. Also remember the number of antecedents for each target.
+                        srctgt = {}
+                        tgtante = {}
+                        for a in antecedents:
+                            match = re.match(r"^([^(< :>)]+)<([^(< :>)]+)$", a)
+                            if match:
+                                srceid = match.group(1)
+                                tgteid = match.group(2)
+                                if srceid == tgteid:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='spurious-splitante-relation',
+                                        message=f"SplitAnte must not point from an entity to itself: '{srceid}<{tgteid}'."
+                                    ).confirm()
+                                elif not tgteid in starting_mentions:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='misplaced-splitante-statement',
+                                        message=f"SplitAnte relation '{a}' must be annotated at the beginning of a mention of entity '{tgteid}'."
+                                    ).confirm()
+                                if srceid+'<'+tgteid in srctgt:
+                                    str_antecedents = ','.join(antecedents)
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='repeated-splitante-relation',
+                                        message=f"SplitAnte relation '{srceid}<{tgteid}' must not be repeated in '{str_antecedents}'."
+                                    ).confirm()
+                                else:
+                                    srctgt[srceid+'<'+tgteid] = True
+                                if tgteid in tgtante:
+                                    tgtante[tgteid].append(srceid)
+                                else:
+                                    tgtante[tgteid] = [srceid]
+                        for tgteid in tgtante:
+                            if len(tgtante[tgteid]) == 1:
+                                str_antecedents = ','.join(antecedents)
+                                Error(
+                                    state=state, config=self.incfg,
+                                    testid='only-one-split-antecedent',
+                                    message=f"SplitAnte statement '{str_antecedents}' must specify at least two antecedents for entity '{tgteid}'."
+                                ).confirm()
+                            # Check in the global dictionary whether this relation has been specified at another mention.
+                            tgtante[tgteid].sort()
+                            if tgteid in state.entity_split_antecedents:
+                                if tgtante[tgteid] != state.entity_split_antecedents[tgteid]['antecedents']:
+                                    Error(
+                                        state=state, config=self.incfg,
+                                        testid='split-antecedent-mismatch',
+                                        message=f"Split antecedent of entity '{tgteid}' does not match '{state.entity_split_antecedents[tgteid]['antecedents']}' specified earlier on line {state.entity_split_antecedents[tgteid]['line']}."
+                                    ).confirm()
+                            else:
+                                state.entity_split_antecedents[tgteid] = {'antecedents': str(tgtante[tgteid]), 'line': state.sentence_line+iline}
+        if len(state.open_entity_mentions)>0:
+            Error(
+                state=state, config=self.incfg,
+                testid='cross-sentence-mention',
+                message=f"Entity mentions must not cross sentence boundaries; still open at sentence end: {str(state.open_entity_mentions)}."
+            ).confirm()
+            # Close the mentions forcibly. Otherwise one omitted closing bracket would cause the error messages to to explode because the words would be collected from the remainder of the file.
+            state.open_entity_mentions = []
+        if len(state.open_discontinuous_mentions)>0:
+            Error(
+                state=state, config=self.incfg,
+                testid='cross-sentence-mention',
+                message=f"Entity mentions must not cross sentence boundaries; still open at sentence end: {str(state.open_discontinuous_mentions)}."
+            ).confirm()
+            # Close the mentions forcibly. Otherwise one omission would cause the error messages to to explode because the words would be collected from the remainder of the file.
+            state.open_discontinuous_mentions = {}
+        # Since we only test mentions within one sentence at present, we do not have to carry all mention spans until the end of the corpus.
+        for eid in state.entity_mention_spans:
+            if sentid in state.entity_mention_spans[eid]:
+                state.entity_mention_spans[eid].pop(sentid)

ud-tools/udtools/src/udtools/state.py

@@ -0,0 +1,176 @@
+import os
+from collections import defaultdict
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    from udtools.src.udtools.incident import IncidentType
+except ModuleNotFoundError:
+    from udtools.incident import IncidentType
+
+
+
+class State:
+    """
+    The State class holds various global data about where we are in the file
+    and what we have seen so far. Typically there will be just one instance of
+    this class.
+    """
+    def __init__(self):
+        # Name of the current input file.
+        self.current_file_name = None
+        # Current line in the input file, or, more precisely, the last line
+        # read so far. Once we start looking at tree integrity, we may find
+        # errors on previous lines as well.
+        self.current_line = 0;
+        # The line in the input file on which the current sentence starts,
+        # including sentence-level comments.
+        self.comment_start_line = 0
+        # The line in the input file on which the current sentence starts
+        # (the first node/token line, skipping comments).
+        self.sentence_line = 0
+        # The most recently read sentence id.
+        self.sentence_id = None
+        # List of input lines representing the current sentence (including
+        # comments and the final empty line). Newline characters omitted.
+        self.current_lines = []
+        # List of token/node lines in the current sentence, each line split
+        # to fields (columns). It is thus a list of lists of strings.
+        self.current_token_node_table = []
+        # Mapping from node ids (including empty nodes) to line numbers in the
+        # input file. Dictionary indexed by string.
+        self.current_node_linenos = {}
+        # Needed to check that no space after last word of sentence does not
+        # co-occur with new paragraph or document.
+        self.spaceafterno_in_effect = False
+        # Incident counter by type. Key: incident type, test class; value: incident count
+        # Incremented in Incident.report(), even if reporting is off or over --max_err.
+        self.error_counter = defaultdict(lambda: defaultdict(int))
+        # Lists of incidents confirmed so far, up to --max_store
+        self.error_tracker = []
+        # Set of detailed error explanations that have been printed so far.
+        # Each explanation will be printed only once. Typically, an explanation
+        # can be identified by test id + language code. Nevertheless, we put
+        # the whole explanation to the set.
+        self.explanation_printed = set()
+        # Some feature-related errors can only be reported if the corpus
+        # contains feature annotation because features are optional in general.
+        # Once we see the first feature, we can flush all accummulated
+        # complaints about missing features.
+        # Key: testid; value: dict with parameters of the error and the list of
+        # its occurrences.
+        self.delayed_feature_errors = {}
+        # Remember all sentence ids seen in all input files (presumably one
+        # corpus). We need it to check that each id is unique.
+        self.known_sent_ids = set()
+        # Similarly, parallel ids should be unique in a corpus. (If multiple
+        # sentences are equivalents of the same virtual sentence in the
+        # parallel collection, they should be distinguished with 'altN'.)
+        self.known_parallel_ids = set()
+        self.parallel_id_lastalt = {}
+        self.parallel_id_lastpart = {}
+        #----------------------------------------------------------------------
+        # Various things that we may have seen earlier in the corpus. The value
+        # is None if we have not seen it, otherwise it is the line number of
+        # the first occurrence.
+        #----------------------------------------------------------------------
+        self.seen_morpho_feature = None
+        self.seen_enhanced_graph = None
+        self.seen_tree_without_enhanced_graph = None
+        # Any difference between non-empty DEPS and HEAD:DEPREL.
+        # (Because we can see many enhanced graphs but no real enhancements.)
+        self.seen_enhancement = None
+        self.seen_empty_node = None
+        self.seen_enhanced_orphan = None
+        # global.entity comment line is needed for Entity annotations in MISC.
+        self.seen_global_entity = None
+        #----------------------------------------------------------------------
+        # Additional observations related to Entity annotation in MISC
+        # (only needed when validating entities and coreference).
+        #----------------------------------------------------------------------
+        # Remember the global.entity attribute string to be able to check that
+        # repeated declarations are identical.
+        self.global_entity_attribute_string = None
+        # The number of entity attributes will be derived from the attribute
+        # string and will be used to check that an entity does not have extra
+        # attributes.
+        self.entity_attribute_number = 0
+        # Key: entity attribute name; value: the index of the attribute in the
+        # entity attribute list.
+        self.entity_attribute_index = {}
+        # Key: entity (cluster) id; value: tuple: (type of the entity, identity
+        # (Wikipedia etc.), line of the first mention)).
+        self.entity_types = {}
+        # Indices of known entity ids in this and other documents.
+        # (Otherwise, if we only needed to know that an entity is known, we
+        # could use self.entity_types above.)
+        self.entity_ids_this_document = {}
+        self.entity_ids_other_documents = {}
+        # List of currently open entity mentions. Items are dictionaries with
+        # entity mention information.
+        self.open_entity_mentions = []
+        # For each entity that has currently open discontinuous mention,
+        # describe the last part of the mention. Key: entity id; value is dict,
+        # its keys: last_ipart, npart, line.
+        self.open_discontinuous_mentions = {}
+        # Key: srceid<tgteid pair; value: type of the entity (may be empty).
+        self.entity_bridge_relations = {}
+        # Key: tgteid; value: sorted list of srceids, serialized to string.
+        self.entity_split_antecedents = {}
+        # Key: [eid][sentid][str(mention_span)]; value: set of node ids.
+        self.entity_mention_spans = {}
+
+
+    def get_current_file_name(self):
+        """
+        Returns the current file name in the form suitable for Incident objects
+        and their string reports (i.e., 'STDIN' instead of '-', basename for
+        paths, 'NONE' otherwise).
+
+        Returns
+        -------
+        str
+            The modified name of the current input file.
+        """
+        if self.current_file_name:
+            if self.current_file_name == '-':
+                return 'STDIN'
+            else:
+                return os.path.basename(self.current_file_name)
+        else:
+            return 'NONE'
+
+
+    def __str__(self):
+        # Summarize the warnings and errors.
+        result = ''
+        passed = True
+        nerror = 0
+        if self.error_counter:
+            nwarning = 0
+            for k, v in self.error_counter[IncidentType.WARNING].items():
+                nwarning += v
+            if nwarning > 0:
+                result += f"Warnings: {nwarning}\n"
+            for k, v in sorted(self.error_counter[IncidentType.ERROR].items()):
+                nerror += v
+                passed = False
+                result += f"{str(k)} errors: {v}\n"
+        if passed:
+            result += '*** PASSED ***'
+        else:
+            result += f'*** FAILED *** with {nerror} errors'
+        return result
+
+
+    def passed(self):
+        for k, v in self.error_counter[IncidentType.ERROR].items():
+            if v > 0:
+                return False
+        return True
+
+
+    def __bool__(self):
+        return self.passed()

ud-tools/udtools/src/udtools/udeval.py

@@ -0,0 +1,882 @@
+#!/usr/bin/env python3
+
+# Code from CoNLL 2018 UD shared task updated for evaluation of enhanced
+# dependencies in IWPT 2020 shared task.
+# -- read DEPS, split on '|', compute overlap
+# New metrics ELAS and EULAS.
+# Gosse Bouma
+# New option --enhancements can switch off evaluation of certain types of
+# enhancements: default --enhancements 0 ... evaluate all enhancement types
+# 1 ... no gapping; 2 ... no coord shared parents; 3 ... no coord shared dependents
+# 4 ... no xsubj (control verbs); 5 ... no relative clauses; 6 ... no case info in deprels;
+# combinations: 12 ... both 1 and 2 apply
+
+# Compatible with Python 2.7 and 3.2+, can be used either as a module
+# or a standalone executable.
+#
+# Copyright 2017, 2018 Institute of Formal and Applied Linguistics (UFAL),
+# Faculty of Mathematics and Physics, Charles University, Czech Republic.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Authors: Milan Straka, Martin Popel <surname@ufal.mff.cuni.cz>
+#
+# Changelog:
+# - [12 Apr 2018] Version 0.9: Initial release.
+# - [19 Apr 2018] Version 1.0: Fix bug in MLAS (duplicate entries in functional_children).
+#                              Add --counts option.
+# - [02 May 2018] Version 1.1: When removing spaces to match gold and system characters,
+#                              consider all Unicode characters of category Zs instead of
+#                              just ASCII space.
+# - [25 Jun 2018] Version 1.2: Use python3 in the she-bang (instead of python).
+#                              In Python2, make the whole computation use `unicode` strings.
+
+# Command line usage
+# ------------------
+# eval.py [-v] [-c] gold_conllu_file system_conllu_file
+#
+# - if no -v is given, only the official IWPT 2020 Shared Task evaluation metrics
+#   are printed
+# - if -v is given, more metrics are printed (as precision, recall, F1 score,
+#   and in case the metric is computed on aligned words also accuracy on these):
+#   - Tokens: how well do the gold tokens match system tokens
+#   - Sentences: how well do the gold sentences match system sentences
+#   - Words: how well can the gold words be aligned to system words
+#   - UPOS: using aligned words, how well does UPOS match
+#   - XPOS: using aligned words, how well does XPOS match
+#   - UFeats: using aligned words, how well does universal FEATS match
+#   - AllTags: using aligned words, how well does UPOS+XPOS+FEATS match
+#   - Lemmas: using aligned words, how well does LEMMA match
+#   - UAS: using aligned words, how well does HEAD match
+#   - LAS: using aligned words, how well does HEAD+DEPREL(ignoring subtypes) match
+#   - CLAS: using aligned words with content DEPREL, how well does
+#       HEAD+DEPREL(ignoring subtypes) match
+#   - MLAS: using aligned words with content DEPREL, how well does
+#       HEAD+DEPREL(ignoring subtypes)+UPOS+UFEATS+FunctionalChildren(DEPREL+UPOS+UFEATS) match
+#   - BLEX: using aligned words with content DEPREL, how well does
+#       HEAD+DEPREL(ignoring subtypes)+LEMMAS match
+# - if -c is given, raw counts of correct/gold_total/system_total/aligned words are printed
+#   instead of precision/recall/F1/AlignedAccuracy for all metrics.
+
+# API usage
+# ---------
+# - load_conllu(file)
+#   - loads CoNLL-U file from given file object to an internal representation
+#   - the file object should return str in both Python 2 and Python 3
+#   - raises UDError exception if the given file cannot be loaded
+# - evaluate(gold_ud, system_ud)
+#   - evaluate the given gold and system CoNLL-U files (loaded with load_conllu)
+#   - raises UDError if the concatenated tokens of gold and system file do not match
+#   - returns a dictionary with the metrics described above, each metric having
+#     three fields: precision, recall and f1
+
+# Description of token matching
+# -----------------------------
+# In order to match tokens of gold file and system file, we consider the text
+# resulting from concatenation of gold tokens and text resulting from
+# concatenation of system tokens. These texts should match -- if they do not,
+# the evaluation fails.
+#
+# If the texts do match, every token is represented as a range in this original
+# text, and tokens are equal only if their range is the same.
+
+# Description of word matching
+# ----------------------------
+# When matching words of gold file and system file, we first match the tokens.
+# The words which are also tokens are matched as tokens, but words in multi-word
+# tokens have to be handled differently.
+#
+# To handle multi-word tokens, we start by finding "multi-word spans".
+# Multi-word span is a span in the original text such that
+# - it contains at least one multi-word token
+# - all multi-word tokens in the span (considering both gold and system ones)
+#   are completely inside the span (i.e., they do not "stick out")
+# - the multi-word span is as small as possible
+#
+# For every multi-word span, we align the gold and system words completely
+# inside this span using LCS on their FORMs. The words not intersecting
+# (even partially) any multi-word span are then aligned as tokens.
+
+
+from __future__ import division
+from __future__ import print_function
+
+import io
+import sys
+import unicodedata
+import unittest
+
+# CoNLL-U column names
+ID, FORM, LEMMA, UPOS, XPOS, FEATS, HEAD, DEPREL, DEPS, MISC = range(10)
+
+# Content and functional relations
+CONTENT_DEPRELS = {
+    "nsubj", "obj", "iobj", "csubj", "ccomp", "xcomp", "obl", "vocative",
+    "expl", "dislocated", "advcl", "advmod", "discourse", "nmod", "appos",
+    "nummod", "acl", "amod", "conj", "fixed", "flat", "compound", "list",
+    "parataxis", "orphan", "goeswith", "reparandum", "root", "dep"
+}
+
+FUNCTIONAL_DEPRELS = {
+    "aux", "cop", "mark", "det", "clf", "case", "cc"
+}
+
+UNIVERSAL_FEATURES = {
+    "PronType", "NumType", "Poss", "Reflex", "Foreign", "Abbr", "Gender",
+    "Animacy", "Number", "Case", "Definite", "Degree", "VerbForm", "Mood",
+    "Tense", "Aspect", "Voice", "Evident", "Polarity", "Person", "Polite"
+}
+
+# UD Error is used when raising exceptions in this module
+class UDError(Exception):
+    pass
+
+
+
+CASE_DEPRELS = {'obl','nmod','conj','advcl'}
+UNIVERSAL_DEPREL_EXTENSIONS = {'pass','relcl','xsubj'}
+
+# Modify the set of deps produced by system to be in accordance with gold treebank type.
+# Return a (filtered) list of (hd, dependency_path) tuples.
+def process_enhanced_deps(deps) :
+    edeps = []
+    if deps != '' and deps != '_':
+        for edep in deps.split('|') :
+            (hd, path) = edep.split(':', 1)
+            steps = path.split('>') # collapsing empty nodes gives rise to paths like this : 3:conj:en>obl:voor
+            edeps.append((hd,steps))   # (3,['conj:en','obj:voor'])
+    return edeps
+
+# Load given CoNLL-U file into internal representation.
+# The file parameter is the open file object.
+# The path parameter is needed only for diagnostic messages.
+def load_conllu(file, path, treebank_type):
+    # Internal representation classes
+    class UDRepresentation:
+        def __init__(self):
+            # Characters of all the tokens in the whole file.
+            # Whitespace between tokens is not included.
+            self.characters = []
+            # List of UDSpan instances with start&end indices into `characters`.
+            self.tokens = []
+            # List of UDWord instances.
+            self.words = []
+            # List of UDSpan instances with start&end indices into `characters`.
+            self.sentences = []
+            # File path may be needed in error messages.
+            self.path = ''
+    class UDSpan:
+        def __init__(self, start, end, line):
+            self.start = start
+            # Note that self.end marks the first position **after the end** of span,
+            # so we can use characters[start:end] or range(start, end).
+            self.end = end
+            # Line number (1-based) will be useful if we need to report an error later.
+            self.line = line
+    class UDWord:
+        def __init__(self, span, columns, is_multiword):
+            # Span of this word (or MWT, see below) within ud_representation.characters.
+            self.span = span
+            # 10 columns of the CoNLL-U file: ID, FORM, LEMMA,...
+            self.columns = columns
+            # is_multiword==True means that this word is part of a multi-word token.
+            # In that case, self.span marks the span of the whole multi-word token.
+            self.is_multiword = is_multiword
+            # Reference to the UDWord instance representing the HEAD (or None if root).
+            self.parent = None
+            # List of references to UDWord instances representing functional-deprel children.
+            self.functional_children = []
+            # Only consider universal FEATS.
+            self.columns[FEATS] = "|".join(sorted(feat for feat in columns[FEATS].split("|")
+                                                  if feat.split("=", 1)[0] in UNIVERSAL_FEATURES))
+            # Let's ignore language-specific deprel subtypes.
+            self.columns[DEPREL] = columns[DEPREL].split(":")[0]
+            # Precompute which deprels are CONTENT_DEPRELS and which FUNCTIONAL_DEPRELS
+            self.is_content_deprel = self.columns[DEPREL] in CONTENT_DEPRELS
+            self.is_functional_deprel = self.columns[DEPREL] in FUNCTIONAL_DEPRELS
+            # store enhanced deps --GB
+            # split string positions and enhanced labels as well?
+            self.columns[DEPS] = process_enhanced_deps(columns[DEPS])
+
+    ud = UDRepresentation()
+
+    # Load the CoNLL-U file
+    ud.path = path
+    index, sentence_start = 0, None
+    line_idx = 0
+    while True:
+        line = file.readline()
+        line_idx += 1 # errors will be displayed indexed from 1
+        if not line:
+            break
+        line = line.rstrip("\r\n")
+
+        # Handle sentence start boundaries
+        if sentence_start is None:
+            # Skip comments
+            if line.startswith("#"):
+                continue
+            # Start a new sentence
+            ud.sentences.append(UDSpan(index, 0, line_idx))
+            sentence_start = len(ud.words)
+        if not line:
+            # Add parent and children UDWord links and check there are no cycles
+            def process_word(word):
+                if word.parent == "remapping":
+                    raise UDError("There is a cycle in the sentence that ends at line %d" % line_idx)
+                if word.parent is None:
+                    head = int(word.columns[HEAD])
+                    if head < 0 or head > len(ud.words) - sentence_start:
+                        raise UDError("HEAD '{}' points outside of the sentence that ends at line {}".format(word.columns[HEAD], line_idx))
+                    if head:
+                        parent = ud.words[sentence_start + head - 1]
+                        word.parent = "remapping"
+                        process_word(parent)
+                        word.parent = parent
+
+            position = sentence_start # need to incrementally keep track of current position for loop detection in relcl
+            for word in ud.words[sentence_start:]:
+                process_word(word)
+                enhanced_deps = word.columns[DEPS]
+                # replace head positions of enhanced dependencies with parent word object -- GB
+                processed_deps = []
+                for (head,steps) in word.columns[DEPS] :       # (3,['conj:en','obj:voor'])
+                    # Empty nodes should have been collapsed during preprocessing.
+                    # If not, we cannot evaluate gapping correctly. However, people
+                    # may care just about basic trees and may not want to bother
+                    # with preprocessing.
+                    if '.' in head:
+                        if treebank_type.get('no_empty_nodes', False):
+                            raise UDError("The collapsed CoNLL-U file still contains references to empty nodes at line {}: {}".format(line_idx, line))
+                        else:
+                            continue
+                    hd = int(head)
+                    parent = ud.words[sentence_start + hd -1] if hd else hd  # just assign '0' to parent for root cases
+                    processed_deps.append((parent,steps))
+                enhanced_deps = processed_deps
+
+                # ignore rel>rel dependencies, and instead append the original hd/rel edge
+                # note that this also ignores other extensions (like adding lemma's)
+                # note that this sometimes introduces duplicates (if orig hd/rel was already included in DEPS)
+                if treebank_type.get('no_gapping', False) : # enhancement 1
+                    processed_deps = []
+                    for (parent,steps) in enhanced_deps :
+                        if len(steps) > 1 :
+                            processed_deps.append((word.parent,[word.columns[DEPREL]]))
+                        else :
+                            if (parent,steps) in processed_deps :
+                                True
+                            else :
+                                processed_deps.append((parent,steps))
+                    enhanced_deps = processed_deps
+
+                # for a given conj node, any rel other than conj in DEPS can be ignored
+                if treebank_type.get('no_shared_parents_in_coordination', False) :   # enhancement  2
+                    for (hd,steps) in enhanced_deps :
+                        if len(steps) == 1 and steps[0].startswith('conj') :
+                            enhanced_deps = [(hd,steps)]
+
+                # deprels not matching ud_hd/ud_dep are spurious.
+                #  czech/pud estonian/ewt syntagrus finnish/pud
+                # TO DO: treebanks that do not mark xcomp and relcl subjects
+                if treebank_type.get('no_shared_dependents_in_coordination', False) : # enhancement  3
+                    processed_deps = []
+                    for (hd,steps) in enhanced_deps :
+                        duplicate = 0
+                        for (hd2,steps2) in enhanced_deps :
+                            if steps == steps2 and hd2 == word.columns[HEAD]  and hd != hd2  : # checking only for ud_hd here, check for ud_dep as well?
+                                duplicate = 1
+                        if not(duplicate) :
+                            processed_deps.append((hd,steps))
+                    enhanced_deps = processed_deps
+
+                # if treebank does not have control relations: subjects of xcomp parents in system are to be skipped
+                # note that rel is actually a path sometimes rel1>rel2 in theory rel2 could be subj?
+                # from lassy-small: 7:conj:en>nsubj:pass|7:conj:en>nsubj:xsubj    (7,['conj:en','nsubj:xsubj'])
+                if treebank_type.get('no_control', False) : # enhancement 4
+                    processed_deps = []
+                    for (parent,steps) in enhanced_deps :
+                        include = 1
+                        if ( parent and parent.columns[DEPREL] == 'xcomp') :
+                            for rel in steps:
+                                if rel.startswith('nsubj') :
+                                    include = 0
+                        if include :
+                            processed_deps.append((parent,steps))
+                    enhanced_deps = processed_deps
+
+                if treebank_type.get('no_external_arguments_of_relative_clauses', False) : # enhancement 5
+                    processed_deps = []
+                    for (parent,steps) in enhanced_deps :
+                        if (steps[0] == 'ref') :
+                            processed_deps.append((word.parent,[word.columns[DEPREL]]))  # append the original relation
+                        # ignore external argument link
+                        # external args are deps of an acl:relcl where that acl also is a dependent of external arg (i.e. ext arg introduces a cycle)
+                        elif ( parent and parent.columns[DEPREL].startswith('acl')  and int(parent.columns[HEAD]) == position - sentence_start ) :
+                            #print('removed external argument')
+                            True
+                        else :
+                            processed_deps.append((parent,steps))
+                    enhanced_deps = processed_deps
+
+                # treebanks where no lemma info has been added
+                if treebank_type.get('no_case_info', False) :  # enhancement number 6
+                    processed_deps = []
+                    for (hd,steps) in enhanced_deps :
+                        processed_steps = []
+                        for dep in steps :
+                            depparts = dep.split(':')
+                            if depparts[0] in  CASE_DEPRELS :
+                                if (len(depparts) == 2 and not(depparts[1] in UNIVERSAL_DEPREL_EXTENSIONS )) :
+                                    dep = depparts[0]
+                            processed_steps.append(dep)
+                        processed_deps.append((hd,processed_steps))
+                    enhanced_deps = processed_deps
+
+                position += 1
+                word.columns[DEPS] = enhanced_deps
+
+            # func_children cannot be assigned within process_word
+            # because it is called recursively and may result in adding one child twice.
+            for word in ud.words[sentence_start:]:
+                if word.parent and word.is_functional_deprel:
+                    word.parent.functional_children.append(word)
+
+            if len(ud.words) == sentence_start :
+                raise UDError("There is a sentence with 0 tokens (possibly a double blank line) at line %d" % line_idx)
+
+            # Check there is a single root node
+            if len([word for word in ud.words[sentence_start:] if word.parent is None]) == 0:
+                raise UDError("There are no roots in the sentence that ends at %d" % line_idx)
+            if not treebank_type.get('multiple_roots_okay', False):
+                if len([word for word in ud.words[sentence_start:] if word.parent is None]) > 1:
+                    raise UDError("There are multiple roots in the sentence that ends at %d" % line_idx)
+
+            # End the sentence
+            ud.sentences[-1].end = index
+            sentence_start = None
+            continue
+
+        # Read next token/word
+        columns = line.split("\t")
+        if len(columns) != 10:
+            raise UDError("The CoNLL-U line does not contain 10 tab-separated columns at line {}: '{}'".format(line_idx, line))
+
+        # Skip empty nodes
+        # If we are evaluating enhanced graphs, empty nodes should have been collapsed
+        # during preprocessing and should not occur here. However, we cannot raise
+        # an exception if they do because the user may be interested just in the
+        # basic tree and may not want to bother with preprocessing.
+        if "." in columns[ID]:
+            # When launching this script, we can specify that empty nodes should be considered errors.
+            if treebank_type.get('no_empty_nodes', False):
+                raise UDError("The collapsed CoNLL-U line still contains empty nodes at line {}: {}".format(line_idx, line))
+            else:
+                continue
+
+        # Delete spaces from FORM, so gold.characters == system.characters
+        # even if one of them tokenizes the space. Use any Unicode character
+        # with category Zs.
+        columns[FORM] = "".join(filter(lambda c: unicodedata.category(c) != "Zs", columns[FORM]))
+        if not columns[FORM]:
+            raise UDError("There is an empty FORM in the CoNLL-U file at line %d" % line_idx)
+
+        # Save token
+        ud.characters.extend(columns[FORM])
+        ud.tokens.append(UDSpan(index, index + len(columns[FORM]), line_idx))
+        index += len(columns[FORM])
+
+        # Handle multi-word tokens to save word(s)
+        if "-" in columns[ID]:
+            try:
+                start, end = map(int, columns[ID].split("-"))
+            except:
+                raise UDError("Cannot parse multi-word token ID '{}' at line {}".format(columns[ID], line_idx))
+
+            words_expected = end - start + 1
+            words_found = 0
+            while words_found < words_expected:
+                word_line = file.readline().rstrip("\r\n")
+                if not word_line:
+                    raise UDError("The CoNLL-U file ends in an unfinished MWT at line {}".format(line_idx))
+                line_idx += 1
+                word_columns = word_line.split("\t")
+                if len(word_columns) != 10:
+                    raise UDError("The CoNLL-U line does not contain 10 tab-separated columns at line {}: '{}'".format(line_idx, word_line))
+                if "." in word_columns[ID]:
+                    if treebank_type.get('no_empty_nodes', False):
+                        raise UDError("The collapsed CoNLL-U line still contains empty nodes at line {}: {}".format(line_idx, line))
+                    else:
+                        continue
+                ud.words.append(UDWord(ud.tokens[-1], word_columns, is_multiword=True))
+                words_found += 1
+
+        # Basic tokens/words
+        else:
+            try:
+                word_id = int(columns[ID])
+            except:
+                raise UDError("Cannot parse word ID '{}' at line {}".format(columns[ID], line_idx))
+            if word_id != len(ud.words) - sentence_start + 1:
+                raise UDError("Incorrect word ID '{}' for word '{}', expected '{}' at line {}".format(
+                    columns[ID], columns[FORM], len(ud.words) - sentence_start + 1, line_idx))
+
+            try:
+                head_id = int(columns[HEAD])
+            except ValueError as e:
+                raise UDError("Cannot parse HEAD '{}' at line {}".format(columns[HEAD], line_idx)) from e
+            if head_id < 0:
+                raise UDError("HEAD cannot be negative at line %d" % line_idx)
+
+            ud.words.append(UDWord(ud.tokens[-1], columns, is_multiword=False))
+
+    if sentence_start is not None:
+        raise UDError("The CoNLL-U file does not end with empty line")
+
+    return ud
+
+
+
+# Evaluate the gold and system treebanks (loaded using load_conllu).
+def evaluate(gold_ud, system_ud):
+    """
+    Takes internal representations of two CoNLL-U files, compares their
+    contents and returns the scores.
+
+    Parameters
+    ----------
+    gold_ud : UDRepresentation
+        Gold standard data.
+    system_ud : UDRepresentationi
+        System output data.
+
+    Raises
+    ------
+    UDError
+        If the underlying texts of the files are not compatible.
+
+    Returns
+    -------
+    dict
+        Indexed by metric names, the values are scores.
+    """
+    class Score:
+        def __init__(self, gold_total, system_total, correct, aligned_total=None):
+            self.correct = correct
+            self.gold_total = gold_total
+            self.system_total = system_total
+            self.aligned_total = aligned_total
+            self.precision = correct / system_total if system_total else 0.0
+            self.recall = correct / gold_total if gold_total else 0.0
+            self.f1 = 2 * correct / (system_total + gold_total) if system_total + gold_total else 0.0
+            self.aligned_accuracy = correct / aligned_total if aligned_total else aligned_total
+    class AlignmentWord:
+        def __init__(self, gold_word, system_word):
+            self.gold_word = gold_word
+            self.system_word = system_word
+    class Alignment:
+        def __init__(self, gold_words, system_words):
+            self.gold_words = gold_words
+            self.system_words = system_words
+            self.matched_words = []
+            self.matched_words_map = {}
+        def append_aligned_words(self, gold_word, system_word):
+            self.matched_words.append(AlignmentWord(gold_word, system_word))
+            self.matched_words_map[system_word] = gold_word
+
+    def spans_score(gold_spans, system_spans):
+        correct, gi, si = 0, 0, 0
+        while gi < len(gold_spans) and si < len(system_spans):
+            if system_spans[si].start < gold_spans[gi].start:
+                si += 1
+            elif gold_spans[gi].start < system_spans[si].start:
+                gi += 1
+            else:
+                correct += gold_spans[gi].end == system_spans[si].end
+                si += 1
+                gi += 1
+
+        return Score(len(gold_spans), len(system_spans), correct)
+
+    def alignment_score(alignment, key_fn=None, filter_fn=None):
+        if filter_fn is not None:
+            gold = sum(1 for gold in alignment.gold_words if filter_fn(gold))
+            system = sum(1 for system in alignment.system_words if filter_fn(system))
+            aligned = sum(1 for word in alignment.matched_words if filter_fn(word.gold_word))
+        else:
+            gold = len(alignment.gold_words)
+            system = len(alignment.system_words)
+            aligned = len(alignment.matched_words)
+
+        if key_fn is None:
+            # Return score for whole aligned words
+            return Score(gold, system, aligned)
+
+        def gold_aligned_gold(word):
+            return word
+        def gold_aligned_system(word):
+            return alignment.matched_words_map.get(word, 'NotAligned') if word is not None else None
+        correct = 0
+        for words in alignment.matched_words:
+            if filter_fn is None or filter_fn(words.gold_word):
+                if key_fn(words.gold_word, gold_aligned_gold) == key_fn(words.system_word, gold_aligned_system):
+                    correct += 1
+
+        return Score(gold, system, correct, aligned)
+
+    def enhanced_alignment_score(alignment, EULAS):
+        # count all matching enhanced deprels in gold, system GB
+        # gold and system = sum of gold and predicted deps
+        # parents are pointers to word object, make sure to compare system parent with aligned word in gold in cases where
+        # tokenization introduces mismatches in number of words per sentence.
+        gold = 0
+        for gold_word in alignment.gold_words :
+            gold += len(gold_word.columns[DEPS])
+        system = 0
+        for system_word in alignment.system_words :
+            system += len(system_word.columns[DEPS])
+        correct = 0
+        for words in alignment.matched_words:
+            gold_deps = words.gold_word.columns[DEPS]
+            system_deps = words.system_word.columns[DEPS]
+            for (parent, dep) in gold_deps :
+                eulas_dep = [d.split(':')[0] for d in dep]
+                for (sparent, sdep) in system_deps:
+                    eulas_sdep = [d.split(':')[0] for d in sdep]
+                    if dep == sdep or ( eulas_dep == eulas_sdep and EULAS ) :
+                        if parent == alignment.matched_words_map.get(sparent, 'NotAligned') :
+                            correct += 1
+                        elif (parent == 0 and sparent == 0) :  # cases where parent is root
+                            correct += 1
+        return Score(gold, system, correct)
+
+    def beyond_end(words, i, multiword_span_end):
+        if i >= len(words):
+            return True
+        if words[i].is_multiword:
+            return words[i].span.start >= multiword_span_end
+        return words[i].span.end > multiword_span_end
+
+    def extend_end(word, multiword_span_end):
+        if word.is_multiword and word.span.end > multiword_span_end:
+            return word.span.end
+        return multiword_span_end
+
+    def find_multiword_span(gold_words, system_words, gi, si):
+        # We know gold_words[gi].is_multiword or system_words[si].is_multiword.
+        # Find the start of the multiword span (gs, ss), so the multiword span is minimal.
+        # Initialize multiword_span_end characters index.
+        if gold_words[gi].is_multiword:
+            multiword_span_end = gold_words[gi].span.end
+            if not system_words[si].is_multiword and system_words[si].span.start < gold_words[gi].span.start:
+                si += 1
+        else: # if system_words[si].is_multiword
+            multiword_span_end = system_words[si].span.end
+            if not gold_words[gi].is_multiword and gold_words[gi].span.start < system_words[si].span.start:
+                gi += 1
+        gs, ss = gi, si
+
+        # Find the end of the multiword span
+        # (so both gi and si are pointing to the word following the multiword span end).
+        while not beyond_end(gold_words, gi, multiword_span_end) or \
+              not beyond_end(system_words, si, multiword_span_end):
+            if gi < len(gold_words) and (si >= len(system_words) or
+                                         gold_words[gi].span.start <= system_words[si].span.start):
+                multiword_span_end = extend_end(gold_words[gi], multiword_span_end)
+                gi += 1
+            else:
+                multiword_span_end = extend_end(system_words[si], multiword_span_end)
+                si += 1
+        return gs, ss, gi, si
+
+    def compute_lcs(gold_words, system_words, gi, si, gs, ss):
+        lcs = [[0] * (si - ss) for i in range(gi - gs)]
+        for g in reversed(range(gi - gs)):
+            for s in reversed(range(si - ss)):
+                if gold_words[gs + g].columns[FORM].lower() == system_words[ss + s].columns[FORM].lower():
+                    lcs[g][s] = 1 + (lcs[g+1][s+1] if g+1 < gi-gs and s+1 < si-ss else 0)
+                lcs[g][s] = max(lcs[g][s], lcs[g+1][s] if g+1 < gi-gs else 0)
+                lcs[g][s] = max(lcs[g][s], lcs[g][s+1] if s+1 < si-ss else 0)
+        return lcs
+
+    def align_words(gold_words, system_words):
+        alignment = Alignment(gold_words, system_words)
+
+        gi, si = 0, 0
+        while gi < len(gold_words) and si < len(system_words):
+            if gold_words[gi].is_multiword or system_words[si].is_multiword:
+                # A: Multi-word tokens => align via LCS within the whole "multiword span".
+                gs, ss, gi, si = find_multiword_span(gold_words, system_words, gi, si)
+
+                if si > ss and gi > gs:
+                    lcs = compute_lcs(gold_words, system_words, gi, si, gs, ss)
+
+                    # Store aligned words
+                    s, g = 0, 0
+                    while g < gi - gs and s < si - ss:
+                        if gold_words[gs + g].columns[FORM].lower() == system_words[ss + s].columns[FORM].lower():
+                            alignment.append_aligned_words(gold_words[gs+g], system_words[ss+s])
+                            g += 1
+                            s += 1
+                        elif lcs[g][s] == (lcs[g+1][s] if g+1 < gi-gs else 0):
+                            g += 1
+                        else:
+                            s += 1
+            else:
+                # B: No multi-word token => align according to spans.
+                if (gold_words[gi].span.start, gold_words[gi].span.end) == (system_words[si].span.start, system_words[si].span.end):
+                    alignment.append_aligned_words(gold_words[gi], system_words[si])
+                    gi += 1
+                    si += 1
+                elif gold_words[gi].span.start <= system_words[si].span.start:
+                    gi += 1
+                else:
+                    si += 1
+
+        return alignment
+
+    # Check that the underlying character sequences match.
+    if gold_ud.characters != system_ud.characters:
+        # Identify the surrounding tokens and line numbers so the error is easier to debug.
+        index = 0
+        while index < len(gold_ud.characters) and index < len(system_ud.characters) and \
+                gold_ud.characters[index] == system_ud.characters[index]:
+            index += 1
+        gtindex = 0
+        while gtindex < len(gold_ud.tokens) and gold_ud.tokens[gtindex].end-1 < index:
+            gtindex += 1
+        stindex = 0
+        while stindex < len(system_ud.tokens) and system_ud.tokens[stindex].end-1 < index:
+            stindex += 1
+        gtokenreport = "The error occurs right at the beginning of the two files.\n"
+        stokenreport = ""
+        if gtindex > 0:
+            nprev = 10 if gtindex >= 10 else gtindex
+            nnext = 10 if gtindex + 10 <= len(gold_ud.tokens) else len(gold_ud.tokens) - gtindex
+            nfirst = gtindex - nprev
+            prevtokens = ' '.join([''.join(gold_ud.characters[t.start:t.end]) for t in gold_ud.tokens[nfirst:gtindex]])
+            nexttokens = ' '.join([''.join(gold_ud.characters[t.start:t.end]) for t in gold_ud.tokens[gtindex:gtindex + nnext]])
+            gtokenreport = "File '{}':\n".format(gold_ud.path)
+            gtokenreport += "  Token no. {} on line no. {} is the last one with all characters reproduced in the other file.\n".format(gtindex, gold_ud.tokens[gtindex-1].line)
+            gtokenreport += "  The previous {} tokens are '{}'.\n".format(nprev, prevtokens)
+            gtokenreport += "  The next {} tokens are '{}'.\n".format(nnext, nexttokens)
+        if stindex > 0:
+            nprev = 10 if stindex >= 10 else stindex
+            nnext = 10 if stindex + 10 <= len(system_ud.tokens) else len(system_ud.tokens) - stindex
+            nfirst = stindex - nprev
+            prevtokens = ' '.join([''.join(system_ud.characters[t.start:t.end]) for t in system_ud.tokens[nfirst:stindex]])
+            nexttokens = ' '.join([''.join(system_ud.characters[t.start:t.end]) for t in system_ud.tokens[stindex:stindex + nnext]])
+            stokenreport = "File '{}':\n".format(system_ud.path)
+            stokenreport += "  Token no. {} on line no. {} is the last one with all characters reproduced in the other file.\n".format(stindex, system_ud.tokens[stindex-1].line)
+            stokenreport += "  The previous {} tokens are '{}'.\n".format(nprev, prevtokens)
+            stokenreport += "  The next {} tokens are '{}'.\n".format(nnext, nexttokens)
+        raise UDError(
+            "The concatenation of tokens in gold file and in system file differ!\n" + gtokenreport + stokenreport +
+            "First 20 differing characters in gold file: '{}' and system file: '{}'".format(
+                "".join(gold_ud.characters[index:index + 20]),
+                "".join(system_ud.characters[index:index + 20])
+            )
+        )
+
+    # Align words
+    alignment = align_words(gold_ud.words, system_ud.words)
+
+    # Compute the F1-scores
+    return {
+        "Tokens": spans_score(gold_ud.tokens, system_ud.tokens),
+        "Sentences": spans_score(gold_ud.sentences, system_ud.sentences),
+        "Words": alignment_score(alignment),
+        "UPOS": alignment_score(alignment, lambda w, _: w.columns[UPOS]),
+        "XPOS": alignment_score(alignment, lambda w, _: w.columns[XPOS]),
+        "UFeats": alignment_score(alignment, lambda w, _: w.columns[FEATS]),
+        "AllTags": alignment_score(alignment, lambda w, _: (w.columns[UPOS], w.columns[XPOS], w.columns[FEATS])),
+        "Lemmas": alignment_score(alignment, lambda w, ga: w.columns[LEMMA] if ga(w).columns[LEMMA] != "_" else "_"),
+        "UAS": alignment_score(alignment, lambda w, ga: ga(w.parent)),
+        "LAS": alignment_score(alignment, lambda w, ga: (ga(w.parent), w.columns[DEPREL])),
+        "ELAS": enhanced_alignment_score(alignment, 0),
+        "EULAS": enhanced_alignment_score(alignment, 1),
+        "CLAS": alignment_score(alignment, lambda w, ga: (ga(w.parent), w.columns[DEPREL]),
+                                filter_fn=lambda w: w.is_content_deprel),
+        "MLAS": alignment_score(alignment, lambda w, ga: (ga(w.parent), w.columns[DEPREL], w.columns[UPOS], w.columns[FEATS],
+                                                         [(ga(c), c.columns[DEPREL], c.columns[UPOS], c.columns[FEATS])
+                                                          for c in w.functional_children]),
+                                filter_fn=lambda w: w.is_content_deprel),
+        "BLEX": alignment_score(alignment, lambda w, ga: (ga(w.parent), w.columns[DEPREL],
+                                                          w.columns[LEMMA] if ga(w).columns[LEMMA] != "_" else "_"),
+                                filter_fn=lambda w: w.is_content_deprel),
+    }
+
+
+
+def load_conllu_file(path, treebank_type=None):
+    """
+    Reads a CoNLL-U file into internal representation.
+
+    Parameters
+    ----------
+    path : str
+        The name of (and path to) the file.
+    treebank_type : dict, optional
+        Additional information about what we expect / should read. The default is None.
+
+    Returns
+    -------
+    UDRepresentation
+        The internal representation of the file contents, usable in evaluate().
+    """
+    if treebank_type is None:
+        treebank_type = {}
+    _file = open(path, mode="r", **({"encoding": "utf-8"}))
+    return load_conllu(_file, path, treebank_type)
+
+
+
+def evaluate_wrapper(args):
+    """
+    Takes file names and options from command line arguments, loads the files,
+    evaluates their similarity and returns the result of evaluate(). Use
+    `--help` to obtain their description (or see udtools.argparser.parse_args_scorer()).
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Command line arguments of the eval.py script.
+
+    Returns
+    -------
+    dict
+        Indexed by metric names, values are scores.
+    """
+    treebank_type = {}
+    enhancements = list(args.enhancements)
+    treebank_type['no_gapping'] = 1 if '1' in enhancements else 0
+    treebank_type['no_shared_parents_in_coordination'] = 1 if '2' in enhancements else 0
+    treebank_type['no_shared_dependents_in_coordination'] = 1 if '3' in enhancements else 0
+    treebank_type['no_control'] = 1 if '4' in enhancements else 0
+    treebank_type['no_external_arguments_of_relative_clauses'] = 1 if '5' in enhancements else 0
+    treebank_type['no_case_info'] = 1 if '6' in enhancements else 0
+    treebank_type['no_empty_nodes'] = args.no_empty_nodes
+    treebank_type['multiple_roots_okay'] = args.multiple_roots_okay
+
+    # Load CoNLL-U files
+    gold_ud = load_conllu_file(args.gold_file, treebank_type)
+    system_ud = load_conllu_file(args.system_file, treebank_type)
+    return evaluate(gold_ud, system_ud)
+
+
+
+def build_evaluation_table(evaluation, verbose=True, counts=False, enhanced=False):
+    """
+    Creates a plaintext table with the results.
+
+    Parameters
+    ----------
+    evaluation : dict
+        The output of the evaluate() function.
+    verbose : bool, optional
+        Print results of all metrics. (Otherwise, print only LAS P+R+F1.)
+        Default is True.
+    counts : bool, optional
+        Print raw counts of correct/gold/system/aligned words instead of
+        precision/recall/F1 for all metrics. Default is False.
+    enhanced : bool, optional
+        Include evaluation of enhanced graphs. Default is False.
+
+    Returns
+    -------
+    str
+        The table with results.
+    """
+    text = []
+
+    # Print the evaluation
+    if not verbose and not counts:
+        text.append("LAS F1 Score: {:.2f}".format(100 * evaluation["LAS"].f1))
+        text.append("MLAS Score: {:.2f}".format(100 * evaluation["MLAS"].f1))
+        text.append("BLEX Score: {:.2f}".format(100 * evaluation["BLEX"].f1))
+        if enhanced:
+            text.append("ELAS F1 Score: {:.2f}".format(100 * evaluation["ELAS"].f1))
+            text.append("EULAS F1 Score: {:.2f}".format(100 * evaluation["EULAS"].f1))
+    else:
+        if counts:
+            text.append("Metric     | Correct   |      Gold | Predicted | Aligned")
+        else:
+            text.append("Metric     | Precision |    Recall |  F1 Score | AligndAcc")
+        text.append("-----------+-----------+-----------+-----------+-----------")
+        metrics = ["Tokens", "Sentences", "Words", "UPOS", "XPOS", "UFeats", "AllTags", "Lemmas", "UAS", "LAS", "CLAS", "MLAS", "BLEX"]
+        if enhanced:
+            metrics += ["ELAS", "EULAS"]
+        for metric in metrics:
+            if counts:
+                text.append("{:11}|{:10} |{:10} |{:10} |{:10}".format(
+                    metric,
+                    evaluation[metric].correct,
+                    evaluation[metric].gold_total,
+                    evaluation[metric].system_total,
+                    evaluation[metric].aligned_total or (evaluation[metric].correct if metric == "Words" else "")
+                ))
+            else:
+                text.append("{:11}|{:10.2f} |{:10.2f} |{:10.2f} |{}".format(
+                    metric,
+                    100 * evaluation[metric].precision,
+                    100 * evaluation[metric].recall,
+                    100 * evaluation[metric].f1,
+                    "{:10.2f}".format(100 * evaluation[metric].aligned_accuracy) if evaluation[metric].aligned_accuracy is not None else ""
+                ))
+
+    return "\n".join(text)
+
+
+
+# Tests, which can be executed with `python -m unittest udeval`.
+class TestAlignment(unittest.TestCase):
+    @staticmethod
+    def _load_words(words):
+        """Prepare fake CoNLL-U files with fake HEAD to prevent multiple roots errors."""
+        lines, num_words = [], 0
+        for w in words:
+            parts = w.split(" ")
+            if len(parts) == 1:
+                num_words += 1
+                lines.append("{}\t{}\t_\t_\t_\t_\t{}\t_\t_\t_".format(num_words, parts[0], int(num_words>1)))
+            else:
+                lines.append("{}-{}\t{}\t_\t_\t_\t_\t_\t_\t_\t_".format(num_words + 1, num_words + len(parts) - 1, parts[0]))
+                for part in parts[1:]:
+                    num_words += 1
+                    lines.append("{}\t{}\t_\t_\t_\t_\t{}\t_\t_\t_".format(num_words, part, int(num_words>1)))
+        return load_conllu((io.StringIO if sys.version_info >= (3, 0) else io.BytesIO)("\n".join(lines+["\n"])),
+                           "in memory test file", {})
+
+    def _test_exception(self, gold, system):
+        self.assertRaises(UDError, evaluate, self._load_words(gold), self._load_words(system))
+
+    def _test_ok(self, gold, system, correct):
+        metrics = evaluate(self._load_words(gold), self._load_words(system))
+        gold_words = sum((max(1, len(word.split(" ")) - 1) for word in gold))
+        system_words = sum((max(1, len(word.split(" ")) - 1) for word in system))
+        self.assertEqual((metrics["Words"].precision, metrics["Words"].recall, metrics["Words"].f1),
+                         (correct / system_words, correct / gold_words, 2 * correct / (gold_words + system_words)))
+
+    def test_exception(self):
+        self._test_exception(["a"], ["b"])
+
+    def test_equal(self):
+        self._test_ok(["a"], ["a"], 1)
+        self._test_ok(["a", "b", "c"], ["a", "b", "c"], 3)
+
+    def test_equal_with_multiword(self):
+        self._test_ok(["abc a b c"], ["a", "b", "c"], 3)
+        self._test_ok(["a", "bc b c", "d"], ["a", "b", "c", "d"], 4)
+        self._test_ok(["abcd a b c d"], ["ab a b", "cd c d"], 4)
+        self._test_ok(["abc a b c", "de d e"], ["a", "bcd b c d", "e"], 5)
+
+    def test_alignment(self):
+        self._test_ok(["abcd"], ["a", "b", "c", "d"], 0)
+        self._test_ok(["abc", "d"], ["a", "b", "c", "d"], 1)
+        self._test_ok(["a", "bc", "d"], ["a", "b", "c", "d"], 2)
+        self._test_ok(["a", "bc b c", "d"], ["a", "b", "cd"], 2)
+        self._test_ok(["abc a BX c", "def d EX f"], ["ab a b", "cd c d", "ef e f"], 4)
+        self._test_ok(["ab a b", "cd bc d"], ["a", "bc", "d"], 2)
+        self._test_ok(["a", "bc b c", "d"], ["ab AX BX", "cd CX a"], 1)

ud-tools/udtools/src/udtools/utils.py

@@ -0,0 +1,434 @@
+import regex as re
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    from udtools.src.udtools.incident import Reference
+except ModuleNotFoundError:
+    from udtools.incident import Reference
+
+
+
+# Constants for the column indices
+COLCOUNT=10
+ID,FORM,LEMMA,UPOS,XPOS,FEATS,HEAD,DEPREL,DEPS,MISC=range(COLCOUNT)
+COLNAMES='ID,FORM,LEMMA,UPOS,XPOS,FEATS,HEAD,DEPREL,DEPS,MISC'.split(',')
+
+
+
+class CompiledRegexes:
+    """
+    The CompiledRegexes class holds various regular expressions needed to
+    recognize individual elements of the CoNLL-U format, precompiled to speed
+    up parsing. Individual expressions are typically not enclosed in ^...$
+    because one can use re.fullmatch() if it is desired that the whole string
+    matches the expression.
+    """
+    def __init__(self):
+        # Whitespace.
+        self.ws = re.compile(r"\s+")
+        # Two consecutive whitespaces.
+        self.ws2 = re.compile(r"\s\s")
+        # Regular word/node id: integer number.
+        self.wordid = re.compile(r"[1-9][0-9]*")
+        # Multiword token id: range of integers.
+        # The two parts are bracketed so they can be captured and processed separately.
+        self.mwtid = re.compile(r"([1-9][0-9]*)-([1-9][0-9]*)")
+        # Empty node id: "decimal" number (but 1.10 != 1.1).
+        # The two parts are bracketed so they can be captured and processed separately.
+        self.enodeid = re.compile(r"([0-9]+)\.([1-9][0-9]*)")
+        # New document comment line. Document id, if present, is bracketed.
+        self.newdoc = re.compile(r"#\s*newdoc(?:\s+(\S+))?")
+        # New paragraph comment line. Paragraph id, if present, is bracketed.
+        self.newpar = re.compile(r"#\s*newpar(?:\s+(\S+))?")
+        # Sentence id comment line. The actual id is bracketed.
+        self.sentid = re.compile(r"#\s*sent_id\s*=\s*(\S+)")
+        # Parallel sentence id comment line. The actual id as well as its predefined parts are bracketed.
+        self.parallelid = re.compile(r"#\s*parallel_id\s*=\s*(([a-z]+)/([-0-9a-z]+)(?:/(alt[1-9][0-9]*|part[1-9][0-9]*|alt[1-9][0-9]*part[1-9][0-9]*))?)")
+        # Sentence text comment line. The actual text is bracketed.
+        self.text = re.compile(r"#\s*text\s*=\s*(.*\S)")
+        # Global entity comment is a declaration of entity attributes in MISC.
+        # It occurs once per document and it is optional (only CorefUD data).
+        # The actual attribute declaration is bracketed so it can be captured in the match.
+        self.global_entity = re.compile(r"#\s*global\.Entity\s*=\s*(.+)")
+        # UPOS tag.
+        self.upos = re.compile(r"[A-Z]+")
+        # Feature=value pair.
+        # Feature name and feature value are bracketed so that each can be captured separately in the match.
+        self.featval = re.compile(r"([A-Z][A-Za-z0-9]*(?:\[[a-z0-9]+\])?)=(([A-Z0-9][A-Z0-9a-z]*)(,([A-Z0-9][A-Z0-9a-z]*))*)")
+        self.val = re.compile(r"[A-Z0-9][A-Za-z0-9]*")
+        # Basic parent reference (HEAD).
+        self.head = re.compile(r"(0|[1-9][0-9]*)")
+        # Enhanced parent reference (head).
+        self.ehead = re.compile(r"(0|[1-9][0-9]*)(\.[1-9][0-9]*)?")
+        # Basic dependency relation (including optional subtype).
+        self.deprel = re.compile(r"[a-z]+(:[a-z]+)?")
+        # Enhanced dependency relation (possibly with Unicode subtypes).
+        # Ll ... lowercase Unicode letters
+        # Lm ... modifier Unicode letters (e.g., superscript h)
+        # Lo ... other Unicode letters (all caseless scripts, e.g., Arabic)
+        # M .... combining diacritical marks
+        # Underscore is allowed between letters but not at beginning, end, or next to another underscore.
+        edeprelpart_resrc = r'[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(_[\p{Ll}\p{Lm}\p{Lo}\p{M}]+)*'
+        # There must be always the universal part, consisting only of ASCII letters.
+        # There can be up to three additional, colon-separated parts: subtype, preposition and case.
+        # One of them, the preposition, may contain Unicode letters. We do not know which one it is
+        # (only if there are all four parts, we know it is the third one).
+        # ^[a-z]+(:[a-z]+)?(:[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(_[\p{Ll}\p{Lm}\p{Lo}\p{M}]+)*)?(:[a-z]+)?$
+        edeprel_resrc = '^[a-z]+(:[a-z]+)?(:' + edeprelpart_resrc + ')?(:[a-z]+)?$'
+        self.edeprel = re.compile(edeprel_resrc)
+
+
+
+# Global variables:
+crex = CompiledRegexes()
+
+
+
+# Support functions.
+
+def is_whitespace(line):
+    return crex.ws.fullmatch(line)
+
+def is_word(cols):
+    return crex.wordid.fullmatch(cols[ID])
+
+def is_multiword_token(cols):
+    return crex.mwtid.fullmatch(cols[ID])
+
+def is_empty_node(cols):
+    return crex.enodeid.fullmatch(cols[ID])
+
+def parse_empty_node_id(cols):
+    m = crex.enodeid.fullmatch(cols[ID])
+    assert m, 'parse_empty_node_id with non-empty node'
+    return m.groups()
+
+def shorten(string):
+    return string if len(string) < 25 else string[:20]+'[...]'
+
+def lspec2ud(deprel):
+    return deprel.split(':', 1)[0]
+
+def nodeid2tuple(nodeid: str):
+    """
+    Node ID can look like a decimal number, but 1.1 != 1.10. To be able to
+    sort node IDs, we need to be able to convert them to a pair of integers
+    (major and minor). For IDs of regular nodes, the ID will be converted to
+    int (major) and the minor will be set to zero.
+    """
+    parts = [int(x) for x in nodeid.split('.', maxsplit=1)]
+    if len(parts) == 1:
+        parts.append(0)
+    return tuple(parts)
+
+def formtl(node):
+    """
+    Returns the word form of a node, possibly accompanied by its
+    transliteration (if available in the MISC column).
+
+    Parameters
+    ----------
+    node : udapi.core.node.Node object
+        The node whose form we want to get.
+
+    Returns
+    -------
+    x : str
+        The form and translit, space-separated. Only form if translit
+        not available.
+    """
+    x = node.form
+    if node.misc['Translit'] != '':
+        x += ' ' + node.misc['Translit']
+    return x
+
+def lemmatl(node):
+    """
+    Returns the lemma of a node, possibly accompanied by its transliteration
+    (if available in the MISC column).
+
+    Parameters
+    ----------
+    node : udapi.core.node.Node object
+        The node whose form we want to get.
+
+    Returns
+    -------
+    x : str
+        The lemma and translit, space-separated. Only form if translit not
+        available.
+    """
+    x = node.lemma
+    if node.misc['LTranslit'] != '':
+        x += ' ' + node.misc['LTranslit']
+    return x
+
+def get_alt_language(node):
+    """
+    In code-switching analysis of foreign words, an attribute in the MISC column
+    will hold the code of the language of the current word. Certain tests will
+    then use language-specific lists from that language instead of the main
+    language of the document. This function returns the alternative language
+    code if present, otherwise it returns None.
+
+    Parameters
+    ----------
+    node : udapi.core.node.Node object
+        The node (word) whose language is being queried.
+    """
+    if node.misc['Lang'] != '':
+        return node.misc['Lang']
+    return None
+
+def deps_list(cols):
+    """
+    Parses the contents of the DEPS column and returns a list of incoming
+    enhanced dependencies. This is needed in early tests, before the sentence
+    has been fed to Udapi.
+
+    Parameters
+    ----------
+    cols : list
+        The values of the columns on the current node / token line.
+
+    Raises
+    ------
+    ValueError
+        If the contents of DEPS cannot be parsed. Note that this does not catch
+        all possible violations of the format, e.g., bad order of the relations
+        will not raise an exception.
+
+    Returns
+    -------
+    deps : list
+        Each list item is a two-member list, containing the parent index (head)
+        and the relation type (deprel).
+    """
+    if cols[DEPS] == '_':
+        deps = []
+    else:
+        deps = [hd.split(':', 1) for hd in cols[DEPS].split('|')]
+    if any(hd for hd in deps if len(hd) != 2):
+        raise ValueError(f'malformed DEPS: {cols[DEPS]}')
+    return deps
+
+def get_line_numbers_for_ids(state, sentence):
+    """
+    Takes a list of sentence lines (mwt ranges, word nodes, empty nodes).
+    For each mwt / node / word, gets the number of the line in the input
+    file where the mwt / node / word occurs. We will need this in other
+    functions to be able to report the line on which an error occurred.
+
+    Parameters
+    ----------
+    sentence : list
+        List of mwt / words / nodes, each represented as a list of columns.
+
+    Returns
+    -------
+    linenos : dict
+        Key: word ID (string, not int; decimal for empty nodes and range for
+        mwt lines). Value: 1-based index of the line in the file (int).
+    """
+    linenos = {}
+    node_line = state.sentence_line - 1
+    for cols in sentence:
+        node_line += 1
+        linenos[cols[ID]] = node_line
+        # For normal words, add them also under integer keys, just in case
+        # we later forget to convert node.ord to string. But we cannot do the
+        # same for empty nodes and multiword tokens.
+        if is_word(cols):
+            linenos[int(cols[ID])] = node_line
+    return linenos
+
+
+def next_sentence(state, inp):
+    """
+    This function yields one sentence at a time from the input stream.
+
+    This function is a generator. The caller can call it in a 'for x in ...'
+    loop. In each iteration of the caller's loop, the generator will generate
+    the next sentence, that is, it will read the next sentence from the input
+    stream. (Technically, the function returns an object, and the object will
+    then read the sentences within the caller's loop.)
+
+    Parameters
+    ----------
+    state : udtools.state.State
+        The state of the validation run.
+    inp : file handle
+        A file open for reading or STDIN.
+
+    Yields
+    ------
+    sentence_lines : list(str)
+        List of CoNLL-U lines that correspond to one sentence, including
+        initial comments (if any) and the final empty line.
+    """
+    sentence_lines = [] # List of lines in the sentence (comments and tokens), minus final empty line, minus newline characters (and minus spurious lines that are neither comment lines nor token lines)
+    for line_counter, line in enumerate(inp):
+        state.current_line = line_counter + 1
+        line = line.rstrip("\n")
+        sentence_lines.append(line)
+        if not line or is_whitespace(line):
+            # If a line is not empty but contains only whitespace, we will
+            # pretend that it terminates a sentence in order to avoid
+            # subsequent misleading error messages.
+            yield sentence_lines
+            sentence_lines = []
+    else: # end of file
+        # If we found additional lines after the last empty line, yield them now.
+        if sentence_lines:
+            yield sentence_lines
+
+
+def features_present(state, line):
+    """
+    In general, the annotation of morphological features is optional, although
+    highly encouraged. However, if the treebank does have features, then certain
+    features become required. This function is called when the first morphological
+    feature is encountered. It remembers that from now on, missing features can
+    be reported as errors. In addition, if any such errors have already been
+    encountered, they will be reported now.
+
+    Parameters
+    ----------
+    state : udtools.state.State
+        The state of the validation run.
+    line : int
+        Number of the line where the current node occurs in the file.
+
+    Reads from state
+    ----------------
+    seen_morpho_feature : int
+        Line number of the first occurrence of a morphological feature in the
+        corpus. None if no feature has been encountered so far.
+    delayed_feature_errors : list(udtools.incident.Incident)
+        The number of the most recently read line from the input file
+        (1-based).
+
+    Writes to state
+    ----------------
+    seen_morpho_feature : int
+        Line number of the first occurrence of a morphological feature in the
+        corpus. None if no feature has been encountered so far.
+    """
+    if not state.seen_morpho_feature:
+        state.seen_morpho_feature = line
+        for testid in state.delayed_feature_errors:
+            for occurrence in state.delayed_feature_errors[testid]['occurrences']:
+                occurrence['incident'].confirm()
+
+
+def get_caused_nonprojectivities(node):
+    """
+    Checks whether a node is in a gap of a nonprojective edge. Report true only
+    if the node's parent is not in the same gap. (We use this function to check
+    that a punctuation node does not cause nonprojectivity. But if it has been
+    dragged to the gap with a larger subtree, then we do not blame it.) This
+    extra condition makes this function different from node.is_nonprojective_gap();
+    another difference is that instead of just detecting the nonprojectivity,
+    we return the nonprojective nodes so we can report them.
+
+    Parameters
+    ----------
+    node : udapi.core.node.Node object
+        The tree node to be tested.
+
+    Returns
+    -------
+    cross : list of udapi.core.node.Node objects
+        The nodes whose attachment is nonprojective because of the current node.
+    """
+    nodes = node.root.descendants
+    iid = node.ord
+    # We need to find all nodes that are not ancestors of this node and lie
+    # on other side of this node than their parent. First get the set of
+    # ancestors.
+    ancestors = []
+    current_node = node
+    while not current_node.is_root():
+        current_node = current_node.parent
+        ancestors.append(current_node)
+    maxid = nodes[-1].ord
+    # Get the lists of nodes to either side of id.
+    # Do not look beyond the parent (if it is in the same gap, it is the parent's responsibility).
+    pid = node.parent.ord
+    if pid < iid:
+        leftidrange = range(pid + 1, iid) # ranges are open from the right (i.e. iid-1 is the last number)
+        rightidrange = range(iid + 1, maxid + 1)
+    else:
+        leftidrange = range(1, iid)
+        rightidrange = range(iid + 1, pid)
+    left = [n for n in nodes if n.ord in leftidrange]
+    right = [n for n in nodes if n.ord in rightidrange]
+    # Exclude nodes whose parents are ancestors of id.
+    leftna = [x for x in left if x.parent not in ancestors]
+    rightna = [x for x in right if x.parent not in ancestors]
+    leftcross = [x for x in leftna if x.parent.ord > iid]
+    rightcross = [x for x in rightna if x.parent.ord < iid]
+    # Once again, exclude nonprojectivities that are caused by ancestors of id.
+    if pid < iid:
+        rightcross = [x for x in rightcross if x.parent.ord > pid]
+    else:
+        leftcross = [x for x in leftcross if x.parent.ord < pid]
+    # Do not return just a boolean value. Return the nonprojective nodes so we can report them.
+    return sorted(leftcross + rightcross)
+
+
+def get_gap(node):
+    """
+    Returns the list of nodes between node and its parent that are not dominated
+    by the parent. If the list is not empty, the node is attached nonprojectively.
+
+    Note that the Udapi Node class does not have a method like this. It has
+    is_nonprojective(), which returns the boolean decision without showing the
+    nodes in the gap. There is also the function is_nonprojective_gap() but it,
+    too, does not deliver what we need.
+
+    Parameters
+    ----------
+    node : udapi.core.node.Node object
+        The tree node to be tested.
+
+    Returns
+    -------
+    gap : list of udapi.core.node.Node objects
+        The nodes in the gap of the current node's relation to its parent,
+        sorted by their ords (IDs).
+    """
+    iid = node.ord
+    pid = node.parent.ord
+    if iid < pid:
+        rangebetween = range(iid + 1, pid)
+    else:
+        rangebetween = range(pid + 1, iid)
+    gap = []
+    if rangebetween:
+        gap = [n for n in node.root.descendants if n.ord in rangebetween and not n in node.parent.descendants]
+    return sorted(gap)
+
+
+def create_references(nodes, state, comment=''):
+    """
+    Takes a list of nodes and converts it to a list of Reference objects to be
+    reported with an Incident.
+
+    Parameters
+    ----------
+    nodes : list(udapi.core.node.Node)
+        The nodes to which we wish to refer.
+    state : udtools.state.State
+        The state of the validation run.
+    comment : str
+        The comment to add to each reference.
+
+    Returns
+    -------
+    references : list(udtools.incident.Reference)
+    """
+    return [Reference(nodeid=str(x.ord), sentid=state.sentence_id, filename=state.get_current_file_name(), lineno=state.current_node_linenos[str(x.ord)], comment=comment) for x in nodes]

ud-tools/udtools/src/udtools/validator.py

@@ -0,0 +1,403 @@
+#! /usr/bin/env python3
+# Original code (2015) by Filip Ginter and Sampo Pyysalo.
+# DZ 2018-11-04: Porting the validator to Python 3.
+# DZ: Many subsequent changes. See the git history.
+import sys
+import io
+import argparse
+# Once we know that the low-level CoNLL-U format is OK, we will be able to use
+# the Udapi library to access the data and perform the tests at higher levels.
+import udapi.block.read.conllu
+# Allow using this module from the root folder of tools even if it is not
+# installed as a package: use the relative path validator/src/validator for
+# submodules. If the path is not available, try the standard qualification,
+# assuming that the user has installed udtools from PyPI and then called
+# from udtools import Validator.
+try:
+    import udtools.src.udtools.utils as utils
+    from udtools.src.udtools.incident import Error, TestClass
+    from udtools.src.udtools.state import State
+    import udtools.src.udtools.data as data
+    from udtools.src.udtools.level6 import Level6
+except ModuleNotFoundError:
+    import udtools.utils as utils
+    from udtools.incident import Error, TestClass
+    from udtools.state import State
+    import udtools.data as data
+    from udtools.level6 import Level6
+
+
+
+class Validator(Level6):
+    def __init__(self, lang=None, level=None, check_coref=None, args=None, datapath=None, output=sys.stderr, max_store=0):
+        """
+        Initialization of the Validator class.
+
+        Parameters
+        ----------
+        lang : str
+            ISO code of the main language of the data to be validated.
+            If not provided separately, it will be searched for in args.
+            If not provided in args either, default is 'ud' (no lang-spec tests).
+        level : int
+            Validation level ranging from 1 to 5.
+            If not provided separately, it will be searched for in args.
+            If not provided in args either, default is 5 (all UD tests).
+        check_coref: bool
+            Should the optional coreference-related tests be performed?
+            If not provided separately, it will be searched for in args.
+            The default value is False.
+        args : argparse.Namespace, optional
+            Parsed commandline arguments, if any. The default is None.
+            Validator itself does not need to search this namespace unless one
+            of its own arguments (lang, level... see above) is not provided
+            directly to the constructor. However, there may be other arguments
+            that have to be passed to the Incident class whenever an incident
+            (error or warning) is recorded by the Validator.
+        datapath : str, optional
+            Path to the folder with JSON files specifying language-specific
+            behavior. If not provided, the Data class will try expected
+            locations relative to the module.
+        output : outstream object, default sys.stderr
+            Where to report incidents when they are encountered. Default is
+            sys.stderr, it could be also sys.stdout, an open file handle, or
+            None. If it is None, the output is suppressed (same as the --quiet
+            command line option) and errors are only saved in state for later
+            processing.
+        max_store : int, optional
+            How many incidents to store in the validation state? Default 0
+            means no limit. Limiting this helps save memory with large
+            treebanks and large numbers of incidents. Especially if the
+            intended use of the Validator object is to immediately report
+            incidents without returning to them later. The limit is applied
+            separately to each test class.
+        """
+        self.data = data.Data(datapath=datapath)
+        if not args:
+            args = argparse.Namespace()
+        # Since we allow args that were not created by our ArgumentParser,
+        # we must be prepared that some attributes do not exist. It will be
+        # thus safer to access them as a dictionary.
+        args_dict = vars(args)
+        if not lang:
+            if 'lang' in args_dict and args_dict['lang'] != None:
+                lang = args_dict['lang']
+            else:
+                lang = 'ud'
+        if not level:
+            if 'level' in args_dict and args_dict['level'] != None:
+                level = args_dict['level']
+            else:
+                level = 5
+        if check_coref == None:
+            if 'check_coref' in args_dict and args_dict['check_coref'] != None:
+                check_coref = args_dict['check_coref']
+            else:
+                check_coref = False
+        self.lang = lang
+        self.level = level
+        self.check_coref = check_coref
+        # Instead of saving the args namespace, we should just save the
+        # configuration of incident storing and reporting.
+        self.incfg = {}
+        if 'quiet' in args_dict:
+            self.incfg['quiet'] = args_dict['quiet']
+        if 'no_warnings' in args_dict:
+            self.incfg['no_warnings'] = args_dict['no_warnings']
+        if 'exclude' in args_dict and args_dict['exclude']:
+            self.incfg['exclude'] = args_dict['exclude']
+        if 'include_only' in args_dict and args_dict['include_only']:
+            self.incfg['include_only'] = args_dict['include_only']
+        if 'max_err' in args_dict:
+            self.incfg['max_err'] = args_dict['max_err']
+        if 'input' in args_dict and len(args_dict['input']) > 1:
+            self.incfg['report_filename'] = True
+        self.incfg['output'] = output
+        self.incfg['max_store'] = max_store
+        self.conllu_reader = udapi.block.read.conllu.Conllu()
+
+
+
+#==============================================================================
+# Entry points.
+#==============================================================================
+
+
+    def validate_files(self, filenames, state=None):
+        """
+        The main entry point, takes a list of filenames that constitute
+        the treebank to be validated. Note that there are tests that consider
+        data from the whole treebank across file boundaries, for example the
+        uniqueness of sentence ids. Unlike other validation methods, this one
+        creates a State object (holding the state of validation) and returns
+        it. The other validation methods take the state from the caller and
+        use it (read from it and write to it).
+
+        Parameters
+        ----------
+        filenames : list(str)
+            List of paths (filenames) to open and validate together. Filename
+            '-' will be interpreted as STDIN.
+        state : udtools.state.State, optional
+            State from previous validation calls if the current call should
+            take them into account. If not provided, a new state will be
+            initialized.
+
+        Returns
+        -------
+        state : udtools.state.State
+            The resulting state of the validation. May contain the overview
+            of all encountered incidents (errors or warnings) if requested.
+        """
+        if state == None:
+            state = State()
+        for filename in filenames:
+            self.validate_file(filename, state)
+        self.validate_end(state)
+        return state
+
+
+    def validate_file(self, filename, state=None):
+        """
+        An envelope around validate_file_handle(). Opens a file or uses STDIN,
+        then calls validate_file_handle() on it.
+
+        Parameters
+        ----------
+        filename : str
+            Name of the file to be read and validated. '-' means STDIN.
+        state : udtools.state.State, optional
+            The state of the validation run. If not provided, a new state will
+            be initialized.
+
+        Returns
+        -------
+        state : udtools.state.State
+            The resulting state of the validation. May contain the overview
+            of all encountered incidents (errors or warnings) if requested.
+        """
+        if state == None:
+            state = State()
+        state.current_file_name = filename
+        if filename == '-':
+            # Set PYTHONIOENCODING=utf-8 before starting Python.
+            # See https://docs.python.org/3/using/cmdline.html#envvar-PYTHONIOENCODING
+            # Otherwise ANSI will be read in Windows and
+            # locale-dependent encoding will be used elsewhere.
+            self.validate_file_handle(sys.stdin, state)
+        else:
+            with io.open(filename, 'r', encoding='utf-8') as inp:
+                self.validate_file_handle(inp, state)
+        return state
+
+
+    def validate_file_handle(self, inp, state=None):
+        """
+        The main entry point for all validation tests applied to one input file.
+        It reads sentences from the input stream one by one, each sentence is
+        immediately tested.
+
+        Parameters
+        ----------
+        inp : open file handle
+            The CoNLL-U-formatted input stream.
+        state : udtools.state.State, optional
+            The state of the validation run. If not provided, a new state will
+            be initialized.
+
+        Returns
+        -------
+        state : udtools.state.State
+            The resulting state of the validation. May contain the overview
+            of all encountered incidents (errors or warnings) if requested.
+        """
+        if state == None:
+            state = State()
+        for lines in utils.next_sentence(state, inp):
+            self.validate_sentence(lines, state)
+        self.check_newlines(state, inp) # level 1
+        return state
+
+
+    def validate_sentence(self, all_lines, state=None):
+        """
+        Entry point for all validation tests applied to one sentence. It can
+        be called from annotation tools to check the sentence once annotated.
+        Note that validate_file_handle() calls it after it was able to
+        recognize a sequence of lines that constitute a sentence; some low-
+        level errors may occur while recognizing the sentence.
+
+        Parameters
+        ----------
+        all_lines : list(str)
+            List of lines in the sentence (comments and tokens), minus final
+            empty line, minus newline characters (and minus spurious lines
+            that are neither comment lines nor token lines).
+        state : udtools.state.State, optional
+            The state of the validation run. If not provided, a new state will
+            be initialized.
+
+        Returns
+        -------
+        state : udtools.state.State
+            The resulting state of the validation. May contain the overview
+            of all encountered incidents (errors or warnings) if requested.
+        """
+        if state == None:
+            state = State()
+        state.current_lines = all_lines
+        # Low-level errors typically mean that we cannot perform further tests
+        # because we could choke on trying to access non-existent data. Or we
+        # may succeed in performing them but the error messages may be misleading.
+        if not self.check_sentence_lines(state): # level 1
+            return state
+        if not self.check_sentence_columns(state): # level 1
+            return state
+        if not self.check_id_sequence(state): # level 1
+            return state
+        if not self.check_token_range_overlaps(state): # level 1
+            return state
+        if self.level >= 2:
+            if not self.check_id_references(state): # level 2
+                return state
+            # Check that the basic tree is single-rooted, connected, cycle-free.
+            if not self.check_tree(state): # level 2
+                return state
+            # Tests of individual nodes that operate on pre-Udapi data structures.
+            # Some of them (bad feature format) may lead to skipping Udapi completely.
+            colssafe = True
+            for i in range(len(state.current_token_node_table)):
+                lineno = state.sentence_line + i
+                cols = state.current_token_node_table[i]
+                # Multiword tokens and empty nodes can or must have certain fields empty.
+                if utils.is_multiword_token(cols):
+                    self.check_mwt_empty_vals(state, cols, lineno)
+                if utils.is_empty_node(cols):
+                    self.check_empty_node_empty_vals(state, cols, lineno) # level 2
+                if utils.is_word(cols) or utils.is_empty_node(cols):
+                    self.check_upos(state, cols, lineno) # level 2
+                    colssafe = self.check_feats_format(state, cols, lineno) and colssafe # level 2 (level 4 tests will be called later)
+                    self.check_deprel_format(state, cols, lineno) # level 2
+                    self.check_deps_format(state, cols, lineno) # level 2; must operate on pre-Udapi DEPS (to see order of relations)
+                self.check_misc(state, cols, lineno) # level 2; must operate on pre-Udapi MISC
+            if not colssafe:
+                return state
+            # Get line numbers for all nodes including empty ones (here linenos
+            # is a dict indexed by cols[ID], i.e., a string).
+            state.current_node_linenos = utils.get_line_numbers_for_ids(state, state.current_token_node_table)
+            # Check that enhanced graphs exist either for all sentences or for
+            # none.
+            self.check_deps_all_or_none(state) # level 2
+            # Check sentence-level metadata in the comment lines.
+            self.check_sent_id(state) # level 2
+            self.check_parallel_id(state) # level 2
+            self.check_text_meta(state) # level 2
+            # If we successfully passed all the critical tests above, it is
+            # probably safe to give the lines to Udapi and ask it to build the
+            # tree data structure for us. Udapi does not want to get the
+            # terminating empty line.
+            tree = self.build_tree_udapi(all_lines)
+            # Tests of individual nodes with Udapi.
+            nodes = tree.descendants_and_empty
+            for node in nodes:
+                if self.level >= 3:
+                    self.check_zero_root(state, node) # level 3
+                    self.check_enhanced_orphan(state, node) # level 3
+                    if self.level >= 4:
+                        # To disallow words with spaces everywhere, use --lang ud.
+                        self.check_words_with_spaces(state, node) # level 4
+                        self.check_feature_values(state, node) # level 4
+                        self.check_deprels(state, node) # level 4
+                        if self.level >= 5:
+                            self.check_auxiliary_verbs(state, node) # level 5
+                            self.check_copula_lemmas(state, node) # level 5
+            # Tests on whole trees and enhanced graphs.
+            self.check_egraph_connected(state, nodes) # level 2
+            if self.level >= 3:
+                # Level 3 checks universally valid consequences of annotation
+                # guidelines. Look at regular nodes and basic tree, not at
+                # enhanced graph.
+                basic_nodes = tree.descendants
+                for node in basic_nodes:
+                    self.check_expected_features(state, node)
+                    self.check_upos_vs_deprel(state, node)
+                    self.check_flat_foreign(state, node)
+                    self.check_left_to_right_relations(state, node)
+                    self.check_single_subject(state, node)
+                    self.check_single_object(state, node)
+                    self.check_nmod_obl(state, node)
+                    self.check_orphan(state, node)
+                    self.check_functional_leaves(state, node)
+                    self.check_fixed_span(state, node)
+                    self.check_goeswith_span(state, node)
+                    self.check_goeswith_morphology_and_edeps(state, node)
+                    self.check_projective_punctuation(state, node)
+            # Optional checks for CorefUD treebanks. They operate on MISC and
+            # currently do not use the Udapi data structures.
+            if self.check_coref:
+                self.check_misc_entity(state)
+        return state
+
+
+    def build_tree_udapi(self, lines):
+        """
+        Calls Udapi to build its data structures from the CoNLL-U lines
+        representing one sentence.
+
+        Parameters
+        ----------
+        lines : list(str)
+            Lines as in the CoNLL-U file, including sentence-level comments if
+            any, but without the newline character at the end of each line.
+            The sentence-terminating empty line is optional in this method.
+
+        Returns
+        -------
+        root : udapi.core.node.Node object
+            The artificial root node (all other nodes and all tree attributes
+            can be accessed from it).
+        """
+        # If the final empty line is present, get rid of it. Udapi would die
+        # when trying to access line[0].
+        mylines = lines
+        if len(mylines) > 0 and (not mylines[-1] or utils.is_whitespace(mylines[-1])):
+            mylines = lines[0:-1]
+        root = self.conllu_reader.read_tree_from_lines(mylines)
+        # We should not return an empty tree (root should not be None).
+        # But we should not be here if the lines are so bad that no tree is built.
+        assert(root)
+        return root
+
+
+    def validate_end(self, state=None):
+        """
+        Final tests after processing the entire treebank (possibly multiple files).
+
+        Parameters
+        ----------
+        state : udtools.state.State, optional
+            The state of the validation run. If not provided, a new state will
+            be initialized. (This is only to unify the interface of all the
+            validate_xxx() methods. Note however that specifically for this
+            method, it does not make sense to run it without state from other
+            validation calls.)
+
+        Returns
+        -------
+        state : udtools.state.State
+            The resulting state of the validation. May contain the overview
+            of all encountered incidents (errors or warnings) if requested.
+        """
+        if state == None:
+            state = State()
+        # After reading the entire treebank (perhaps multiple files), check whether
+        # the DEPS annotation was not a mere copy of the basic trees.
+        if self.level>2 and state.seen_enhanced_graph and not state.seen_enhancement:
+            Error(
+                state=state, config=self.incfg,
+                level=3,
+                testclass=TestClass.ENHANCED,
+                testid='edeps-identical-to-basic-trees',
+                message="Enhanced graphs are copies of basic trees in the entire dataset. This can happen for some simple sentences where there is nothing to enhance, but not for all sentences. If none of the enhancements from the guidelines (https://universaldependencies.org/u/overview/enhanced-syntax.html) are annotated, the DEPS should be left unspecified"
+            ).confirm()
+        return state

ud-tools/udtools/tests/test-cases/README.md

@@ -0,0 +1,5 @@
+# Test the validator in Windows command line (cmd)
+
+```batch
+tools\test-cases\test.bat 2> tools\test-cases\test.log
+```

ud-tools/udtools/tests/test-cases/eval/eval.txt

@@ -0,0 +1,17 @@
+Metric     | Precision |    Recall |  F1 Score | AligndAcc
+-----------+-----------+-----------+-----------+-----------
+Tokens     |     99.50 |     99.80 |     99.65 |
+Sentences  |     98.01 |     98.60 |     98.31 |
+Words      |     99.50 |     99.80 |     99.65 |
+UPOS       |     95.86 |     96.15 |     96.01 |     96.34
+XPOS       |     77.55 |     77.78 |     77.67 |     77.94
+UFeats     |     90.50 |     90.77 |     90.64 |     90.95
+AllTags    |     76.71 |     76.94 |     76.83 |     77.09
+Lemmas     |     97.26 |     97.55 |     97.40 |     97.74
+UAS        |     92.14 |     92.41 |     92.27 |     92.60
+LAS        |     88.96 |     89.23 |     89.10 |     89.41
+CLAS       |     87.59 |     88.01 |     87.80 |     88.28
+MLAS       |     74.01 |     74.37 |     74.19 |     74.59
+BLEX       |     85.52 |     85.93 |     85.72 |     86.19
+ELAS       |      0.00 |      0.00 |      0.00 |
+EULAS      |      0.00 |      0.00 |      0.00 |

ud-tools/udtools/tests/test-cases/invalid-level1/.gitattributes

@@ -0,0 +1,2 @@
+# Do not convert CRLF to LF in the test file that intentionally contains CRLF.
+non-unix-newline.conllu -text

ud-tools/udtools/tests/test-cases/invalid-level1/columns-format-minimal.conllu

@@ -0,0 +1,5 @@
+# sent_id = tanl1
+# text = LONDRA .
+1	LONDRA	 Lon dra	NOUN	SP	_	0	root	_	_
+2	.	.	PUNCT	FS	_	1	 punct	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/columns-format.conllu

@@ -0,0 +1,24 @@
+# errors = number-of-columns, empty-column, leading-whitespace, trailing-whitespace, repeated-whitespace, invalid-whitespace-mwt, invalid-whitespace
+# sent_id = tanl1
+# text = LONDRA .
+1	LONDRA	Londra	NOUN	SP	_	0	root	_	_	X
+2	.	.	PUNCT	FS	_	1	punct	_	_
+
+# sent_id = tanl2
+# text = Gas dalla statua .
+# this is comment
+1	Gas	gas	NOUN	S	Gender=Masc|Number=Sing	0	root	_	_
+2-3	da lla	_	_	_	_	_	_	_	_
+2	da	da	ADP		_	4	case	_	_
+3	la	la	DET	RD	Gender=Fem|Number=Sing|PronType=Art	4	det	_	_
+4	statua	statua	NOUN	S	Gender=Fem|Number=Sing	1	nmod	_	_
+ 5	.	.	PUNCT	 FS	_	1	punct	_	_
+
+# sent_id = tanl3
+# text = Evacuata la Tate Gallery .
+1	Evacuata	evacuare	VERB 	V	 Gender=Fem|Number=Sing	0	root	_	_
+2	la	il	DE T	RD	Gender=Fem|Number=Sing|PronType=Art	3	det	_	_
+3	Tate	Tate	PROPN	SP	_	1	nsubj	_	_
+4	Gallery	Gallery	PROPN	SP	_	3	flat	_	_
+5	.	.	PUNCT	FS	_	1	punct	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/duplicate-id.conllu

@@ -0,0 +1,6 @@
+# not valid: IDs must be sequential integers (1, 2, ...)
+# sent_id = duplicate-id
+# text = valid PUNCT
+1	valid	valid	NOUN	SP	_	0	root	_	_
+1	PUNCT	.	PUNCT	FS	_	0	root	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/empty-field.conllu

@@ -0,0 +1,5 @@
+# sent_id = empty-field
+# text =
+# not valid: no field can be empty.
+1		valid	NOUN	SP	_	0	root	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/empty-head.conllu

@@ -0,0 +1,5 @@
+# not valid: HEAD must not be empty
+# sent_id = empty-head
+# text = have
+1	have	have	VERB	VB	Tens=Pres		root	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/empty-sentence.conllu

@@ -0,0 +1,8 @@
+# not valid: sentences must contain at least one word.
+# text =
+
+# valid one-word sentence.
+# sent_id = test-15
+# text = valid
+1	valid	valid	NOUN	SP	_	0	root	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/extra-empty-line.conllu

@@ -0,0 +1,13 @@
+# valid one-word sentence.
+# sent_id = extra-empty-line1
+# text = valid
+1	valid	valid	NOUN	SP	_	0	root	_	_
+
+
+
+# format error: sentences must be separated by exactly one empty line
+# valid one-word sentence.
+# sent_id = extra-empty-line2
+# text = valid
+1	valid	valid	NOUN	SP	_	0	root	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/id-starting-from-2.conllu

@@ -0,0 +1,10 @@
+# sent_id = id-starting-from-2a
+# text = valid
+# valid one-word sentence.
+1	valid	valid	NOUN	SP	_	0	root	_	_
+
+# sent_id = id-starting-from-2b
+# text = valid
+# not valid: ID must start at 1 for each new sentence
+2	valid	valid	NOUN	SP	_	0	root	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/id-with-extra-0.conllu

@@ -0,0 +1,5 @@
+# not valid: word IDs must be integers 1, 2, 3, ...
+# text = nonvalid
+# sent_id = id-with-extra-0
+01	nonvalid	nonvalid	NOUN	_	_	0	root	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/invalid-line.conllu

@@ -0,0 +1,24 @@
+# errors = invalid-line
+# sent_id = tanl1
+# text = LONDRA
+1	LONDRA	Londra	NOUN	SP	_	0	root	_	_
+-	.	.	PUNCT	FS	_	1	punct	_	_
+
+# sent_id = tanl2
+# text = Gas dalla statua
+# this is comment
+1	Gas	gas	NOUN	S	Gender=Masc|Number=Sing	0	root	_	_
+2-3	dalla	_	_	_	_	_	_	_	_
+2	da	da	ADP	EA	_	4	case	_	_
+3	la	la	DET	RD	Gender=Fem|Number=Sing|PronType=Art	4	det	_	_
+4	statua	statua	NOUN	S	Gender=Fem|Number=Sing	1	nmod	_	_
+ 5	.	.	PUNCT	FS	_	1	punct	_	_
+
+# sent_id = tanl3
+# text = Evacuata la Tate Gallery .
+1	Evacuata	evacuare	VERB	V	Gender=Fem|Number=Sing	0	root	_	_
+2	la	il	DET	RD	Gender=Fem|Number=Sing|PronType=Art	3	det	_	_
+3	Tate	Tate	PROPN	SP	_	1	nsubj	_	_
+4	Gallery	Gallery	PROPN	SP	_	3	flat	_	_
+5	.	.	PUNCT	FS	_	1	punct	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/invalid-range.conllu

@@ -0,0 +1,11 @@
+# not valid: (first-last) multiword ranges must have first <= last
+# sent_id = invalid-range
+# text = I haven't have not a clue PUNCT
+1	I	I	PRON	PRN	Num=Sing|Per=1	2	nsubj	_	_
+2-1	haven't	_	_	_	_	_	_	_	_
+2	have	have	VERB	VB	Tens=Pres	0	root	_	_
+3	not	not	ADV	RB	_	2	aux	_	_
+4	a	a	DET	DT	_	5	det	_	_
+5	clue	clue	NOUN	NN	Num=Sing	2	obj	_	_
+6	PUNCT	.	PUNCT	PUNCT	_	2	punct	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/invalid-word-id.conllu

@@ -0,0 +1,5 @@
+# not valid: word IDs must be integers 1, 2, 3, ...
+# text = nonvalid
+# sent_id = id-with-extra-0
+01	nonvalid	nonvalid	NOUN	_	_	0	root	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/invalid-word-interval.conllu

@@ -0,0 +1,11 @@
+# not valid: first and last in multiword ranges must be integers
+# sent_id = invalid-range-format
+# text = I haven't have not a clue PUNCT
+1	I	I	PRON	PRN	Num=Sing|Per=1	2	nsubj	_	_
+2-X	haven't	_	_	_	_	_	_	_	_
+2	have	have	VERB	VB	Tens=Pres	0	root	_	_
+3	not	not	ADV	RB	_	2	aux	_	_
+4	a	a	DET	DT	_	5	det	_	_
+5	clue	clue	NOUN	NN	Num=Sing	2	obj	_	_
+6	PUNCT	.	PUNCT	PUNCT	_	2	punct	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/misindexed-empty-node.conllu

@@ -0,0 +1,7 @@
+# sent_id = misindexed-empty-node
+# text = This holes
+# not valid: empty nodes indexed i.1, i.2, etc. after word with index i
+1	This	this	PRON	_	_	0	root	2.2:nsubj	_
+2.2	_	_	_	_	_	_	_	0:root	_
+2	holes	hole	NOUN	_	_	1	orphan	2.2:obj	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/misordered-multiword.conllu

@@ -0,0 +1,12 @@
+# not valid: multiword tokens must appear before the first word in their
+# range
+# sent_id = misordered-multiword
+# text = I have haven't a clue PUNCT
+1	I	I	PRON	PRN	Num=Sing|Per=1	2	nsubj	_	_
+2	have	have	VERB	VB	Tens=Pres	0	root	_	_
+2-3	haven't	_	_	_	_	_	_	_	_
+3	not	not	ADV	RB	_	2	aux	_	_
+4	a	a	DET	DT	_	5	det	_	_
+5	clue	clue	NOUN	NN	Num=Sing	2	obj	_	_
+6	PUNCT	.	PUNCT	PUNCT	_	2	punct	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/misplaced-comment-end.conllu

@@ -0,0 +1,13 @@
+# not valid: comment lines should precede a sentence
+# sent_id = misplaced-comment-end
+# text = I haven't a clue PUNCT
+1	I	I	PRON	PRN	Num=Sing|Per=1	2	nsubj	_	_
+2-3	haven't	_	_	_	_	_	_	_	_
+2	have	have	VERB	VB	Tens=Pres	0	root	_	_
+3	not	not	ADV	RB	_	2	aux	_	_
+4	a	a	DET	DT	_	5	det	_	_
+5	clue	clue	NOUN	NN	Num=Sing	2	obj	_	_
+6	PUNCT	.	PUNCT	PUNCT	_	2	punct	_	_
+
+# this comment should not be here as it does not precede a sentence.
+

ud-tools/udtools/tests/test-cases/invalid-level1/misplaced-comment-mid.conllu

@@ -0,0 +1,12 @@
+# not valid: comment lines inside sentences are disallowed.
+# sent_id = misplaced-comment-mid
+# text = I haven't a clue PUNCT
+1	I	I	PRON	PRN	Num=Sing|Per=1	2	nsubj	_	_
+2-3	haven't	_	_	_	_	_	_	_	_
+# this comment should not be here
+2	have	have	VERB	VB	Tens=Pres	0	root	_	_
+3	not	not	ADV	RB	_	2	aux	_	_
+4	a	a	DET	DT	_	5	det	_	_
+5	clue	clue	NOUN	NN	Num=Sing	2	obj	_	_
+6	PUNCT	.	PUNCT	PUNCT	_	2	punct	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/misplaced-comment.conllu

@@ -0,0 +1,24 @@
+# sent_id = tanl1
+# text = LONDRA .
+1	LONDRA	Londra	NOUN	SP	_	0	root	_	_
+# mispaced comment
+2	.	.	PUNCT	FS	_	1	punct	_	_
+
+# sent_id = tanl2
+# text = Gas dalla statua .
+# this is comment
+1	Gas	gas	NOUN	S	Gender=Masc|Number=Sing	0	root	_	_
+2-3	dalla	_	_	_	_	_	_	_	_
+2	da	da	ADP	_	_	4	case	_	_
+3	la	la	DET	RD	Gender=Fem|Number=Sing|PronType=Art	4	det	_	_
+4	statua	statua	NOUN	S	Gender=Fem|Number=Sing	1	nmod	_	_
+5	.	.	PUNCT	FS	_	1	punct	_	_
+
+# sent_id = tanl3
+# text = Evacuata la Tate Gallery .
+1	Evacuata	evacuare	VERB	V	Gender=Fem|Number=Sing	0	root	_	_
+2	la	il	DET	RD	Gender=Fem|Number=Sing|PronType=Art	3	det	_	_
+3	Tate	Tate	PROPN	SP	_	1	nsubj	_	_
+4	Gallery	Gallery	PROPN	SP	_	3	flat	_	_
+5	.	.	PUNCT	FS	_	1	punct	_	_
+

ud-tools/udtools/tests/test-cases/invalid-level1/misplaced-empty-node-2.conllu

@@ -0,0 +1,13 @@
+# not valid: multiword tokens must appear before the first word in their
+# range
+# sent_id = misordered-empty
+# text = I have haven't a clue PUNCT
+1	I	I	PRON	PRN	Num=Sing|Per=1	2	nsubj	_	_
+2-3	haven't	_	_	_	_	_	_	_	_
+1.1	_	_	_	_	_	_	_	_	_
+2	have	have	VERB	VB	Tens=Pres	0	root	_	_
+3	not	not	ADV	RB	_	2	aux	_	_
+4	a	a	DET	DT	_	5	det	_	_
+5	clue	clue	NOUN	NN	Num=Sing	2	obj	_	_
+6	PUNCT	.	PUNCT	PUNCT	_	2	punct	_	_
+