scitex 2.14.0__py3-none-any.whl → 2.15.2__py3-none-any.whl

scitex/scholar/core/_mixins/__init__.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/core/_mixins/__init__.py
+
+"""
+Scholar mixin classes for modular functionality.
+
+Each mixin provides a specific set of methods for the Scholar class.
+"""
+
+from ._enrichers import EnricherMixin
+from ._library_handlers import LibraryHandlerMixin
+from ._loaders import LoaderMixin
+from ._pdf_download import PDFDownloadMixin
+from ._pipeline import PipelineMixin
+from ._project_handlers import ProjectHandlerMixin
+from ._savers import SaverMixin
+from ._search import SearchMixin
+from ._services import ServiceMixin
+from ._url_finding import URLFindingMixin
+
+__all__ = [
+    "EnricherMixin",
+    "URLFindingMixin",
+    "PDFDownloadMixin",
+    "LoaderMixin",
+    "SearchMixin",
+    "SaverMixin",
+    "ProjectHandlerMixin",
+    "LibraryHandlerMixin",
+    "PipelineMixin",
+    "ServiceMixin",
+]
+
+
+# EOF

scitex/scholar/core/_mixins/_enrichers.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/core/_mixins/_enrichers.py
+
+"""
+Enricher mixin for Scholar class.
+
+Provides paper enrichment functionality including metadata enrichment,
+impact factor lookup, and citation count retrieval.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from copy import deepcopy
+from typing import TYPE_CHECKING, Dict, Optional, Union
+
+import nest_asyncio
+
+from scitex import logging
+from scitex.scholar.impact_factor.ImpactFactorEngine import ImpactFactorEngine
+
+if TYPE_CHECKING:
+    from ..Paper import Paper
+    from ..Papers import Papers
+
+logger = logging.getLogger(__name__)
+
+
+class EnricherMixin:
+    """Mixin providing paper enrichment methods."""
+
+    async def enrich_papers_async(self, papers: Papers) -> Papers:
+        """Async version of enrich_papers for use in async contexts.
+
+        Args:
+            papers: Papers collection to enrich.
+
+        Returns
+        -------
+            Enriched Papers collection
+        """
+        from ..Papers import Papers
+
+        enriched_list = []
+
+        for paper in papers:
+            try:
+                results = await self._scholar_engine.search_async(
+                    title=paper.metadata.basic.title,
+                    year=paper.metadata.basic.year,
+                    authors=(
+                        paper.metadata.basic.authors[0]
+                        if paper.metadata.basic.authors
+                        else None
+                    ),
+                )
+
+                enriched_paper = self._merge_enrichment_data(paper, results)
+                enriched_list.append(enriched_paper)
+                title = paper.metadata.basic.title or "No title"
+                logger.info(f"{self.name}: Enriched: {title[:50]}...")
+
+            except Exception as e:
+                title = paper.metadata.basic.title or "No title"
+                logger.warning(
+                    f"{self.name}: Failed to enrich paper '{title[:50]}...': {e}"
+                )
+                enriched_list.append(paper)
+
+        enriched_papers = Papers(enriched_list, project=self.project)
+
+        if self.config.resolve("enrich_impact_factors", None, True):
+            enriched_papers = self._enrich_impact_factors(enriched_papers)
+
+        return enriched_papers
+
+    def enrich_papers(
+        self, papers: Optional[Papers] = None
+    ) -> Union[Papers, Dict[str, int]]:
+        """Enrich papers with metadata from multiple sources.
+
+        Args:
+            papers: Papers collection to enrich. If None, enriches all papers
+                   in current project.
+
+        Returns
+        -------
+            - If papers provided: Returns enriched Papers collection
+            - If no papers: Returns dict with enrichment statistics for project
+        """
+        from ..Papers import Papers
+
+        if papers is None:
+            return self._enrich_current_project()
+
+        enriched_list = []
+        nest_asyncio.apply()
+
+        for paper in papers:
+            try:
+                results = asyncio.run(
+                    self._scholar_engine.search_async(
+                        title=paper.metadata.basic.title,
+                        year=paper.metadata.basic.year,
+                        authors=(
+                            paper.metadata.basic.authors[0]
+                            if paper.metadata.basic.authors
+                            else None
+                        ),
+                    )
+                )
+
+                enriched_paper = self._merge_enrichment_data(paper, results)
+                enriched_list.append(enriched_paper)
+                title = paper.metadata.basic.title or "No title"
+                logger.info(f"{self.name}: Enriched: {title[:50]}...")
+
+            except Exception as e:
+                title = paper.metadata.basic.title or "No title"
+                logger.warning(
+                    f"{self.name}: Failed to enrich paper '{title[:50]}...': {e}"
+                )
+                enriched_list.append(paper)
+
+        enriched_papers = Papers(enriched_list, project=self.project)
+
+        if self.config.resolve("enrich_impact_factors", None, True):
+            enriched_papers = self._enrich_impact_factors(enriched_papers)
+
+        return enriched_papers
+
+    def _enrich_impact_factors(self, papers: Papers) -> Papers:
+        """Add journal impact factors to papers.
+
+        Args:
+            papers: Papers collection to enrich with impact factors
+
+        Returns
+        -------
+            Papers collection with impact factors added where available
+        """
+        try:
+            jcr_engine = ImpactFactorEngine()
+            papers = jcr_engine.enrich_papers(papers)
+            return papers
+        except Exception as e:
+            logger.debug(
+                f"{self.name}: JCR engine unavailable: {e}, "
+                "falling back to calculation method"
+            )
+        return papers
+
+    def _merge_enrichment_data(self, paper: Paper, results: Dict) -> Paper:
+        """Merge enrichment results into paper object.
+
+        Creates a new Paper object with merged data to avoid modifying the original.
+        """
+        enriched = deepcopy(paper)
+
+        if not results:
+            return enriched
+
+        # ID section
+        if "id" in results:
+            if results["id"].get("doi") and not enriched.metadata.id.doi:
+                enriched.metadata.set_doi(results["id"]["doi"])
+            if results["id"].get("pmid") and not enriched.metadata.id.pmid:
+                enriched.metadata.id.pmid = results["id"]["pmid"]
+            if results["id"].get("arxiv_id") and not enriched.metadata.id.arxiv_id:
+                enriched.metadata.id.arxiv_id = results["id"]["arxiv_id"]
+
+        # Basic metadata section
+        if "basic" in results:
+            if results["basic"].get("abstract"):
+                enriched.metadata.basic.abstract = results["basic"]["abstract"]
+
+            if results["basic"].get("title"):
+                new_title = results["basic"]["title"]
+                current_title = enriched.metadata.basic.title or ""
+                if not current_title or len(new_title) > len(current_title):
+                    enriched.metadata.basic.title = new_title
+
+            if results["basic"].get("authors") and not enriched.metadata.basic.authors:
+                enriched.metadata.basic.authors = results["basic"]["authors"]
+
+            if results["basic"].get("year") and not enriched.metadata.basic.year:
+                enriched.metadata.basic.year = results["basic"]["year"]
+
+            if (
+                results["basic"].get("keywords")
+                and not enriched.metadata.basic.keywords
+            ):
+                enriched.metadata.basic.keywords = results["basic"]["keywords"]
+
+        # Publication metadata
+        if "publication" in results:
+            pub = results["publication"]
+            meta_pub = enriched.metadata.publication
+            if pub.get("journal") and not meta_pub.journal:
+                meta_pub.journal = pub["journal"]
+            if pub.get("publisher") and not meta_pub.publisher:
+                meta_pub.publisher = pub["publisher"]
+            if pub.get("volume") and not meta_pub.volume:
+                meta_pub.volume = pub["volume"]
+            if pub.get("issue") and not meta_pub.issue:
+                meta_pub.issue = pub["issue"]
+            if pub.get("pages") and not meta_pub.pages:
+                meta_pub.pages = pub["pages"]
+
+        # Citation metadata
+        if "citation_count" in results:
+            count = results["citation_count"].get("count") or results[
+                "citation_count"
+            ].get("total")
+            if count:
+                current_count = enriched.metadata.citation_count.total or 0
+                if not current_count or count > current_count:
+                    enriched.metadata.citation_count.total = count
+
+        # URL metadata
+        if "url" in results:
+            if results["url"].get("pdf"):
+                pdf_url = results["url"]["pdf"]
+                if not any(p.get("url") == pdf_url for p in enriched.metadata.url.pdfs):
+                    enriched.metadata.url.pdfs.append(
+                        {"url": pdf_url, "source": "enrichment"}
+                    )
+            if results["url"].get("url") and not enriched.metadata.url.publisher:
+                enriched.metadata.url.publisher = results["url"]["url"]
+
+        return enriched
+
+    def _enrich_current_project(self) -> Dict[str, int]:
+        """Enrich all papers in the current project.
+
+        Returns
+        -------
+            Dictionary with enrichment statistics
+        """
+        if not self.project:
+            raise ValueError(
+                "No project specified. Use Scholar(project='name') "
+                "or provide papers to enrich()."
+            )
+
+        papers = self.load_project(self.project)
+        logger.info(
+            f"{self.name}: Enriching {len(papers)} papers in project '{self.project}'"
+        )
+
+        enriched_papers = self.enrich_papers(papers)
+
+        enriched_count = sum(
+            1
+            for i, p in enumerate(enriched_papers)
+            if p.abstract and not papers[i].abstract
+        )
+
+        saved_ids = self.save_papers_to_library(enriched_papers)
+
+        return {
+            "enriched": enriched_count,
+            "failed": len(papers) - enriched_count,
+            "total": len(papers),
+            "saved": len(saved_ids),
+        }
+
+
+# EOF

scitex/scholar/core/_mixins/_library_handlers.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/core/_mixins/_library_handlers.py
+
+"""
+Library handler mixin for Scholar class.
+
+Provides library-wide statistics and backup functionality.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Union
+
+from scitex import logging
+from scitex.logging import ScholarError
+
+logger = logging.getLogger(__name__)
+
+
+class LibraryHandlerMixin:
+    """Mixin providing library management methods."""
+
+    def get_library_statistics(self) -> Dict[str, Any]:
+        """Get comprehensive statistics for the entire Scholar library.
+
+        Returns
+        -------
+            Dictionary with library-wide statistics
+        """
+        master_dir = self.config.get_library_master_dir()
+        projects = self.list_projects()
+
+        stats = {
+            "total_projects": len(projects),
+            "total_papers": (
+                len(list(master_dir.glob("*"))) if master_dir.exists() else 0
+            ),
+            "projects": projects,
+            "library_path": str(self.config.path_manager.library_dir),
+            "master_path": str(master_dir),
+        }
+
+        if master_dir.exists():
+            total_size = sum(
+                f.stat().st_size for f in master_dir.rglob("*") if f.is_file()
+            )
+            stats["storage_mb"] = total_size / (1024 * 1024)
+        else:
+            stats["storage_mb"] = 0
+
+        return stats
+
+    def backup_library(self, backup_path: Union[str, Path]) -> Dict[str, Any]:
+        """Create a backup of the Scholar library.
+
+        Args:
+            backup_path: Path for the backup
+
+        Returns
+        -------
+            Dictionary with backup information
+        """
+        backup_path = Path(backup_path)
+        library_path = self.config.path_manager.library_dir
+
+        if not library_path.exists():
+            raise ScholarError("Library directory does not exist")
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_dir = backup_path / f"scholar_library_backup_{timestamp}"
+
+        logger.info(f"{self.name}: Creating library backup at {backup_dir}")
+        shutil.copytree(library_path, backup_dir)
+
+        backup_info = {
+            "timestamp": timestamp,
+            "source": str(library_path),
+            "backup": str(backup_dir),
+            "size_mb": sum(
+                f.stat().st_size for f in backup_dir.rglob("*") if f.is_file()
+            )
+            / (1024 * 1024),
+        }
+
+        metadata_file = backup_dir / "backup_metadata.json"
+        with open(metadata_file, "w") as f:
+            json.dump(backup_info, f, indent=2)
+
+        logger.info(
+            f"{self.name}: Library backup completed: {backup_info['size_mb']:.2f} MB"
+        )
+        return backup_info
+
+
+# EOF

