brat.py

import glob
import logging
from dataclasses import dataclass
from os import listdir, path
from typing import Dict, List, Optional, Union

import datasets
from datasets import BuilderConfig, DatasetInfo, Features, Sequence, SplitGenerator, Value

logger = logging.getLogger(__name__)


@dataclass
class BratConfig(BuilderConfig):
    """BuilderConfig for BRAT."""

    url: str = None  # type: ignore
    description: Optional[str] = None
    citation: Optional[str] = None
    homepage: Optional[str] = None

    # paths to directories or files per split (relative to url or data_dir)
    split_paths: Optional[Dict[str, Union[str, List[str]]]] = None
    file_name_blacklist: Optional[List[str]] = None
    ann_file_extension: str = "ann"
    txt_file_extension: str = "txt"


class Brat(datasets.GeneratorBasedBuilder):
    BUILDER_CONFIG_CLASS = BratConfig

    def _info(self):
        return DatasetInfo(
            description=self.config.description,
            citation=self.config.citation,
            homepage=self.config.homepage,
            features=Features(
                {
                    "context": Value("string"),
                    "file_name": Value("string"),
                    "spans": Sequence(
                        {
                            "id": Value("string"),
                            "type": Value("string"),
                            "locations": Sequence(
                                {
                                    "start": Value("int32"),
                                    "end": Value("int32"),
                                }
                            ),
                            "text": Value("string"),
                        }
                    ),
                    "relations": Sequence(
                        {
                            "id": Value("string"),
                            "type": Value("string"),
                            "arguments": Sequence(
                                {"type": Value("string"), "target": Value("string")}
                            ),
                        }
                    ),
                    "equivalence_relations": Sequence(
                        {
                            "type": Value("string"),
                            "targets": Sequence(Value("string")),
                        }
                    ),
                    "events": Sequence(
                        {
                            "id": Value("string"),
                            "type": Value("string"),
                            "trigger": Value("string"),
                            "arguments": Sequence(
                                {"type": Value("string"), "target": Value("string")}
                            ),
                        }
                    ),
                    "attributions": Sequence(
                        {
                            "id": Value("string"),
                            "type": Value("string"),
                            "target": Value("string"),
                            "value": Value("string"),
                        }
                    ),
                    "normalizations": Sequence(
                        {
                            "id": Value("string"),
                            "type": Value("string"),
                            "target": Value("string"),
                            "resource_id": Value("string"),
                            "entity_id": Value("string"),
                        }
                    ),
                    "notes": Sequence(
                        {
                            "id": Value("string"),
                            "type": Value("string"),
                            "target": Value("string"),
                            "note": Value("string"),
                        }
                    ),
                }
            ),
        )

    @staticmethod
    def _get_location(location_string):
        parts = location_string.split(" ")
        assert (
            len(parts) == 2
        ), f"Wrong number of entries in location string. Expected 2, but found: {parts}"
        return {"start": int(parts[0]), "end": int(parts[1])}

    @staticmethod
    def _get_span_annotation(annotation_line):
        """
        example input:
        T1	Organization 0 4	Sony
        """

        _id, remaining, text = annotation_line.split("\t", maxsplit=2)
        _type, locations = remaining.split(" ", maxsplit=1)
        return {
            "id": _id,
            "text": text,
            "type": _type,
            "locations": [Brat._get_location(loc) for loc in locations.split(";")],
        }

    @staticmethod
    def _get_event_annotation(annotation_line):
        """
        example input:
        E1	MERGE-ORG:T2 Org1:T1 Org2:T3
        """
        _id, remaining = annotation_line.strip().split("\t")
        args = [dict(zip(["type", "target"], a.split(":"))) for a in remaining.split(" ")]
        return {
            "id": _id,
            "type": args[0]["type"],
            "trigger": args[0]["target"],
            "arguments": args[1:],
        }

    @staticmethod
    def _get_relation_annotation(annotation_line):
        """
        example input:
        R1	Origin Arg1:T3 Arg2:T4
        """

        _id, remaining = annotation_line.strip().split("\t")
        _type, remaining = remaining.split(" ", maxsplit=1)
        args = [dict(zip(["type", "target"], a.split(":"))) for a in remaining.split(" ")]
        return {"id": _id, "type": _type, "arguments": args}

    @staticmethod
    def _get_equivalence_relation_annotation(annotation_line):
        """
        example input:
        *	Equiv T1 T2 T3
        """
        _, remaining = annotation_line.strip().split("\t")
        parts = remaining.split(" ")
        return {"type": parts[0], "targets": parts[1:]}

    @staticmethod
    def _get_attribute_annotation(annotation_line):
        """
        example input (binary: implicit value is True, if present, False otherwise):
        A1	Negation E1
        example input (multi-value: explicit value)
        A2	Confidence E2 L1
        """

        _id, remaining = annotation_line.strip().split("\t")
        parts = remaining.split(" ")
        # if no value is present, it is implicitly "true"
        if len(parts) == 2:
            parts.append("true")
        return {
            "id": _id,
            "type": parts[0],
            "target": parts[1],
            "value": parts[2],
        }

    @staticmethod
    def _get_normalization_annotation(annotation_line):
        """
        example input:
        N1	Reference T1 Wikipedia:534366	Barack Obama
        """
        _id, remaining, text = annotation_line.split("\t", maxsplit=2)
        _type, target, ref = remaining.split(" ")
        res_id, ent_id = ref.split(":")
        return {
            "id": _id,
            "type": _type,
            "target": target,
            "resource_id": res_id,
            "entity_id": ent_id,
        }

    @staticmethod
    def _get_note_annotation(annotation_line):
        """
        example input:
        #1	AnnotatorNotes T1	this annotation is suspect
        """
        _id, remaining, note = annotation_line.split("\t", maxsplit=2)
        _type, target = remaining.split(" ")
        return {
            "id": _id,
            "type": _type,
            "target": target,
            "note": note,
        }

    @staticmethod
    def _read_annotation_file(filename):
        """
        reads a BRAT v1.3 annotations file (see https://brat.nlplab.org/standoff.html)
        """

        res = {
            "spans": [],
            "events": [],
            "relations": [],
            "equivalence_relations": [],
            "attributions": [],
            "normalizations": [],
            "notes": [],
        }

        with open(filename) as file:
            for i, line in enumerate(file):
                if len(line.strip()) == 0:
                    continue
                ann_type = line[0]

                # strip away the new line character
                if line.endswith("\n"):
                    line = line[:-1]

                if ann_type == "T":
                    res["spans"].append(Brat._get_span_annotation(line))
                elif ann_type == "E":
                    res["events"].append(Brat._get_event_annotation(line))
                elif ann_type == "R":
                    res["relations"].append(Brat._get_relation_annotation(line))
                elif ann_type == "*":
                    res["equivalence_relations"].append(
                        Brat._get_equivalence_relation_annotation(line)
                    )
                elif ann_type in ["A", "M"]:
                    res["attributions"].append(Brat._get_attribute_annotation(line))
                elif ann_type == "N":
                    res["normalizations"].append(Brat._get_normalization_annotation(line))
                elif ann_type == "#":
                    res["notes"].append(Brat._get_note_annotation(line))
                else:
                    raise ValueError(
                        f'unknown BRAT annotation id type: "{line}" (from file {filename} @line {i}). '
                        f"Annotation ids have to start with T (spans), E (events), R (relations), "
                        f"A (attributions), or N (normalizations). See "
                        f"https://brat.nlplab.org/standoff.html for the BRAT annotation file "
                        f"specification."
                    )
        return res

    def _generate_examples(self, base_dir: str, files: Optional[List[str]] = None, directory: Optional[str] = None):
        """Read context (.txt) and annotation (.ann) files."""
        if files is None:
            if directory is None:
                raise ValueError("Either files or directory has to be provided.")
            _directory = path.join(base_dir, directory)
            _files = glob.glob(f"{_directory}/*.{self.config.ann_file_extension}")
            files = sorted(path.splitext(fn)[0] for fn in _files)
            if len(files) == 0:
                raise ValueError(f"No files found in directory: {_directory}")
        else:
            if directory is not None:
                raise ValueError("Only one of files or directory can be provided.")
            files = [path.join(base_dir, fn) for fn in files]

        for filename in files:
            basename = path.basename(filename)
            if (
                self.config.file_name_blacklist is not None
                and basename in self.config.file_name_blacklist
            ):
                logger.info(f"skip annotation file: {basename} (blacklisted)")
                continue

            ann_fn = f"{filename}.{self.config.ann_file_extension}"
            brat_annotations = Brat._read_annotation_file(ann_fn)

            txt_fn = f"{filename}.{self.config.txt_file_extension}"
            txt_content = open(txt_fn).read()
            brat_annotations["context"] = txt_content
            brat_annotations["file_name"] = basename

            yield basename, brat_annotations

    def _split_generators(self, dl_manager):
        """Returns SplitGenerators."""

        if self.config.data_dir is not None:
            data_dir = self.config.data_dir
            logging.warning(f"load from data_dir: {data_dir}")
        else:
            # since subclasses of BuilderConfig are not allowed to define
            # attributes without defaults, check here
            assert self.config.url is not None, "data url not specified"

            data_dir = dl_manager.download_and_extract(self.config.url)

        # if no subdirectory mapping is provided, ...
        if self.config.split_paths is None:
            # ... use available subdirectories as split names ...
            subdirs = [f for f in listdir(data_dir) if path.isdir(path.join(data_dir, f))]
            if len(subdirs) > 0:
                split_paths = {subdir: {"directory": subdir} for subdir in subdirs}
            else:
                # ... otherwise, default to a single train split with the base directory
                split_paths = {"train": {"directory": ""}}
        else:
            split_paths = {}
            for split, paths in self.config.split_paths.items():
                if isinstance(paths, str):
                    split_paths[split] = {"directory": paths}
                elif isinstance(paths, list):
                    split_paths[split] = {"files": paths}
                else:
                    raise ValueError(
                        f"split_paths must be a dict containing either a single path to a directory "
                        f"or a list of file paths, but found: {paths}"
                    )

        return [
            SplitGenerator(
                name=split,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "base_dir": data_dir,
                    **split_kwargs,
                },
            )
            for split, split_kwargs in split_paths.items()
        ]