cc_gigafida.py

"""(A publicly available subsample of) a reference corpus of Slovene texts."""


import glob
import logging
import os
import os.path
import re
import xml.etree.ElementTree as ET
from copy import deepcopy
from typing import Optional

import datasets

XML_NAMESPACE = "{http://www.w3.org/XML/1998/namespace}"


def namespace(element):
    # https://stackoverflow.com/a/12946675
    m = re.match(r'\{.*\}', element.tag)
    return m.group(0) if m else ''


_CITATION = """\
@misc{ccGigafida,
    title = {Written corpus {ccGigafida} 1.0},
    author = {Logar, Nata{\v s}a and Erjavec, Toma{\v z} and Krek, Simon and Gr{\v c}ar, Miha and Holozan, Peter},
    url = {http://hdl.handle.net/11356/1035},
    note = {Slovenian language resource repository {CLARIN}.{SI}},
    copyright = {Creative Commons - Attribution-{NonCommercial}-{ShareAlike} 4.0 International ({CC} {BY}-{NC}-{SA} 4.0)},
    issn = {2820-4042},
    year = {2013}
}
"""

_DESCRIPTION = """\
The ccGigafida corpus contains a subsample of the Gigafida corpus. The Gigafida corpus is an extensive collection of 
Slovene text of various genres, from daily newspapers, magazines, all kinds of books (fiction, non-fiction, textbooks), 
web pages, transcriptions of parliamentary debates and similar.
"""

_HOMEPAGE = "http://eng.slovenscina.eu/korpusi/proste-zbirke"

_LICENSE = "Creative Commons - Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)"

_URLS = {
    "ccGigafida": "https://www.clarin.si/repository/xmlui/bitstream/handle/11356/1035/ccGigafidaV1_0.zip"
}


