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

scitex/scholar/.legacy/_ScholarAPI.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -28,29 +29,29 @@ logger = logging.getLogger(__name__)
 
 class ScholarAPI:
     """High-level API for scholar operations."""
-    
+
     def __init__(self, library_name: str = "default"):
         """Initialize Scholar API.
-        
+
         Args:
             library_name: Library to use (default: "default")
         """
         self.library_name = library_name
         self.lookup = get_default_lookup()
-        
+
         # Set base paths
         scitex_dir = Path(os.getenv("SCITEX_DIR", Path.home() / ".scitex"))
         self.base_dir = scitex_dir / "scholar" / "library" / library_name
-        
+
         # Use enhanced storage manager
         self.storage = EnhancedStorageManager(self.base_dir)
-        
+
     def get_paper_by_doi(self, doi: str) -> Optional[Paper]:
         """Get paper by DOI.
-        
+
         Args:
             doi: DOI to lookup
-            
+
         Returns:
             Paper object if found
         """
@@ -59,15 +60,15 @@ class ScholarAPI:
         if not storage_key:
             logger.debug(f"DOI not found in index: {doi}")
             return None
-            
+
         return self._load_paper_from_storage(storage_key)
-        
+
     def get_paper_by_title(self, title: str) -> Optional[Paper]:
         """Get paper by exact title match.
-        
+
         Args:
             title: Paper title
-            
+
         Returns:
             Paper object if found
         """
@@ -75,57 +76,61 @@ class ScholarAPI:
         if not storage_key:
             logger.debug(f"Title not found in index: {title[:50]}...")
             return None
-            
+
         return self._load_paper_from_storage(storage_key)
-        
-    def find_similar_papers(self, title: str, authors: Optional[List[str]] = None,
-                          year: Optional[int] = None) -> List[Tuple[Paper, float]]:
+
+    def find_similar_papers(
+        self,
+        title: str,
+        authors: Optional[List[str]] = None,
+        year: Optional[int] = None,
+    ) -> List[Tuple[Paper, float]]:
         """Find similar papers based on title, authors, and year.
-        
+
         Args:
             title: Paper title
             authors: Author list
             year: Publication year
-            
+
         Returns:
             List of (Paper, similarity_score) tuples
         """
         candidates = self.lookup.find_duplicates(title, authors, year)
-        
+
         results = []
         for storage_key, score in candidates:
             paper = self._load_paper_from_storage(storage_key)
             if paper:
                 results.append((paper, score))
-                
+
         return results
-        
+
     def _load_paper_from_storage(self, storage_key: str) -> Optional[Paper]:
         """Load paper from storage directory.
-        
+
         Args:
             storage_key: 8-character storage key
-            
+
         Returns:
             Paper object if found
         """
         # Try enhanced storage first
         paper_dir = self.storage.storage_dir / storage_key
         metadata_path = paper_dir / "metadata.json"
-        
+
         # Fall back to old structure if needed
         if not metadata_path.exists():
             paper_dir = self.storage.storage_dir / "by_key" / storage_key
             metadata_path = paper_dir / "metadata.json"
-            
+
         if not metadata_path.exists():
             logger.warning(f"Metadata not found for key: {storage_key}")
             return None
-            
+
         try:
-            with open(metadata_path, 'r') as f:
+            with open(metadata_path, "r") as f:
                 data = json.load(f)
-                
+
             # Check for PDF with actual filename
             pdf_info = self.storage.get_pdf_info(storage_key)
             if pdf_info:
@@ -137,86 +142,86 @@ class ScholarAPI:
                 pdfs = list(paper_dir.glob("*.pdf"))
                 if pdfs:
                     data["pdf_path"] = pdfs[0]
-                    
+
             return Paper(**data)
-            
+
         except Exception as e:
             logger.error(f"Failed to load paper {storage_key}: {e}")
             return None
-            
+
     def has_pdf(self, doi: str) -> bool:
         """Check if paper has PDF.
-        
+
         Args:
             doi: DOI to check
-            
+
         Returns:
             True if PDF exists
         """
         storage_key = self.lookup.lookup_by_doi(doi)
         if not storage_key:
             return False
-            
+
         metadata = self.lookup.lookup_by_key(storage_key)
         return metadata.get("has_pdf", False) if metadata else False
-        
+
     def get_pdf_path(self, doi: str) -> Optional[Path]:
         """Get PDF path for a paper.
-        
+
         Args:
             doi: DOI to lookup
-            
+
         Returns:
             Path to PDF if exists
         """
         storage_key = self.lookup.lookup_by_doi(doi)
         if not storage_key:
             return None
-            
+
         # Use enhanced storage to find actual PDF
         pdf_info = self.storage.get_pdf_info(storage_key)
         if pdf_info:
             pdf_path = self.storage.storage_dir / storage_key / pdf_info["filename"]
             return pdf_path if pdf_path.exists() else None
-            
+
         # Fall back to old structure
         pdfs = self.storage.list_pdfs(storage_key)
         if pdfs:
             return self.storage.storage_dir / storage_key / pdfs[0]
-            
+
         return None
-        
+
     def get_papers_needing_pdf(self) -> List[Paper]:
         """Get list of papers without PDFs."""
         storage_keys = self.lookup.get_papers_without_pdf()
-        
+
         papers = []
         for key in storage_keys:
             paper = self._load_paper_from_storage(key)
             if paper:
                 papers.append(paper)
-                
+
         return papers
-        
+
     def get_papers_needing_doi(self) -> List[Paper]:
         """Get list of papers without DOIs."""
         storage_keys = self.lookup.get_papers_without_doi()
-        
+
         papers = []
         for key in storage_keys:
             paper = self._load_paper_from_storage(key)
             if paper:
                 papers.append(paper)
-                
+
         return papers
-        
+
     def update_lookup_index(self, paper: Paper, storage_key: str) -> bool:
         """Update lookup index for a paper.
-        
+
         Args:
             paper: Paper object
             storage_key: Storage key
-            
+
         Returns:
             Success status
         """
@@ -226,7 +231,7 @@ class ScholarAPI:
         pdf_size = pdf_info["size_bytes"] if pdf_info else None
         pdf_filename = pdf_info["filename"] if pdf_info else None
         original_filename = pdf_info["original_filename"] if pdf_info else None
-        
+
         # Update basic entry
         success = self.lookup.add_entry(
             storage_key=storage_key,
@@ -235,32 +240,36 @@ class ScholarAPI:
             authors=paper.authors,
             year=paper.year,
             has_pdf=has_pdf,
-            pdf_size=pdf_size
+            pdf_size=pdf_size,
         )
-        
+
         # Update PDF details if available
         if has_pdf and success:
             self.lookup.mark_pdf_download(
                 storage_key=storage_key,
                 pdf_size=pdf_size,
                 pdf_filename=pdf_filename,
-                original_filename=original_filename
+                original_filename=original_filename,
             )
-            
+
         return success
-        
+
     def get_statistics(self) -> Dict:
         """Get comprehensive statistics."""
         lookup_stats = self.lookup.get_statistics()
-        
+
         # Add enhanced storage statistics
         storage_stats = self.storage.get_storage_stats()
-        lookup_stats.update({
-            "storage_size_mb": storage_stats.get("total_size_mb", 0),
-            "pdfs_with_original_names": storage_stats.get("pdfs_with_original_names", 0),
-            "human_readable_links": storage_stats.get("human_readable_links", 0)
-        })
-            
+        lookup_stats.update(
+            {
+                "storage_size_mb": storage_stats.get("total_size_mb", 0),
+                "pdfs_with_original_names": storage_stats.get(
+                    "pdfs_with_original_names", 0
+                ),
+                "human_readable_links": storage_stats.get("human_readable_links", 0),
+            }
+        )
+
         return lookup_stats
 
 
@@ -286,22 +295,22 @@ def get_pdf_path(doi: str, library: str = "default") -> Optional[Path]:
 if __name__ == "__main__":
     print("SciTeX Scholar API")
     print("=" * 60)
-    
+
     # Example usage
     api = ScholarAPI()
-    
+
     # Check if paper exists
     paper = api.get_paper_by_doi("10.1234/example")
     if paper:
         print(f"Found: {paper}")
         print(f"Has PDF: {api.has_pdf(paper.doi)}")
-        
+
     # Get papers needing PDFs
     need_pdf = api.get_papers_needing_pdf()
     print(f"\nPapers without PDFs: {len(need_pdf)}")
-    
+
     # Get statistics
     stats = api.get_statistics()
     print(f"\nStatistics: {stats}")
 
-# EOF
+# EOF

scitex/scholar/.legacy/_tmp/search_engine/_BaseSearchEngine.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -41,9 +42,7 @@ class BaseSearchEngine(ABC):
         self._last_request = 0
 
     @abstractmethod
-    async def search_async(
-        self, query: str, limit: int = 20, **kwargs
-    ) -> List[Paper]:
+    async def search_async(self, query: str, limit: int = 20, **kwargs) -> List[Paper]:
         """Search for papers asynchronously.
 
         Parameters
@@ -98,4 +97,5 @@ class BaseSearchEngine(ABC):
         """String representation of the search engine."""
         return f"{self.__class__.__name__}(name='{self.name}', rate_limit={self.rate_limit})"
 
+
 # EOF

scitex/scholar/.legacy/_tmp/search_engine/_UnifiedSearcher.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -240,9 +241,7 @@ class UnifiedSearcher:
                 if paper.similarity_score(unique_paper) > 0.85:
                     is_duplicate = True
                     # Keep the one with more information
-                    if (paper.citation_count or 0) > (
-                        unique_paper.citation_count or 0
-                    ):
+                    if (paper.citation_count or 0) > (unique_paper.citation_count or 0):
                         unique_papers.remove(unique_paper)
                         unique_papers.append(paper)
                     break
@@ -252,9 +251,7 @@ class UnifiedSearcher:
 
         return unique_papers
 
-    def build_local_index(
-        self, pdf_dirs: List[Union[str, Path]]
-    ) -> Dict[str, Any]:
+    def build_local_index(self, pdf_dirs: List[Union[str, Path]]) -> Dict[str, Any]:
         """Build local search index.
 
         Parameters
