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

scitex/scholar/.legacy/metadata/doi/batch/_SourceStatsManagerForBatchDOIResolution.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -50,9 +51,7 @@ class SourceStatsManagerForBatchDOIResolution:
         """
         self.config = config or ScholarConfig()
         self.max_worker = self.config.resolve("max_worker", max_worker)
-        self.progress_path = self.config.get_doi_resolution_progress_path(
-            progress_path
-        )
+        self.progress_path = self.config.get_doi_resolution_progress_path(progress_path)
         self._source_success_rates: Dict[str, Dict[str, float]] = {}
         self._load_source_stats()
 
@@ -94,9 +93,7 @@ class SourceStatsManagerForBatchDOIResolution:
             "adaptive_enabled": self.config.resolve(
                 "rate_limit_adaptive", None, True, bool
             ),
-            "max_retries": self.config.resolve(
-                "rate_limit_max_retries", None, 3, int
-            ),
+            "max_retries": self.config.resolve("rate_limit_max_retries", None, 3, int),
         }
 
     def validate_configuration(self) -> Dict[str, Any]:
@@ -201,9 +198,7 @@ class SourceStatsManagerForBatchDOIResolution:
         Returns:
             Success rate (0.0 to 1.0)
         """
-        return self._source_success_rates.get(source, {}).get(
-            "success_rate", 0.0
-        )
+        return self._source_success_rates.get(source, {}).get("success_rate", 0.0)
 
     def update_source_stats(self, source: str, success: bool):
         """Update source performance statistics.

scitex/scholar/.legacy/metadata/doi/batch/__init__.py

@@ -15,7 +15,9 @@ This module contains focused, single-responsibility classes for batch DOI resolu
 
 from ._ProgressManagerForBatchDOIResolution import ProgressManagerForBatchDOIResolution
 from ._MetadataHandlerForBatchDOIResolution import MetadataHandlerForBatchDOIResolution
-from ._SourceStatsManagerForBatchDOIResolution import SourceStatsManagerForBatchDOIResolution
+from ._SourceStatsManagerForBatchDOIResolution import (
+    SourceStatsManagerForBatchDOIResolution,
+)
 
 __all__ = [
     "ProgressManagerForBatchDOIResolution",

scitex/scholar/.legacy/metadata/doi/resolvers/_BatchDOIResolver.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -74,9 +75,7 @@ class BatchDOIResolver:
         """
         # Initialize configuration manager first
         self.config = config or ScholarConfig()
