scitex 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

scitex/scholar/storage/ScholarLibrary.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -23,9 +24,7 @@ class ScholarLibrary:
     """Unified Scholar library management combining cache and storage operations."""
 
     def __init__(
-        self,
-        project: Union[str, Path] = None,
-        config: Optional[ScholarConfig] = None
+        self, project: Union[str, Path] = None, config: Optional[ScholarConfig] = None
     ):
         """Initialize ScholarLibrary.
 
@@ -39,7 +38,7 @@ class ScholarLibrary:
         if isinstance(project, Path):
             # If Path is the library root dir (e.g., ~/.scitex/scholar/library)
             # use the default project from config
-            if project.name == 'library':
+            if project.name == "library":
                 self.project = self.config.resolve("project", None)
                 self.config.library_dir = str(project)
             else:
@@ -47,7 +46,7 @@ class ScholarLibrary:
                 # e.g., /home/user/.scitex/scholar/library/myproject -> "myproject"
                 self.project = project.name if project.is_dir() else project.stem
                 # Set library_dir to parent if it's named 'library'
-                if project.parent.name == 'library':
+                if project.parent.name == "library":
                     self.config.library_dir = str(project.parent)
         else:
             # Standard project name
@@ -56,12 +55,8 @@ class ScholarLibrary:
         self._cache_manager = LibraryCacheManager(
             project=self.project, config=self.config
         )
-        self._library_manager = LibraryManager(
-            project=self.project, config=self.config
-        )
-        self.bibtex_handler = BibTeXHandler(
-            project=self.project, config=self.config
-        )
+        self._library_manager = LibraryManager(project=self.project, config=self.config)
+        self.bibtex_handler = BibTeXHandler(project=self.project, config=self.config)
 
     def load_paper(self, library_id: str) -> Dict[str, Any]:
         """Load paper metadata from library."""
@@ -88,79 +83,106 @@ class ScholarLibrary:
         Supports both old flat Paper and new Pydantic Paper structures.
         """
         # Check if this is a Pydantic Paper (has metadata attribute)
-        if hasattr(paper, 'metadata'):
+        if hasattr(paper, "metadata"):
             # New Pydantic Paper structure
             return self._library_manager.save_resolved_paper(
                 # Required fields
-                title=paper.metadata.basic.title or '',
-                doi=paper.metadata.id.doi or '',
-
+                title=paper.metadata.basic.title or "",
+                doi=paper.metadata.id.doi or "",
                 # Optional bibliographic fields
                 year=paper.metadata.basic.year,
                 authors=paper.metadata.basic.authors,
                 journal=paper.metadata.publication.journal,
                 abstract=paper.metadata.basic.abstract,
-
                 # Additional bibliographic fields
                 volume=paper.metadata.publication.volume,
                 issue=paper.metadata.publication.issue,
-                pages=f"{paper.metadata.publication.first_page or ''}-{paper.metadata.publication.last_page or ''}" if paper.metadata.publication.first_page else None,
+                pages=f"{paper.metadata.publication.first_page or ''}-{paper.metadata.publication.last_page or ''}"
+                if paper.metadata.publication.first_page
+                else None,
                 publisher=paper.metadata.publication.publisher,
                 issn=paper.metadata.publication.issn,
-
                 # Enrichment fields
                 citation_count=paper.metadata.citation_count.total,
                 impact_factor=paper.metadata.publication.impact_factor,
-
                 # Library management
                 library_id=paper.container.library_id,
                 project=self.project,
             )
         else:
             # Old flat Paper structure (legacy support)
