fix: causal-candidate-extraction uses text+char-span format

Replace the old tokens-as-segments / integer-entity-id format with the
standard text (plain str) + entity ([[start, end], ...] char offsets) format
used by all other datasets in the project.

Spans are derived from the causality-identification tagged text so the
conversion no longer requires the original XML source files.

causal-candidate-extraction/test.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ad5e0271e92b904d5411453ae3f5643540eabf721accdc7ec4e78c91b4757da2
-size 49728
+oid sha256:e3b46dbdcebd10ba40e05be7f15e45f3eea2531f4b1e8b9b64c8e7e764fc84eb
+size 62472

causal-candidate-extraction/train.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:36140219a24ab363966ed55377daea38fc4ce1d9e18bb8bd7787f698ec7facc5
-size 252771
+oid sha256:48071c919f99226bb86c00319c44e816ec185f026ec38532933edb9b3689679c
+size 335896

conversion_script.py

@@ -22,23 +22,54 @@ def convert_for_causality_detection(split: Split) -> None:
     df.to_parquet(f"./causality-detection/{split}.parquet", engine="pyarrow")
 
 def convert_for_causal_candidate_extraction(split: Split) -> None:
-    def map_to_tokens(text: str):
-        splits: list[str] = []
-        tags: list[set[int]] = []
-        curtags: set[int] = set()
-        for match in re.finditer(r"(.*?)<(/?)e(\d+)>", text):
-            splits.append(match[1])
-            tags.append(list(curtags))
-            if match[2] == "":
-                curtags.add(int(match[3]))
+    def extract_entity_spans(tagged_text: str, relations: list) -> tuple[str, list]:
+        """Return (plain_text, [[start, end], ...]) for entities in causal relations."""
+        causal_eids: set[str] = set()
+        for rel in relations:
+            if rel["relationship"] == 1:
+                causal_eids.add(rel["first"])
+                causal_eids.add(rel["second"])
+
+        # Single pass: track plain-text offset while consuming tags
+        plain_chars: list[str] = []
+        open_at: dict[str, int] = {}
+        spans: list[list[int]] = []
+        i = 0
+        while i < len(tagged_text):
+            m = re.match(r'<(/?)(e\d+)>', tagged_text[i:])
+            if m:
+                eid = m.group(2)
+                if m.group(1) == "":        # opening tag
+                    if eid in causal_eids:
+                        open_at[eid] = len(plain_chars)
+                else:                        # closing tag
+                    if eid in open_at:
+                        spans.append([open_at.pop(eid), len(plain_chars)])
+                i += m.end()
             else:
-                curtags.remove(int(match[3]))
-        return pd.Series((splits, tags))
-    df = pd.read_xml(f"{split}-corpus.xml")
-    df[["tokens", "entity"]] = df["sentence"].apply(map_to_tokens)
+                plain_chars.append(tagged_text[i])
+                i += 1
+
+        return "".join(plain_chars), spans
+
+    df = pd.read_xml(f"{split}-corpus.xml", dtype_backend="pyarrow")
+    # Reuse the relation parsing from convert_for_causality_identification
+    def map_label(label: str) -> list:
+        if label == "Non-Causal":
+            return []
+        relations = []
+        for t in label[len("Cause-Effect("):-1].split("),("):
+            left, right = t.strip("()").split(",")
+            relations.append({"relationship": 1, "first": left, "second": right})
+        return relations
+
+    df["relations"] = df["label"].apply(map_label)
+    df[["text", "entity"]] = df.apply(
+        lambda row: pd.Series(extract_entity_spans(row["sentence"], row["relations"])),
+        axis=1,
+    )
     df["index"] = df["id"].apply(lambda x: f"scite_{split}_{x}")
-    df = df[["index", "tokens", "entity"]].set_index("index")
-    print(df)
+    df = df[["index", "text", "entity"]].set_index("index")
     df.to_parquet(f"./causal-candidate-extraction/{split}.parquet", engine="pyarrow")
 
 def convert_for_causality_identification(split: Split) -> None: