pmc_open_access_xml.py

# coding=utf-8
# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This dataset script is based on pmc/open_access.py loading script.

"""PMC Open Access Subset enriched from XML."""

import datetime
import pandas as pd
import numpy as np
from itertools import compress, chain
from collections import defaultdict
import re
from lxml import etree
import json

import datasets
from datasets.tasks import LanguageModeling


# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
_CITATION = ""

_DESCRIPTION = """\
The PMC Open Access Subset includes more than 3.4 million journal articles and preprints that are made available under
license terms that allow reuse. 
Not all articles in PMC are available for text mining and other reuse, many have copyright protection, however articles
in the PMC Open Access Subset are made available under Creative Commons or similar licenses that generally allow more
liberal redistribution and reuse than a traditional copyrighted work. 
The PMC Open Access Subset is one part of the PMC Article Datasets

This version takes XML version as source, benefiting from the structured text
to split the articles in parts, naming the introduction, methods, results,
discussion and conclusion, and refers with keywords in the text to external or internal
resources (articles, figures, tables, formulas, boxed-text, quotes, code, footnotes, chemicals, graphics, medias).
"""

_HOMEPAGE = "https://www.ncbi.nlm.nih.gov/pmc/tools/openftlist/"

# TODO: Add the licence for the dataset here if you can find it
_LICENSE = """
https://www.ncbi.nlm.nih.gov/pmc/about/copyright/

Within the PMC Open Access Subset, there are three groupings:

Commercial Use Allowed - CC0, CC BY, CC BY-SA, CC BY-ND licenses
Non-Commercial Use Only - CC BY-NC, CC BY-NC-SA, CC BY-NC-ND licenses; and
Other - no machine-readable Creative Commons license, no license, or a custom license.
"""

_URL_ROOT = "https://ftp.ncbi.nlm.nih.gov/pub/pmc/"
_URL      = _URL_ROOT+"oa_bulk/{subset}/xml/"

_SUBSETS = {
    "commercial": "oa_comm",
    "non_commercial": "oa_noncomm",
    "other": "oa_other",
}
_BASELINE_DATE = "2022-01-16"

REFS_KEYS     = ["pmid_ref", "unknown_pub_ref", "figure_ref", "table_ref", "formula_ref", "box_ref", "code_ref", 
                 "quote_ref", "chem_ref", "supplementary_ref", "footnote_ref", "graphic_ref", "media_ref"]
CONTENT_KEYS  = ["introduction", "methods", "results", "discussion", "conclusion",
                 "front", "body", "back", "figure", "table", "formula", "box", 
                 "code", "quote", "chem", "supplementary", "footnote"]
begin_doc_rgx = re.compile("""<!DOCTYPE.*""")
def clean_raw(xml_text):
    """
    Fixes the formating of xml of files and returns it. 
    Some have bad formating but they can be fixed/improved
    """
    #Some XML can't be parsed because they are not starting with the DOCTYPE declaration
    # Could be disabled if we handle the parsing error (TBD, how many files would be trashed)
    
    begin_doc = begin_doc_rgx.search(xml_text)
    xml_text  = xml_text[begin_doc.start():]
    
    #Some XML are poisoned with consecutive tabs and new lines
    # xml_text  = re.sub('\s+',' ',xml_text) # Commented because <code> requires those spacing
    return xml_text

# Tag name to "reference type" linking
TAG_DIC = {"fig":(" ##FIG## ","figure_ref"),             "table-wrap":(" ##TAB## ","table_ref"),
           "array":(" ##TAB## ","table_ref"),            "boxed-text":(" ##BOX## ","box_ref"), 
           "graphic":(" ##GRAPH## ","graphic_ref"),      "inline-graphic":(" ##GRAPH## ","graphic_ref"),
           "media":(" ##MEDIA## ","media_ref"),          "inline-media":(" ##MEDIA## ","media_ref"),
           "disp-formula":(" ##FORMU## ","formula_ref"), "inline-formula":(" ##FORMU## ","formula_ref"),
           "table-wrap-foot":(" ##FOOTN## ","footnote_ref"), "fn-group":(" ##FOOTN## ","footnote_ref"), 
           "code":(" ##CODE## ","code_ref"),                 "chem-struct-wrap":(" ##CHEM## ","chem_ref"),
           "disp-quote":(" ##QUOTE## ","quote_ref"),         "speech":(" ##QUOTE## ","quote_ref"),
           "supplementary-material":(" ##SUPPL## ","supplementary_ref"),
           "inline-supplementary-material":(" ##SUPPL## ","supplementary_ref")}