scitex/scholar/core/_mixins/_loaders.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/core/_mixins/_loaders.py
+
+"""
+Loader mixin for Scholar class.
+
+Provides methods for loading papers from projects and BibTeX files.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, Union
+
+from scitex import logging
+
+if TYPE_CHECKING:
+    from ..Papers import Papers
+
+logger = logging.getLogger(__name__)
+
+
+class LoaderMixin:
+    """Mixin providing paper loading methods."""
+
+    def load_project(self, project: Optional[str] = None) -> Papers:
+        """Load papers from a project using library manager service.
+
+        Args:
+            project: Project name (uses self.project if None)
+
+        Returns
+        -------
+            Papers collection from the project
+        """
+        from ..Paper import Paper
+        from ..Papers import Papers
+
+        project_name = project or self.project
+        if not project_name:
+            raise ValueError("No project specified")
+
+        logger.info(f"{self.name}: Loading papers from project: {project_name}")
+
+        library_dir = self.config.path_manager.library_dir
+        project_dir = library_dir / project_name
+
+        if not project_dir.exists():
+            logger.warning(
+                f"{self.name}: Project directory does not exist: {project_dir}"
+            )
+            return Papers([], project=project_name)
+
+        papers = []
+        for item in project_dir.iterdir():
+            if item.name in ["info", "project_metadata.json", "README.md"]:
+                continue
+
+            if item.is_symlink():
+                master_path = item.resolve()
+                if master_path.exists():
+                    metadata_file = master_path / "metadata.json"
+                    if metadata_file.exists():
+                        try:
+                            with open(metadata_file) as f:
+                                metadata = json.load(f)
+
+                            paper = Paper.from_dict(metadata)
+                            papers.append(paper)
+                        except Exception as e:
+                            logger.warning(
+                                f"{self.name}: Failed to load metadata "
+                                f"from {metadata_file}: {e}"
+                            )
+
+        logger.info(
+            f"{self.name}: Loaded {len(papers)} papers from project: {project_name}"
+        )
+        return Papers(papers, project=project_name)
+
+    def load_bibtex(self, bibtex_input: Union[str, Path]) -> Papers:
+        """Load Papers collection from BibTeX file or content.
+
+        Args:
+            bibtex_input: BibTeX file path or content string
+
+        Returns
+        -------
+            Papers collection
+        """
+        from ..Papers import Papers
+
+        papers = self._library.papers_from_bibtex(bibtex_input)
+
+        papers_collection = Papers(papers, config=self.config, project=self.project)
+        papers_collection.library = self._library
+
+        return papers_collection
+
+
+# EOF