scitex 2.13.0__py3-none-any.whl → 2.15.1__py3-none-any.whl

scitex/scholar/core/_mixins/_project_handlers.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/core/_mixins/_project_handlers.py
+
+"""
+Project handler mixin for Scholar class.
+
+Provides project management functionality.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectHandlerMixin:
+    """Mixin providing project management methods."""
+
+    def _ensure_project_exists(
+        self, project: str, description: Optional[str] = None
+    ) -> Path:
+        """Ensure project directory exists, create if needed (PRIVATE).
+
+        Args:
+            project: Project name
+            description: Optional project description
+
+        Returns
+        -------
+            Path to the project directory
+        """
+        project_dir = self.config.get_library_project_dir(project)
+        info_dir = project_dir / "info"
+
+        if not project_dir.exists():
+            project_dir.mkdir(parents=True, exist_ok=True)
+            logger.info(f"{self.name}: Auto-created project directory: {project}")
+
+        info_dir.mkdir(parents=True, exist_ok=True)
+
+        old_metadata_file = project_dir / "project_metadata.json"
+        metadata_file = info_dir / "project_metadata.json"
+
+        if old_metadata_file.exists() and not metadata_file.exists():
+            shutil.move(str(old_metadata_file), str(metadata_file))
+            logger.info(f"{self.name}: Moved project metadata to info directory")
+
+        if not metadata_file.exists():
+            metadata = {
+                "name": project,
+                "description": description or f"Papers for {project} project",
+                "created": datetime.now().isoformat(),
+                "created_by": "SciTeX Scholar",
+                "auto_created": True,
+            }
+
+            with open(metadata_file, "w") as f:
+                json.dump(metadata, f, indent=2)
+
+            logger.info(
+                f"{self.name}: Created project metadata in info directory: {project}"
+            )
+
+        return project_dir
+
+    def _create_project_metadata(
+        self, project: str, description: Optional[str] = None
+    ) -> Path:
+        """Create project directory and metadata (PRIVATE).
+
+        DEPRECATED: Use _ensure_project_exists instead.
+
+        Args:
+            project: Project name
+            description: Optional project description
+
+        Returns
+        -------
+            Path to the created project directory
+        """
+        return self._ensure_project_exists(project, description)
+
+    def list_projects(self) -> List[Dict[str, Any]]:
+        """List all projects in the Scholar library.
+
+        Returns
+        -------
+            List of project information dictionaries
+        """
+        library_dir = self.config.path_manager.library_dir
+        projects = []
+
+        for item in library_dir.iterdir():
+            if item.is_dir() and item.name != "MASTER":
+                project_info = {
+                    "name": item.name,
+                    "path": str(item),
+                    "papers_count": len(list(item.glob("*"))),
+                    "created": None,
+                    "description": None,
+                }
+
+                metadata_file = item / "project_metadata.json"
+                if metadata_file.exists():
+                    try:
+                        with open(metadata_file) as f:
+                            metadata = json.load(f)
+                        project_info.update(metadata)
+                    except Exception as e:
+                        logger.debug(f"Failed to load metadata for {item.name}: {e}")
+
+                projects.append(project_info)
+
+        return sorted(projects, key=lambda x: x["name"])
+
+
+# EOF

scitex/scholar/core/_mixins/_savers.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/core/_mixins/_savers.py
+
+"""
+Saver mixin for Scholar class.
+
+Provides methods for saving papers to library and BibTeX format.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from scitex import logging
+
+if TYPE_CHECKING:
+    from ..Papers import Papers
+
+logger = logging.getLogger(__name__)
+
+
+class SaverMixin:
+    """Mixin providing paper saving methods."""
+
+    def save_papers_to_library(self, papers: Papers) -> List[str]:
+        """Save papers collection to library.
+
+        Args:
+            papers: Papers collection to save
+
+        Returns
+        -------
+            List of paper IDs saved
+        """
+        saved_ids = []
+        for paper in papers:
+            try:
+                paper_id = self._library.save_paper(paper)
+                saved_ids.append(paper_id)
+            except Exception as e:
+                logger.warning(f"{self.name}: Failed to save paper: {e}")
+
+        logger.info(
+            f"{self.name}: Saved {len(saved_ids)}/{len(papers)} papers to library"
+        )
+        return saved_ids
+
+    def save_papers_as_bibtex(
+        self, papers: Papers, output_path: Optional[Union[str, Path]] = None
+    ) -> str:
+        """Save papers to BibTeX format with enrichment metadata.
+
+        Args:
+            papers: Papers collection to save
+            output_path: Optional path to save the BibTeX file
+
+        Returns
+        -------
+            BibTeX content as string with enrichment metadata included
+        """
+        from ..storage.BibTeXHandler import BibTeXHandler
+
+        bibtex_handler = BibTeXHandler(project=self.project, config=self.config)
+        return bibtex_handler.papers_to_bibtex(papers, output_path)
+
+
+# EOF

