conversion_script.py

#!/usr/bin/env python3

"""
Run this script as ./conversion_script.py to convert PolitiCause DIRECTLY
from its original repository into HF-compatible parquet files.

Citation / original source
---------------------------
Garcia Corral, P., Bechara, H., Zhang, R., & Jankin, S. (2024). "PolitiCause:
An Annotation Scheme and Corpus for Causality in Political Texts." Proc. of
LREC-COLING 2024, pages 12836-12845. https://aclanthology.org/2024.lrec-main.1124/
Repo (verified live, public, no login): github.com/pgarco/PolitiCAUSE
License: CC BY-NC 4.0 (verified: the paper's own PDF header states "(c) 2024
ELRA Language Resource Association: CC BY-NC 4.0"; not restated in the repo
itself, which has no LICENSE file).

Text is drawn from two political-speech sources (paper Section 4.1): UNGD
(UN General Debate speech transcripts) and UKPress (UK government press
conference transcripts) -- not social media or parliamentary debate text.

NOTE on Hagen et al. 2026 (arXiv:2510.08224) Table 2's "implicit signals"
characterization of this dataset: the PolitiCause paper itself explicitly
disclaims implicit-causality coverage ("Our annotation scheme is not
designed to capture implicit causality..."), so that characterization
looks inconsistent with the primary source -- flagged here rather than
silently reproduced; not resolved by this script.

Two upstream files, two different granularities:

1. ``data/{train,val,test}.csv`` -- ``,text,label`` (label in {0,1}), one row
   per one of 17,780 UNIQUE sentences, already split (12446/2667/2667). This
   is the ONLY file the paper's own experiments use (three transformer
   classifiers, sentence-level causal/non-causal only -- no extraction
   results reported). Used here for causality-detection: upstream train+val
   -> causalatee train (merged, since causalatee has no dev slot -- see
   `with_validation_split` elsewhere in this toolkit), upstream test ->
   causalatee test.

2. ``data/span_annotations.csv`` -- ``,id,ra,text,spans,accept,confidence,
   label,mean_conf``, 55,754 rows over the SAME 17,780 sentences, with 2-9
   independent annotator passes per sentence (``ra`` = annotator code).
   ``label``/``text`` are identical across every row for a given ``id``
   (confirmed: this is the per-sentence GOLD, not a per-annotator opinion).
   ``accept`` is per-ANNOTATOR: whether that rater judged the sentence
   causal (with ``spans`` populated) on their individual pass -- confirmed
   real example where one rater accept=1 with real cause/effect spans,
   while the id's own gold ``label`` is 0 (the other 2 raters rejected it,
   majority/gold overruled this one rater's read). ``spans`` is a Python-
   repr'd list of single-key dicts; role keys seen: Cause, Effect (this
   project's schema), plus Subject/Connector (~10% of role-tagged spans --
   NOT part of causalatee's schema, dropped here) -- some sentences have
   MULTIPLE Cause/Effect pairs per row (up to 10 spans in one annotation).

   Since the paper never reduces these multi-rater passes to one canonical
   gold span set (it has no extraction results to need one), this script
   defines its own reconciliation policy for the causal-candidate-extraction/
   causality-identification tasks, restricted to gold-causal ids
   (label==1, 5070 of them):
     - only consider accept==1 rows (the annotator's own read agreed the
       sentence was causal);
     - among those, prefer a row with an equal, nonzero count of Cause and
       Effect spans (a "balanced" pass) over an unbalanced one, then break
       ties by that rater's own confidence rating (descending);
     - if NO accept==1 row for an id has at least one non-empty Cause AND
       one non-empty Effect at all, the id is DROPPED (461/5070 = 9.1%,
       verified: every rater on these left Cause or Effect entirely
       unmarked, e.g. [{'Cause': ''}, {'Effect': '...'}] -- a genuine
       annotation gap, not a parsing bug);
     - on the winning row, Cause spans and Effect spans are paired in
       list order, one relation per pair, truncating to
       min(#Cause, #Effect) if the winning row itself is imbalant (423/4609
       kept ids, ~9%, have exactly one extra unpaired span dropped this
       way -- a documented, minor loss, not a bug).
   Net: 4609/5070 gold-causal sentences (90.9%) end up with >=1 relation;
   4381 of those have exactly one pair, the rest 2-4.

   Span text is matched into ``text`` via plain substring search (verified:
   0/5070 chosen spans failed to locate) -- offsets are exact character
   positions of the SAME substring recorded by prodigy's annotation
   interface, which is occasionally NOT word-aligned in the source data
   itself (e.g. a real chosen span reading "atients to be better supported"
   missing its leading "P") -- an existing source-data imprecision, not
   something this script "fixes".

   ``span_annotations.csv`` has no train/val/test split of its own -- ids
   are mapped to causalatee train/test by matching each row's exact
   ``text`` against the {train,val,test}.csv split files (verified: all
   17,780 unique texts across the 3 split files match a span_annotations
   id 1:1, and every matched row's gold ``label`` agrees with its split
   file's ``label`` with 0 mismatches).
"""

import ast
from pathlib import Path

import pandas as pd

from causalatee.data.constants import ClassLabel, Relation, Task
from causalatee.data.utils import insert_entity_markers, verify_dataset