def get_ref_indexes(ref_el_l, refs_pmid, refs_nonpmid_keys):
    """
    For all the element found as xref, give them an index to be later found in their corresponding section.
    Also sort them into the different types of references (eg <array> and <table-wrap> are both
    labeled as table_ref).
    """
    count_ref_d = defaultdict(lambda:0)
    reference_d = {}
    for k, v in refs_pmid.items():
        reference_d[k] = (v, " ##REF## ", "pmid_ref")
    for i, k in enumerate(refs_nonpmid_keys):
        reference_d[k] = (i, " ##UREF## ", "unknown_pub_ref")
        
    refs_key_l = []
    for el in ref_el_l:
        keyword, ref_name = TAG_DIC[el.tag]
        idx = count_ref_d[ref_name]
        key = el.attrib["id"] if "id" in el.attrib.keys() else f"{el.tag}{idx}"
        reference_d[key] = (idx, keyword, ref_name)
        refs_key_l.append(key)
        count_ref_d[ref_name]+=1
    return reference_d, refs_key_l

def parseout_el_refs(el, rids):
    """
    Extract the text from the tag opening to its closing, discarding the tail's text.
    Removes xml namespace from the text for storage savings, such as:
        - xmlns:xlink="http://www.w3.org/1999/xlink"
        - xmlns:mml="http://www.w3.org/1998/Math/MathML"
        
    Extract then from the text all the references founds to the rids dictionnary,
    and replace them by keywords of the corresponding family (eg " ##FIG## " for a figure,
    " ##TAB## " for a table, or " ##MATHS## " for mathematical formulas)
    
    Returns the parsed text, the identifiers for the references and the references text that
    were replaced by the keywords. (eg, "Figure 2" was a hypertext reference and got replaced by " ##FIG## ")
    """
    res_rid     = defaultdict(list)
    res_reftext = defaultdict(list)
    for xref in el.xpath(".//xref[not(ancestor::xref)]"): #Ignore innermost of imbricated references
        rid = xref.get("rid")
        if rid in rids.keys():
            ref_idx, ref_kword, ref_class = rids[rid]
            res_rid[ref_class].append(ref_idx)
            res_reftext[ref_class].append("".join(xref.itertext()))
            parent  = xref.getparent()
            tail    = xref.tail if xref.tail else ""
            prev_el = xref.getprevious()
            if prev_el is None:
                parent.text  = "".join([(parent.text if parent.text else ""), ref_kword, tail])
            else:
                prev_el.tail = "".join([(prev_el.tail if prev_el.tail else ""), ref_kword, tail])
            parent.remove(xref)

    text = etree.tostring(el, with_tail=False, encoding='unicode', method='xml')
    #Removing the xml namespace, (otherwise they would be everywhere)
    tag_start = text.find(">")+1
    tag_txt = text[:tag_start]
    
    for k, v in el.nsmap.items():
        tag_txt = tag_txt.replace(f' xmlns:{k}="{v}"', "", 1)

    text = "".join([tag_txt, text[tag_start:]])
            
    return text, res_rid, res_reftext


def get_references(article_tree):
    """
    Retrieve two dictionnaries of the bibr references for that article.
    The first has the references' PMID for those having one.
    The second contains the <ref> tag fields, that could be identified to retrieve the
    referenced documents (some have PMID that could be found from the title and authors of a document).
    """
    references_pmid    = {}
    references_nonpmid = []
    references_nonpmid_keys = []
    refs = article_tree.find(".//ref-list")
    if refs is None: #Some don't have any references 
        return {}, [], []
    refs = refs.findall("ref")
    for i, ref in enumerate(refs):
        pmid = None
        for pubid in ref.findall(".//pub-id"):
            if pubid.get("pub-id-type") == "pmid":
                pmid = int(pubid.text)
                break
        if pmid is not None and pmid<100000000: 
            #In an article (oa_comm:PMC2679651), broken PMID were found (>10e9). 
            #May be several of those. Not sure what to do with them, and what threshold to use
            #Keeping them would result in loosing info about the reference (article title, authors, ...)
            
            #Only the PMID is kept, as it links to the documents in pubmed abstract dataset.
            references_pmid[ref.attrib["id"]] = str(pmid)
        else:
            ref_key = ref.attrib["id"] if "id" in ref.attrib.keys() else f"URef{i+1}"
            citation_d = defaultdict(list)
            #Authors are the only elements that can come in multiples (I could be wrong)
            for el in ref.iterdescendants():
                if isinstance(el.text, str) and isinstance(el.tag, str):
                    citation_d[el.tag].append(el.text)
            references_nonpmid.append(dict(citation_d))
            references_nonpmid_keys.append(ref_key)
    
    return references_pmid, references_nonpmid, references_nonpmid_keys

