bugfix

enhanced-cobald-dataset.py

@@ -1,5 +1,5 @@
-from datasets import DatasetBuilder, GeneratorBasedBuilder, BuilderConfig
-from datasets import Sequence, Value
+import datasets
+from datasets import GeneratorBasedBuilder, BuilderConfig, Sequence, Value
 
 from .parsing import parse_incr
 
@@ -39,7 +39,7 @@ class EnhancedCobaldDataset(GeneratorBasedBuilder):
                 "xpos": Sequence(Value("string")),
                 # huggingface datasets can't handle dicts with dynamic keys, so represent feats as string
                 "feats": Sequence(Value("string")),
-                "heads": Sequence(Value("int")),
+                "heads": Sequence(Value("int32")),
                 "deprels": Sequence(Value("string")),
                 "deps": Sequence(Value("string")),
                 "miscs": Sequence(Value("string")),
@@ -64,4 +64,4 @@ class EnhancedCobaldDataset(GeneratorBasedBuilder):
         Generator function that reads a CoNLL-U file and yields one sentence at a time.
         Each sentence is represented as a dictionary where each field is a list.
         """
-        yield from parse_incr(filepath)
+        yield from enumerate(parse_incr(filepath))

parsing.py

@@ -3,6 +3,13 @@ import json
 
 ROOT_HEAD = 0
 
+# ========================= Field level =========================
+
+def parse_nullable(field: str) -> str | None:
+    if field in ["", "_"]:
+        return None
+    return field
+
 
 def is_null_index(x: str) -> bool:
     try:
@@ -11,11 +18,16 @@ def is_null_index(x: str) -> bool:
     except ValueError:
         return False
 
-# ========================= Field level =========================
+def is_range_index(x: str) -> bool:
+    try:
+        a, b = x.split('-')
+        return a.isdecimal() and b.isdecimal()
+    except ValueError:
+        return False
 
-def parse_nullable(field: str) -> str | None:
-    if field in ["", "_"]:
-        return None
+def parse_id(field: str) -> str:
+    if not field.isdecimal() and not is_null_index(field) and not is_range_index(field):
+        raise ValueError(f"Incorrect token id: {field}.")
     return field
 
 
@@ -73,7 +85,7 @@ def parse_deps(field: str) -> str | None:
     if field in ["", "_"]:
         return None
 
-    token_deps = parse_joint_field(field, inner_sep='=', outer_sep='|')
+    token_deps = parse_joint_field(field, inner_sep=':', outer_sep='|')
 
     # Validate deps.
     if len(token_deps) == 0:
@@ -87,27 +99,53 @@ def parse_deps(field: str) -> str | None:
 
 Token = dict[str, str]
 
+def validate_null_token(token: Token):
+    if token['word'] != "#NULL":
+        raise ValueError(f"Null token must have #NULL form, not {token['word']}.")
+    if token['head'] is not None:
+        raise ValueError(f"Null token must have no head, but found {token['head']}.")
+    if token['deprel'] is not None:
+        raise ValueError(f"Null token must have no deprel, but found {token['deprel']}.")
+    if token['misc'] != 'ellipsis':
+        raise ValueError(f"Null token must have 'ellipsis' misc, not {token['misc']}.")
+
+def validate_range_token(token: Token):
+    if token['lemma'] != '_':
+        raise ValueError(f"Range token lemma must be _, but found {token['lemma']}.")
+    if token['upos'] is not None:
+        raise ValueError(f"Range token upos must be _, but found {token['upos']}.")
+    if token['xpos'] is not None:
+        raise ValueError(f"Range token xpos must be _, but found {token['xpos']}.")
+    if token['feats'] is not None:
+        raise ValueError(f"Range token feats must be _, but found {token['feats']}.")
+    if token['head'] is not None:
+        raise ValueError(f"Range token head must be _, but found {token['head']}.")
+    if token['deprel'] is not None:
+        raise ValueError(f"Range token deprel must be _, but found {token['deprel']}.")
+    if token['misc'] is not None:
+        raise ValueError(f"Range token misc must be _, but found {token['misc']}.")
+    if token['deepslot'] is not None:
+        raise ValueError(f"Range token deepslot must be _, but found {token['deepslot']}.")
+    if token['semclass'] is not None:
+        raise ValueError(f"Range token semclass must be _, but found {token['semclass']}.")
+
+def validate_regular_token(token: Token):
+    if token['head'] == token['id']:
+        raise ValueError(f"Self-loop detected in head.")
+    for head in json.loads(token['deps']):
+        if head == token['id']:
+            raise ValueError(f"Self-loop detected in deps. head: {head}, id: {token['id']}")
+
 def validate_token(token: Token):
-    # Validate token.
-    if token['word'] == NULL:
-        if not is_null_index(token['id']):
-            raise ValueError(f"Null token id must be floats (e.g. 1.1), not {token['id']}.")
-        if token['head'] is not None:
-            raise ValueError(f"Null token must have no head, but found {token['head']}.")
-        if token['deprel'] is not None:
-            raise ValueError(f"Null token must have no deprel, but found {token['deprel']}.")
-        if token['misc'] != 'ellipsis':
-            raise ValueError(f"Null token must have 'ellipsis' misc, not {token['misc']}.")
+    idtag = token['id']
+    if idtag.isdecimal():
+        validate_regular_token(token)
+    elif is_range_index(idtag):
+        validate_range_token(token)
+    elif is_null_index(idtag):
+        validate_null_token(token)
     else:
-        if not token['id'].isdecimal():
-            raise ValueError(f"Regular token must have integer id, but found {token['id']}.")
-        if not token['head'].isdecimal() and token['head'] is not None:
-            raise ValueError(f"Regular token must have integer head, not {token['head']}.")
-        if token['head'] == token['id']:
-            raise ValueError(f"Self-loop detected in head.")
-        for head in token['deps']:
-            if head == token['id']:
-                raise ValueError(f"Self-loop detected in deps.")
+        raise ValueError(f"Incorrect token id: {idtag}.")
 
 
 def parse_token(line: str) -> Token:
@@ -119,10 +157,10 @@ def parse_token(line: str) -> Token:
         token = {
             "id": parse_id(fields[0]),
             "word": parse_word(fields[1]),
-            "lemma": parse_nullable(fields[2]),
+            "lemma": fields[2] if fields[2] != "" else None,
             "upos": parse_nullable(fields[3]),
             "xpos": parse_nullable(fields[4]),
-            "feats": parse_feats(feats[5]),
+            "feats": parse_feats(fields[5]),
             "head": parse_head(fields[6]),
             "deprel": parse_nullable(fields[7]),
             "deps": parse_deps(fields[8]),
@@ -133,7 +171,7 @@ def parse_token(line: str) -> Token:
         validate_token(token)
 
     except Exception as e:
-        raise ValueError(f"Validation failed on token {idtag}: {e}")
+        raise ValueError(f"Validation failed on token {fields[0]}: {e}")
 
     return token
 
@@ -171,7 +209,7 @@ def validate_sentence(sentence: Sentence):
 
     # Validate sentence heads and ids agreement.
     ids = set(sentence["ids"])
-    int_ids = {idtag for idtag in sentence["ids"] if idtag.isdecimal()}
+    int_ids = {int(idtag) for idtag in sentence["ids"] if idtag.isdecimal()}
 
     contiguous_int_ids = set(range(min(int_ids), max(int_ids) + 1))
     if int_ids != contiguous_int_ids:
@@ -187,10 +225,11 @@ def validate_sentence(sentence: Sentence):
     if excess_heads:
         raise ValueError(f"Heads are inconsistent with sentence ids. Excessive heads: {excess_heads}.")
 
-    sentence_deps_heads = set(
-        head for deps in sentence["deps"] for head in json.loads(deps)
-        if head != str(ROOT_HEAD)
-    )
+    sentence_deps_heads = {
+        head
+        for deps in sentence["deps"] if deps is not None
+        for head in json.loads(deps) if head != str(ROOT_HEAD)
+    }
     excess_deps_heads = sentence_deps_heads - ids
     if excess_deps_heads:
         raise ValueError(f"Deps heads are inconsistent with sentence ids. Excessive heads: {excess_deps_heads}.")
@@ -199,7 +238,7 @@ def validate_sentence(sentence: Sentence):
 def parse_sentence(token_lines: list[str], metadata: dict) -> Sentence:
     try:
         sentence = {
-            "ids": []
+            "ids": [],
             "words": [],
             "lemmas": [],
             "upos": [],
@@ -213,7 +252,7 @@ def parse_sentence(token_lines: list[str], metadata: dict) -> Sentence:
             "semclasses": []
         }
         for token_line in token_lines:
-            token = parse_token(line)
+            token = parse_token(token_line)
             sentence["ids"].append(token["id"])
             sentence["words"].append(token["word"])
             sentence["lemmas"].append(token["lemma"])
@@ -244,8 +283,16 @@ def parse_incr(file_path: str):
         "text": <text from metadata or None>,
         "ids": list of sentence tokens ids,
         "words": list of tokens forms,
-         ...
-        Also "lemmas", "upos", "xpos", "feats", "heads", "deprels", "deps", "miscs", "deepslots", "semclasses".
+        "lemmas",
+        "upos",
+        "xpos",
+        "feats",         .
+        "heads",         .
+        "deprels",       .
+        "deps",
+        "miscs",
+        "deepslots",
+        "semclasses"
     }
 
     The input file should have metadata lines starting with '#' (e.g., "# sent_id = 1")