Update parquet files

README.md

@@ -1,219 +0,0 @@
----
-pretty_name: XML-parsed PMC
-task_categories:
-- text-classification
-- summarization
-- other
-annotations_creators:
-- no-annotation
-language_creators:
-- expert-generated
-language:
-- en
-size_categories:
-- 1M<n<10M
-source_datasets:
-- original
-license:
-- cc0-1.0
-- cc-by-4.0
-- cc-by-sa-4.0
-- cc-by-nc-4.0
-- cc-by-nd-4.0
-- cc-by-nc-nd-4.0
-- cc-by-nc-sa-4.0
-- unknown
-- other
-multilinguality:
-- monolingual
-task_ids: []
-tags:
-- research papers
-- biology
-- medecine
----
-
-# Dataset Card for PMC Open Access XML
-
-## Table of Contents
-- [Dataset Description](#dataset-description)
-  - [Dataset Summary](#dataset-summary)
-  - [Supported Tasks](#supported-tasks-and-leaderboards)
-  - [Languages](#languages)
-- [Dataset Structure](#dataset-structure)
-  - [Data Instances](#data-instances)
-  - [Data Fields](#data-instances)
-  - [Data Splits](#data-instances)
-- [Dataset Creation](#dataset-creation)
-  - [Curation Rationale](#curation-rationale)
-  - [Source Data](#source-data)
-  - [Annotations](#annotations)
-  - [Personal and Sensitive Information](#personal-and-sensitive-information)
-- [Considerations for Using the Data](#considerations-for-using-the-data)
-  - [Social Impact of Dataset](#social-impact-of-dataset)
-  - [Discussion of Biases](#discussion-of-biases)
-  - [Other Known Limitations](#other-known-limitations)
-- [Additional Information](#additional-information)
-  - [Dataset Curators](#dataset-curators)
-  - [Licensing Information](#licensing-information)
-  - [Citation Information](#citation-information)
-
-## Dataset Description
-
-- **Homepage:** https://www.ncbi.nlm.nih.gov/pmc/tools/openftlist/
-- **Repository:** [Needs More Information]
-- **Paper:** [Needs More Information]
-- **Leaderboard:** [Needs More Information]
-- **Point of Contact:** [Needs More Information]
-
-### Dataset Summary
-
-The XML Open Access 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 reference with keywords in the text to external or internal
-resources (articles, figures, tables, formulas, boxed-text, quotes, code, footnotes, chemicals, graphics, medias).
-
-The dataset was initially created with relation-extraction tasks in mind, between the references in text and the content of the
-references (e.g. for PMID, by joining the refered article abstract from the pubmed dataset), but aims in a larger extent to provide
-a corpus of pre-annotated text for other tasks (e.g. figure caption to graphic, glossary definition detection, summarization).
-
-### Supported Tasks and Leaderboards
-
-[Needs More Information]
-
-### Languages
-
-[Needs More Information]
-
-## Dataset Structure
-
-### Data Fields
-
-- "accession_id": The PMC ID of the article
-- "pmid":         The PubMed ID of the article
-- "introduction": List of \<title\> and \<p\> elements in \<body\>, sharing their root with a \<title\> containing "introduction" or "background".
-- "methods":      Same as introduction with "method" keyword.
-- "results":      Same as introduction with "result" keyword.
-- "discussion":   Same as introduction with "discussion" keyword.
-- "conclusion":   Same as introduction with "conclusion" keyword. 
-- "front":        List of \<title\> and \<p\> elements in \<front\> after everything else has been searched.
-- "body":         List of \<title\> and \<p\> elements in \<body\> after everything else has been searched.
-- "back":         List of \<title\> and \<p\> elements in \<back\> after everything else has been searched.
-- "figure":       List of \<fig\> elements of the article.
-- "table":        List of \<table-wrap\> and \<array\> elements of the article.
-- "formula":      List of \<disp-formula\> and \<inline-formula\> elements of the article.
-- "box":          List of \<boxed-text\> elements of the article.
-- "code":         List of \<code\> elements of the article.
-- "quote":        List of \<disp-quote\> and \<speech\> elements of the article.
-- "chemical":     List of \<chem-struct-wrap\> elements of the article.
-- "supplementary": List of \<supplementary-material\> and \<inline-supplementary-material\> elements of the article.
-- "footnote":      List of \<fn-group\> and \<table-wrap-foot\> elements of the article.
-- "graphic":       List of \<graphic\> and \<inline-graphic\> elements of the article.
-- "media":         List of \<media\> and \<inline-media\> elements of the article.
-- "glossary": Glossary if found in the XML
-- "unknown_references": JSON of a dictionnary of each "tag":"text" for the reference that did not indicate a PMID
-- "n_references": Total number of references and unknown references
-- "license": The licence of the article
-- "retracted": If the article was retracted or not
-- "last_updated": Last update of the article
-- "citation": Citation of the article
-- "package_file": path to the folder containing the graphics and media files of the article (to append to the base URL: ftp.ncbi.nlm.nih.gov/pub/pmc/)
-
-In text, the references are in the form ##KEYWORD##IDX_REF##OLD_TEXT##, with keywords (REF, UREF, FIG, TAB, FORMU, BOX, CODE, QUOTE, CHEM, SUPPL, FOOTN, GRAPH, MEDIA) referencing respectively to "pubmed articles" (external), "unknown_references", "figure", "table", "formula", "box", "code", "quote", "chem", "supplementary", "footnote", "graphic" and "media".
-### Data Splits
-
-[Needs More Information]
-
-## Dataset Creation
-
-### Curation Rationale
-
-Internal references (figures, tables, ...) were found using specific tags. Deciding on those tags was done by testing and by looking in the documentation
-for the different kind of possible usage.
-Then, to split the article into introduction, methods, results, discussion and conclusion, specific keywords in titles were used. Because there are no rules
-in this xml to tag those sections, finding the keyword seemed like the most reliable approach to do so. A drawback is that many section do not have those 
-keywords in the titles but could be assimilated to those. However, the huge diversity in the titles makes it harder to label such sections. This could be the
-work of further versions of this dataset.
-
-### Source Data
-
-#### Initial Data Collection and Normalization
-
-Data was obtained from:
-- ftp.ncbi.nlm.nih.gov/pub/pmc/oa_bulk/oa_noncomm/xml/
-- ftp.ncbi.nlm.nih.gov/pub/pmc/oa_bulk/oa_comm/xml/
-- ftp.ncbi.nlm.nih.gov/pub/pmc/oa_bulk/oa_other/xml/
-
-Additional content for individual articles (graphics, media) can be obtained from:
-- ftp.ncbi.nlm.nih.gov/pub/pmc + "package_file"
-
-#### Who are the source language producers?
-
-[Needs More Information]
-
-### Annotations
-
-#### Annotation process
-
-[Needs More Information]
-
-#### Who are the annotators?
-
-[Needs More Information]
-
-### Personal and Sensitive Information
-
-[Needs More Information]
-
-## Considerations for Using the Data
-
-### Social Impact of Dataset
-
-[Needs More Information]
-
-### Discussion of Biases
-
-The articles XML are similar accross collections. This means that if a certain collection handles the structure in unusual ways, the whole collection might not be as
-well annotated than others. This concerns all the sections (intro, methods, ...), the external references (pmids) and the internal references (tables, figures, ...).
-To illustrate that, references are sometime given as a range (e.g. 10-15). In that case, only reference 10 and 15 are linked. This could potentially be handled in a
-future version.
-
-### Other Known Limitations
-
-[Needs More Information]
-
-### Preprocessing recommendations
-
-- Filter out empty contents.
-- Remove unwanted references from the text, and replace either by the "references_text" or by the reference content itself.
-- Unescape HTML special characters: `import html; html.unescape(my_text)`
-- Remove superfluous line break in text.
-- Remove XML tags (\<italic\>, \<sup\>, \<sub\>, ...), replace by special tokens? 
-- Join the items of the contents' lists.
-
-## Additional Information
-
-### Dataset Curators
-
-[Needs More Information]
-
-### Licensing Information
-
-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.
-
-### Citation Information
-
-[Needs More Information]

non_commercial/partial-train/0000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc9252ea998ed907ee5e2fc060ab55be88e32f2e78c9355c6c2e2aa3f7aef89a
+size 212504220

non_commercial/partial-train/0001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a24efca564e1b3573aa739bcba53f131c6a31e4683b2e38908d278c4cc85034c
+size 224176755

non_commercial/partial-train/0002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af66b0afaf5fe278854c521bb794f98a1ba55487901e26fb83de0656792d8c1a
+size 234243104

non_commercial/partial-train/0003.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d7c68c7bf75d74f53f3f79537842afd63dd185f7ecce4b3a6117d8db4e44e8a
+size 229292455

non_commercial/partial-train/0004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:115eb47159eb222b11a3867b9e618a420d4c9794b45e8fa6f5bbdf327209acf3
+size 224353264

non_commercial/partial-train/0005.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:062fa332166cad5dfe72386ca18520affeeaac6a09e2d9e7f621f6362650757a
+size 228341905

non_commercial/partial-train/0006.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38acb1fb3ac3948a9ba9641cf07485d50f6aebf33dc803197dd85f78ae0964b4
+size 234984993

non_commercial/partial-train/0007.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e2626e95395462aa09cbfdc468e02979f56662cd4a503b6f68b5aac0c57bfd8
+size 237959350

non_commercial/partial-train/0008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:573ffcd4306e7b31b344512c3461f844dc4043934e023722c69fe23f1ed00dbc
+size 230268880

non_commercial/partial-train/0009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78627db101d0d58c01330aedf01c451933823bfe7df6e65d210f6e7696a93d77
+size 173599458

pmc_open_access_xml.py

@@ -1,660 +0,0 @@
-# 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-11-18"
-
-REFS_KEYS     = ["pmid_ref", "unknown_pub_ref", "figure_ref", "table_ref", "formula_ref", "box_ref", "code_ref",
-                 "quote_ref", "chemical_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", "chemical", "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","chemical_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##4##Doe 2022##" for a figure,
-    "##TAB##0##Table 1##" for a table, or "##MATHS##1##(2)##" for mathematical formulas)
-
-    The range reference (e.g. 1-3 or 15-17) are replaced by their range (1,2,3 or 15,16,17)
-
-    Returns the parsed text
-    """
-    for xref in el.xpath(".//xref"):
-        inner_text = "".join(xref.itertext())
-        if inner_text == "":  # Removing "empty" references
-            tail    = xref.tail if xref.tail else ""
-            prev_el = xref.getprevious()
-            parent  = xref.getparent()
-            if prev_el is None:
-                parent.text  = "".join([(parent.text if parent.text else ""), tail])
-            else:
-                prev_el.tail = "".join([(prev_el.tail if prev_el.tail else ""), tail])
-            parent.remove(xref)
-
-    res_rid     = defaultdict(list)
-    res_reftext = defaultdict(list)
-    ref_rstart, ref_rstop = None, None
-    has_ref_range = None
-    for xref in el.xpath(".//xref[not(ancestor::xref)]"): #Ignore innermost of imbricated references
-        inner_text = "".join(xref.itertext())
-        parent  = xref.getparent()
-        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(inner_text)
-
-            tail    = xref.tail if xref.tail else ""
-            #### START HANDLING REF RANGE ########
-            try:
-                if has_ref_range is None:
-                    if ref_kword in ["UREF", "REF"]:                 # Otherwise it's a year
-                        has_ref_range = res_reftext[ref_class][-1].isnumeric() and int(res_reftext[ref_class][-1]) < 500
-
-                if has_ref_range and ref_kword in ["UREF", "REF"]:
-                    if tail=="-":
-                        ref_rstart = int(res_reftext[ref_class][-1])
-                        tail = ", "
-                    elif ref_rstart is not None:
-                        ref_rstop = int(res_reftext[ref_class][-1])
-                        new_ref_kwords = [f"##{ref_kword}##{ref_idx}##{inner_text}##"]
-                        for i in range(ref_rstart+1, ref_rstop):
-                            new_rid = re.sub(str(ref_rstop), str(i), rid, count=1)
-                            ref_idx_, ref_kword_, ref_class_ = rids[new_rid]
-                            res_rid[ref_class_].insert(-1, ref_idx_)
-                            res_reftext[ref_class_].insert(-1, str(i))
-                            new_ref_kwords.insert(-1, f"##{ref_kword_}##{ref_idx_}##{str(i)}##")
-                        ref_kword = ", ".join(new_ref_kwords)
-                        ref_rstart = None
-            except (KeyError, ValueError):
-                ref_rstart = None
-                continue  # The substitution failed, happen when text don't match the rid
-            #### END HANDLING REF RANGE ########
-
-            prev_el = xref.getprevious()
-            if prev_el is None:
-                parent.text  = "".join([(parent.text if parent.text else ""), f"##{ref_kword}##{ref_idx}##{inner_text}##", tail])
-            else:
-                prev_el.tail = "".join([(prev_el.tail if prev_el.tail else ""), f"##{ref_kword}##{ref_idx}##{inner_text}##", 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
-
-
-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 = {}
-
-    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 = 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 = parseout_el_refs(el, rids)
-
-        ref_class = rids[key][2]
-        text_l_d[ref_class].insert(0, new_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])
-
-    path_l, 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_t_paths, tmp_t_texts_lowcase  = [], []
-        part_el = article_tree.find(".//"+part)
-        if part_el is None:
-            res_content_d[part] = []
-            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 = parseout_el_refs(el, rids)
-            tmp_path_l.append(article_tree.getelementpath(el))
-            tmp_text_l.append(new_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
-            t_paths, t_texts_lowcase = tmp_t_paths, tmp_t_texts_lowcase
-        else:
-            res_content_d[part] = tmp_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] = []
-            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
-        res_content_d[name_section] = list(compress(text_l, mask_contents))
-
-    processed_mask = ~processed_mask #Finally, add the body part as everything that don't belong to previous categories
-    res_content_d["body"] = list(compress(text_l, processed_mask))
-
-    return (res_content_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")),
-                    "chemical":      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")}
-                    ),
-                    "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"
-                baseline_archive_url = f"{url}{basename}{baseline}.tar.gz"
-                try:
-                    baseline_file_list = dl_manager.download(baseline_file_list_url)
-                    baseline_archive = dl_manager.download(baseline_archive_url)
-                except FileNotFoundError:  # non-commercial PMC000xxxxxx baseline does not exist
-                    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]
-            for incremental in incrementals:
-                incremental_file_list_url = f"{url}{basename}{incremental}.filelist.csv"
-                incremental_archive_url = f"{url}{basename}{incremental}.tar.gz"
-                try:
-                    incremental_file_list = dl_manager.download(incremental_file_list_url)
-                    incremental_archive = dl_manager.download(incremental_archive_url)
-                except FileNotFoundError:  # Some increment might not exist
-                    continue
-                incremental_paths["incremental_file_lists"].append(incremental_file_list)
-                incremental_paths["incremental_archives"].append(incremental_archive)
-
-        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)
-        processed_ids = set()
-
-        # Incrementals
-        if incremental_file_lists:
-            for incremental_file_list, incremental_archive in zip(incremental_file_lists[::-1], incremental_archives[::-1]):
-                try:
-                    incrementals = pd.read_csv(incremental_file_list, index_col="AccessionID")
-                except FileNotFoundError:  # File not found can happen here in stream mode
-                    continue
-                incrementals = incrementals.join(oa_package_list).reset_index().set_index("Article File")
-                incrementals.File = incrementals.File.fillna('')
-                incrementals = incrementals.to_dict(orient="index")
-
-                for path, file in incremental_archive:
-                    data = incrementals.pop(path)
-                    pmcid = data["AccessionID"]
-                    if pmcid in processed_ids: #oa_package_list.loc[pmcid, "yet_processed"]:
-                        continue
-                    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, n_ref = construct_datadict(article_tree)
-                    glossary = np.array([[k,v] for k,v in content_d["glossary"].items()])
-                    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"],
-                        "chemical":      content_d["chemical"],
-                        "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"],
-                        "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"],
-                    }
-                    processed_ids.add(pmcid)
-                    yield pmcid, data
-
-        # 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.File = baselines.File.fillna('')
-            baselines = baselines.to_dict(orient="index")
-
-            for path, file in baseline_archive:
-                data = baselines.pop(path)
-                pmcid = data["AccessionID"]
-                if pmcid in processed_ids:
-                    continue
-                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, n_ref = construct_datadict(article_tree)
-                glossary = np.array([[k,v] for k,v in content_d["glossary"].items()])
-                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"],
-                    "chemical":      content_d["chemical"],
-                    "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"],
-                    "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"],
-                }
-                processed_ids.add(pmcid)
-                yield pmcid, data
-
-            #except FileNotFoundError:  # non-commercial PMC000xxxxxx baseline does not exist
-            #    continue