def construct_datadict(article_tree):
    """
    Where the magic happens. A long script that:
    - Get the external references (from pmid if present)
    - Get glossary and remove it from the document
    - Find internal references (figures, tables, ...) and build a xref dictionary
    - Extract paragraphs and titles with their path in the document
    - Titles are used to identify ["introduction", "methods", "results" and "discussion"]
    - The path are then used to group paragraphs and titles into corresponding content.
    - Remaining p and title are put in three other section: front, body, back
    
    Returns:
        - content_d: Dictionnary with the content result
        - reference_d: The references of each kind (figure, table, ...) for each content type (intro, figure caption, ...)
        - reference_text_d: The replaced text by the keywords of the references, with keys matching reference_d.
        - reference_count: The count of unique external-document references.
        
    Useful information about the tags can be found here: https://jats.nlm.nih.gov/archiving/tag-library/1.3/
    """

    res_content_d, res_reference_d, res_reference_text_d = {}, defaultdict(dict), defaultdict(dict)
    
    refs_pmid, refs_nonpmid, refs_nonpmid_keys = get_references(article_tree)
    reference_count = len(refs_pmid)+len(refs_nonpmid)
    
    res_content_d["unknown_pub"] = json.dumps(refs_nonpmid)
    refs_el = article_tree.find(".//ref-list")
    if refs_el is not None:
        refs_el.getparent().remove(refs_el)
    
    # Extracts the glossary if exists, and removes it from the tree
    glossary = {}
    def search_def(el):
        for item in el.findall(".//def-item"):
            abbrev = item.find(".//term")
            if abbrev is None:
                continue
            k = "".join(abbrev.itertext())
            definition = item.find(".//def")
            definition = "".join(definition.itertext()) if definition is not None else ""
            glossary[k] = definition
            
    for el in article_tree.findall(".//glossary"):
        search_def(el)
        el.getparent().remove(el)
    for el in article_tree.findall(".//def-list"):
        search_def(el) #There may be still more def-list outside of a glossary
        el.getparent().remove(el)
    res_content_d["glossary"] = glossary
        
    # After testing, no question were found in the dataset, so I commented that part
    # question_l = []
    # for el in article_tree.xpath(".//question-preamble|.//question|.//answer|.//explanation"):
        # text, _, _ = parseout_el_refs(el, {})
        # question_l.append(text)
    # res_content_d["question"] = "\n".join(question_l)
    # for el in article_tree.xpath(".//question-wrap-group|.//question-wrap|.//answer-set|.//explanation"):
        # el.getparent().remove(el)
    
    # One big query is faster than multiple small ones
    ref_el_l = article_tree.xpath(".//fig|.//table-wrap|.//array|.//supplementary-material\
                                  |.//inline-supplementary-material|.//disp-formula\
                                  |.//inline-formula|.//graphic|.//inline-graphic\
                                  |.//media|.//inline-media|.//boxed-text\
                                  |.//table-wrap-foot|.//fn-group|.//chem-struct-wrap\
                                  |.//code|.//disp-quote|.//speech")
    rids, key_l = get_ref_indexes(ref_el_l, refs_pmid, refs_nonpmid_keys)
    text_l_d, refs_l_d, refs_text_l_d = defaultdict(list),defaultdict(list),defaultdict(list)
    for el, key in zip(ref_el_l[::-1], key_l[::-1]):
        #The iteration is done backward to always process first the most inner reference,
        # it makes the processing is agnostic to structure rules differences between articles
        new_text, new_xref_id, new_xref_text = parseout_el_refs(el, rids)

        ref_class = rids[key][2]
        text_l_d[ref_class].insert(0, new_text)
        refs_l_d[ref_class].insert(0, new_xref_id)
        refs_text_l_d[ref_class].insert(0, new_xref_text)

        repl_xref = etree.Element("xref", attrib={"rid":key})
        repl_xref.tail = el.tail
        el.addprevious(repl_xref)
        el.getparent().remove(el)
                
    # Finally, the discovered references and text are added to the result
    for ref_k in REFS_KEYS[2:]: #Slicing from 2, to not add pmid and unknown ref here
        res_content_d[ref_k[:-4]] = text_l_d[ref_k]#"\n".join(text_l_d[ref_k])
        if ref_k in ["graphic_ref", "media_ref"]: #They don't take references
            continue
        for ref_k2 in REFS_KEYS:
            tmp_l = [refs_d[ref_k2] for refs_d in refs_l_d[ref_k]]
            res_reference_d[ref_k[:-4]][ref_k2]      = list(chain(*tmp_l)) # [:-4] slicing to remove the "_ref" part
            tmp_l = [refs_d[ref_k2] for refs_d in refs_text_l_d[ref_k]]
            res_reference_text_d[ref_k[:-4]][ref_k2] = list(chain(*tmp_l))

    def add_part_to_dics(part, text_l, refs_l, ref_texts_l):
        """Repeated code to add various parts to the document"""
        res_content_d[part] = text_l #"\n".join(text_l)
        for ref_k in REFS_KEYS:
            tmp_l = [refs_d[ref_k] for refs_d in refs_l]
            res_reference_d[part][ref_k] =  list(chain(*tmp_l)) 
            tmp_l = [refs_d[ref_k] for refs_d in ref_texts_l]
            res_reference_text_d[part][ref_k] =   list(chain(*tmp_l))
            
    path_l, text_l, refs_l, refs_text_l = [], [], [], []
    t_paths, t_texts_lowcase  = [], []
    for part in ["front", "body", "back"]: #Iterate parts and insert first front and back
        tmp_path_l, tmp_text_l, tmp_refs_l, tmp_refs_text_l = [], [], [], []
        tmp_t_paths, tmp_t_texts_lowcase  = [], []
        part_el = article_tree.find(".//"+part)
        if part_el is None:
            res_content_d[part] = []#""
            for target_key in REFS_KEYS:
                res_reference_d[part][target_key] = []
                res_reference_text_d[part][target_key] = []
            continue
        #Only the outermost p are kept, to prevent duplication.
        #Also seen title with p inside. not(ancestor::title) prevents duplication of that p
        for el in part_el.xpath(".//p[not(ancestor::p) and not(ancestor::title)]| .//title[not(ancestor::p) and not(ancestor::title)]"):
            new_text, new_xref_id, new_xref_text = parseout_el_refs(el, rids)
            tmp_path_l.append(article_tree.getelementpath(el))
            tmp_text_l.append(new_text)
            tmp_refs_l.append(new_xref_id)
            tmp_refs_text_l.append(new_xref_text)
            if el.tag=="title":
                tmp_t_paths.append(tmp_path_l[-1])
                tmp_t_texts_lowcase.append(new_text.lower())   
        if part=="body": #We keep the body for processing right bellow. 
            path_l, text_l      = tmp_path_l, tmp_text_l
            refs_l, refs_text_l = tmp_refs_l, tmp_refs_text_l
            t_paths, t_texts_lowcase = tmp_t_paths, tmp_t_texts_lowcase
        else:
            add_part_to_dics(part, tmp_text_l, tmp_refs_l, tmp_refs_text_l)

    # Figuring from the titles which are the different categories
    mask_intro = np.array(["introduction" in t_text or "background" in t_text for t_text in t_texts_lowcase]).astype(bool)
    mask_metho = np.array(["method" in t_text  for t_text in t_texts_lowcase]).astype(bool)
    mask_resul = np.array(["result" in t_text for t_text in t_texts_lowcase]).astype(bool)
    mask_discu = np.array(["discussion" in t_text for t_text in t_texts_lowcase]).astype(bool)
    mask_concl = np.array(["conclusion" in t_text for t_text in t_texts_lowcase]).astype(bool)
    processed_mask = np.zeros(len(text_l), dtype="bool")
    for mask, name_section in zip([mask_intro, mask_metho, mask_resul, mask_discu, mask_concl],
                                  ["introduction", "methods", "results", "discussion", "conclusion"]):
        if not np.any(mask):
            res_content_d[name_section] = []#""
            for target_key in REFS_KEYS:
                res_reference_d[name_section][target_key] = []
                res_reference_text_d[name_section][target_key] = []
            continue

        filtered_path_l = list(compress(t_paths, mask))
        levels    = np.array([len(path.split("/")) for path in filtered_path_l])
        root_path = filtered_path_l[np.argmin(levels)]
        root_path = root_path[:root_path.rindex("/")]
        mask_contents = np.array([path.startswith(root_path) for path in path_l]).astype(bool)
        processed_mask |= mask_contents
        add_part_to_dics(name_section, list(compress(text_l, mask_contents)), 
                         list(compress(refs_l, mask_contents)), list(compress(refs_text_l, mask_contents)))

    processed_mask = ~processed_mask #Finally, add the body part as everything that don't belong to previous categories
    add_part_to_dics("body", list(compress(text_l, processed_mask)), 
                     list(compress(refs_l, processed_mask)), list(compress(refs_text_l, processed_mask)))
    
    res_reference_d      = dict(res_reference_d)
    res_reference_text_d = dict(res_reference_text_d)
        
    return (res_content_d, res_reference_d, res_reference_text_d, reference_count)

