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

scitex/scholar/pipelines/ScholarPipelineSingle.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/scholar/pipelines/ScholarPipelineSingle.py"
-)
+
+__FILE__ = "./src/scitex/scholar/pipelines/ScholarPipelineSingle.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -49,6 +48,8 @@ from scitex.scholar.storage import PaperIO
 logger = logging.getLogger(__name__)
 
 """Functions & Classes"""
+
+
 class ScholarPipelineSingle:
     """Orchestrates full paper acquisition pipeline"""
 
@@ -103,8 +104,8 @@ class ScholarPipelineSingle:
             paper = await self._step_04_resolve_metadata(paper, io, force)
 
             # Step 5. Find PDF URLs
-            browser_manager, context, auth_gateway = (
-                await self._step_05_setup_browser(paper, io)
+            browser_manager, context, auth_gateway = await self._step_05_setup_browser(
+                paper, io
             )
             if context:
                 # Step 6. Download PDF (with manual mode support)
@@ -182,16 +183,12 @@ class ScholarPipelineSingle:
             from scitex.scholar.metadata_engines import ScholarEngine
 
             engine = ScholarEngine()
-            metadata_dict = await engine.search_async(
-                doi=paper.metadata.id.doi
-            )
+            metadata_dict = await engine.search_async(doi=paper.metadata.id.doi)
             if metadata_dict:
                 self._merge_metadata_into_paper(paper, metadata_dict)
                 self._enrich_impact_factor(paper)
                 io.save_metadata()
-                logger.success(
-                    f"{self.name}: Metadata enriched from search engines"
-                )
+                logger.success(f"{self.name}: Metadata enriched from search engines")
             else:
                 paper.metadata.basic.title = "Pending metadata resolution"
                 paper.metadata.basic.title_engines = ["pending"]
@@ -207,9 +204,7 @@ class ScholarPipelineSingle:
                 from scitex.scholar.metadata_engines import ScholarEngine
 
                 engine = ScholarEngine()
-                metadata_dict = await engine.search_async(
-                    doi=paper.metadata.id.doi
-                )
+                metadata_dict = await engine.search_async(doi=paper.metadata.id.doi)
                 if metadata_dict:
                     self._merge_metadata_into_paper(paper, metadata_dict)
                     self._enrich_impact_factor(paper)
@@ -235,18 +230,17 @@ class ScholarPipelineSingle:
             browser_mode=self.browser_mode,
             auth_manager=auth_manager,
         )
-        browser, context = (
-            await browser_manager.get_authenticated_browser_and_context_async()
-        )
+        (
+            browser,
+            context,
+        ) = await browser_manager.get_authenticated_browser_and_context_async()
         auth_gateway = AuthenticationGateway(
             auth_manager=auth_manager,
             browser_manager=browser_manager,
         )
         return browser_manager, context, auth_gateway
 
-    async def _step_06_find_pdf_urls(
-        self, paper, io, context, auth_gateway, force
-    ):
+    async def _step_06_find_pdf_urls(self, paper, io, context, auth_gateway, force):
         if not paper.metadata.url.pdfs or force:
             logger.info(f"{self.name}: Finding PDF URLs...")
             try:
@@ -295,9 +289,7 @@ class ScholarPipelineSingle:
         )
         return downloaded_file, temp_pdf_path
 
-    def _step_07_handle_downloaded_pdf(
-        self, paper, io, downloaded_file, temp_pdf_path
-    ):
+    def _step_07_handle_downloaded_pdf(self, paper, io, downloaded_file, temp_pdf_path):
         if downloaded_file == temp_pdf_path and temp_pdf_path.exists():
             import shutil
 
@@ -312,9 +304,7 @@ class ScholarPipelineSingle:
         else:
             io.save_pdf(downloaded_file)
             io.save_metadata()
-        logger.info(
-            f"{self.name}: PDF downloaded and saved ({str(downloaded_file)})"
-        )
+        logger.info(f"{self.name}: PDF downloaded and saved ({str(downloaded_file)})")
         logger.info(f"{self.name}: Updated metadata.path.pdfs")
 
     def _step_07_check_manual_download(self, io):
@@ -341,35 +331,25 @@ class ScholarPipelineSingle:
             logger.info(
                 f"{self.name}: Found recent PDF: {latest_pdf.name} ({latest_pdf.stat().st_size / 1e6:.2f} MB)"
             )
-            logger.info(
-                f"{self.name}: Assuming this is the manually downloaded PDF"
-            )
+            logger.info(f"{self.name}: Assuming this is the manually downloaded PDF")
             io.save_pdf(latest_pdf)
             io.save_metadata()
-            logger.success(
-                f"{self.name}: Manually downloaded PDF saved to MASTER"
-            )
+            logger.success(f"{self.name}: Manually downloaded PDF saved to MASTER")
             logger.info(f"{self.name}: Updated metadata.path.pdfs")
         else:
-            logger.warning(
-                f"{self.name}: No recent PDFs found in downloads directory"
-            )
+            logger.warning(f"{self.name}: No recent PDFs found in downloads directory")
             logger.warning(
                 f"{self.name}: PDF download incomplete - manual intervention required"
             )
 
-    async def _step_07_download_pdf(
-        self, paper, io, context, auth_gateway, force
-    ):
+    async def _step_07_download_pdf(self, paper, io, context, auth_gateway, force):
         if (not io.has_pdf() or force) and paper.metadata.url.pdfs:
             logger.info(f"{self.name}: Downloading PDF...")
             from scitex.scholar.pdf_download import ScholarPDFDownloader
 
             downloader = ScholarPDFDownloader(context)