@@ -353,9 +350,7 @@ def search_sync(
         Search results
     """
     return asyncio.run(
-        search_async(
-            query, sources, limit, email, semantic_scholar_api_key, **kwargs
-        )
+        search_async(query, sources, limit, email, semantic_scholar_api_key, **kwargs)
     )
 
 

scitex/scholar/.legacy/_tmp/search_engine/__init__.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -28,33 +29,25 @@ from .local._LocalSearchEngine import LocalSearchEngine
 from .local._VectorSearchEngine import VectorSearchEngine
 
 # Import unified searcher
-from ._UnifiedSearcher import (
-    UnifiedSearcher,
-    search_async,
-    search_sync,
-    build_index
-)
+from ._UnifiedSearcher import UnifiedSearcher, search_async, search_sync, build_index
 
 __all__ = [
     # Base class
-    'BaseSearchEngine',
-
+    "BaseSearchEngine",
     # Concrete search engines
-    'PubMedSearchEngine',
-    'ArxivSearchEngine',
-    'SemanticScholarSearchEngine',
-    'CrossRefSearchEngine',
-    'GoogleScholarSearchEngine',
-    'LocalSearchEngine',
-    'VectorSearchEngine',
-
+    "PubMedSearchEngine",
+    "ArxivSearchEngine",
+    "SemanticScholarSearchEngine",
+    "CrossRefSearchEngine",
+    "GoogleScholarSearchEngine",
+    "LocalSearchEngine",
+    "VectorSearchEngine",
     # Unified searcher
-    'UnifiedSearcher',
-
+    "UnifiedSearcher",
     # Convenience functions
-    'search_async',
-    'search_sync',
-    'build_index'
+    "search_async",
+    "search_sync",
+    "build_index",
 ]
 
 # EOF

scitex/scholar/.legacy/_tmp/search_engine/local/_LocalSearchEngine.py

@@ -26,106 +26,109 @@ logger = logging.getLogger(__name__)
 
 class LocalSearchEngine(BaseSearchEngine):
     """Search engine for local PDF files."""
-    
+
     def __init__(self, index_path: Optional[Path] = None):
         super().__init__(name="local", rate_limit=0)
         self.index_path = index_path or get_scholar_dir() / "local_index.json"
         self.index = self._load_index()
-    
+
     async def search_async(self, query: str, limit: int = 20, **kwargs) -> List[Paper]:
         """Search local PDF collection."""
         # Local search is synchronous, wrap in async
         return await asyncio.to_thread(self._search_sync, query, limit, kwargs)
-    
+
     def _search_sync(self, query: str, limit: int, kwargs: dict) -> List[Paper]:
         """Synchronous local search implementation."""
         if not self.index:
             return []
-        
+
         # Simple keyword matching
         query_terms = query.lower().split()
         scored_papers = []
-        
+
         for paper_data in self.index.values():
             # Calculate relevance score
             score = 0
             searchable_text = f"{paper_data.get('title', '')} {paper_data.get('abstract', '')} {' '.join(paper_data.get('keywords', []))}".lower()
-            
+
             for term in query_terms:
                 score += searchable_text.count(term)
-            
+
             if score > 0:
                 # Create Paper object
                 paper = Paper(
-                    title=paper_data.get('title', 'Unknown Title'),
-                    authors=paper_data.get('authors', []),
-                    abstract=paper_data.get('abstract', ''),
-                    source='local',
-                    year=paper_data.get('year'),
-                    keywords=paper_data.get('keywords', []),
-                    pdf_path=Path(paper_data.get('pdf_path', ''))
+                    title=paper_data.get("title", "Unknown Title"),
+                    authors=paper_data.get("authors", []),
+                    abstract=paper_data.get("abstract", ""),
+                    source="local",
+                    year=paper_data.get("year"),
+                    keywords=paper_data.get("keywords", []),
+                    pdf_path=Path(paper_data.get("pdf_path", "")),
                 )
                 scored_papers.append((score, paper))
-        
+
         # Sort by score and return top results
         scored_papers.sort(key=lambda x: x[0], reverse=True)
         return [paper for score, paper in scored_papers[:limit]]
-    
+
     def _load_index(self) -> Dict[str, Any]:
         """Load local search index."""
         if self.index_path.exists():
             try:
-                with open(self.index_path, 'r') as f:
+                with open(self.index_path, "r") as f:
                     return json.load(f)
             except Exception as e:
                 logger.warning(f"Failed to load local index: {e}")
         return {}
-    
+
     def build_index(self, pdf_dirs: List[Path]) -> Dict[str, Any]:
         """Build search index from PDF directories."""
         logger.info(f"Building local index from {len(pdf_dirs)} directories")
-        
+
         index = {}
-        stats = {'files_indexed': 0, 'errors': 0}
-        
+        stats = {"files_indexed": 0, "errors": 0}
+
         for pdf_dir in pdf_dirs:
             if not pdf_dir.exists():
                 continue
-                
+
             for pdf_path in pdf_dir.rglob("*.pdf"):
                 try:
                     # Extract text and metadata
                     paper_data = self._extract_pdf_metadata(pdf_path)
                     if paper_data:
                         index[str(pdf_path)] = paper_data
-                        stats['files_indexed'] += 1
+                        stats["files_indexed"] += 1
                 except Exception as e:
                     logger.warning(f"Failed to index {pdf_path}: {e}")
-                    stats['errors'] += 1
-        
+                    stats["errors"] += 1
+
         # Save index
         self.index = index
         self._save_index()
-        
-        logger.info(f"Indexed {stats['files_indexed']} files with {stats['errors']} errors")
+
+        logger.info(
+            f"Indexed {stats['files_indexed']} files with {stats['errors']} errors"
+        )
         return stats
-    
+
     def _extract_pdf_metadata(self, pdf_path: Path) -> Optional[Dict[str, Any]]:
         """Extract metadata from PDF file."""
         # This is a placeholder - in real implementation would use PyPDF2 or similar
         return {
-            'title': pdf_path.stem.replace('_', ' ').title(),
-            'authors': [],
-            'abstract': '',
-            'year': None,
-            'keywords': [],
-            'pdf_path': str(pdf_path)
+            "title": pdf_path.stem.replace("_", " ").title(),
+            "authors": [],
+            "abstract": "",
+            "year": None,
+            "keywords": [],
+            "pdf_path": str(pdf_path),
         }
-    
+
     def _save_index(self) -> None:
         """Save index to disk."""
         self.index_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.index_path, 'w') as f:
+        with open(self.index_path, "w") as f:
             json.dump(self.index, f, indent=2)
 
-# EOF
+
+# EOF