import glob import logging from dataclasses import dataclass from os import listdir, path from typing import Dict, List, Optional 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 subdirectory_mapping: Optional[Dict[str, 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, files=None, directory=None): """Read context (.txt) and annotation (.ann) files.""" if files is None: assert ( directory is not None ), "If files is None, directory has to be provided, but it is also None." _files = glob.glob(f"{directory}/*.{self.config.ann_file_extension}") files = sorted(path.splitext(fn)[0] 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.""" subdirectory_mapping = self.config.subdirectory_mapping # 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" # if url points to a local directory, just point to that if path.exists(self.config.url) and path.isdir(self.config.url): data_dir = self.config.url # otherwise, download and extract else: data_dir = dl_manager.download_and_extract(self.config.url) logging.info(f"load from data dir: {data_dir}") # if no subdirectory mapping is provided, ... if subdirectory_mapping 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: subdirectory_mapping = {subdir: subdir for subdir in subdirs} else: # ... otherwise, default to a single train split with the base directory subdirectory_mapping = {"": "train"} return [ SplitGenerator( name=split, # These kwargs will be passed to _generate_examples gen_kwargs={ "directory": path.join(data_dir, subdir), }, ) for subdir, split in subdirectory_mapping.items() ]