scitex/scholar/core/_mixins/_search.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/_search.py
+
+"""
+Search mixin for Scholar class.
+
+Provides search functionality for local library and across projects.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional
+
+from scitex import logging
+
+if TYPE_CHECKING:
+    from ..Papers import Papers
+
+logger = logging.getLogger(__name__)
+
+
+class SearchMixin:
+    """Mixin providing search methods."""
+
+    def search_library(self, query: str, project: Optional[str] = None) -> Papers:
+        """Search papers in local library.
+
+        For new literature search (not in library), use AI2 Scholar QA:
+        https://scholarqa.allen.ai/chat/ then process with:
+        papers = scholar.load_bibtex('file.bib') followed by scholar.enrich(papers)
+
+        Args:
+            query: Search query
+            project: Project filter (uses self.project if None)
+
+        Returns
+        -------
+            Papers collection matching the query
+        """
+        from ..Papers import Papers
+
+        logger.info(f"{self.name}: Searching library for: {query}")
+        return Papers([], project=project or self.project)
+
+    def search_across_projects(
+        self, query: str, projects: Optional[List[str]] = None
+    ) -> Papers:
+        """Search for papers across multiple projects or the entire library.
+
+        Args:
+            query: Search query
+            projects: List of project names to search (None for all)
+
+        Returns
+        -------
+            Papers collection with search results
+        """
+        from ..Paper import Paper
+        from ..Papers import Papers
+
+        if projects is None:
+            all_projects = [p["name"] for p in self.list_projects()]
+        else:
+            all_projects = projects
+
+        all_papers = []
+        for project in all_projects:
+            try:
+                project_dir = self.config.get_library_project_dir(project)
+                for item in project_dir.iterdir():
+                    if item.is_symlink() or item.is_dir():
+                        paper_dir = item.resolve() if item.is_symlink() else item
+                        metadata_file = paper_dir / "metadata.json"
+                        if metadata_file.exists():
+                            try:
+                                paper = Paper.model_validate_json(
+                                    metadata_file.read_text()
+                                )
+                                query_lower = query.lower()
+                                title = (paper.metadata.basic.title or "").lower()
+                                abstract = (paper.metadata.basic.abstract or "").lower()
+                                authors = paper.metadata.basic.authors or []
+                                if (
+                                    query_lower in title
+                                    or query_lower in abstract
+                                    or any(
+                                        query_lower in (a or "").lower()
+                                        for a in authors
+                                    )
+                                ):
+                                    all_papers.append(paper)
+                            except Exception as e:
+                                logger.debug(
+                                    f"{self.name}: Failed to load {metadata_file}: {e}"
+                                )
+            except Exception as e:
+                logger.debug(f"{self.name}: Failed to search project {project}: {e}")
+
+        return Papers(all_papers, config=self.config, project="search_results")
+
+
+# EOF

scitex/scholar/core/_mixins/_services.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/core/_mixins/_services.py
+
+"""
+Services mixin for Scholar class.
+
+Provides internal service properties with lazy loading.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from scitex.scholar.auth import ScholarAuthManager
+from scitex.scholar.browser import ScholarBrowserManager
+from scitex.scholar.config import ScholarConfig
+from scitex.scholar.metadata_engines.ScholarEngine import ScholarEngine
+from scitex.scholar.storage import LibraryManager, ScholarLibrary
+
+
+class ServiceMixin:
+    """Mixin providing internal service properties."""
+
+    def _init_config(self, config) -> ScholarConfig:
+        """Initialize configuration from various input types."""
+        if config is None:
+            return ScholarConfig.load()
+        elif isinstance(config, (str, Path)):
+            return ScholarConfig.from_yaml(config)
+        elif isinstance(config, ScholarConfig):
+            return config
+        else:
+            raise TypeError(f"Invalid config type: {type(config)}")
+
+    @property
+    def _scholar_engine(self) -> ScholarEngine:
+        """Get Scholar engine for search and enrichment (PRIVATE)."""
+        if not hasattr(self, "_ServiceMixin__scholar_engine"):
+            self.__scholar_engine = None
+        if self.__scholar_engine is None:
+            self.__scholar_engine = ScholarEngine(config=self.config)
+        return self.__scholar_engine
+
+    @property
+    def _auth_manager(self) -> ScholarAuthManager:
+        """Get authentication manager service (PRIVATE)."""
+        if not hasattr(self, "_ServiceMixin__auth_manager"):
+            self.__auth_manager = None
+        if self.__auth_manager is None:
+            self.__auth_manager = ScholarAuthManager()
+        return self.__auth_manager
+
+    @property
+    def _browser_manager(self) -> ScholarBrowserManager:
+        """Get browser manager service (PRIVATE)."""
+        if not hasattr(self, "_ServiceMixin__browser_manager"):
+            self.__browser_manager = None
+        if self.__browser_manager is None:
+            self.__browser_manager = ScholarBrowserManager(
+                auth_manager=self._auth_manager,
+                chrome_profile_name="system",
+                browser_mode=self.browser_mode,
+            )
+        return self.__browser_manager
+
+    @property
+    def _library_manager(self) -> LibraryManager:
+        """Get library manager service - low-level operations (PRIVATE)."""
+        if not hasattr(self, "_ServiceMixin__library_manager"):
+            self.__library_manager = None
+        if self.__library_manager is None:
+            self.__library_manager = LibraryManager(
+                project=self.project, config=self.config
+            )
+        return self.__library_manager
+
+    @property
+    def _library(self) -> ScholarLibrary:
+        """Get Scholar library service - high-level operations (PRIVATE)."""
+        if not hasattr(self, "_ServiceMixin__library"):
+            self.__library = None
+        if self.__library is None:
+            self.__library = ScholarLibrary(project=self.project, config=self.config)
+        return self.__library
+
+
+# EOF