-        self.source_stats_manager = SourceStatsManagerForBatchDOIResolution(
-            config
-        )
+        self.source_stats_manager = SourceStatsManagerForBatchDOIResolution(config)
 
         # Use SingleDOIResolver composition for core DOI resolution
         self.single_doi_resolver = SingleDOIResolver(
@@ -93,10 +92,8 @@ class BatchDOIResolver:
         self.metadata_handler = MetadataHandlerForBatchDOIResolution()
 
         # Initialize progress manager
-        doi_resolution_progress_path = (
-            self.config.get_doi_resolution_progress_path(
-                doi_resolution_progress_file
-            )
+        doi_resolution_progress_path = self.config.get_doi_resolution_progress_path(
+            doi_resolution_progress_file
         )
 
         self.progress_manager = ProgressManagerForBatchDOIResolution(
@@ -119,9 +116,7 @@ class BatchDOIResolver:
         self._start_time = self.progress_manager._start_time
 
         # Performance tracking (delegated to config manager)
-        self._source_success_rates = (
-            self.source_stats_manager._source_success_rates
-        )
+        self._source_success_rates = self.source_stats_manager._source_success_rates
 
     # def bibtex2dois(
     #     self, bibtex_path: Path, sources: Optional[List[str]] = None
@@ -193,9 +188,7 @@ class BatchDOIResolver:
                         f"DOI resolution for '{title_50}' was already resolved"
                     )
                 else:
-                    logger.success(
-                        f"Skipping already resolved paper: {title_50}..."
-                    )
+                    logger.success(f"Skipping already resolved paper: {title_50}...")
                 continue
 
             papers_to_process.append(paper)
@@ -225,9 +218,7 @@ class BatchDOIResolver:
                 == self.metadata_handler.get_paper_key(paper)
             ]
             if len(similar_papers) > 1:
-                logger.warning(
-                    f"Potential duplicate: {paper.get('title', '')[:50]}..."
-                )
+                logger.warning(f"Potential duplicate: {paper.get('title', '')[:50]}...")
 
             tasks.append((paper, ii_, len(papers_to_process)))
 
@@ -292,15 +283,11 @@ class BatchDOIResolver:
 
         # Use historical performance if available
         journal = paper.get("journal", "").lower()
-        success_rate = self.source_stats_manager.get_source_success_rate(
-            journal
-        )
+        success_rate = self.source_stats_manager.get_source_success_rate(journal)
         if success_rate > 0:
             # Sort by success rate for this journal
             sources.sort(
-                key=lambda s: self.source_stats_manager.get_source_success_rate(
-                    s
-                ),
+                key=lambda s: self.source_stats_manager.get_source_success_rate(s),
                 reverse=True,
             )
 
@@ -589,9 +576,7 @@ if __name__ == "__main__":
         print(f"\nConfig Summary:\n{config_summary}")
 
         # Show progress summary
-        progress_summary = (
-            batch_doi_resolver.progress_manager.get_progress_summary()
-        )
+        progress_summary = batch_doi_resolver.progress_manager.get_progress_summary()
         print(f"\nProgress Summary:\n{progress_summary}")
 
     asyncio.run(main())

scitex/scholar/.legacy/metadata/doi/resolvers/_BibTeXDOIResolver.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -81,9 +82,7 @@ class BibTeXDOIResolver:
         logger.info(f"Loaded {total} bibtex_entries from {bibtex_input_path}")
 
         # Copy to library for future reference
-        self._library_cache_manager.copy_bibtex_to_library(
-            bibtex_input_path, project
-        )
+        self._library_cache_manager.copy_bibtex_to_library(bibtex_input_path, project)
 
         pending_bibtex_entries = []
         for bibtex_entry in bibtex_entries:
@@ -91,9 +90,7 @@ class BibTeXDOIResolver:
 
             if "doi" in bibtex_entry and bibtex_entry["doi"]:
                 if bibtex_entry_id not in self.progress["processed"]:
-                    self.progress["processed"][bibtex_entry_id] = bibtex_entry[
-                        "doi"
-                    ]
+                    self.progress["processed"][bibtex_entry_id] = bibtex_entry["doi"]
                 self.results["existing"].append(
                     {
                         "bibtex_entry_id": bibtex_entry_id,
@@ -141,17 +138,12 @@ class BibTeXDOIResolver:
 
             if bibtex_entry_id in self.progress["processed"]:
                 if self.progress["processed"][bibtex_entry_id] != "not_found":
-                    bibtex_entry["doi"] = self.progress["processed"][
-                        bibtex_entry_id
-                    ]
+                    bibtex_entry["doi"] = self.progress["processed"][bibtex_entry_id]
                     bibtex_entry["doi_source"] = "cache"
                 continue
 
             if bibtex_entry_id in self.progress["failed"]:
-                if (
-                    self.progress["failed"][bibtex_entry_id].get("attempts", 0)
-                    >= 3
-                ):
+                if self.progress["failed"][bibtex_entry_id].get("attempts", 0) >= 3:
                     continue
 
             pending_bibtex_entries.append(bibtex_entry)
@@ -212,9 +204,7 @@ class BibTeXDOIResolver:
                         title=title,
                         doi=doi,
                         year=int(year) if year and year.isdigit() else None,
-                        authors=(
-                            normalized_authors if normalized_authors else None
-                        ),
+                        authors=(normalized_authors if normalized_authors else None),
                         source=source,
                         metadata=result.get("metadata"),
                         bibtex_source="bibtex",
@@ -235,18 +225,14 @@ class BibTeXDOIResolver:
                             "journal": journal,
                         }
                     )
-                    logger.debug(
-                        f"Resolved DOI for '{title}': {doi} (via {source})"
-                    )
+                    logger.debug(f"Resolved DOI for '{title}': {doi} (via {source})")
                 else:
                     # Save unresolved entry to library
                     self.single_doi_resolver._library_cache_manager.save_entry(
                         title=title,
                         doi=None,
                         year=int(year) if year and year.isdigit() else None,
-                        authors=(
-                            normalized_authors if normalized_authors else None
-                        ),
+                        authors=(normalized_authors if normalized_authors else None),
                         source=None,
                         metadata=None,
                         bibtex_source="bibtex",
@@ -305,9 +291,7 @@ class BibTeXDOIResolver:
             logger.success(f"Summary CSV generated: {summary_path}")
 
         resolved_count = sum(
-            1
-            for val_ in self.progress["processed"].values()
-            if val_ != "not_found"
+            1 for val_ in self.progress["processed"].values() if val_ != "not_found"
         )
         failed_count = len(self.progress["failed"])
 
@@ -392,9 +376,7 @@ class BibTeXDOIResolver:
                     }
                 )
 