class OpenAccessXMLConfig(datasets.BuilderConfig):
    """BuilderConfig for the PMC Open Access Subset."""

    def __init__(self, subsets=None, **kwargs):
        """BuilderConfig for the PMC Open Access Subset.
        Args:
            subsets (:obj:`List[str]`): List of subsets/groups to load.
            **kwargs: Keyword arguments forwarded to super.
        """
        subsets = [subsets] if isinstance(subsets, str) else subsets
        super().__init__(
            name="+".join(subsets), **kwargs,
        )
        self.subsets = subsets if self.name != "all" else list(_SUBSETS.keys())


class OpenAccessXML(datasets.GeneratorBasedBuilder):
    """PMC Open Access Subset enriched from XML files."""

    VERSION = datasets.Version("1.0.0")
    BUILDER_CONFIG_CLASS = OpenAccessXMLConfig
    BUILDER_CONFIGS = [OpenAccessXMLConfig(subsets="all")] + [OpenAccessXMLConfig(subsets=subset) for subset in _SUBSETS]
    DEFAULT_CONFIG_NAME = "all"

    def _info(self):
        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=datasets.Features(
                {
                    "accession_id":  datasets.Value("string"),
                    "pmid":          datasets.Value("string"),
                    
                    "introduction":  datasets.features.Sequence(datasets.Value("string")),
                    "methods":       datasets.features.Sequence(datasets.Value("string")),
                    "results":       datasets.features.Sequence(datasets.Value("string")),
                    "discussion":    datasets.features.Sequence(datasets.Value("string")),
                    "conclusion":    datasets.features.Sequence(datasets.Value("string")),
                    
                    "front":    datasets.features.Sequence(datasets.Value("string")),
                    "body":     datasets.features.Sequence(datasets.Value("string")),
                    "back":     datasets.features.Sequence(datasets.Value("string")),

                    "figure":        datasets.features.Sequence(datasets.Value("string")),
                    "table":         datasets.features.Sequence(datasets.Value("string")),
                    "formula":       datasets.features.Sequence(datasets.Value("string")),
                    "box":           datasets.features.Sequence(datasets.Value("string")),
                    "code":          datasets.features.Sequence(datasets.Value("string")),
                    "quote":         datasets.features.Sequence(datasets.Value("string")),
                    "chem":          datasets.features.Sequence(datasets.Value("string")),
                    "supplementary": datasets.features.Sequence(datasets.Value("string")),
                    "footnote":      datasets.features.Sequence(datasets.Value("string")),
                    "graphic":       datasets.features.Sequence(datasets.Value("string")),
                    "media":         datasets.features.Sequence(datasets.Value("string")),
                    
                    "unknown_pub": datasets.Value("string"),
                    # "question":    datasets.Value("string"),
                    "glossary":    datasets.features.Sequence(
                        {"acronym": datasets.Value("string"), "definition": datasets.Value("string")}
                    ),

                    "references":      {k_cont:{k_ref:datasets.features.Sequence(datasets.Value("string" if k_ref=="pmid_ref" else "int32"))  for k_ref in REFS_KEYS} for k_cont in CONTENT_KEYS},
                    "references_text": {k_cont:{k_ref:datasets.features.Sequence(datasets.Value("string")) for k_ref in REFS_KEYS} for k_cont in CONTENT_KEYS},
                            # -> With the 2 level dict, each item looks like this:
                            # "introduction":{"pmid_ref":           datasets.features.Sequence(datasets.Value("string")),
                            #                 "unknown_pub_ref":    datasets.features.Sequence(datasets.Value("string")),
                            #                 "figure_ref":         datasets.features.Sequence(datasets.Value("string")),
                            #                 "table_ref":          datasets.features.Sequence(datasets.Value("string")),
                            #                 "formula_ref":        datasets.features.Sequence(datasets.Value("string")),
                            #                 "box_ref":            datasets.features.Sequence(datasets.Value("string")),
                            #                 "code_ref":           datasets.features.Sequence(datasets.Value("string")),
                            #                 "quote_ref":          datasets.features.Sequence(datasets.Value("string")),
                            #                 "chem_ref":           datasets.features.Sequence(datasets.Value("string")),
                            #                 "supplementary_ref":  datasets.features.Sequence(datasets.Value("string")),
                            #                 "footnote_ref":       datasets.features.Sequence(datasets.Value("string")),
                            #                 "graphic_ref":        datasets.features.Sequence(datasets.Value("string")),
                            #                 "media_ref":          datasets.features.Sequence(datasets.Value("string")),
                            # },

                    "n_references": datasets.Value("int32"),
                    "license": datasets.Value("string"),
                    "retracted": datasets.Value("string"),
                    "last_updated": datasets.Value("string"),
                    "citation": datasets.Value("string"),
                    "package_file": datasets.Value("string"),
                }
            ),
            homepage=_HOMEPAGE,
            license=_LICENSE,
            citation=_CITATION,
            task_templates=[LanguageModeling(text_column="content")],
        )

    def _split_generators(self, dl_manager):

        incremental_paths = {
            "incremental_file_lists": [],
            "incremental_archives": []
            }
        
        baseline_package_list = dl_manager.download(f"{_URL_ROOT}oa_file_list.csv")
  
        baseline_file_lists    = []
        baseline_archives      = []
        for subset in self.config.subsets:
            url = _URL.format(subset=_SUBSETS[subset])
            basename = f"{_SUBSETS[subset]}_xml."
            # Baselines
            baselines = [f"PMC00{i}xxxxxx.baseline.{_BASELINE_DATE}" for i in range(9)]

            for baseline in baselines:
                baseline_file_list_url = f"{url}{basename}{baseline}.filelist.csv"
                try:
                    baseline_file_list = dl_manager.download(baseline_file_list_url)
                except FileNotFoundError:  # non-commercial PMC000xxxxxx baseline does not exist
                    continue
                baseline_archive_url = f"{url}{basename}{baseline}.tar.gz"
                try:
                    baseline_archive = dl_manager.download(baseline_archive_url)
                except FileNotFoundError:
                    continue
                baseline_file_lists.append(baseline_file_list)
                baseline_archives.append(baseline_archive)

            baseline_file_list_url = f"{url}{basename}{baseline}.filelist.csv"
            
            # Incremental commented because some articles are already in the main parts (updates?)
            # Need to find a way to add them to the dataset without duplicating the articles.
            # Also adding them would mean that each new day the dataset is loaded, the whole dataset is recreated.
            # date_delta = datetime.date.today() - datetime.date.fromisoformat(_BASELINE_DATE)
            # incremental_dates = [
                # (datetime.date.fromisoformat(_BASELINE_DATE) + datetime.timedelta(days=i + 1)).isoformat()
                # for i in range(date_delta.days)
            # ]
            # incrementals = [f"incr.{date}" for date in incremental_dates]
            # incremental_urls = {
                # "incremental_file_lists": [
                    # f"{url}{basename}{incremental}.filelist.csv" for incremental in incrementals
                # ],
                # "incremental_archives": [f"{url}{basename}{incremental}.tar.gz" for incremental in incrementals],
            # }
            # paths = dl_manager.download(incremental_urls)
            # incremental_paths["incremental_file_lists"].extend(paths["incremental_file_lists"])
            # incremental_paths["incremental_archives"].extend(paths["incremental_archives"])

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "baseline_file_lists": baseline_file_lists,
                    "baseline_archives": [dl_manager.iter_archive(archive) for archive in baseline_archives],
                    "baseline_package_list": baseline_package_list,
                    # "incremental_file_lists": incremental_paths["incremental_file_lists"],
                    # "incremental_archives": [
                        # dl_manager.iter_archive(archive) for archive in incremental_paths["incremental_archives"]
                    # ],
                },
            ),
        ]

    def _generate_examples(self, baseline_file_lists, baseline_archives, baseline_package_list): #, incremental_file_lists, incremental_archives
        #Loading the file listing folders of individual PMC Article package (with medias and graphics)
        oa_package_list = pd.read_csv(baseline_package_list, index_col="Accession ID")
        oa_package_list = oa_package_list[["File"]]
        oa_package_list.sort_index(inplace=True)
        
        # Baselines
        for baseline_file_list, baseline_archive in zip(baseline_file_lists, baseline_archives):

            try:
                baselines = pd.read_csv(baseline_file_list, index_col="AccessionID")
                baselines = baselines.join(oa_package_list).reset_index().set_index("Article File")
                baselines = baselines.to_dict(orient="index")
                for path, file in baseline_archive:
                    data = baselines.pop(path)
                    content = file.read()
                    try:
                        text = content.decode("utf-8").strip()
                    except UnicodeDecodeError as e:
                        text = content.decode("latin-1").strip()
                    text = clean_raw(text)
                    try:
                        article_tree = etree.ElementTree(etree.fromstring(text))
                    except etree.XMLSyntaxError: #In some files, xml is broken
                        continue
                        
                    content_d, reference_d, reference_text_d, n_ref = construct_datadict(article_tree)
                    glossary = np.array([[k,v] for k,v in content_d["glossary"].items()])
                    pmcid    = data["AccessionID"]
                    data = {
                        "introduction":  content_d["introduction"],
                        "methods":       content_d["methods"],
                        "results":       content_d["results"],
                        "discussion":    content_d["discussion"],
                        "conclusion":    content_d["conclusion"],
                        "front":         content_d["front"],
                        "body":          content_d["body"],
                        "back":          content_d["back"],
                        "figure":        content_d["figure"],
                        "table":         content_d["table"],
                        "formula":       content_d["formula"],
                        "box":           content_d["box"],
                        "code":          content_d["code"],
                        "quote":         content_d["quote"],
                        "chem":          content_d["chem"],
                        "supplementary": content_d["supplementary"],
                        "footnote":      content_d["footnote"],
                        "graphic":       content_d["graphic"],
                        "media":         content_d["media"],
                        
                        # "question":         content_d["question"],
                        "unknown_pub": content_d["unknown_pub"],
                        "references": reference_d,
                        "references_text": reference_text_d,
                        "glossary": {"acronym":glossary[:,0], "definition":glossary[:,1]} if len(glossary)>0 else {"acronym":[], "definition":[]},
                        "n_references": n_ref,
                        "pmid": data["PMID"],
                        "accession_id": pmcid,
                        "license": data["License"],
                        "last_updated": data["LastUpdated (YYYY-MM-DD HH:MM:SS)"],
                        "retracted": data["Retracted"],
                        "citation": data["Article Citation"],
                        "package_file": data["File"],
                    }

                    yield pmcid, data

            except FileNotFoundError:  # non-commercial PMC000xxxxxx baseline does not exist
                continue
                
        # Incrementals
        # if incremental_file_lists:
            # for incremental_file_list, incremental_archive in zip(incremental_file_lists, incremental_archives):
                # incrementals = pd.read_csv(incremental_file_list, index_col="Article File").to_dict(orient="index")
                # for path, file in incremental_archive:
                    # ...
                    # 
                    # yield key, data