scitex/scholar/core/_mixins/_url_finding.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/scholar/core/_mixins/_url_finding.py
+
+"""
+URL finding mixin for Scholar class.
+
+Provides URL resolution and PDF URL discovery functionality.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+
+
+class URLFindingMixin:
+    """Mixin providing URL finding methods."""
+
+    async def _find_urls_for_doi_async(self, doi: str, context) -> Dict[str, Any]:
+        """Find all URLs for a DOI (orchestration layer).
+
+        Workflow:
+            DOI -> Publisher URL -> PDF URLs -> OpenURL (fallback)
+
+        Args:
+            doi: DOI string
+            context: Authenticated browser context
+
+        Returns
+        -------
+            Dictionary with URL information: {
+                "url_doi": "https://doi.org/...",
+                "url_publisher": "https://publisher.com/...",
+                "urls_pdf": [{"url": "...", "source": "zotero_translator"}],
+                "url_openurl_resolved": "..." (if fallback used)
+            }
+        """
+        from scitex.scholar.auth.gateway import (
+            OpenURLResolver,
+            normalize_doi_as_http,
+            resolve_publisher_url_by_navigating_to_doi_page,
+        )
+        from scitex.scholar.url_finder.ScholarURLFinder import ScholarURLFinder
+
+        urls = {"url_doi": normalize_doi_as_http(doi)}
+
+        # Step 1: Resolve publisher URL
+        page = await context.new_page()
+        try:
+            url_publisher = await resolve_publisher_url_by_navigating_to_doi_page(
+                doi, page
+            )
+            urls["url_publisher"] = url_publisher
+        finally:
+            await page.close()
+
+        # Step 2: Find PDF URLs from publisher URL
+        url_finder = ScholarURLFinder(context, config=self.config)
+        urls_pdf = []
+
+        if url_publisher:
+            urls_pdf = await url_finder.find_pdf_urls(url_publisher)
+
+        # Step 3: Try OpenURL fallback if no PDFs found
+        if not urls_pdf:
+            openurl_resolver = OpenURLResolver(config=self.config)
+            page = await context.new_page()
+            try:
+                url_openurl_resolved = await openurl_resolver.resolve_doi(doi, page)
+                urls["url_openurl_resolved"] = url_openurl_resolved
+
+                if url_openurl_resolved and url_openurl_resolved != "skipped":
+                    urls_pdf = await url_finder.find_pdf_urls(url_openurl_resolved)
+            finally:
+                await page.close()
+
+        urls["urls_pdf"] = self._deduplicate_pdf_urls(urls_pdf) if urls_pdf else []
+
+        return urls
+
+    def _deduplicate_pdf_urls(self, urls_pdf: List[Dict]) -> List[Dict]:
+        """Remove duplicate PDF URLs.
+
+        Args:
+            urls_pdf: List of PDF URL dicts
+
+        Returns
+        -------
+            Deduplicated list of PDF URL dicts
+        """
+        seen = set()
+        unique = []
+        for pdf in urls_pdf:
+            url = pdf.get("url") if isinstance(pdf, dict) else pdf
+            if url not in seen:
+                seen.add(url)
+                unique.append(pdf)
+        return unique
+
+
+# EOF

scitex/scholar/core/journal_normalizer.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/scholar/core/journal_normalizer.py
 """
 Journal Name Normalizer.