-            paper_dict = paper.to_dict() if hasattr(paper, 'to_dict') else {}
+            paper_dict = paper.to_dict() if hasattr(paper, "to_dict") else {}
 
             return self._library_manager.save_resolved_paper(
                 # Required fields
-                title=self._extract_primitive(getattr(paper, 'title', paper_dict.get('title', ''))),
-                doi=self._extract_primitive(getattr(paper, 'doi', paper_dict.get('doi', ''))),
-
+                title=self._extract_primitive(
+                    getattr(paper, "title", paper_dict.get("title", ""))
+                ),
+                doi=self._extract_primitive(
+                    getattr(paper, "doi", paper_dict.get("doi", ""))
+                ),
                 # Optional bibliographic fields
-                year=self._extract_primitive(getattr(paper, 'year', paper_dict.get('year'))),
-                authors=self._extract_primitive(getattr(paper, 'authors', paper_dict.get('authors'))),
-                journal=self._extract_primitive(getattr(paper, 'journal', paper_dict.get('journal'))),
-                abstract=self._extract_primitive(getattr(paper, 'abstract', paper_dict.get('abstract'))),
-
+                year=self._extract_primitive(
+                    getattr(paper, "year", paper_dict.get("year"))
+                ),
+                authors=self._extract_primitive(
+                    getattr(paper, "authors", paper_dict.get("authors"))
+                ),
+                journal=self._extract_primitive(
+                    getattr(paper, "journal", paper_dict.get("journal"))
+                ),
+                abstract=self._extract_primitive(
+                    getattr(paper, "abstract", paper_dict.get("abstract"))
+                ),
                 # Additional bibliographic fields
-                volume=self._extract_primitive(getattr(paper, 'volume', paper_dict.get('volume'))),
-                issue=self._extract_primitive(getattr(paper, 'issue', paper_dict.get('issue'))),
-                pages=self._extract_primitive(getattr(paper, 'pages', paper_dict.get('pages'))),
-                publisher=self._extract_primitive(getattr(paper, 'publisher', paper_dict.get('publisher'))),
-                issn=self._extract_primitive(getattr(paper, 'issn', paper_dict.get('issn'))),
-
+                volume=self._extract_primitive(
+                    getattr(paper, "volume", paper_dict.get("volume"))
+                ),
+                issue=self._extract_primitive(
+                    getattr(paper, "issue", paper_dict.get("issue"))
+                ),
+                pages=self._extract_primitive(
+                    getattr(paper, "pages", paper_dict.get("pages"))
+                ),
+                publisher=self._extract_primitive(
+                    getattr(paper, "publisher", paper_dict.get("publisher"))
+                ),
+                issn=self._extract_primitive(
+                    getattr(paper, "issn", paper_dict.get("issn"))
+                ),
                 # Enrichment fields
-                citation_count=self._extract_primitive(getattr(paper, 'citation_count', paper_dict.get('citation_count'))),
-                impact_factor=self._extract_primitive(getattr(paper, 'journal_impact_factor', paper_dict.get('journal_impact_factor'))),
-
+                citation_count=self._extract_primitive(
+                    getattr(paper, "citation_count", paper_dict.get("citation_count"))
+                ),
+                impact_factor=self._extract_primitive(
+                    getattr(
+                        paper,
+                        "journal_impact_factor",
+                        paper_dict.get("journal_impact_factor"),
+                    )
+                ),
                 # Source tracking
-                doi_source=self._extract_primitive(getattr(paper, 'doi_source', paper_dict.get('doi_source'))),
-                title_source=self._extract_primitive(getattr(paper, 'title_source', paper_dict.get('title_source'))),
-                abstract_source=self._extract_primitive(getattr(paper, 'abstract_source', paper_dict.get('abstract_source'))),
-
+                doi_source=self._extract_primitive(
+                    getattr(paper, "doi_source", paper_dict.get("doi_source"))
+                ),
+                title_source=self._extract_primitive(
+                    getattr(paper, "title_source", paper_dict.get("title_source"))
+                ),
+                abstract_source=self._extract_primitive(
+                    getattr(paper, "abstract_source", paper_dict.get("abstract_source"))
+                ),
                 # Library management
-                library_id=self._extract_primitive(getattr(paper, 'library_id', paper_dict.get('library_id'))),
+                library_id=self._extract_primitive(
+                    getattr(paper, "library_id", paper_dict.get("library_id"))
+                ),
                 project=self.project,
             )
 
-    def papers_from_bibtex(
-        self, bibtex_input: Union[str, Path]
-    ) -> List["Paper"]:
+    def papers_from_bibtex(self, bibtex_input: Union[str, Path]) -> List["Paper"]:
         """Create Papers from BibTeX file or content."""
         return self.bibtex_handler.papers_from_bibtex(bibtex_input)
 
