| from dataclasses import dataclass |
| from datetime import datetime |
| from typing import Optional, List |
| from pathlib import Path |
|
|
| from ..parsers.bib_parser import BibEntry |
| from ..analyzers.metadata_comparator import ComparisonResult |
| from ..analyzers.duplicate_detector import DuplicateGroup |
|
|
|
|
| @dataclass |
| class EntryReport: |
| """Report for a single bib entry (bib-only: entry + comparison).""" |
| entry: BibEntry |
| comparison: Optional[ComparisonResult] |
|
|
|
|
| class ReportGenerator: |
| """Generates bibliography-only markdown reports.""" |
|
|
| def __init__( |
| self, |
| minimal_verified: bool = False, |
| check_preprint_ratio: bool = True, |
| preprint_warning_threshold: float = 0.50, |
| ): |
| self.entries: List[EntryReport] = [] |
| self.duplicate_groups: Optional[List[DuplicateGroup]] = None |
| self.bib_files: List[str] = [] |
| self.minimal_verified = minimal_verified |
| self.check_preprint_ratio = check_preprint_ratio |
| self.preprint_warning_threshold = preprint_warning_threshold |
|
|
| def add_entry_report(self, report: EntryReport): |
| self.entries.append(report) |
|
|
| def set_metadata(self, bib_files: str | List[str], tex_files: str | List[str] = None): |
| if isinstance(bib_files, str): |
| self.bib_files = [bib_files] |
| else: |
| self.bib_files = list(bib_files) if bib_files else [] |
|
|
| def set_duplicate_groups(self, groups: List[DuplicateGroup]): |
| self.duplicate_groups = groups |
|
|
| def _is_verified(self, entry: EntryReport) -> bool: |
| return not self._has_issues(entry) |
|
|
| def _has_issues(self, entry: EntryReport) -> bool: |
| return bool(entry.comparison and entry.comparison.has_issues) |
|
|
| def _is_preprint(self, entry: BibEntry) -> bool: |
| preprint_keywords = [ |
| "arxiv", "biorxiv", "medrxiv", "ssrn", "preprint", |
| "openreview", "techreport", "technical report", "working paper", |
| ] |
| if entry.entry_type.lower() in ["techreport", "unpublished", "misc"]: |
| text = " ".join([ |
| entry.journal.lower(), entry.booktitle.lower(), |
| entry.publisher.lower(), entry.entry_type.lower(), |
| ]) |
| if any(k in text for k in preprint_keywords): |
| return True |
| if entry.has_arxiv: |
| return True |
| venue = " ".join([entry.journal.lower(), entry.booktitle.lower(), entry.publisher.lower()]) |
| return any(k in venue for k in preprint_keywords) |
|
|
| def get_summary_stats(self) -> dict: |
| """Return bibliography issue counts only (no LaTeX).""" |
| total = len(self.entries) |
| title_mismatches = author_mismatches = year_mismatches = unable_to_verify = 0 |
| for e in self.entries: |
| if not e.comparison: |
| continue |
| if e.comparison.has_issues: |
| for issue in e.comparison.issues: |
| if "Title mismatch" in issue: |
| title_mismatches += 1 |
| elif "Author mismatch" in issue: |
| author_mismatches += 1 |
| elif "Year mismatch" in issue: |
| year_mismatches += 1 |
| elif "Unable to find" in issue: |
| unable_to_verify += 1 |
|
|
| stats = {} |
| if title_mismatches > 0: |
| stats["Title Mismatches"] = title_mismatches |
| if author_mismatches > 0: |
| stats["Author Mismatches"] = author_mismatches |
| if year_mismatches > 0: |
| stats["Year Mismatches"] = year_mismatches |
| if unable_to_verify > 0: |
| stats["Unable to Verify"] = unable_to_verify |
| if self.duplicate_groups: |
| stats["Duplicate Groups"] = len(self.duplicate_groups) |
| return stats |
|
|
| def _generate_issues_section(self) -> List[str]: |
| lines = ["## ⚠️ Critical Issues Detected", ""] |
| has_any = False |
|
|
| if self.duplicate_groups: |
| has_any = True |
| lines.append("### 🔄 Duplicate Entries") |
| for i, group in enumerate(self.duplicate_groups, 1): |
| lines.append(f"#### Group {i} (Similarity: {group.similarity_score:.0%})") |
| lines.append(f"**Reason:** {group.reason}") |
| lines.append("") |
| lines.append("| Key | Title | Year |") |
| lines.append("|-----|-------|------|") |
| for entry in group.entries: |
| lines.append(f"| `{entry.key}` | {entry.title} | {entry.year} |") |
| lines.append("") |
|
|
| issue_entries = [e for e in self.entries if self._has_issues(e)] |
| if issue_entries: |
| has_any = True |
| lines.append("### ⚠️ Metadata Issues") |
| for report in issue_entries: |
| lines.extend(self._format_entry_detail(report, is_verified=False)) |
|
|
| if not has_any: |
| lines.append("🎉 **No critical issues found!**") |
| return lines |
|
|
| def _generate_verified_section(self) -> List[str]: |
| lines = ["## ✅ Verified Entries", ""] |
| verified = [e for e in self.entries if self._is_verified(e)] |
| if not verified: |
| lines.append("_No verified entries found._") |
| return lines |
| lines.append(f"Found **{len(verified)}** entries with correct metadata.") |
| lines.append("") |
| lines.append("<details>") |
| lines.append("<summary>Click to view verified entries</summary>") |
| lines.append("") |
| for report in verified: |
| lines.extend(self._format_entry_detail(report, minimal=self.minimal_verified, is_verified=True)) |
| lines.append("</details>") |
| return lines |
|
|
| def _format_entry_detail(self, report: EntryReport, minimal: bool = False, is_verified: bool = False) -> List[str]: |
| entry = report.entry |
| comp = report.comparison |
| lines = [] |
| icon = "✅" if is_verified else "⚠️" |
| lines.append(f"#### {icon} `{entry.key}`") |
| lines.append(f"**Title:** {entry.title}") |
| lines.append("") |
| if comp: |
| status_icon = "✅" if comp.is_match else "❌" |
| lines.append(f"- **Metadata Status:** {status_icon} {comp.source.upper()} (Confidence: {comp.confidence:.1%})") |
| if comp.has_issues and not minimal: |
| lines.append(" - **Discrepancies:**") |
| for issue in comp.issues: |
| if "Mismatch" in issue or "mismatch" in issue: |
| lines.append(f" - 🔴 {issue}") |
| if "Title" in issue: |
| lines.append(f" - **Bib:** `{comp.bib_title}`") |
| lines.append(f" - **Fetched:** `{comp.fetched_title}`") |
| elif "Author" in issue: |
| lines.append(f" - **Bib:** `{', '.join(comp.bib_authors)}`") |
| lines.append(f" - **Fetched:** `{', '.join(comp.fetched_authors)}`") |
| else: |
| lines.append(f" - 🔸 {issue}") |
| lines.append("") |
| lines.append("---") |
| lines.append("") |
| return lines |
|
|
| def save_bibliography_report(self, filepath: str): |
| """Generate and save bibliography-only report.""" |
| total = len(self.entries) |
| verified = sum(1 for e in self.entries if self._is_verified(e)) |
| issues = sum(1 for e in self.entries if self._has_issues(e)) |
| dup_str = str(len(self.duplicate_groups)) if self.duplicate_groups else "N/A" |
|
|
| preprint_str = "N/A" |
| preprint_warning = [] |
| if self.check_preprint_ratio and self.entries: |
| preprint_count = sum(1 for e in self.entries if self._is_preprint(e.entry)) |
| preprint_ratio = preprint_count / len(self.entries) |
| preprint_str = f"{preprint_count} ({preprint_ratio:.1%})" |
| if preprint_ratio > self.preprint_warning_threshold: |
| preprint_warning = [ |
| "", |
| f"> ⚠️ **High Preprint Ratio:** {preprint_ratio:.1%} of entries are preprints.", |
| ] |
|
|
| bib_names = ", ".join([f"`{Path(f).name}`" for f in self.bib_files]) if self.bib_files else "N/A" |
| lines = [ |
| "# Bibliography Validation Report", |
| "", |
| f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", |
| "", |
| "| File Type | Filename |", |
| "|-----------|----------|", |
| f"| **Bib File(s)** | {bib_names} |", |
| "", |
| "> **⚠️ Disclaimer:** This report is generated by an automated tool. Please verify reported issues manually.", |
| "", |
| "## 📊 Summary", |
| "", |
| "| Metric | Count |", |
| "|--------|-------|", |
| f"| **Total Entries** | {total} |", |
| f"| ✅ **Verified (Clean)** | {verified} |", |
| f"| ⚠️ **With Issues** | {issues} |", |
| f"| 🔄 **Duplicate Groups** | {dup_str} |", |
| f"| 📄 **Preprints** | {preprint_str} |", |
| "", |
| ] |
| if preprint_warning: |
| lines.extend(preprint_warning) |
| lines.append("") |
| lines.extend(self._generate_issues_section()) |
| lines.append("") |
| lines.extend(self._generate_verified_section()) |
| lines.append("") |
| lines.append("---") |
| lines.append(f"Report generated by **CiteScan** on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") |
|
|
| with open(filepath, "w", encoding="utf-8") as f: |
| f.write("\n".join(lines)) |
|
|