@@ -29,13 +28,14 @@ Usage:
 
 from __future__ import annotations
 
+import asyncio
 import json
 import os
 import re
 import time
 from pathlib import Path
-from typing import Optional, Set, Dict, List, Tuple, Any
-import asyncio
+from typing import Any, Dict, List, Optional
+
 import aiohttp
 
 from scitex import logging
@@ -98,7 +98,7 @@ class JournalNormalizer:
     Data is cached locally with daily refresh from OpenAlex.
     """
 
-    _instance: Optional["JournalNormalizer"] = None
+    _instance: Optional[JournalNormalizer] = None
 
     def __init__(self, cache_dir: Optional[Path] = None):
         self._cache_dir = cache_dir or _get_default_cache_dir()
@@ -118,7 +118,7 @@ class JournalNormalizer:
         self._journal_count = 0
 
     @classmethod
-    def get_instance(cls, cache_dir: Optional[Path] = None) -> "JournalNormalizer":
+    def get_instance(cls, cache_dir: Optional[Path] = None) -> JournalNormalizer:
         """Get singleton instance."""
         if cls._instance is None:
             cls._instance = cls(cache_dir)
@@ -129,11 +129,11 @@ class JournalNormalizer:
         if not self._cache_file.exists():
             return False
         try:
-            with open(self._cache_file, "r") as f:
+            with open(self._cache_file) as f:
                 data = json.load(f)
             cached_time = data.get("timestamp", 0)
             return (time.time() - cached_time) < CACHE_TTL_SECONDS
-        except (json.JSONDecodeError, IOError):
+        except (OSError, json.JSONDecodeError):
             return False
 
     def _load_from_cache(self) -> bool:
@@ -141,7 +141,7 @@ class JournalNormalizer:
         if not self._cache_file.exists():
             return False
         try:
-            with open(self._cache_file, "r") as f:
+            with open(self._cache_file) as f:
                 data = json.load(f)
 
             self._issn_l_data = data.get("issn_l_data", {})
@@ -154,7 +154,7 @@ class JournalNormalizer:
 
             logger.info(f"Loaded {self._journal_count} journals from normalizer cache")
             return True
-        except (json.JSONDecodeError, IOError) as e:
+        except (OSError, json.JSONDecodeError) as e:
             logger.warning(f"Failed to load journal normalizer cache: {e}")
             return False
 
@@ -173,7 +173,7 @@ class JournalNormalizer:
             with open(self._cache_file, "w") as f:
                 json.dump(data, f)
             logger.info(f"Saved {len(self._issn_l_data)} journals to normalizer cache")
-        except IOError as e:
+        except OSError as e:
             logger.warning(f"Failed to save journal normalizer cache: {e}")
 
     def _add_journal(self, source_data: Dict[str, Any]) -> None:
@@ -310,14 +310,20 @@ class JournalNormalizer:
     def _fetch_journals_sync(
         self, max_pages: int = 500, filter_oa_only: bool = False
     ) -> None:
-        """Synchronous wrapper for fetching journals."""
+        """Synchronous wrapper for fetching journals (handles nested event loops)."""
+        import concurrent.futures
+
         try:
-            loop = asyncio.get_event_loop()
+            asyncio.get_running_loop()
+            # Already in async context - use thread to avoid nested loop error
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(
+                    asyncio.run, self._fetch_journals_async(max_pages, filter_oa_only)
+                )
+                future.result(timeout=120)
         except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-        loop.run_until_complete(self._fetch_journals_async(max_pages, filter_oa_only))
+            # No running loop - safe to run directly
+            asyncio.run(self._fetch_journals_async(max_pages, filter_oa_only))
 
     def ensure_loaded(self, force_refresh: bool = False, max_pages: int = 500) -> None:
         """
