conversion_script.py

#!/usr/bin/env python3

"""
Run this script as ./conversion_script.py to convert FinCausal 2023's
English subtask into HF-compatible parquet files.

Citation / original source
---------------------------
Moreno-Sandoval, A., Porta-Zamorano, J., Carbajo-Coronado, B., Samy, D.,
Mariko, D., & El-Haj, M. (2023). "The Financial Document Causality
Detection Shared Task (FinCausal 2023)." 2023 IEEE International
Conference on Big Data (BigData), pp. 2855-2860. Also self-archived as
arXiv:2401.13545 (verified: Table II there reports "Train: 2949
documents; Test: 480 documents" for the English subtask -- an exact
match to the row counts fetched here, confirming this is a faithful,
complete copy of the labeled training data).

The task's OFFICIAL host is a CodaLab competition
(codalab.lisn.upsaclay.fr/competitions/14596), gated behind shared-task
registration -- unlike FinCausal 2020 (see ../FinCausal), the organizers
did not publish a plain, ungated data repo. This script instead fetches
from a shared-task PARTICIPANT's public mirror,
github.com/pavanbaswani/Fincausal_SharedTask-2023 (verified live,
public, no login) -- its `raw_data/training_subtask_en.csv` matches the
paper's own reported row count exactly, giving confidence it's a
complete, unmodified copy of the real labeled data. No LICENSE file or
terms are stated in that repo; flagged here rather than guessed at --
resolve before any redistribution beyond research use.

Only the ENGLISH subtask is converted here (the paper's own row counts
above are English-only; a separate Spanish subtask exists in the same
shared task but is not covered by this script). The repo's OWN
`raw_data/test_subtask_en.csv` is the shared task's blind test set --
verified: it has only `Index;Text` columns, no `Cause`/`Effect` at all --
so it is NOT used here. The only labeled English data anywhere is
`raw_data/training_subtask_en.csv` (2949 rows). The repo also ships a
`conll/{train,dev,test}.txt` BIO-tagged re-split of that SAME labeled
pool (verified: a spot-checked conll/test.txt segment's text is present
in training_subtask_en.csv, not in the blind test file) -- not used here
either, since re-deriving character spans from someone else's BIO
tokenization would be more failure-prone than this project's already-
proven plain substring lookup (see FinCausal 2020/PolitiCause), and
because inventing our own split (below) keeps the split logic auditable
in one place rather than depending on a third party's undocumented
random seed.

Format: semicolon-delimited CSV, `Index;Text;Cause;Effect` -- verified:
EVERY row has non-empty Cause and Effect (0/2949 empty either way), i.e.
unlike FinCausal 2020, this public release contains ONLY pre-filtered
causal segments, no non-causal ones at all. This matches Hagen et al.
2026 (arXiv:2510.08224) Table 2's own characterization of FinCausal-23
(a "-" for noncausal sentence count) -- not a gap in this conversion.

causality-DETECTION is offered here, but it's degenerate on its own: since
every segment is pre-filtered causal, the table has exactly one class (all
Causal, via causalatee.data.utils.identification_batch_to_detection on the
identification table below) -- not meaningful for training/evaluating
detection on FinCausal-23 alone, but still useful when POOLED with other
datasets' negatives for a combined detection table.
`Text` is one whole SEGMENT ("up to three sentences" per the paper),
matching FinCausal 2020/BioCause/TCR's "keep the whole multi-sentence
unit together" granularity for the same reason (cause/effect here can
span the full segment). A segment with N causal relations gets N rows
sharing one base `Index` with a ".N" suffix (verified: e.g. "1813.1813.0"
/ "1813.1813.1" for a 2-relation segment; single-relation segments use a
bare integer index instead) -- exactly the same convention as FinCausal
2020's Task 2, parsed the same way (try the bare index first is not
needed here since the base is always the part before the first ".").
Cause/Effect are given as plain substrings of Text (no character
offsets, unlike FinCausal 2020) -- located here via `str.find`, verified
0/2949 substrings failed to locate.

No train/test split exists in the only labeled file (it's one flat pool
after excluding the blind test) -- this script invents its own,
deterministic, GROUPED BY SEGMENT (never splitting a multi-relation
segment's rows across train/test) using a fixed-seed shuffle
(`random.Random(20230)`, `2023` for the shared task year + `0` so it
reads unambiguously as a seed, not a stray relation count) over the 2630
segments, ~85%/15% train/test.
"""

import random
from pathlib import Path

import pandas as pd

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