-    def paper_from_bibtex_entry(
-        self, entry: Dict[str, Any]
-    ) -> Optional["Paper"]:
+    def paper_from_bibtex_entry(self, entry: Dict[str, Any]) -> Optional["Paper"]:
         """Convert BibTeX entry to Paper."""
         return self.bibtex_handler.paper_from_bibtex_entry(entry)
 
@@ -172,7 +194,6 @@ class ScholarLibrary:
 
 
 if __name__ == "__main__":
-
     # Implement main guard to demonstrate typical usage of this script
     def main():
         pass

scitex/scholar/storage/_DeduplicationManager.py

@@ -105,14 +105,13 @@ class DeduplicationManager:
                                 paper_groups[main_fp].append(path)
 
         # Filter to only groups with duplicates
-        duplicates = {
-            fp: paths for fp, paths in paper_groups.items()
-            if len(paths) > 1
-        }
+        duplicates = {fp: paths for fp, paths in paper_groups.items() if len(paths) > 1}
 
         if duplicates:
             total_dups = sum(len(paths) - 1 for paths in duplicates.values())
-            logger.warning(f"Found {len(duplicates)} groups with {total_dups} duplicate papers")
+            logger.warning(
+                f"Found {len(duplicates)} groups with {total_dups} duplicate papers"
+            )
         else:
             logger.info("No duplicates found")
 
@@ -166,12 +165,24 @@ class DeduplicationManager:
         if not title:
             return ""
         # Remove special characters and normalize whitespace
-        title = re.sub(r'[^\w\s]', '', title.lower())
-        title = ' '.join(title.split())
+        title = re.sub(r"[^\w\s]", "", title.lower())
+        title = " ".join(title.split())
         # Remove common words
-        stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for'}
+        stop_words = {
+            "the",
+            "a",
+            "an",
+            "and",
+            "or",
+            "but",
+            "in",
+            "on",
+            "at",
+            "to",
+            "for",
+        }
         words = [w for w in title.split() if w not in stop_words]
-        return ' '.join(words)
+        return " ".join(words)
 
     def _normalize_author(self, author: str) -> str:
         """Normalize author name for comparison."""
@@ -179,18 +190,16 @@ class DeduplicationManager:
             return ""
         # Extract last name
         author = author.strip()
-        if ',' in author:
+        if "," in author:
             # Last, First format
