Update pubmed25_debug.py

pubmed25_debug.py

@@ -582,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
 
-                                # Validate the final structure against the features schema
+                                # --- !!! 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)
+
+                                # --- 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