academic-refchecker 1.2.46__tar.gz → 1.2.48__tar.gz

{academic_refchecker-1.2.46/src/academic_refchecker.egg-info → academic_refchecker-1.2.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: academic-refchecker
-Version: 1.2.46
+Version: 1.2.48
 Summary: A comprehensive tool for validating reference accuracy in academic papers
 Author-email: Mark Russinovich <markrussinovich@hotmail.com>
 License-Expression: MIT

{academic_refchecker-1.2.46 → academic_refchecker-1.2.48}/src/__version__.py

@@ -1,3 +1,3 @@
 """Version information for RefChecker."""
 
-__version__ = "1.2.46"
+__version__ = "1.2.48"

{academic_refchecker-1.2.46 → academic_refchecker-1.2.48/src/academic_refchecker.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: academic-refchecker
-Version: 1.2.46
+Version: 1.2.48
 Summary: A comprehensive tool for validating reference accuracy in academic papers
 Author-email: Mark Russinovich <markrussinovich@hotmail.com>
 License-Expression: MIT

{academic_refchecker-1.2.46 → academic_refchecker-1.2.48}/src/checkers/local_semantic_scholar.py

@@ -430,11 +430,22 @@ class LocalNonArxivReferenceChecker:
                 logger.debug(f"Local DB: Author mismatch - {author_error}")
                 errors.append(create_author_error(author_error, paper_data.get('authors', [])))
         
-        # Verify year
+        # Verify year (with tolerance)
         paper_year = paper_data.get('year')
-        if year and paper_year and year != paper_year:
-            logger.debug(f"Local DB: Year mismatch - cited: {year}, actual: {paper_year}")
-            errors.append(create_year_warning(year, paper_year))
+        if year and paper_year:
+            # Get year tolerance from config (default to 1 if not available)
+            year_tolerance = 1  # Default tolerance
+            try:
+                from config.settings import get_config
+                config = get_config()
+                year_tolerance = config.get('text_processing', {}).get('year_tolerance', 1)
+            except (ImportError, Exception):
+                pass  # Use default if config not available
+            
+            # Only flag as mismatch if the difference is greater than tolerance
+            if abs(year - paper_year) > year_tolerance:
+                logger.debug(f"Local DB: Year mismatch - cited: {year}, actual: {paper_year}")
+                errors.append(create_year_warning(year, paper_year))
         
         # Verify DOI
         paper_doi = None

{academic_refchecker-1.2.46 → academic_refchecker-1.2.48}/src/core/refchecker.py

@@ -1922,16 +1922,27 @@ class ArxivReferenceChecker:
                     'ref_authors_correct': ', '.join(correct_names)
                 })
         
-        # Verify year
+        # Verify year (with tolerance)
         paper_year = paper_data.get('year')
-        if year and paper_year and year != paper_year:
-            logger.debug(f"DB Verification: Year mismatch - cited: {year}, actual: {paper_year}")
-            from utils.error_utils import format_year_mismatch
-            errors.append({
-                'warning_type': 'year',
-                'warning_details': format_year_mismatch(year, paper_year),
-                'ref_year_correct': paper_year
-            })
+        if year and paper_year:
+            # Get year tolerance from config (default to 1 if not available)
+            year_tolerance = 1  # Default tolerance
+            try:
+                from config.settings import get_config
+                config = get_config()
+                year_tolerance = config.get('text_processing', {}).get('year_tolerance', 1)
+            except (ImportError, Exception):
+                pass  # Use default if config not available
+            
+            # Only flag as mismatch if the difference is greater than tolerance
+            if abs(year - paper_year) > year_tolerance:
+                logger.debug(f"DB Verification: Year mismatch - cited: {year}, actual: {paper_year}")
+                from utils.error_utils import format_year_mismatch
+                errors.append({
+                    'warning_type': 'year',
+                    'warning_details': format_year_mismatch(year, paper_year),
+                    'ref_year_correct': paper_year
+                })
         
         # Verify DOI
         if doi and external_ids.get('DOI'):
@@ -2626,9 +2637,19 @@ class ArxivReferenceChecker:
             
             # Generate corrected reference using all available corrections
             corrected_data = self._extract_corrected_data_from_error(consolidated_entry, verified_data)