-            with open(
-                summary_path, "w", newline="", encoding="utf-8"
-            ) as csvfile:
+            with open(summary_path, "w", newline="", encoding="utf-8") as csvfile:
                 fieldnames = [
                     "bibtex_entry_id",
                     "title",
@@ -418,20 +400,14 @@ class BibTeXDOIResolver:
 
     def print_summary(self, bibtex_input_path, bibtex_output_path):
         """Print summary of resolution results."""
-        self.progress_file = (
-            self.cache_dir / f"{bibtex_input_path.stem}_progress.json"
-        )
+        self.progress_file = self.cache_dir / f"{bibtex_input_path.stem}_progress.json"
         self.progress = self._load_progress(bibtex_input_path)
         total = len(self.progress["processed"]) + len(self.progress["failed"])
         resolved = sum(
-            1
-            for val_ in self.progress["processed"].values()
-            if val_ != "not_found"
+            1 for val_ in self.progress["processed"].values() if val_ != "not_found"
         )
         not_found = sum(
-            1
-            for val_ in self.progress["processed"].values()
-            if val_ == "not_found"
+            1 for val_ in self.progress["processed"].values() if val_ == "not_found"
         )
         failed = len(self.progress["failed"])
 
@@ -439,9 +415,9 @@ class BibTeXDOIResolver:
         print("DOI Resolution Summary")
         print("=" * 60)
         print(f"Total bibtex_entries:    {total}")
-        print(f"DOIs resolved:    {resolved} ({resolved/total*100:.1f}%)")
-        print(f"DOIs not found:   {not_found} ({not_found/total*100:.1f}%)")
-        print(f"Failed bibtex_entries:   {failed} ({failed/total*100:.1f}%)")
+        print(f"DOIs resolved:    {resolved} ({resolved / total * 100:.1f}%)")
+        print(f"DOIs not found:   {not_found} ({not_found / total * 100:.1f}%)")
+        print(f"Failed bibtex_entries:   {failed} ({failed / total * 100:.1f}%)")
 
         if self.progress["started_at"]:
             started = datetime.fromisoformat(self.progress["started_at"])
@@ -458,9 +434,7 @@ class BibTeXDOIResolver:
 
     def _load_progress(self, bibtex_input_path) -> Dict[str, any]:
         """Load progress from cache file."""
-        self.progress_file = (
-            self.cache_dir / f"{bibtex_input_path.stem}_progress.json"
-        )
+        self.progress_file = self.cache_dir / f"{bibtex_input_path.stem}_progress.json"
         if self.progress_file.exists():
             try:
                 with open(self.progress_file, "r") as file_:
@@ -476,9 +450,7 @@ class BibTeXDOIResolver:
 
     def _save_progress(self, bibtex_input_path):
         """Save progress to cache file."""
-        self.progress_file = (
-            self.cache_dir / f"{bibtex_input_path.stem}_progress.json"
-        )
+        self.progress_file = self.cache_dir / f"{bibtex_input_path.stem}_progress.json"
         self.progress = self._load_progress(bibtex_input_path)
         self.progress["last_updated"] = datetime.now().isoformat()
         try:
@@ -533,9 +505,7 @@ class BibTeXDOIResolver:
             hours = seconds / 3600
             return f"{hours:.1f}h"
 
-    def _print_progress(
-        self, current: int, total: int, bibtex_entry_title: str = ""
-    ):
+    def _print_progress(self, current: int, total: int, bibtex_entry_title: str = ""):
         """Print progress with ETA like rsync."""
         if self.start_time is None:
             return

scitex/scholar/.legacy/metadata/doi/resolvers/_DOIResolver.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------

scitex/scholar/.legacy/metadata/doi/resolvers/_SingleDOIResolver.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -79,13 +80,9 @@ class SingleDOIResolver:
         self.sources = self.config.resolve("sources", sources)
 
         # Emails
-        self.crossref_email = self.config.resolve(
-            "crossref_email", email_crossref
-        )
+        self.crossref_email = self.config.resolve("crossref_email", email_crossref)
         self.pubmed_email = self.config.resolve("pubmed_email", email_pubmed)
-        self.openalex_email = self.config.resolve(
-            "openalex_email", email_openalex
-        )
+        self.openalex_email = self.config.resolve("openalex_email", email_openalex)
         self.semantic_scholar_email = self.config.resolve(
             "semantic_scholar_email",
             email_semantic_scholar,
@@ -107,9 +104,7 @@ class SingleDOIResolver:
 
         # Initialize classes
         self._rate_limit_handler = RateLimitHandler()
-        self._source_rotation_manager = SourceRotationManager(
-            self._rate_limit_handler
-        )
+        self._source_rotation_manager = SourceRotationManager(self._rate_limit_handler)
         self._source_manager = SourceManager(
             sources=self.sources,
             email_crossref=email_crossref,
@@ -235,18 +230,14 @@ class SingleDOIResolver:
         except RuntimeError:
             # No event loop, create one
             return asyncio.run(
-                self.metadata2doi_async(
-                    title, year, authors, bibtex_entry, skip_cache
-                )
+                self.metadata2doi_async(title, year, authors, bibtex_entry, skip_cache)
             )
 
     def text2dois(self, text: str) -> List[str]:
         """Extract DOIs from text using URL extractor source."""
         try:
             url_doi_source = self._source_manager.get_source("url_doi_source")
-            if url_doi_source and hasattr(
-                url_doi_source, "extract_dois_from_text"
-            ):
+            if url_doi_source and hasattr(url_doi_source, "extract_dois_from_text"):
                 return url_doi_source.extract_dois_from_text(text)
             return []
         except Exception as e:
@@ -302,8 +293,7 @@ class SingleDOIResolver:
         normalized_authors = None
         if authors:
             normalized_authors = [
-                self.text_normalizer.normalize_author_name(author)
-                for author in authors
+                self.text_normalizer.normalize_author_name(author) for author in authors
             ]
 
         # Log if changes were made
@@ -311,9 +301,7 @@ class SingleDOIResolver:
             logger.debug(f"Title normalized: '{title}' → '{normalized_title}'")
 
         if authors and normalized_authors and normalized_authors != authors:
-            logger.debug(
-                f"Authors normalized: {authors} → {normalized_authors}"
-            )
+            logger.debug(f"Authors normalized: {authors} → {normalized_authors}")
 
         return normalized_title, normalized_authors
 

scitex/scholar/.legacy/metadata/doi/sources/.combined-SemanticScholarSource/_SemanticScholarSource.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -40,10 +41,10 @@ class SemanticScholarSource(BaseDOISource):
     def __init__(self, email: str = "research@example.com", api_key: str = None):
         super().__init__()  # Initialize base class to access utilities
         self.email = email
-        self.api_key = api_key or os.getenv('SEMANTIC_SCHOLAR_API_KEY')
+        self.api_key = api_key or os.getenv("SEMANTIC_SCHOLAR_API_KEY")
         self._session = None
         self.base_url = "https://api.semanticscholar.org/graph/v1"
-        
+
         # Enhanced rate limiting based on API key availability
         self._rate_limit_delay = 0.5 if self.api_key else 2.0  # Faster with API key
 
@@ -55,12 +56,12 @@ class SemanticScholarSource(BaseDOISource):
 
             self._session = requests.Session()
             headers = {"User-Agent": f"SciTeX/1.0 (mailto:{self.email})"}
-            
+
             # Add API key if available
             if self.api_key:
                 headers["x-api-key"] = self.api_key
                 logger.info("Using Semantic Scholar API key for enhanced rate limits")
-            
+
             self._session.headers.update(headers)
         return self._session
 
@@ -109,48 +110,54 @@ class SemanticScholarSource(BaseDOISource):
                 return doi
 
         return None
-        
-    def _extract_doi_from_paper(self, paper: dict, query_title: str, query_year: Optional[int]) -> Optional[str]:
+
+    def _extract_doi_from_paper(
+        self, paper: dict, query_title: str, query_year: Optional[int]
+    ) -> Optional[str]:
         """Enhanced DOI extraction from paper with multiple validation strategies."""
         paper_title = paper.get("title", "")
         paper_year = paper.get("year")
-        
+
         # Title matching
         if not paper_title or not self._is_title_match(query_title, paper_title):
             return None
-            
+
         # Year validation (if provided) - allow 2 year difference for robustness
         if query_year and paper_year:
             try:
-                paper_year_int = int(paper_year) if isinstance(paper_year, str) else paper_year
-                query_year_int = int(query_year) if isinstance(query_year, str) else query_year
-                
+                paper_year_int = (
+                    int(paper_year) if isinstance(paper_year, str) else paper_year
+                )
+                query_year_int = (
+                    int(query_year) if isinstance(query_year, str) else query_year
+                )
+
                 if abs(paper_year_int - query_year_int) > 2:
                     return None
             except (ValueError, TypeError):
                 pass  # Skip year validation if conversion fails
-        
+
         # Extract DOI from multiple possible fields
         external_ids = paper.get("externalIds", {})
-        
+
         # Primary DOI field
         if external_ids and "DOI" in external_ids:
             doi = external_ids["DOI"]
             if doi:
                 return doi.strip()
-        
+
         # Alternative DOI sources
         for field in ["doi", "DOI"]:
             if field in paper and paper[field]:
                 return paper[field].strip()
-        
+
         # Extract from URL field if present using utility
         paper_url = paper.get("url", "")
         if paper_url:
             doi = self.url_doi_extractor.extract_doi_from_url(paper_url)
             if doi:
                 return doi
-        
+
         return None
 
     def get_abstract(self, doi: str) -> Optional[str]:
@@ -164,9 +171,7 @@ class SemanticScholarSource(BaseDOISource):
                 data = response.json()
                 abstract = data.get("abstract")
                 if abstract:
-                    logger.debug(
-                        f"Found abstract from Semantic Scholar for DOI: {doi}"
-                    )
+                    logger.debug(f"Found abstract from Semantic Scholar for DOI: {doi}")
                     return abstract
             elif response.status_code == 404:
                 logger.debug(f"Paper not found in Semantic Scholar: {doi}")
@@ -213,7 +218,7 @@ class SemanticScholarSource(BaseDOISource):
             if doi:
                 paper_title = paper.get("title", "")
                 paper_year = paper.get("year")
-                
+
                 extracted_authors = []
                 for author in paper.get("authors", []):
                     if author.get("name"):
@@ -225,14 +230,10 @@ class SemanticScholarSource(BaseDOISource):
                     "journal": paper.get("venue"),
                     "journal_source": "semantic_scholar",
                     "year": (
-                        paper_year
-                        if isinstance(paper_year, int)
-                        else paper.get("year")
+                        paper_year if isinstance(paper_year, int) else paper.get("year")
                     ),
                     "abstract": paper.get("abstract"),
-                    "authors": (
-                        extracted_authors if extracted_authors else None
-                    ),
+                    "authors": (extracted_authors if extracted_authors else None),
                 }
 
         return None
@@ -249,32 +250,32 @@ class SemanticScholarSource(BaseDOISource):
         """Resolve DOI from CorpusID using Semantic Scholar API."""
         if not corpus_id or not corpus_id.isdigit():
             return None
-            
+
         try:
             url = f"{self.base_url}/paper/CorpusId:{corpus_id}"
             params = {"fields": "externalIds,title"}
-            
+
             response = self.session.get(url, params=params, timeout=15)
-            
+
             if response.status_code == 429:
                 raise requests.HTTPError("Rate limited", response=response)
             elif response.status_code == 404:
                 logger.debug(f"CorpusID {corpus_id} not found in Semantic Scholar")
                 return None
-            
+
             response.raise_for_status()
-            
+
             data = response.json()
-            external_ids = data.get('externalIds', {})
-            doi = external_ids.get('DOI')
-            
+            external_ids = data.get("externalIds", {})
+            doi = external_ids.get("DOI")
+
             if doi:
                 logger.info(f"Resolved CorpusID {corpus_id} → DOI: {doi}")
                 return doi
             else:
                 logger.debug(f"CorpusID {corpus_id} found but no DOI available")
                 return None
-                
+
         except requests.HTTPError as e:
             if e.response and e.response.status_code == 429:
                 raise  # Re-raise for retry logic
@@ -284,4 +285,5 @@ class SemanticScholarSource(BaseDOISource):
             logger.debug(f"CorpusID resolution error for {corpus_id}: {e}")
             return None
 
+
 # EOF