@@ -347,7 +353,8 @@ class JournalNormalizer:
         Args:
             journal_name: Any journal name variant, abbreviation, or ISSN
 
-        Returns:
+        Returns
+        -------
             ISSN-L if found, None otherwise
         """
         self.ensure_loaded()
@@ -381,7 +388,8 @@ class JournalNormalizer:
         Args:
             journal_name: Any journal name variant
 
-        Returns:
+        Returns
+        -------
             Canonical journal name, or original if not found
         """
         issn_l = self.get_issn_l(journal_name)
@@ -396,7 +404,8 @@ class JournalNormalizer:
         Args:
             journal_name: Any journal name variant
 
-        Returns:
+        Returns
+        -------
             Abbreviated title if available
         """
         issn_l = self.get_issn_l(journal_name)
@@ -411,7 +420,8 @@ class JournalNormalizer:
         Args:
             journal_name: Any journal name variant
 
-        Returns:
+        Returns
+        -------
             Dict with canonical_name, abbreviated_title, alternate_titles, issns, is_oa, publisher
         """
         issn_l = self.get_issn_l(journal_name)
@@ -427,7 +437,8 @@ class JournalNormalizer:
             name1: First journal name
             name2: Second journal name
 
-        Returns:
+        Returns
+        -------
             True if both names resolve to the same ISSN-L
         """
         issn_l_1 = self.get_issn_l(name1)
@@ -446,7 +457,8 @@ class JournalNormalizer:
         Args:
             journal_name: Any journal name variant
 
-        Returns:
+        Returns
+        -------
             True if journal is OA
         """
         issn_l = self.get_issn_l(journal_name)
@@ -462,7 +474,8 @@ class JournalNormalizer:
             query: Search query
             limit: Maximum results
 
-        Returns:
+        Returns
+        -------
             List of matching journal info dicts
         """
         self.ensure_loaded()
@@ -497,8 +510,6 @@ class JournalNormalizer:
 
 
 # ==================== Convenience Functions ====================
-
-
 def get_journal_normalizer(cache_dir: Optional[Path] = None) -> JournalNormalizer:
     """Get the journal normalizer singleton."""
     return JournalNormalizer.get_instance(cache_dir)