-            corrected_format = format_corrected_reference(reference, corrected_data, consolidated_entry)
-            if corrected_format:
-                consolidated_entry['ref_corrected_format'] = corrected_format
+            
+            # Generate all three formats for user convenience
+            from utils.text_utils import format_corrected_plaintext, format_corrected_bibtex, format_corrected_bibitem
+            plaintext_format = format_corrected_plaintext(reference, corrected_data, consolidated_entry)
+            bibtex_format = format_corrected_bibtex(reference, corrected_data, consolidated_entry)
+            bibitem_format = format_corrected_bibitem(reference, corrected_data, consolidated_entry)
+            
+            if plaintext_format:
+                consolidated_entry['ref_corrected_plaintext'] = plaintext_format
+            if bibtex_format:
+                consolidated_entry['ref_corrected_bibtex'] = bibtex_format
+            if bibitem_format:
+                consolidated_entry['ref_corrected_bibitem'] = bibitem_format
             
             # Store the consolidated entry (write to file at end of run)
             self.errors.append(consolidated_entry)
@@ -2685,11 +2706,21 @@ class ArxivReferenceChecker:
             if error_type != 'unverified':
                 error_entry['ref_standard_format'] = self.format_standard_reference(error)
                 
-                # Generate corrected reference in original format
+                # Generate corrected reference in all formats for user convenience
                 corrected_data = self._extract_corrected_data_from_error(error, verified_data)
-                corrected_format = format_corrected_reference(reference, corrected_data, error_entry)
-                if corrected_format:
-                    error_entry['ref_corrected_format'] = corrected_format
+                
+                # Generate all three formats
+                from utils.text_utils import format_corrected_plaintext, format_corrected_bibtex, format_corrected_bibitem
+                plaintext_format = format_corrected_plaintext(reference, corrected_data, error_entry)
+                bibtex_format = format_corrected_bibtex(reference, corrected_data, error_entry)
+                bibitem_format = format_corrected_bibitem(reference, corrected_data, error_entry)
+                
+                if plaintext_format:
+                    error_entry['ref_corrected_plaintext'] = plaintext_format
+                if bibtex_format:
+                    error_entry['ref_corrected_bibtex'] = bibtex_format
+                if bibitem_format:
+                    error_entry['ref_corrected_bibitem'] = bibitem_format
             else:
                 error_entry['ref_standard_format'] = None
             
@@ -2761,8 +2792,29 @@ class ArxivReferenceChecker:
                         f.write(f"  {error_entry['ref_verified_url']}\n")
                         f.write("\n")
                     
-                    # Show corrected reference in original format if available
-                    if error_entry.get('ref_corrected_format'):
+                    # Show corrected reference in all formats if available
+                    formats_written = False
+                    
+                    # Plain text format
+                    if error_entry.get('ref_corrected_plaintext'):
+                        f.write("CORRECTED REFERENCE (Plain Text):\n")
+                        f.write(f"{error_entry['ref_corrected_plaintext']}\n\n")
+                        formats_written = True
+                    
+                    # BibTeX format
+                    if error_entry.get('ref_corrected_bibtex'):
+                        f.write("CORRECTED REFERENCE (BibTeX):\n")
+                        f.write(f"{error_entry['ref_corrected_bibtex']}\n\n")
+                        formats_written = True
+                    
+                    # Bibitem/LaTeX format  
+                    if error_entry.get('ref_corrected_bibitem'):
+                        f.write("CORRECTED REFERENCE (LaTeX/Biblatex):\n")
+                        f.write(f"{error_entry['ref_corrected_bibitem']}\n\n")
+                        formats_written = True
+                    
+                    # Fallback to legacy format if no new formats available
+                    if not formats_written and error_entry.get('ref_corrected_format'):
                         f.write("CORRECTED REFERENCE:\n")
                         f.write(f"{error_entry['ref_corrected_format']}\n\n")
                     

{academic_refchecker-1.2.46 → academic_refchecker-1.2.48}/src/utils/doi_utils.py