_TRAIN_CSV_URL = (
    "https://raw.githubusercontent.com/pavanbaswani/Fincausal_SharedTask-2023"
    "/main/raw_data/training_subtask_en.csv"
)
_TEST_FRACTION = 0.15
_SPLIT_SEED = 20230


def _base_index(idx: str) -> str:
    return idx.split(".", 1)[0] if "." in idx else idx


def _load_segments() -> list[dict]:
    """One dict per segment: {"text", "causes": [...], "effects": [...]}."""
    df = pd.read_csv(_TRAIN_CSV_URL, sep=";", dtype={"Index": str})
    df["base"] = df["Index"].apply(_base_index)
    segments = []
    for _, group in df.groupby("base", sort=False):
        segments.append({
            "text": group["Text"].iloc[0],
            "causes": group["Cause"].tolist(),
            "effects": group["Effect"].tolist(),
        })
    return segments


def _split_segments() -> dict[str, list[dict]]:
    segments = _load_segments()
    order = list(range(len(segments)))
    random.Random(_SPLIT_SEED).shuffle(order)
    n_test = round(len(order) * _TEST_FRACTION)
    test_idx, train_idx = set(order[:n_test]), set(order[n_test:])
    return {
        "train": [segments[i] for i in sorted(train_idx)],
        "test": [segments[i] for i in sorted(test_idx)],
    }


def convert_for_causal_candidate_extraction(split: str) -> None:
    segments = _split_segments()[split]
    out = []
    for i, seg in enumerate(segments):
        text = seg["text"]
        spans = sorted({
            (text.find(s), text.find(s) + len(s))
            for s in seg["causes"] + seg["effects"]
        })
        out.append({"index": f"fincausal23_{split}_{i}", "text": text, "entity": [list(s) for s in spans]})
    df = pd.DataFrame(out).set_index("index")
    for error in verify_dataset(df, Task.CausalCandidateExtraction):
        print(f"WARNING [FinCausal23 {Task.CausalCandidateExtraction}/{split}]: {error}")
    df.to_parquet(f"./causal-candidate-extraction/{split}.parquet", engine="pyarrow")


def convert_for_causality_identification(split: str) -> None:
    segments = _split_segments()[split]
    out = []
    for i, seg in enumerate(segments):
        text = seg["text"]
        span_to_id: dict[tuple[int, int], str] = {}
        segment_map: dict[str, list[tuple[int, int]]] = {}
        relations = []
        for cause, effect in zip(seg["causes"], seg["effects"]):
            ids = {}
            for role, s in (("cause", cause), ("effect", effect)):
                span = (text.find(s), text.find(s) + len(s))
                if span not in span_to_id:
                    eid = f"e{len(span_to_id) + 1}"
                    span_to_id[span] = eid
                    segment_map[eid] = [span]
                ids[role] = span_to_id[span]
            relations.append({"relationship": Relation.Procausal, "first": ids["cause"], "second": ids["effect"]})
        marked_text = insert_entity_markers(text, segment_map)
        out.append({"index": f"fincausal23_{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 [FinCausal23 {Task.CausalityIdentification}/{split}]: {error}")
    df.to_parquet(f"./causality-identification/{split}.parquet", engine="pyarrow")


def convert_for_causality_detection(split: str) -> None:
    """Write a causality-detection table anyway, even though it's useless
    ALONE (single-class: every row is Causal, since FinCausal-23's public
    data is pre-filtered causal-only -- see module docstring). Deliberately
    NOT listed in docs/datasets/FinCausal23.md's ``supported_tasks`` (and
    excluded from conf-causality-repro's own sweep, see that repo's
    evaluation/data.py) so this project's own paper never trains/evaluates
    detection on FinCausal-23 in isolation. Still written to disk so
    causalatee users can pool it with other datasets' negatives for a
    combined detection table, per explicit instruction.
    """
    identification = pd.read_parquet(f"./causality-identification/{split}.parquet")
    batch = {"text": identification["text"].tolist(), "relations": identification["relations"].tolist()}
    out = identification_batch_to_detection(batch)
    df = pd.DataFrame({
        "index": [f"fincausal23_{split}_{i}" for i in range(len(out["text"]))],
        "text": out["text"],
        "label": out["label"],
    }).set_index("index")
    for error in verify_dataset(df, Task.CausalityDetection):
        print(f"WARNING [FinCausal23 {Task.CausalityDetection}/{split}]: {error}")
    Path("./causality-detection").mkdir(exist_ok=True)
    df.to_parquet(f"./causality-detection/{split}.parquet", engine="pyarrow")


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