Update pubmed25.py

pubmed25.py

@@ -12,28 +12,15 @@
 # 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.
-"""
-MEDLINE/PubMed data loader for Hugging Face Datasets.
-
-This script is based on the original NCBI PubMed dataset script from Hugging Face.
-Modifications by:
-- Hoang Ha (LIG): Updated for 2025 baseline structure and integrated full abstract parsing.
-- Tiziri Terkmani (Research Engineer, LIG, Team SIGMA): Enhanced abstract parsing logic was adapted for the NanoBubble Project: https://nanobubbles.hypotheses.org/
-
-**Important Caution:** The default URL configuration in this script is set up as an
-example and primarily targets files from the **2025 baseline**. To download data
-covering the full intended range (e.g., 2015-2025), you **MUST** modify the `_URLs`
-list below to include the correct file paths for **ALL** desired years from the
-NCBI FTP server (ftp://ftp.ncbi.nlm.nih.gov/pubmed/baseline/). The number of files
-per year varies. Use with caution and verify the downloaded data range.
-"""
+"""MEDLINE/PubMed data - Modified for full abstract text extraction."""
+
 
 import copy
 import gzip
 import xml.etree.ElementTree as ET # Using standard ElementTree
 
 import datasets
-
+import random
 
 logger = datasets.logging.get_logger(__name__)
 
@@ -53,9 +40,27 @@ _HOMEPAGE = "https://www.nlm.nih.gov/databases/download/pubmed_medline.html"
 
 _LICENSE = "" # Assuming standard NLM terms apply, check source for specifics
 
-# Example URLs - Replace with desired baseline/update files
-_URLs = [f"https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed25n{i:04d}.xml.gz" for i in range(800, 1274)]
+# Parameters
+total_files = 1274
+num_bins = 50
+total_urls = 20
+
+# Compute bin size
+bin_size = total_files // num_bins
+
+# Sample one random file from each bin
+selected_indices = []
+for b in range(num_bins):
+    start = b * bin_size + 1
+    end = min((b + 1) * bin_size + 1, total_files + 1)
+    if start < end:
+        selected_indices.append(random.randint(start, end - 1))
 
+# Ensure we only keep 20 URLs total (in case rounding leads to more)
+selected_indices = sorted(random.sample(selected_indices, total_urls))
+
+# Create URLs
+_URLs = [f"https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed25n{i:04d}.xml.gz" for i in range(1200, 1274)]
 
 # Copyright Ferry Boender, released under the MIT license.
 # Modified by @Narsil to handle more oddities
@@ -577,92 +582,85 @@ class Pubmed(datasets.GeneratorBasedBuilder):
 
 
     def _generate_examples(self, filenames):
-        """Yields examples parsing XML files using iterparse for memory efficiency."""
-        id_ = 0 # Simple counter for yielding unique keys for examples
+        """Yields examples parsing XML files using iterparse for memory efficiency, skipping duplicate PMIDs."""
+        # id_ = 0 # Simple counter if needed for logging, but not used as key anymore
+        yielded_pmids = set() # Keep track of PMIDs we've already yielded
 
         for filename in filenames:
             logger.info(f"Processing file: {filename}")
             try:
                 with gzip.open(filename, "rb") as f: # Read as bytes for ET
-                    # Use iterparse to process the XML incrementally
                     context = ET.iterparse(f, events=("end",))
-                    # Get the root element iterator (needed for clearing)
-                    event, root = next(context)
+                    event, root = next(context) # Get root iterator
 
                     for event, elem in context:
-                        # Process each PubmedArticle element when its closing tag is found
                         if event == "end" and elem.tag == "PubmedArticle":
-                            article_dict_wrapper = None # Reset for each article
+                            article_dict_wrapper = None
+                            pmid = "UNKNOWN_PMID" # Default for logging if extraction fails early
                             try:
-                                # Parse the completed element into our dictionary structure
                                 article_dict_wrapper = self.xml_to_dictionnary(elem)
-                                # Expected structure: {'PubmedArticle': {...actual data...}}
 
                                 if not article_dict_wrapper or 'PubmedArticle' not in article_dict_wrapper:
                                     logger.warning(f"Parser returned empty or invalid structure for a PubmedArticle element in {filename}")