@@ -99,9 +99,8 @@ def compare_dois(doi1: str, doi2: str) -> bool:
     """
     Compare two DOIs for equality, handling different formats and prefixes.
     
-    This function performs exact matching after normalization, which means
-    DOIs are only considered equal if they are identical after removing
-    prefixes, case differences, and punctuation.
+    This function performs exact matching after normalization, with support
+    for partial DOI citations where a shorter DOI is a valid prefix of a longer one.
     
     Args:
         doi1: First DOI to compare
@@ -117,8 +116,27 @@ def compare_dois(doi1: str, doi2: str) -> bool:
     norm_doi1 = normalize_doi(doi1)
     norm_doi2 = normalize_doi(doi2)
 
-    # DOIs must be exactly identical after normalization
-    return norm_doi1 == norm_doi2
+    # First try exact match
+    if norm_doi1 == norm_doi2:
+        return True
+    
+    # Handle partial DOI citations - if one DOI is a prefix of the other, consider it a match
+    # This handles cases like "10.1007" being cited instead of the full "10.1007/s10458-025-09691-y"
+    if len(norm_doi1) != len(norm_doi2):
+        shorter_doi = norm_doi1 if len(norm_doi1) < len(norm_doi2) else norm_doi2
+        longer_doi = norm_doi2 if len(norm_doi1) < len(norm_doi2) else norm_doi1
+        
+        # Only consider it a valid partial match if:
+        # 1. The shorter DOI is at least 7 characters (e.g., "10.1007")
+        # 2. The longer DOI starts with the shorter DOI
+        # 3. The next character in the longer DOI is '/' or '.' (valid DOI separators)
+        if (len(shorter_doi) >= 7 and 
+            longer_doi.startswith(shorter_doi) and 
+            len(longer_doi) > len(shorter_doi) and
+            longer_doi[len(shorter_doi)] in ['/', '.']):
+            return True
+    
+    return False
 
 
 def construct_doi_url(doi: str) -> str:

{academic_refchecker-1.2.46 → academic_refchecker-1.2.48}/src/utils/error_utils.py

@@ -183,6 +183,14 @@ def clean_venue_for_comparison(venue: str) -> str:
     return normalize_venue_for_display(venue)
 
 
+def format_missing_venue(correct_venue: str) -> str:
+    """
+    Format a missing venue message with only the actual value.
+    """
+    # Only show the actual venue; omit the empty cited line
+    return f"Missing venue: '{correct_venue}'"
+
+
 def create_venue_warning(cited_venue: str, correct_venue: str) -> Dict[str, str]:
     """
     Create a standardized venue warning dictionary.
@@ -197,7 +205,15 @@ def create_venue_warning(cited_venue: str, correct_venue: str) -> Dict[str, str]
     # Clean both venues for display in the warning
     clean_cited = clean_venue_for_comparison(cited_venue)
     clean_correct = clean_venue_for_comparison(correct_venue)
