Initial deploy - HaRC reference checker

README.md

@@ -1,12 +1,36 @@
 ---
-title: Harc
+title: HaRC - Hallucinated Reference Checker
 emoji: 📚
-colorFrom: gray
-colorTo: green
+colorFrom: purple
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.4.0
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
+license: mit
+short_description: Verify academic references against databases
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# HaRC - Hallucinated Reference Checker
+
+Verify your paper's references against academic databases before submission.
+
+## Features
+
+- **Upload PDF** - Extract and check references automatically
+- **Paste BibTeX** - Check your `.bib` file directly
+- **Multiple databases** - Semantic Scholar, DBLP, Google Scholar, Open Library
+- **Fuzzy matching** - Handles author name variations and typos
+
+## How it works
+
+1. Upload your PDF or paste your BibTeX
+2. References are extracted and parsed
+3. Each reference is checked against academic databases
+4. Results show verified references and any issues found
+
+## Links
+
+- [GitHub Repository](https://github.com/gurusha01/HaRC)
+- [PyPI Package](https://pypi.org/project/harcx/)
+- [CLI Documentation](https://github.com/gurusha01/HaRC#readme)

app.py

@@ -0,0 +1,378 @@
+"""HaRC - Hallucinated Reference Checker (Hugging Face Spaces version)."""
+
+import re
+import tempfile
+from pathlib import Path
+
+import gradio as gr
+import pymupdf  # PyMuPDF
+
+from reference_checker import check_citations
+
+
+def extract_references_section(text: str) -> str:
+    """Extract the references/bibliography section from paper text."""
+    # Common section headers for references
+    patterns = [
+        r'\n\s*References\s*\n',
+        r'\n\s*REFERENCES\s*\n',
+        r'\n\s*Bibliography\s*\n',
+        r'\n\s*BIBLIOGRAPHY\s*\n',
+        r'\n\s*Works Cited\s*\n',
+        r'\n\s*Literature Cited\s*\n',
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            return text[match.end():]
+
+    # If no header found, return last 30% of document (often contains refs)
+    return text[int(len(text) * 0.7):]
+
+
+def parse_references_from_text(text: str) -> list[dict]:
+    """Parse individual references from extracted text.
+
+    Uses heuristics to identify reference boundaries and extract metadata.
+    """
+    references = []
+
+    # Clean up text
+    text = re.sub(r'\s+', ' ', text)
+
+    # Try to split by common reference patterns
+    # Pattern 1: [1], [2], etc.
+    numbered_refs = re.split(r'\[\d+\]\s*', text)
+    if len(numbered_refs) > 3:
+        refs_list = [r.strip() for r in numbered_refs if r.strip()]
+    else:
+        # Pattern 2: 1. 2. 3. etc at start of line
+        refs_list = re.split(r'(?:^|\n)\d+\.\s+', text)
+        refs_list = [r.strip() for r in refs_list if r.strip()]
+
+    if len(refs_list) < 3:
+        # Pattern 3: Split by author name patterns (Name, Initial.)
+        refs_list = re.split(r'(?<=[.?!])\s+(?=[A-Z][a-z]+,?\s+[A-Z]\.)', text)
+        refs_list = [r.strip() for r in refs_list if r.strip() and len(r) > 30]
+
+    for ref_text in refs_list[:100]:  # Limit to 100 refs
+        ref = parse_single_reference(ref_text)
+        if ref and ref.get('title'):
+            references.append(ref)
+
+    return references
+
+
+def parse_single_reference(text: str) -> dict | None:
+    """Parse a single reference string into structured data."""
+    if len(text) < 20:
+        return None
+
+    ref = {}
+
+    # Extract year (4 digits, typically 1900-2099)
+    year_match = re.search(r'\b(19|20)\d{2}\b', text)
+    if year_match:
+        ref['year'] = year_match.group()
+
+    # Extract DOI if present
+    doi_match = re.search(r'10\.\d{4,}/[^\s]+', text)
+    if doi_match:
+        ref['doi'] = doi_match.group().rstrip('.')
+
+    # Extract arXiv ID if present
+    arxiv_match = re.search(r'arXiv:(\d{4}\.\d{4,5})', text, re.IGNORECASE)
+    if arxiv_match:
+        ref['arxiv'] = arxiv_match.group(1)
+
+    # Try to extract title (usually in quotes or after authors, before journal)
+    # Pattern: Look for text in quotes
+    title_match = re.search(r'["\u201c]([^"\u201d]+)["\u201d]', text)
+    if title_match:
+        ref['title'] = title_match.group(1).strip()
+    else:
+        # Heuristic: title is often after year and authors, before journal/venue
+        # Take a reasonable chunk after the year
+        if year_match:
+            after_year = text[year_match.end():].strip()
+            # Remove leading punctuation
+            after_year = re.sub(r'^[.,)\]]\s*', '', after_year)
+            # Take first sentence-like chunk
+            title_candidate = re.split(r'[.!?]', after_year)[0].strip()
+            if 10 < len(title_candidate) < 200:
+                ref['title'] = title_candidate
+
+    # If still no title, try beginning of text (before year)
+    if not ref.get('title') and year_match:
+        before_year = text[:year_match.start()].strip()
+        # Look for the last comma-separated segment before year as potential title
+        parts = before_year.rsplit('.', 1)
+        if len(parts) > 1 and len(parts[-1].strip()) > 10:
+            ref['title'] = parts[-1].strip()
+
+    # Extract authors (usually at the beginning)
+    if year_match:
+        author_text = text[:year_match.start()].strip()
+        # Clean up and extract author names
+        author_text = re.sub(r'[,.]$', '', author_text)
+        if author_text and len(author_text) < 500:
+            # Split by 'and' or comma
+            author_parts = re.split(r'\s+and\s+|,\s*', author_text)
+            authors = []
+            for part in author_parts:
+                part = part.strip()
+                # Filter out non-name parts
+                if part and len(part) > 2 and not part.isdigit():
+                    # Check if it looks like a name (has capital letter)
+                    if re.search(r'[A-Z]', part):
+                        authors.append(part)
+            if authors:
+                ref['authors'] = authors[:10]  # Limit to 10 authors
+
+    return ref if ref.get('title') else None
+
+
+def references_to_bibtex(references: list[dict]) -> str:
+    """Convert references to BibTeX format."""
+    entries = []
+
+    for i, ref in enumerate(references):
+        key = f"ref{i+1}"
+        entry_type = "article"
+
+        fields = []
+        if ref.get('title'):
+            # Escape special characters
+            title = ref['title'].replace('{', '\\{').replace('}', '\\}')
+            fields.append(f'  title = {{{title}}}')
+        if ref.get('authors'):
+            authors_str = ' and '.join(ref['authors'])
+            fields.append(f'  author = {{{authors_str}}}')
+        if ref.get('year'):
+            fields.append(f'  year = {{{ref["year"]}}}')
+        if ref.get('doi'):
+            fields.append(f'  doi = {{{ref["doi"]}}}')
+        if ref.get('arxiv'):
+            fields.append(f'  eprint = {{{ref["arxiv"]}}}')
+            fields.append('  archiveprefix = {arXiv}')
+
+        if fields:
+            entry = f"@{entry_type}{{{key},\n"
+            entry += ",\n".join(fields)
+            entry += "\n}"
+            entries.append(entry)
+
+    return "\n\n".join(entries)
+
+
+def process_pdf(pdf_file) -> tuple[str, str, str]:
+    """Process uploaded PDF and check references.
+
+    Returns: (summary, issues_text, verified_text)
+    """
+    if pdf_file is None:
+        return "Please upload a PDF file.", "", ""
+
+    try:
+        # Extract text from PDF
+        doc = pymupdf.open(pdf_file.name)
+        full_text = ""
+        for page in doc:
+            full_text += page.get_text()
+        doc.close()
+
+        if not full_text.strip():
+            return "Could not extract text from PDF. The file might be scanned/image-based.", "", ""
+
+        # Extract references section
+        refs_text = extract_references_section(full_text)
+
+        # Parse references
+        references = parse_references_from_text(refs_text)
+
+        if not references:
+            return "No references could be extracted from the PDF.", "", ""
+
+        # Convert to BibTeX
+        bibtex = references_to_bibtex(references)
+
+        # Save to temp file and check
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.bib', delete=False) as f:
+            f.write(bibtex)
+            bib_path = f.name
+
+        try:
+            issues = check_citations(bib_path, verbose=False)
+            issue_keys = {r.entry.key for r in issues}
+        finally:
+            Path(bib_path).unlink(missing_ok=True)
+
+        # Build results
+        verified = []
+        problems = []
+
+        for i, ref in enumerate(references):
+            key = f"ref{i+1}"
+            title = ref.get('title', 'Unknown')
+            authors = ', '.join(ref.get('authors', [])[:3])
+            if len(ref.get('authors', [])) > 3:
+                authors += ' et al.'
+            year = ref.get('year', '')
+
+            if key in issue_keys:
+                issue = next(r for r in issues if r.entry.key == key)
+                problems.append(f"**{title}**\n  {authors} ({year})\n  *Issue: {issue.message}*")
+            else:
+                verified.append(f"**{title}**\n  {authors} ({year})")
+
+        # Summary
+        total = len(references)
+        verified_count = len(verified)
+        issues_count = len(problems)
+
+        summary = f"## Results\n\n"
+        summary += f"- **Total references found:** {total}\n"
+        summary += f"- **Verified:** {verified_count}\n"
+        summary += f"- **Issues found:** {issues_count}\n"
+
+        if issues_count == 0:
+            summary += "\n All references verified successfully!"
+        elif issues_count > total * 0.5:
+            summary += "\n Many issues found - some may be due to parsing errors."
+
+        issues_text = "\n\n".join(problems) if problems else "No issues found!"
+        verified_text = "\n\n".join(verified) if verified else "No verified references."
+
+        return summary, issues_text, verified_text
+
+    except Exception as e:
+        return f"Error processing PDF: {str(e)}", "", ""
+
+
+def process_bibtex(bibtex_text: str) -> tuple[str, str, str]:
+    """Process pasted BibTeX and check references."""
+    if not bibtex_text.strip():
+        return "Please paste your BibTeX content.", "", ""
+
+    try:
+        # Save to temp file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.bib', delete=False) as f:
+            f.write(bibtex_text)
+            bib_path = f.name
+
+        try:
+            from reference_checker.parser import parse_bib_file
+            entries = parse_bib_file(bib_path)
+            issues = check_citations(bib_path, verbose=False)
+            issue_keys = {r.entry.key for r in issues}
+        finally:
+            Path(bib_path).unlink(missing_ok=True)
+
+        # Build results
+        verified = []
+        problems = []
+
+        for entry in entries:
+            authors = ', '.join(entry.authors[:3])
+            if len(entry.authors) > 3:
+                authors += ' et al.'
+
+            if entry.key in issue_keys:
+                issue = next(r for r in issues if r.entry.key == entry.key)
+                problems.append(f"**[{entry.key}] {entry.title}**\n  {authors} ({entry.year})\n  *Issue: {issue.message}*")
+            else:
+                verified.append(f"**[{entry.key}] {entry.title}**\n  {authors} ({entry.year})")
+
+        # Summary
+        total = len(entries)
+        verified_count = len(verified)
+        issues_count = len(problems)
+
+        summary = f"## Results\n\n"
+        summary += f"- **Total entries:** {total}\n"
+        summary += f"- **Verified:** {verified_count}\n"
+        summary += f"- **Issues found:** {issues_count}\n"
+
+        if issues_count == 0:
+            summary += "\n All references verified successfully!"
+
+        issues_text = "\n\n".join(problems) if problems else "No issues found!"
+        verified_text = "\n\n".join(verified) if verified else "No verified references."
+
+        return summary, issues_text, verified_text
+
+    except Exception as e:
+        return f"Error processing BibTeX: {str(e)}", "", ""
+
+
+# Build Gradio interface
+with gr.Blocks(
+    title="HaRC - Hallucinated Reference Checker",
+    theme=gr.themes.Soft(primary_hue="purple"),
+) as demo:
+    gr.Markdown("""
+    # HaRC - Hallucinated Reference Checker
+
+    Verify your paper's references against academic databases.
+    Catches fake, misspelled, or incorrect citations before submission.
+
+    **Checks against:** Semantic Scholar, DBLP, Google Scholar, Open Library
+    """)
+
+    with gr.Tabs():
+        with gr.TabItem("Upload PDF"):
+            gr.Markdown("Upload your paper and we'll extract and verify the references.")
+            pdf_input = gr.File(label="Upload PDF", file_types=[".pdf"])
+            pdf_button = gr.Button("Check References", variant="primary")
+
+            with gr.Row():
+                pdf_summary = gr.Markdown(label="Summary")
+
+            with gr.Row():
+                with gr.Column():
+                    pdf_issues = gr.Markdown(label="Issues Found")
+                with gr.Column():
+                    pdf_verified = gr.Markdown(label="Verified References")
+
+            pdf_button.click(
+                fn=process_pdf,
+                inputs=[pdf_input],
+                outputs=[pdf_summary, pdf_issues, pdf_verified],
+            )
+
+        with gr.TabItem("Paste BibTeX"):
+            gr.Markdown("Paste your `.bib` file contents directly.")
+            bib_input = gr.Textbox(
+                label="BibTeX Content",
+                placeholder="@article{example2023,\n  title = {Example Paper},\n  author = {John Doe},\n  year = {2023}\n}",
+                lines=10,
+            )
+            bib_button = gr.Button("Check References", variant="primary")
+
+            with gr.Row():
+                bib_summary = gr.Markdown(label="Summary")
+
+            with gr.Row():
+                with gr.Column():
+                    bib_issues = gr.Markdown(label="Issues Found")
+                with gr.Column():
+                    bib_verified = gr.Markdown(label="Verified References")
+
+            bib_button.click(
+                fn=process_bibtex,
+                inputs=[bib_input],
+                outputs=[bib_summary, bib_issues, bib_verified],
+            )
+
+    gr.Markdown("""
+    ---
+    **Note:** PDF reference extraction uses heuristics and may not be 100% accurate.
+    For best results, use the BibTeX tab with your actual `.bib` file.
+
+    [GitHub](https://github.com/gurusha01/HaRC) | [PyPI](https://pypi.org/project/harcx/)
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.0.0
+pymupdf>=1.23.0
+harcx>=0.2.0