class CcGigafida(datasets.GeneratorBasedBuilder):
    """(A publicly available subsample of) a reference corpus of Slovene texts."""

    VERSION = datasets.Version("1.0.1")

    BUILDER_CONFIGS = [
        datasets.BuilderConfig(name="public", version=VERSION,
                               description="Load the publicly available dataset (ccGigafida)."),
        datasets.BuilderConfig(name="private", version=VERSION,
                               description="Load the privately available dataset (Gigafida/Gigafida2) by manuallly "
                                           "providing the path to the data."),
    ]

    DEFAULT_CONFIG_NAME = "public"

    def _info(self):
        features = datasets.Features(
            {
                "id_doc": datasets.Value("string"),
                "doc_title": datasets.Value("string"),
                "authors": datasets.Sequence(datasets.Value("string")),
                "publish_date": datasets.Value("string"),
                "publisher": datasets.Value("string"),
                "genres": datasets.Sequence(datasets.Value("string")),
                "doc_tokenized": datasets.Sequence(datasets.Sequence(datasets.Sequence(datasets.Value("string")))),
                "doc_lemmas": datasets.Sequence(datasets.Sequence(datasets.Sequence(datasets.Value("string")))),
                "doc_msds": datasets.Sequence(datasets.Sequence(datasets.Sequence(datasets.Value("string")))),
                "doc_string": datasets.Sequence(datasets.Sequence(datasets.Value("string"))),
                "id_sents": datasets.Sequence(datasets.Sequence(datasets.Value("string")))
            }
        )

        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=features,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        if self.config.name == "public":
            urls = _URLS["ccGigafida"]
            data_dir = dl_manager.download_and_extract(urls)
            data_dir = os.path.join(data_dir, "ccGigafidaV1_0")
        else:
            if dl_manager.manual_dir is None or not os.path.exists(dl_manager.manual_dir):
                logging.warning("data_dir does not point to a valid directory")

            # Allow user to specify path to the private Gigafida directory: `load_dataset(..., data_dir=...)`
            data_dir = dl_manager.manual_dir

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={"data_dir": data_dir}
            )
        ]

    def _generate_examples(self, data_dir):
        GENRE_MAPPING = {
            "SSJ.T": "tisk", "SSJ.T.K": "tisk/knjižno", "SSJ.T.K.L": "tisk/knjižno/leposlovno",
            "SSJ.T.K.S": "tisk/knjižno/strokovno", "SSJ.T.P": "tisk/periodično", "SSJ.T.P.C": "tisk/periodično/časopis",
            "SSJ.T.P.R": "tisk/periodično/revija", "SSJ.T.D": "tisk/drugo", "SSJ.I": "internet"
        }
        # genres are prefixed by "ssj:" in Gigafida 2.0
        for genre, description in deepcopy(GENRE_MAPPING).items():
            GENRE_MAPPING[f"ssj:{genre}"] = description

        # Recursively search for xml files in subdirectories
        all_files = [os.path.join(data_dir, file_name)
                     for file_name in glob.glob(os.path.join(data_dir, "**", "*.xml"), recursive=True)
                     if os.path.isfile(os.path.join(data_dir, file_name))]
        all_files = sorted(all_files)  # fix order

        for _idx_file, file_path in enumerate(all_files):
            curr_doc = ET.parse(file_path)
            root = curr_doc.getroot()
            NAMESPACE = namespace(root)
            id_doc = root.attrib[f"{XML_NAMESPACE}id"]

            # Document metadata
            bibl_el = root.find(f".//{NAMESPACE}bibl")
            doc_title = bibl_el.find(f"{NAMESPACE}title").text.strip()
            authors = list(map(lambda _tag: _tag.text.strip(), bibl_el.findall(f"{NAMESPACE}author")))
            publish_date = bibl_el.find(f"{NAMESPACE}date").text.strip()
            publisher = bibl_el.find(f"{NAMESPACE}publisher").text.strip()

            category_tags = root.findall(f".//{NAMESPACE}catRef")
            genres = []
            for _tag in category_tags:
                # in ccGigafida, the genres are noted with a "#" prefix
                __tag = _tag.attrib["target"][1:] if _tag.attrib["target"].startswith("#") else _tag.attrib["target"]
                mapped_tag = GENRE_MAPPING.get(__tag, None)
                # In addition to the genre of the document, there is sometimes a category assigned by the deduplication tool (dedup:nodup)
                if mapped_tag is None:
                    continue

                genres.append(mapped_tag)

            # Tokenized and raw string version - raw string version preserves spaces
            body_tag = root.find(f".//{NAMESPACE}body")
            tokenized_doc, doc_str = [], []
            doc_sent_ids = []
            doc_msds, doc_lemmas = [], []

            for para_tag in body_tag.findall(f".//{NAMESPACE}p"):
                id_para = para_tag.attrib[f"{XML_NAMESPACE}id"]
                tokenized_para, para_str = [], []
                para_msds, para_lemmas = [], []
                para_sent_ids = []

                for _idx_sent, sent_tag in enumerate(para_tag.findall(f".//{NAMESPACE}s")):
                    # ccGigafida does not have sentence IDs:
                    #   construct ID by taking the paragraph ID + their index in the paragraph
                    id_sent = sent_tag.attrib.get(f"{XML_NAMESPACE}id", None)
                    if id_sent is None:
                        id_sent = f"{id_para}.{_idx_sent}"

                    tokenized_sent, str_sent = [], []
                    msd_tags, lemmas = [], []
                    for child_tag in sent_tag:
                        tag_str = child_tag.tag[len(NAMESPACE):]
                        if tag_str not in {"w", "S", "c", "pc"}:
                            logging.warning(f"Found unexpected tag in a sentence: '{tag_str}', skipping it.")
                            continue

                        # Tag for whitespace in ccGigafida
                        if tag_str == "S":
                            str_sent.append(" ")

                        # Tag for:
                        # - single-letter characters in ccGigafida;
                        # - whitespace in Gigafida
                        elif tag_str == "c":
                            str_sent.append(child_tag.text)
                            if child_tag.text != " ":
                                tokenized_sent.append(child_tag.text)
                                msd_tags.append(child_tag.attrib["ana"][len("mte:"):] if "ana" in child_tag.attrib else "")
                                lemmas.append(child_tag.text)

                        # word or punctuation character
                        else:
                            str_sent.append(child_tag.text)
                            tokenized_sent.append(child_tag.text)
                            msd_tags.append(child_tag.attrib["ana"][len("mte:"):] if "ana" in child_tag.attrib else child_tag.attrib["msd"])
                            lemmas.append(child_tag.attrib["lemma"] if "lemma" in child_tag.attrib else child_tag.text)

                    str_sent = "".join(str_sent)
                    tokenized_para.append(tokenized_sent)
                    para_str.append(str_sent)
                    para_sent_ids.append(id_sent)
                    para_msds.append(msd_tags)
                    para_lemmas.append(lemmas)

                tokenized_doc.append(tokenized_para)
                doc_str.append(para_str)
                doc_sent_ids.append(para_sent_ids)
                doc_msds.append(para_msds)
                doc_lemmas.append(para_lemmas)

            yield _idx_file, {
                "id_doc": id_doc,
                "doc_title": doc_title,
                "authors": authors,
                "publish_date": publish_date,
                "publisher": publisher,
                "genres": genres,
                "doc_tokenized": tokenized_doc,
                "doc_lemmas": doc_lemmas,
                "doc_msds": doc_msds,
                "doc_string": doc_str,
                "id_sents": doc_sent_ids
            }