-    
+
+    # If cited venue cleans to empty, treat as missing venue instead of mismatch
+    if not clean_cited and clean_correct:
+        return {
+            'warning_type': 'venue',
+            'warning_details': format_missing_venue(clean_correct),
+            'ref_venue_correct': correct_venue
+        }
+
     return {
         'warning_type': 'venue',
         'warning_details': format_three_line_mismatch("Venue mismatch", clean_cited, clean_correct),

{academic_refchecker-1.2.46 → academic_refchecker-1.2.48}/src/utils/text_utils.py

@@ -506,8 +506,10 @@ def clean_author_name(author):
     # Fix spacing around periods in initials (e.g., "Y . Li" -> "Y. Li")
     author = re.sub(r'(\w)\s+\.', r'\1.', author)
     
-    # Remove common prefixes/suffixes
-    author = re.sub(r'\b(Dr\.?|Prof\.?|Professor|Mr\.?|Ms\.?|Mrs\.?)\s*', '', author, flags=re.IGNORECASE)
+    # Remove common honorific prefixes only when they are standalone at the start (require trailing whitespace)
+    # Previous pattern falsely removed the leading "Mr" from names like "Mrinmaya" due to optional whitespace.
+    # Anchor to start and require at least one space after the title to avoid stripping inside longer names.
+    author = re.sub(r'^(?:Dr|Prof|Professor|Mr|Ms|Mrs)\.?\s+', '', author, flags=re.IGNORECASE)
     
     # Remove email addresses
     author = re.sub(r'\S+@\S+\.\S+', '', author)
@@ -2100,7 +2102,7 @@ def compare_authors(cited_authors: list, correct_authors: list, normalize_func=N
                 # Use standardized three-line formatting for author mismatch
                 cited_display = format_author_for_display(cited_author)
                 full_author_list = ', '.join(correct_names)
-                error_msg = format_author_mismatch(i+1, f"{cited_display} (not found in author list - et al case)", f"Correct authors: {full_author_list}")
+                error_msg = format_author_mismatch(i+1, f"{cited_display} (not found in author list - et al case)", f"{full_author_list}")
                 return False, error_msg
         
         return True, f"Authors match (verified {len(cleaned_cited)} of {len(correct_names)} with et al)"
@@ -3588,6 +3590,12 @@ def calculate_title_similarity(title1: str, title2: str) -> float:
     # Normalize titles for comparison
     t1 = title1.lower().strip()
     t2 = title2.lower().strip()
+
+    # Remove trailing year suffixes like ", 2024" or " 2024" for robust matching
+    def strip_trailing_year(s: str) -> str:
+        return re.sub(r"[,\s]*\b(19|20)\d{2}\b\s*$", "", s).strip()
+    t1 = strip_trailing_year(t1)
+    t2 = strip_trailing_year(t2)
     
     # Exact match
     if t1 == t2:
@@ -4676,6 +4684,13 @@ def normalize_venue_for_display(venue: str) -> str:
     
     venue_text = venue.strip()
     
+    # Strip leading editor name lists like "..., editors, Venue ..." or "..., eds., Venue ..."
+    # This prevents author/editor lists from being treated as venue
+    # Match 'editors,' 'editor,' or 'eds.,' possibly after a comma; capture the remainder as venue
+    editors_match = re.search(r"(?:^|,)\s*(?:editors?|eds?\.?|editor)\s*,\s*(.+)$", venue_text, re.IGNORECASE)
+    if editors_match:
+        venue_text = editors_match.group(1).strip()
+    
     # Extract venue from complex editor strings (e.g. "In Smith, J.; and Doe, K., eds., Conference Name, volume 1")
     # This handles patterns like "In [authors], eds., [venue], [optional metadata]" (case-insensitive)
     editor_match = re.search(r'in\s+[^,]+(?:,\s*[^,]*)*,\s*eds?\.,\s*(.+?)(?:,\s*volume\s*\d+|,\s*pp?\.|$)', venue_text, re.IGNORECASE)
@@ -4702,7 +4717,9 @@ def normalize_venue_for_display(venue: str) -> str:
     prefixes_to_remove = [
         r'^\d{4}\s+\d+(st|nd|rd|th)\s+',  # "2012 IEEE/RSJ"
         r'^\d{4}\s+',                     # "2024 "
-        r'^proceedings\s+(of\s+)?(the\s+)?((acm|ieee|usenix|aaai|sigcomm|sigkdd|sigmod|sigops|vldb|osdi|sosp|eurosys)\s+)*(\d+(st|nd|rd|th)\s+)?',  # "Proceedings of the [ORG] [ORG] 29th"
+    # Remove 'Proceedings of [the] [ORG]* [ordinal]*' only when followed by at least one word
+    # This avoids cutting a venue down to just 'Proceedings of the'
+    r'^proceedings\s+of\s+(?!the\s*$)(?:the\s+)?(?:(?:acm|ieee|usenix|aaai|sigcomm|sigkdd|sigmod|sigops|vldb|osdi|sosp|eurosys)\s+)*(?:\d+(?:st|nd|rd|th)\s+)?',
         r'^proc\.\s+of\s+(the\s+)?(\d+(st|nd|rd|th)\s+)?(ieee\s+)?',        # "Proc. of the IEEE" (require "of")
         r'^procs\.\s+of\s+(the\s+)?(\d+(st|nd|rd|th)\s+)?(ieee\s+)?',       # "Procs. of the IEEE" (require "of")
         r'^in\s+',
@@ -4741,4 +4758,8 @@ def normalize_venue_for_display(venue: str) -> str:
     venue_text = re.sub(r'\s+', ' ', venue_text)     # Normalize whitespace
     venue_text = venue_text.strip()
     
+    # If what's left is too generic (e.g., just 'Proceedings of the'), treat as no venue
+    if venue_text.lower() in {"proceedings of the", "proceedings of"}:
+        return ""
+    
     return venue_text