-                                    elem.clear() # Free memory for this element
-                                    root.clear() # Periodically clear root too? Maybe not needed per element.
+                                    elem.clear()
                                     continue
 
                                 article = article_dict_wrapper.get('PubmedArticle')
-
-                                # Ensure the extracted article data is not empty
                                 if not article or not isinstance(article, dict):
                                     logger.warning(f"Parsed empty or invalid article data from element in {filename}")
                                     elem.clear()
                                     continue
 
-                                # --- Data Cleaning and Structuring ---
-                                # 1. Flatten the ReferenceList structure
-                                self.update_citation(article)
-
-                                # 2. Create the default structure expected by the schema
-                                new_article = default_article()
-
-                                # 3. Merge the parsed data into the default structure
-                                deepupdate(new_article, article)
-
-                                # --- Validation and Yielding ---
-                                # Retrieve PMID for yielding and logging (ensure it's valid)
-                                pmid_val = new_article.get("MedlineCitation", {}).get("PMID", 0)
-                                pmid = 0
+                                # --- Extract PMID early for duplicate check ---
+                                pmid_val = article.get("MedlineCitation", {}).get("PMID", 0)
                                 try:
                                     pmid = int(pmid_val)
                                     if pmid <= 0: raise ValueError("PMID must be positive")
                                 except (ValueError, TypeError):
                                     logger.warning(f"Skipping article due to invalid or missing PMID: '{pmid_val}' in {filename}")
                                     elem.clear()
-                                    continue # Skip this article
+                                    continue # Skip this article if PMID invalid
+
+                                # --- !!! DUPLICATE CHECK !!! ---
+                                if pmid in yielded_pmids:
+                                    logger.warning(f"Skipping duplicate PMID {pmid} found in {filename}.")
+                                    elem.clear()
+                                    continue # Skip this duplicate entry
+                                # --- End DUPLICATE CHECK ---
+
+                                # --- If not duplicate, proceed with processing ---
+                                self.update_citation(article)
+                                new_article = default_article()
+                                deepupdate(new_article, article)
 
-                                # Validate the final structure against the features schema
+                                # --- Final validation before yield (PMID check redundant but safe) ---
+                                final_pmid_check = new_article.get("MedlineCitation", {}).get("PMID", 0)
+                                if final_pmid_check != pmid:
+                                     logger.error(f"PMID mismatch after processing! Expected {pmid}, got {final_pmid_check}. Skipping article.")
+                                     elem.clear()
+                                     continue
+
+                                # Validate against schema
                                 encoded_example = self.info.features.encode_example(new_article)
 
                                 # Yield pmid as key and the validated dictionary
                                 yield pmid, new_article # Use actual PMID as the example key
-                                id_ += 1 # Increment processed count if needed
+                                yielded_pmids.add(pmid) # Add to set *after* successful yield
 
                             except Exception as e:
-                                # Catch errors during parsing, deepupdate, or encoding for a single article
-                                pmid_for_log = article.get("MedlineCitation", {}).get("PMID", "UNKNOWN") if 'article' in locals() else "UNKNOWN"
-                                logger.error(f"Failed to process article PMID {pmid_for_log} in {filename}: {e}", exc_info=True)
-                                # Optionally log the problematic article data (can be large)
+                                logger.error(f"Failed to process article PMID {pmid} in {filename}: {e}", exc_info=False) # exc_info=True for full traceback
+                                # Logging data causing error can be helpful but verbose:
                                 # if 'new_article' in locals(): logger.debug(f"Problematic data: {new_article}")
 
                             finally:
-                                # --- Memory Management ---
-                                # Crucial step for iterparse: clear the element and its descendants
-                                elem.clear()
-                                # Optionally, clear previous siblings from the root periodically
-                                # while root and root.getprevious() is not None:
-                                #    del root.getparent()[0]
-
-                    # Clear the root element after processing the file
+                                elem.clear() # Clear the element in all cases (success, skip, error)
+
                     if root is not None:
                         root.clear()
 
             except ET.ParseError as e:
                 logger.error(f"XML ParseError in file {filename}: {e}")
-                continue # Skip to the next file
+                continue
             except gzip.BadGzipFile:
                 logger.error(f"Bad Gzip File error for {filename}. It might be corrupted or incomplete.")
                 continue