-            downloaded_file, temp_pdf_path = (
-                await self._step_07_download_pdf_from_url(
-                    paper, io, context, auth_gateway, downloader
-                )
+            downloaded_file, temp_pdf_path = await self._step_07_download_pdf_from_url(
+                paper, io, context, auth_gateway, downloader
             )
             if downloaded_file:
                 self._step_07_handle_downloaded_pdf(
@@ -409,9 +389,7 @@ class ScholarPipelineSingle:
     # ----------------------------------------
     # Helper functions
     # ----------------------------------------
-    def _link_to_project(
-        self, paper: Paper, project: str, io: PaperIO
-    ) -> Path:
+    def _link_to_project(self, paper: Paper, project: str, io: PaperIO) -> Path:
         """Create human-readable symlink in project directory."""
         from scitex.scholar import ScholarConfig
 
@@ -464,9 +442,7 @@ class ScholarPipelineSingle:
         content = f"DOI:{doi}"
         return hashlib.md5(content.encode()).hexdigest()[:8].upper()
 
-    def _merge_metadata_into_paper(
-        self, paper: Paper, metadata_dict: dict
-    ) -> None:
+    def _merge_metadata_into_paper(self, paper: Paper, metadata_dict: dict) -> None:
         """Merge metadata dictionary from ScholarEngine into Paper object."""
 
         # Helper to safely update field with engine tracking and type conversion
@@ -629,9 +605,7 @@ class ScholarPipelineSingle:
             metrics = if_engine.get_metrics(journal)
 
             if metrics and metrics.get("impact_factor"):
-                paper.metadata.publication.impact_factor = metrics[
-                    "impact_factor"
-                ]
+                paper.metadata.publication.impact_factor = metrics["impact_factor"]
                 paper.metadata.publication.impact_factor_engines = [
                     metrics.get("source", "JCR")
                 ]

scitex/scholar/pipelines/SearchQueryParser.py

@@ -61,7 +61,7 @@ class SearchQueryParser:
         remaining_text = self.original_query
 
         # Extract year filter: year:2020-2024 or year:>2020 or year:<2024
-        year_pattern = r'year:(\d{4})-(\d{4})|year:([><])(\d{4})'
+        year_pattern = r"year:(\d{4})-(\d{4})|year:([><])(\d{4})"
         year_matches = re.findall(year_pattern, remaining_text)
         for match in year_matches:
             if match[0] and match[1]:  # Range format: 2020-2024
@@ -69,64 +69,64 @@ class SearchQueryParser:
                 self.year_end = int(match[1])
             elif match[2] and match[3]:  # Comparison format: >2020
                 year = int(match[3])
-                if match[2] == '>':
+                if match[2] == ">":
                     self.year_start = year
                 else:  # <
                     self.year_end = year
-        remaining_text = re.sub(year_pattern, '', remaining_text)
+        remaining_text = re.sub(year_pattern, "", remaining_text)
 
         # Extract impact factor filter: impact_factor:>5 or if:>5
-        if_pattern = r'(?:impact_factor|if):([><])?([\d.]+)'
+        if_pattern = r"(?:impact_factor|if):([><])?([\d.]+)"
         if_matches = re.findall(if_pattern, remaining_text)
         for match in if_matches:
             value = float(match[1])
-            if match[0] == '>':
+            if match[0] == ">":
                 self.min_impact_factor = value
-            elif match[0] == '<':
+            elif match[0] == "<":
                 self.max_impact_factor = value
             else:
                 self.min_impact_factor = value
-        remaining_text = re.sub(if_pattern, '', remaining_text)
+        remaining_text = re.sub(if_pattern, "", remaining_text)
 
         # Extract citation count filter: citations:>100
-        cit_pattern = r'citations?:([><])?([\d]+)'
+        cit_pattern = r"citations?:([><])?([\d]+)"
         cit_matches = re.findall(cit_pattern, remaining_text)
         for match in cit_matches:
             value = int(match[1])
-            if match[0] == '>':
+            if match[0] == ">":
                 self.min_citations = value
-            elif match[0] == '<':
+            elif match[0] == "<":
                 self.max_citations = value
             else:
                 self.min_citations = value
-        remaining_text = re.sub(cit_pattern, '', remaining_text)
+        remaining_text = re.sub(cit_pattern, "", remaining_text)
 
         # Extract open access filter: open_access:true or oa:true
-        oa_pattern = r'(?:open_access|oa):(true|false|yes|no|1|0)'
+        oa_pattern = r"(?:open_access|oa):(true|false|yes|no|1|0)"
         oa_match = re.search(oa_pattern, remaining_text, re.IGNORECASE)
         if oa_match:
             oa_value = oa_match.group(1).lower()
-            self.open_access = oa_value in ['true', 'yes', '1']
-        remaining_text = re.sub(oa_pattern, '', remaining_text, flags=re.IGNORECASE)
+            self.open_access = oa_value in ["true", "yes", "1"]
+        remaining_text = re.sub(oa_pattern, "", remaining_text, flags=re.IGNORECASE)
 
         # Extract document type filter: type:article or type:review
-        type_pattern = r'type:(article|review|conference|book)'
+        type_pattern = r"type:(article|review|conference|book)"
         type_match = re.search(type_pattern, remaining_text, re.IGNORECASE)
         if type_match:
             self.document_type = type_match.group(1).lower()
-        remaining_text = re.sub(type_pattern, '', remaining_text, flags=re.IGNORECASE)
+        remaining_text = re.sub(type_pattern, "", remaining_text, flags=re.IGNORECASE)
 
         # Extract negative keywords (words starting with -)
-        neg_pattern = r'-(\w+)'
+        neg_pattern = r"-(\w+)"
         neg_matches = re.findall(neg_pattern, remaining_text)
         self.negative_keywords = neg_matches
-        remaining_text = re.sub(neg_pattern, '', remaining_text)
+        remaining_text = re.sub(neg_pattern, "", remaining_text)
 
         # Extract quoted phrases as single keywords
         quoted_pattern = r'"([^"]+)"'
         quoted_matches = re.findall(quoted_pattern, remaining_text)
         self.positive_keywords.extend(quoted_matches)
-        remaining_text = re.sub(quoted_pattern, '', remaining_text)
+        remaining_text = re.sub(quoted_pattern, "", remaining_text)
 
         # Remaining words are positive keywords
         words = remaining_text.split()
@@ -135,32 +135,32 @@ class SearchQueryParser:
 
     def get_keyword_query(self) -> str:
         """Get cleaned keyword query (positive keywords only)."""
-        return ' '.join(self.positive_keywords)
+        return " ".join(self.positive_keywords)
 
     def get_filters(self) -> Dict[str, Any]:
         """Get all filters as dictionary."""
         filters = {}
 
         if self.positive_keywords:
-            filters['positive_keywords'] = self.positive_keywords
+            filters["positive_keywords"] = self.positive_keywords
         if self.negative_keywords:
-            filters['negative_keywords'] = self.negative_keywords
+            filters["negative_keywords"] = self.negative_keywords
         if self.year_start is not None:
-            filters['year_start'] = self.year_start
+            filters["year_start"] = self.year_start
         if self.year_end is not None:
-            filters['year_end'] = self.year_end
+            filters["year_end"] = self.year_end
         if self.min_impact_factor is not None:
-            filters['min_impact_factor'] = self.min_impact_factor
+            filters["min_impact_factor"] = self.min_impact_factor
         if self.max_impact_factor is not None:
-            filters['max_impact_factor'] = self.max_impact_factor
+            filters["max_impact_factor"] = self.max_impact_factor
         if self.min_citations is not None:
-            filters['min_citations'] = self.min_citations
+            filters["min_citations"] = self.min_citations
         if self.max_citations is not None:
-            filters['max_citations'] = self.max_citations
+            filters["max_citations"] = self.max_citations
         if self.open_access is not None:
-            filters['open_access'] = self.open_access
+            filters["open_access"] = self.open_access
         if self.document_type is not None:
-            filters['document_type'] = self.document_type
+            filters["document_type"] = self.document_type
 
         return filters
 
@@ -169,13 +169,13 @@ class SearchQueryParser:
         api_filters = {}
 
         if self.year_start is not None:
-            api_filters['year_start'] = self.year_start
+            api_filters["year_start"] = self.year_start
         if self.year_end is not None:
-            api_filters['year_end'] = self.year_end
+            api_filters["year_end"] = self.year_end
         if self.open_access is not None:
-            api_filters['open_access'] = self.open_access
+            api_filters["open_access"] = self.open_access
         if self.document_type is not None:
-            api_filters['document_type'] = self.document_type
+            api_filters["document_type"] = self.document_type
 
         return api_filters
 
@@ -184,15 +184,15 @@ class SearchQueryParser:
         post_filters = {}
 
         if self.negative_keywords:
-            post_filters['negative_keywords'] = self.negative_keywords
+            post_filters["negative_keywords"] = self.negative_keywords
         if self.min_impact_factor is not None:
-            post_filters['min_impact_factor'] = self.min_impact_factor
+            post_filters["min_impact_factor"] = self.min_impact_factor
         if self.max_impact_factor is not None:
-            post_filters['max_impact_factor'] = self.max_impact_factor
+            post_filters["max_impact_factor"] = self.max_impact_factor
         if self.min_citations is not None:
-            post_filters['min_citations'] = self.min_citations
+            post_filters["min_citations"] = self.min_citations
         if self.max_citations is not None:
-            post_filters['max_citations'] = self.max_citations
+            post_filters["max_citations"] = self.max_citations
 
         return post_filters
 
@@ -202,23 +202,23 @@ class SearchQueryParser:
 
         # Positive keywords
         if self.positive_keywords:
-            keyword_part = ' '.join(self.positive_keywords)
-            parts.append(f'({keyword_part})[Title/Abstract]')
+            keyword_part = " ".join(self.positive_keywords)
+            parts.append(f"({keyword_part})[Title/Abstract]")
 
         # Negative keywords
         for neg in self.negative_keywords:
-            parts.append(f'NOT {neg}[Title/Abstract]')
+            parts.append(f"NOT {neg}[Title/Abstract]")
 
         # Year range
         if self.year_start and self.year_end:
-            parts.append(f'{self.year_start}:{self.year_end}[pdat]')
+            parts.append(f"{self.year_start}:{self.year_end}[pdat]")
         elif self.year_start:
             current_year = datetime.now().year
-            parts.append(f'{self.year_start}:{current_year}[pdat]')
+            parts.append(f"{self.year_start}:{current_year}[pdat]")
         elif self.year_end:
-            parts.append(f'1900:{self.year_end}[pdat]')
+            parts.append(f"1900:{self.year_end}[pdat]")
 
-        return ' AND '.join(parts) if parts else ''
+        return " AND ".join(parts) if parts else ""
 
     def to_crossref_params(self) -> Dict[str, Any]:
         """Convert to CrossRef API parameters."""
@@ -226,16 +226,16 @@ class SearchQueryParser:
 
         # Query
         if self.positive_keywords:
-            params['query.bibliographic'] = ' '.join(self.positive_keywords)
+            params["query.bibliographic"] = " ".join(self.positive_keywords)
 
         # Year filter
         if self.year_start:
-            params['filter'] = f'from-pub-date:{self.year_start}'
+            params["filter"] = f"from-pub-date:{self.year_start}"
         if self.year_end:
-            if 'filter' in params:
-                params['filter'] += f',until-pub-date:{self.year_end}'
+            if "filter" in params:
+                params["filter"] += f",until-pub-date:{self.year_end}"
             else:
-                params['filter'] = f'until-pub-date:{self.year_end}'
+                params["filter"] = f"until-pub-date:{self.year_end}"
 
         return params
 
@@ -245,16 +245,16 @@ class SearchQueryParser:
 
         # Positive keywords
         for kw in self.positive_keywords:
-            if ' ' in kw:  # Quoted phrase
+            if " " in kw:  # Quoted phrase
                 parts.append(f'all:"{kw}"')
             else:
-                parts.append(f'all:{kw}')
+                parts.append(f"all:{kw}")
 
         # Negative keywords
         for neg in self.negative_keywords:
-            parts.append(f'ANDNOT all:{neg}')
+            parts.append(f"ANDNOT all:{neg}")
 
-        return ' AND '.join(parts) if parts else ''
+        return " AND ".join(parts) if parts else ""
 
     def __repr__(self) -> str:
         return (

scitex/scholar/search_engines/ScholarSearchEngine.py

@@ -31,8 +31,12 @@ from typing import List, Dict, Any, Optional, Literal
 from datetime import datetime
 
 from scitex import logging
-from scitex.scholar.pipelines.ScholarPipelineSearchParallel import ScholarPipelineSearchParallel
-from scitex.scholar.pipelines.ScholarPipelineSearchSingle import ScholarPipelineSearchSingle
+from scitex.scholar.pipelines.ScholarPipelineSearchParallel import (
+    ScholarPipelineSearchParallel,
+)
+from scitex.scholar.pipelines.ScholarPipelineSearchSingle import (
+    ScholarPipelineSearchSingle,
+)
 from scitex.scholar.pipelines.SearchQueryParser import SearchQueryParser
 
 logger = logging.getLogger(__name__)
@@ -43,7 +47,7 @@ class ScholarSearchEngine:
 
     def __init__(
         self,
-        default_mode: Literal['parallel', 'single'] = 'parallel',
+        default_mode: Literal["parallel", "single"] = "parallel",
         use_cache: bool = True,
         email: str = None,
     ):
@@ -74,11 +78,11 @@ class ScholarSearchEngine:
 
         # Statistics
         self.stats = {
-            'total_searches': 0,
-            'parallel_searches': 0,
-            'single_searches': 0,
-            'total_results': 0,
-            'avg_search_time': 0.0,
+            "total_searches": 0,
+            "parallel_searches": 0,
+            "single_searches": 0,
+            "total_results": 0,
+            "avg_search_time": 0.0,
         }
 
         logger.info(
@@ -89,7 +93,7 @@ class ScholarSearchEngine:
     async def search(
         self,
         query: str,
-        mode: Optional[Literal['parallel', 'single']] = None,
+        mode: Optional[Literal["parallel", "single"]] = None,
         filters: Optional[Dict[str, Any]] = None,
         max_results: int = 100,
         parse_query: bool = True,
@@ -125,7 +129,7 @@ class ScholarSearchEngine:
             )
         """
         start_time = datetime.now()
-        self.stats['total_searches'] += 1
+        self.stats["total_searches"] += 1
 
         # Determine search mode
         search_mode = mode or self.default_mode
@@ -139,7 +143,7 @@ class ScholarSearchEngine:
             combined_filters = {**parsed_filters, **(filters or {})}
 
             # Build clean query from positive keywords
-            clean_query = ' '.join(parsed_filters.get('positive_keywords', [query]))
+            clean_query = " ".join(parsed_filters.get("positive_keywords", [query]))
 
             logger.info(
                 f"{self.name}: Parsed query '{query}' -> "
@@ -150,13 +154,13 @@ class ScholarSearchEngine:
             combined_filters = filters or {}
 
         # Select pipeline
-        if search_mode == 'parallel':
+        if search_mode == "parallel":
             pipeline = self.parallel_pipeline
-            self.stats['parallel_searches'] += 1
+            self.stats["parallel_searches"] += 1
             logger.info(f"{self.name}: Using parallel search mode")
         else:
             pipeline = self.single_pipeline
-            self.stats['single_searches'] += 1
+            self.stats["single_searches"] += 1
             logger.info(f"{self.name}: Using single (sequential) search mode")
 
         # Execute search
@@ -169,16 +173,16 @@ class ScholarSearchEngine:
 
             # Update statistics
             search_time = (datetime.now() - start_time).total_seconds()
-            n = self.stats['total_searches']
-            self.stats['avg_search_time'] = (
-                (self.stats['avg_search_time'] * (n - 1) + search_time) / n
-            )
-            self.stats['total_results'] += len(result.get('results', []))
+            n = self.stats["total_searches"]
+            self.stats["avg_search_time"] = (
+                self.stats["avg_search_time"] * (n - 1) + search_time
+            ) / n
+            self.stats["total_results"] += len(result.get("results", []))
 
             # Add search engine metadata
-            result['metadata']['search_mode'] = search_mode
-            result['metadata']['parsed_query'] = clean_query if parse_query else None
-            result['metadata']['original_query'] = query
+            result["metadata"]["search_mode"] = search_mode
+            result["metadata"]["parsed_query"] = clean_query if parse_query else None
+            result["metadata"]["original_query"] = query
 
             logger.success(
                 f"{self.name}: Search completed in {search_time:.2f}s, "
@@ -194,7 +198,7 @@ class ScholarSearchEngine:
     async def search_by_doi(
         self,
         doi: str,
-        mode: Optional[Literal['parallel', 'single']] = None,
+        mode: Optional[Literal["parallel", "single"]] = None,
     ) -> Dict[str, Any]:
         """Search for a paper by DOI.
 
@@ -217,7 +221,7 @@ class ScholarSearchEngine:
     async def search_by_title(
         self,
         title: str,
-        mode: Optional[Literal['parallel', 'single']] = None,
+        mode: Optional[Literal["parallel", "single"]] = None,
         max_results: int = 10,
     ) -> Dict[str, Any]:
         """Search for papers by title.
@@ -246,9 +250,9 @@ class ScholarSearchEngine:
             Dict with statistics from engine and pipelines
         """
         return {
-            'engine_stats': self.stats,
-            'parallel_pipeline_stats': self.parallel_pipeline.get_statistics(),
-            'single_pipeline_stats': self.single_pipeline.get_statistics(),
+            "engine_stats": self.stats,
+            "parallel_pipeline_stats": self.parallel_pipeline.get_statistics(),
+            "single_pipeline_stats": self.single_pipeline.get_statistics(),
         }
 
     def get_supported_engines(self) -> List[str]:

scitex/scholar/search_engines/_BaseSearchEngine.py

@@ -87,9 +87,7 @@ class BaseSearchEngine(ABC):
         pass
 
     def _build_query_with_filters(
-        self,
-        base_query: str,
-        filters: Optional[Dict[str, Any]] = None
+        self, base_query: str, filters: Optional[Dict[str, Any]] = None
     ) -> str:
         """Helper to build engine-specific query with filters.
 
@@ -105,9 +103,7 @@ class BaseSearchEngine(ABC):
         return base_query
 
     def _apply_post_filters(
-        self,
-        results: List[Dict[str, Any]],
-        filters: Optional[Dict[str, Any]] = None
+        self, results: List[Dict[str, Any]], filters: Optional[Dict[str, Any]] = None
     ) -> List[Dict[str, Any]]:
         """Apply client-side filters that couldn't be pushed to API.
 
@@ -124,47 +120,48 @@ class BaseSearchEngine(ABC):
         filtered = results
 
         # Filter by negative keywords in title/abstract
-        negative_keywords = filters.get('negative_keywords', [])
+        negative_keywords = filters.get("negative_keywords", [])
         if negative_keywords:
             filtered = [
-                paper for paper in filtered
+                paper
+                for paper in filtered
                 if not self._contains_negative_keywords(paper, negative_keywords)
             ]
 
         # Filter by minimum citations
-        min_citations = filters.get('min_citations')
+        min_citations = filters.get("min_citations")
         if min_citations is not None:
             filtered = [
-                paper for paper in filtered
+                paper
+                for paper in filtered
                 if self._get_citation_count(paper) >= min_citations
             ]
 
         # Filter by maximum citations
-        max_citations = filters.get('max_citations')
+        max_citations = filters.get("max_citations")
         if max_citations is not None:
             filtered = [
-                paper for paper in filtered
+                paper
+                for paper in filtered
                 if self._get_citation_count(paper) <= max_citations
             ]
 
         return filtered
 
     def _contains_negative_keywords(
-        self,
-        paper: Dict[str, Any],
-        negative_keywords: List[str]
+        self, paper: Dict[str, Any], negative_keywords: List[str]
     ) -> bool:
         """Check if paper contains any negative keywords."""
         # Get searchable text
         text_parts = []
 
-        if 'basic' in paper:
-            if paper['basic'].get('title'):
-                text_parts.append(paper['basic']['title'].lower())
-            if paper['basic'].get('abstract'):
-                text_parts.append(paper['basic']['abstract'].lower())
+        if "basic" in paper:
+            if paper["basic"].get("title"):
+                text_parts.append(paper["basic"]["title"].lower())
+            if paper["basic"].get("abstract"):
+                text_parts.append(paper["basic"]["abstract"].lower())
 
-        searchable_text = ' '.join(text_parts)
+        searchable_text = " ".join(text_parts)
 
         # Check for negative keywords
         for neg_kw in negative_keywords:
@@ -175,8 +172,8 @@ class BaseSearchEngine(ABC):
 
     def _get_citation_count(self, paper: Dict[str, Any]) -> int:
         """Extract citation count from paper metadata."""
-        if 'metrics' in paper and paper['metrics'].get('citation_count'):
-            return paper['metrics']['citation_count']
+        if "metrics" in paper and paper["metrics"].get("citation_count"):
+            return paper["metrics"]["citation_count"]
         return 0