-            return author.split(',')[0].strip().lower()
+            return author.split(",")[0].strip().lower()
         else:
             # First Last format
             parts = author.split()
             return parts[-1].lower() if parts else ""
 
     def merge_duplicate_papers(
-        self,
-        paper_dirs: List[Path],
-        strategy: str = "best_metadata"
+        self, paper_dirs: List[Path], strategy: str = "best_metadata"
     ) -> Tuple[Path, List[Path]]:
         """Merge duplicate papers into one canonical entry.
 
@@ -234,13 +243,16 @@ class DeduplicationManager:
 
         # Save merged metadata
         metadata_file = keep_dir / "metadata.json"
-        metadata_backup = keep_dir / f"metadata.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        metadata_backup = (
+            keep_dir
+            / f"metadata.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        )
 
         # Backup original
         shutil.copy2(metadata_file, metadata_backup)
 
         # Write merged metadata
-        with open(metadata_file, 'w') as f:
+        with open(metadata_file, "w") as f:
             json.dump(merged_metadata, f, indent=2)
 
         # Merge any PDFs or other files
@@ -263,6 +275,7 @@ class DeduplicationManager:
         citation_count = metadata.get("citation_count", 0)
         if citation_count:
             import math
+
             score += min(int(math.log10(citation_count + 1) * 100), 500)
 
         # Impact factor
@@ -315,7 +328,7 @@ class DeduplicationManager:
         merged["_deduplication"] = {
             "merged_from": [str(p[1].name) for p in scored_papers],
             "merge_timestamp": datetime.now().isoformat(),
-            "scores": {str(p[1].name): p[0] for p in scored_papers}
+            "scores": {str(p[1].name): p[0] for p in scored_papers},
         }
 
         # Merge from other papers
@@ -332,14 +345,18 @@ class DeduplicationManager:
             old_cc = merged.get("citation_count", 0) or 0
             if new_cc > old_cc:
                 merged["citation_count"] = metadata["citation_count"]
-                merged["citation_count_source"] = metadata.get("citation_count_source", "merged")
+                merged["citation_count_source"] = metadata.get(
+                    "citation_count_source", "merged"
+                )
 
             # Take highest impact factor
             new_if = metadata.get("impact_factor", 0) or 0
             old_if = merged.get("impact_factor", 0) or 0
             if new_if > old_if:
                 merged["impact_factor"] = metadata["impact_factor"]
-                merged["impact_factor_source"] = metadata.get("impact_factor_source", "merged")
+                merged["impact_factor_source"] = metadata.get(
+                    "impact_factor_source", "merged"
+                )
 
             # Take DOI if missing
             if not merged.get("doi") and metadata.get("doi"):
@@ -400,7 +417,7 @@ class DeduplicationManager:
             "duplicates_merged": 0,
             "dirs_removed": 0,
             "broken_symlinks_removed": 0,
-            "errors": 0
+            "errors": 0,
         }
 
         # Find all duplicates
@@ -434,7 +451,11 @@ class DeduplicationManager:
                     # Remove duplicate directories
                     for remove_dir in remove_dirs:
                         # Move to .deduplicated directory instead of deleting
-                        dedup_dir = self.master_dir / ".deduplicated" / datetime.now().strftime("%Y%m%d_%H%M%S")
+                        dedup_dir = (
+                            self.master_dir
+                            / ".deduplicated"
+                            / datetime.now().strftime("%Y%m%d_%H%M%S")
+                        )
                         dedup_dir.mkdir(parents=True, exist_ok=True)
 
                         target = dedup_dir / remove_dir.name
@@ -482,13 +503,17 @@ class DeduplicationManager:
                         target = item.resolve(strict=True)
                     except (OSError, RuntimeError):
                         # Symlink is broken
-                        logger.info(f"Removing broken symlink: {project_dir.name}/{item.name}")
+                        logger.info(
+                            f"Removing broken symlink: {project_dir.name}/{item.name}"
+                        )
                         item.unlink()
                         removed_count += 1
 
         return removed_count
 
-    def _update_project_symlinks(self, fingerprint: str, keep_dir: Path, remove_dirs: List[Path]):
+    def _update_project_symlinks(
+        self, fingerprint: str, keep_dir: Path, remove_dirs: List[Path]
+    ):
         """Update project symlinks after deduplication."""
         removed_ids = {d.name for d in remove_dirs}
 
@@ -537,7 +562,9 @@ class DeduplicationManager:
                 with open(metadata_file) as f:
                     existing_metadata = json.load(f)
 
-                existing_fingerprint = self._generate_paper_fingerprint(existing_metadata)
+                existing_fingerprint = self._generate_paper_fingerprint(
+                    existing_metadata
+                )
 
                 if fingerprint == existing_fingerprint:
                     return paper_dir
@@ -545,4 +572,4 @@ class DeduplicationManager:
             except Exception:
                 continue
 
-        return None
+        return None

scitex/scholar/storage/_LibraryCacheManager.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -79,9 +80,7 @@ class LibraryCacheManager:
                         try:
                             with open(metadata_file, "r") as f:
                                 metadata = json.load(f)
-                            stored_title = (
-                                metadata.get("title", "").lower().strip()
-                            )
+                            stored_title = metadata.get("title", "").lower().strip()
                             stored_year = metadata.get("year")
                             stored_doi = metadata.get("doi")
 
@@ -372,9 +371,7 @@ class LibraryCacheManager:
                 "title": title,
                 "title_source": bibtex_source if bibtex_source else "input",
                 "year": year,
-                "year_source": (
-                    bibtex_source if bibtex_source and year else "input"
-                ),
+                "year_source": (bibtex_source if bibtex_source and year else "input"),
                 "authors": authors or [],
                 "authors_source": (
                     bibtex_source if bibtex_source and authors else "input"
@@ -392,9 +389,7 @@ class LibraryCacheManager:
             with open(metadata_file, "w") as file_:
                 json.dump(unresolved_metadata, file_, indent=2)
 
-            logger.info(
-                f"Saved unresolved entry: {paper_id} ({title[:50]}...)"
-            )
+            logger.info(f"Saved unresolved entry: {paper_id} ({title[:50]}...)")
 
             self._ensure_project_symlink(
                 title,
@@ -464,21 +459,15 @@ class LibraryCacheManager:
     ) -> bool:
         try:
             if not paper_id:
-                _, _, paper_id = (
-                    self.config.path_manager.get_paper_storage_paths(
-                        title=title,
-                        year=year,
-                        authors=authors,
-                        project="MASTER",
-                    )
+                _, _, paper_id = self.config.path_manager.get_paper_storage_paths(
+                    title=title,
+                    year=year,
+                    authors=authors,
+                    project="MASTER",
                 )
 
-            readable_name = self._generate_readable_name(
-                authors, year, journal
-            )
-            project_dir = self.config.path_manager.get_library_project_dir(
-                self.project
-            )
+            readable_name = self._generate_readable_name(authors, year, journal)
+            project_dir = self.config.path_manager.get_library_project_dir(self.project)
             symlink_path = project_dir / readable_name
             relative_path = f"../MASTER/{paper_id}"
 
@@ -492,9 +481,7 @@ class LibraryCacheManager:
                 symlink_path.unlink()
 
             symlink_path.symlink_to(relative_path)
-            logger.success(
-                f"Created symlink:\n{symlink_path} -> {relative_path}"
-            )
+            logger.success(f"Created symlink:\n{symlink_path} -> {relative_path}")
             return True
 
         except Exception as exc_:
@@ -533,9 +520,7 @@ class LibraryCacheManager:
         # Journal (clean up for filename usage)
         if journal:
             # Clean journal name for filename usage, keep it as-is but remove problematic chars
-            journal_cleaned = "".join(
-                c for c in journal if c.isalnum() or c in "._-"
-            )
+            journal_cleaned = "".join(c for c in journal if c.isalnum() or c in "._-")
             journal = journal_cleaned if journal_cleaned else "Unknown"
         else:
             journal = "Unknown"
@@ -544,14 +529,10 @@ class LibraryCacheManager:
         readable_name = f"{first_author}-{year_str}-{journal}"
 
         # Clean up filename
-        readable_name = "".join(
-            c for c in readable_name if c.isalnum() or c in "._-"
-        )
+        readable_name = "".join(c for c in readable_name if c.isalnum() or c in "._-")
         return readable_name
 
-    def get_unresolved_entries(
-        self, project_name: Optional[str] = None
-    ) -> List[Dict]:
+    def get_unresolved_entries(self, project_name: Optional[str] = None) -> List[Dict]:
         """Get list of unresolved entries from Scholar library.
 
         Args:
@@ -583,27 +564,19 @@ class LibraryCacheManager:
                                 # Check if entry is unresolved
                                 if (
                                     metadata.get("doi_resolution_failed")
-                                    or metadata.get("resolution_status")
-                                    == "unresolved"
+                                    or metadata.get("resolution_status") == "unresolved"
                                     or not metadata.get("doi")
                                 ):
-
                                     unresolved_entries.append(
                                         {
                                             "paper_id": paper_dir.name,
-                                            "title": metadata.get(
-                                                "title", "Unknown"
-                                            ),
+                                            "title": metadata.get("title", "Unknown"),
                                             "year": metadata.get("year"),
-                                            "authors": metadata.get(
-                                                "authors", []
-                                            ),
+                                            "authors": metadata.get("authors", []),
                                             "last_attempt": metadata.get(
                                                 "doi_last_attempt"
                                             ),
-                                            "metadata_file": str(
-                                                metadata_file
-                                            ),
+                                            "metadata_file": str(metadata_file),
                                         }
                                     )