_BASE_URL = "https://raw.githubusercontent.com/pgarco/PolitiCAUSE/main/data"


def _fetch(fname: str) -> pd.DataFrame:
    return pd.read_csv(f"{_BASE_URL}/{fname}")


def _split_texts() -> dict[str, set[str]]:
    """causalatee split name -> set of sentence texts in that split."""
    train = pd.concat([_fetch("train.csv"), _fetch("val.csv")])
    test = _fetch("test.csv")
    return {"train": set(train["text"]), "test": set(test["text"])}


def convert_for_causality_detection(split: str) -> None:
    texts = _split_texts()[split]
    files = ["train.csv", "val.csv"] if split == "train" else ["test.csv"]
    df = pd.concat(_fetch(f) for f in files)
    df = df[df["text"].isin(texts)]
    rows = [
        {"index": f"politicause_{split}_{i}", "text": r["text"],
         "label": ClassLabel.Causal if r["label"] else ClassLabel.Uncausal}
        for i, r in enumerate(df.to_dict("records"))
    ]
    df = pd.DataFrame(rows).set_index("index")
    for error in verify_dataset(df, Task.CausalityDetection):
        print(f"WARNING [PolitiCause causality detection/{split}]: {error}")
    df.to_parquet(f"./causality-detection/{split}.parquet", engine="pyarrow")


def _reconcile_spans() -> pd.DataFrame:
    """One canonical {id, text, causes, effects} row per gold-causal id."""
    span = _fetch("span_annotations.csv")
    causal = span[span["label"] == 1].copy()
    accepted = causal[causal["accept"] == 1].copy()

    def parsed_roles(spans_repr: str) -> tuple[list[str], list[str]]:
        spans = ast.literal_eval(spans_repr)
        causes = [d["Cause"] for d in spans if "Cause" in d and d["Cause"].strip()]
        effects = [d["Effect"] for d in spans if "Effect" in d and d["Effect"].strip()]
        return causes, effects

    accepted["causes"], accepted["effects"] = zip(*accepted["spans"].apply(parsed_roles))
    accepted["usable"] = accepted["causes"].apply(len).gt(0) & accepted["effects"].apply(len).gt(0)
    accepted["imbalance"] = (accepted["causes"].apply(len) - accepted["effects"].apply(len)).abs()

    ranked = accepted.sort_values(["usable", "imbalance", "confidence"], ascending=[False, True, False])
    best = ranked.drop_duplicates("id", keep="first")
    dropped = int((~best["usable"]).sum())
    print(f"PolitiCause: dropped {dropped}/{len(best)} causal ids with no usable accept=1 Cause+Effect pair")
    return best[best["usable"]][["id", "text", "causes", "effects"]]


def convert_for_causal_candidate_extraction(split: str) -> None:
    texts = _split_texts()[split]
    reconciled = _reconcile_spans()
    reconciled = reconciled[reconciled["text"].isin(texts)]
    out = []
    for i, r in enumerate(reconciled.to_dict("records")):
        text = r["text"]
        n = min(len(r["causes"]), len(r["effects"]))
        entity = []
        for cause, effect in zip(r["causes"][:n], r["effects"][:n]):
            entity.append([text.find(cause), text.find(cause) + len(cause)])
            entity.append([text.find(effect), text.find(effect) + len(effect)])
        out.append({"index": f"politicause_{split}_{i}", "text": text, "entity": entity})
    df = pd.DataFrame(out).set_index("index")
    for error in verify_dataset(df, Task.CausalCandidateExtraction):
        print(f"WARNING [PolitiCause causal candidate extraction/{split}]: {error}")
    df.to_parquet(
        f"./causal-candidate-extraction/{split}.parquet", engine="pyarrow"
    )


def convert_for_causality_identification(split: str) -> None:
    texts = _split_texts()[split]
    reconciled = _reconcile_spans()
    reconciled = reconciled[reconciled["text"].isin(texts)]
    out = []
    for i, r in enumerate(reconciled.to_dict("records")):
        text = r["text"]
        n = min(len(r["causes"]), len(r["effects"]))
        segments: dict[str, list[tuple[int, int]]] = {}
        relations = []
        for j, (cause, effect) in enumerate(zip(r["causes"][:n], r["effects"][:n])):
            cause_id, effect_id = f"e{2 * j + 1}", f"e{2 * j + 2}"
            segments[cause_id] = [(text.find(cause), text.find(cause) + len(cause))]
            segments[effect_id] = [(text.find(effect), text.find(effect) + len(effect))]
            relations.append({"relationship": Relation.Procausal, "first": cause_id, "second": effect_id})
        marked_text = insert_entity_markers(text, segments)
        out.append({"index": f"politicause_{split}_{i}", "text": marked_text, "relations": relations})
    df = pd.DataFrame(out).set_index("index")
    for error in verify_dataset(df, Task.CausalityIdentification):
        print(f"WARNING [PolitiCause causality identification/{split}]: {error}")
    df.to_parquet(
        f"./causality-identification/{split}.parquet", engine="pyarrow"
    )


if __name__ == "__main__":
    for split in ["train", "test"]:
        convert_for_causality_detection(split)
        convert_for_causal_candidate_extraction(split)
        convert_for_causality_identification(split)