Big change, reference idx and text inside text

pmc_open_access_xml.py

@@ -71,15 +71,15 @@ _SUBSETS = {
 }
 _BASELINE_DATE = "2022-09-03"
 
-REFS_KEYS     = ["pmid_ref", "unknown_pub_ref", "figure_ref", "table_ref", "formula_ref", "box_ref", "code_ref", 
+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", 
+                 "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. 
+    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
@@ -93,16 +93,16 @@ def clean_raw(xml_text):
     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")}
+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):
     """
@@ -113,9 +113,9 @@ def get_ref_indexes(ref_el_l, refs_pmid, refs_nonpmid_keys):
     count_ref_d = defaultdict(lambda:0)
     reference_d = {}
     for k, v in refs_pmid.items():
-        reference_d[k] = (v, " ##REF## ", "pmid_ref")
+        reference_d[k] = (v, "REF", "pmid_ref")
     for i, k in enumerate(refs_nonpmid_keys):
-        reference_d[k] = (i, " ##UREF## ", "unknown_pub_ref")
+        reference_d[k] = (i, "UREF", "unknown_pub_ref")
 
     refs_key_l = []
     for el in ref_el_l:
@@ -133,15 +133,14 @@ def parseout_el_refs(el, rids):
     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)
+    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, 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## ")
+    Returns the parsed text
     """
     for xref in el.xpath(".//xref"):
         inner_text = "".join(xref.itertext())
@@ -172,22 +171,22 @@ def parseout_el_refs(el, rids):
             #### START HANDLING REF RANGE ########
             try:
                 if has_ref_range is None:
-                    if ref_kword in [" ##UREF## ", " ##REF## "]:                 # Otherwise it's a year
+                    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 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 = [ref_kword]
+                        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, ref_kword_)
+                            new_ref_kwords.insert(-1, f"##{ref_kword_}##{ref_idx_}##{str(i)}##")
                         ref_kword = ", ".join(new_ref_kwords)
                         ref_rstart = None
             except (KeyError, ValueError):
@@ -197,9 +196,9 @@ def parseout_el_refs(el, rids):
 
             prev_el = xref.getprevious()
             if prev_el is None:
-                parent.text  = "".join([(parent.text if parent.text else ""), ref_kword, tail])
+                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 ""), ref_kword, tail])
+                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')
@@ -212,7 +211,7 @@ def parseout_el_refs(el, rids):
 
     text = "".join([tag_txt, text[tag_start:]])
 
-    return text, res_rid, res_reftext
+    return text
 
 
 def get_references(article_tree):
@@ -226,7 +225,7 @@ def get_references(article_tree):
     references_nonpmid = []
     references_nonpmid_keys = []
     refs = article_tree.find(".//ref-list")
-    if refs is None: #Some don't have any references 
+    if refs is None: #Some don't have any references
         return {}, [], []
     refs = refs.findall("ref")
     for i, ref in enumerate(refs):
@@ -236,10 +235,10 @@ def get_references(article_tree):
                 pmid = int(pubid.text)
                 break
         if pmid is not None and pmid<100000000: 
-            #In an article (oa_comm:PMC2679651), broken PMID were found (>10e9). 
+            #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:
@@ -272,7 +271,7 @@ def construct_datadict(article_tree):
 
     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)
+    res_content_d = {}
 
     refs_pmid, refs_nonpmid, refs_nonpmid_keys = get_references(article_tree)
     reference_count = len(refs_pmid)+len(refs_nonpmid)
@@ -305,7 +304,7 @@ def construct_datadict(article_tree):
     # 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, {})
+        # 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"):
@@ -319,16 +318,14 @@ def construct_datadict(article_tree):
                                   |.//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)
+    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, new_xref_id, new_xref_text = parseout_el_refs(el, rids)
+        new_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
@@ -338,52 +335,30 @@ def construct_datadict(article_tree):
     # 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 = [], [], [], []
+
+    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_refs_l, tmp_refs_text_l = [], [], [], []
+        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] = []#""
-            for target_key in REFS_KEYS:
-                res_reference_d[part][target_key] = []
-                res_reference_text_d[part][target_key] = []
+            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, new_xref_id, new_xref_text = parseout_el_refs(el, rids)
+            new_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. 
+                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)
+            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)
@@ -395,10 +370,7 @@ def construct_datadict(article_tree):
     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] = []
+            res_content_d[name_section] = []
             continue
 
         filtered_path_l = list(compress(t_paths, mask))
@@ -407,17 +379,12 @@ def construct_datadict(article_tree):
         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)))
+        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
-    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)
+    res_content_d["body"] = list(compress(text_l, processed_mask))
 
-    return (res_content_d, res_reference_d, res_reference_text_d, reference_count)
+    return (res_content_d, reference_count)
 
 class OpenAccessXMLConfig(datasets.BuilderConfig):
     """BuilderConfig for the PMC Open Access Subset."""
@@ -456,7 +423,7 @@ class OpenAccessXML(datasets.GeneratorBasedBuilder):
                     "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")),
@@ -478,25 +445,6 @@ class OpenAccessXML(datasets.GeneratorBasedBuilder):
                     "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"),
@@ -606,7 +554,7 @@ class OpenAccessXML(datasets.GeneratorBasedBuilder):
                     except etree.XMLSyntaxError: #In some files, xml is broken
                         continue
 
-                    content_d, reference_d, reference_text_d, n_ref = construct_datadict(article_tree)
+                    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"],
@@ -630,8 +578,6 @@ class OpenAccessXML(datasets.GeneratorBasedBuilder):
                         "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"],
@@ -670,7 +616,7 @@ class OpenAccessXML(datasets.GeneratorBasedBuilder):
                 except etree.XMLSyntaxError: #In some files, xml is broken
                     continue
 
-                content_d, reference_d, reference_text_d, n_ref = construct_datadict(article_tree)
+                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"],
@@ -694,8 +640,6 @@ class OpenAccessXML(datasets.GeneratorBasedBuilder):
                     "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"],