aiagents4pharma 1.43.0__py3-none-any.whl → 1.45.0__py3-none-any.whl

aiagents4pharma/talk2scholars/tests/{test_base_paper_downloader.py → test_utils_base_paper_downloader.py}

@@ -3,11 +3,11 @@ Unit tests for BasePaperDownloader.
 Tests the abstract base class functionality and common methods.
 """
 
+import inspect
 import unittest
-from typing import Any, Dict, Optional, Tuple
+from typing import Any
 from unittest.mock import Mock, patch
 
-import inspect
 import requests
 
 from aiagents4pharma.talk2scholars.tools.paper_download.utils.base_paper_downloader import (
@@ -31,8 +31,8 @@ class ConcretePaperDownloader(BasePaperDownloader):
         return f"https://test.com/{identifier}.pdf"
 
     def extract_paper_metadata(
-        self, metadata: Any, identifier: str, pdf_result: Optional[Tuple[str, str]]
-    ) -> Dict[str, Any]:
+        self, metadata: Any, identifier: str, pdf_result: tuple[str, str] | None
+    ) -> dict[str, Any]:
         """Concrete implementation for testing."""
         return {
             "Title": f"Test Paper {identifier}",
@@ -53,21 +53,19 @@ class ConcretePaperDownloader(BasePaperDownloader):
         """Concrete implementation for testing."""
         return f"test_{identifier}.pdf"
 
-    def _get_paper_identifier_info(self, paper: Dict[str, Any]) -> str:
+    def _get_paper_identifier_info(self, paper: dict[str, Any]) -> str:
         """Concrete implementation for testing."""
         return f" ({paper.get('identifier', 'unknown')})"
 
-    def _add_service_identifier(self, entry: Dict[str, Any], identifier: str) -> None:
+    def _add_service_identifier(self, entry: dict[str, Any], identifier: str) -> None:
         """Concrete implementation for testing."""
         entry["test_id"] = identifier
 
-    def get_paper_identifier_info_public(self, paper: Dict[str, Any]) -> str:
+    def get_paper_identifier_info_public(self, paper: dict[str, Any]) -> str:
         """Public wrapper to access protected identifier info for tests."""
         return self._get_paper_identifier_info(paper)
 
-    def add_service_identifier_public(
-        self, entry: Dict[str, Any], identifier: str
-    ) -> None:
+    def add_service_identifier_public(self, entry: dict[str, Any], identifier: str) -> None:
         """Public wrapper to access protected service identifier for tests."""
         self._add_service_identifier(entry, identifier)
 
@@ -109,9 +107,7 @@ class TestBasePaperDownloader(unittest.TestCase):
         mock_response = Mock()
         mock_response.raise_for_status = Mock()
         mock_response.iter_content.return_value = [b"PDF chunk 1", b"PDF chunk 2"]
-        mock_response.headers = {
-            "Content-Disposition": 'attachment; filename="paper.pdf"'
-        }
+        mock_response.headers = {"Content-Disposition": 'attachment; filename="paper.pdf"'}
         mock_get.return_value = mock_response
 
         # Mock temporary file
@@ -121,9 +117,7 @@ class TestBasePaperDownloader(unittest.TestCase):
         mock_temp_file.__exit__ = Mock(return_value=None)
         mock_tempfile.return_value = mock_temp_file
 
-        result = self.downloader.download_pdf_to_temp(
-            "https://test.com/paper.pdf", "12345"
-        )
+        result = self.downloader.download_pdf_to_temp("https://test.com/paper.pdf", "12345")
 
         # Verify result
         self.assertEqual(result, ("/tmp/test.pdf", "paper.pdf"))
@@ -153,9 +147,7 @@ class TestBasePaperDownloader(unittest.TestCase):
         """Test PDF download with network error."""
         mock_get.side_effect = requests.RequestException("Network error")
 
-        result = self.downloader.download_pdf_to_temp(
-            "https://test.com/paper.pdf", "12345"
-        )
+        result = self.downloader.download_pdf_to_temp("https://test.com/paper.pdf", "12345")
 
         self.assertIsNone(result)
 
@@ -235,12 +227,8 @@ class TestBasePaperDownloader(unittest.TestCase):
                 raise requests.RequestException("Fetch failed")
             return {"test": identifier}
 
-        with patch.object(
-            self.downloader, "fetch_metadata", side_effect=mock_fetch_metadata
-        ):
-            with patch.object(
-                self.downloader, "download_pdf_to_temp", return_value=None
-            ):
+        with patch.object(self.downloader, "fetch_metadata", side_effect=mock_fetch_metadata):
+            with patch.object(self.downloader, "download_pdf_to_temp", return_value=None):
                 result = self.downloader.process_identifiers(identifiers)
 
         # Valid identifier should succeed
@@ -316,11 +304,11 @@ class TestBasePaperDownloader(unittest.TestCase):
         """Test building summary with long list (should show only top 3)."""
         article_data = {}
         for i in range(5):  # More than 3
-            article_data[f"{i+1}"] = {
-                "Title": f"Paper {i+1}",
-                "identifier": f"{i+1}",
+            article_data[f"{i + 1}"] = {
+                "Title": f"Paper {i + 1}",
+                "identifier": f"{i + 1}",
                 "access_type": "open_access_downloaded",
-                "Abstract": f"Abstract {i+1}",
+                "Abstract": f"Abstract {i + 1}",
             }
 
         result = self.downloader.build_summary(article_data)
@@ -388,9 +376,7 @@ class TestBasePaperDownloader(unittest.TestCase):
             BasePaperDownloader.construct_pdf_url(self.downloader, {}, "test")
 
         with self.assertRaises(NotImplementedError):
-            BasePaperDownloader.extract_paper_metadata(
-                self.downloader, {}, "test", None
-            )
+            BasePaperDownloader.extract_paper_metadata(self.downloader, {}, "test", None)
 
         with self.assertRaises(NotImplementedError):
             BasePaperDownloader.get_service_name(self.downloader)
@@ -402,15 +388,13 @@ class TestBasePaperDownloader(unittest.TestCase):
             BasePaperDownloader.get_default_filename(self.downloader, "test")
 
         # Protected abstract methods: call via getattr to avoid W0212 while still executing code.
+        method_name_1 = "_get_paper_identifier_info"
         with self.assertRaises(NotImplementedError):
-            getattr(BasePaperDownloader, "_get_paper_identifier_info")(
-                self.downloader, {}
-            )
+            getattr(BasePaperDownloader, method_name_1)(self.downloader, {})
 
+        method_name_2 = "_add_service_identifier"
         with self.assertRaises(NotImplementedError):
-            getattr(BasePaperDownloader, "_add_service_identifier")(
-                self.downloader, {}, "test"
-            )
+            getattr(BasePaperDownloader, method_name_2)(self.downloader, {}, "test")
 
     @patch("tempfile.NamedTemporaryFile")
     @patch("requests.get")
@@ -420,9 +404,7 @@ class TestBasePaperDownloader(unittest.TestCase):
         mock_response = Mock()
         mock_response.raise_for_status = Mock()
         mock_response.iter_content.return_value = [b"PDF data"]
-        mock_response.headers = {
-            "Content-Disposition": 'attachment; filename="paper.pdf"'
-        }
+        mock_response.headers = {"Content-Disposition": 'attachment; filename="paper.pdf"'}
         mock_get.return_value = mock_response
 
         # Mock temporary file
@@ -434,9 +416,7 @@ class TestBasePaperDownloader(unittest.TestCase):
 
         # Patch re.search to raise an exception during filename extraction
         with patch("re.search", side_effect=requests.RequestException("Regex error")):
-            result = self.downloader.download_pdf_to_temp(
-                "https://test.com/paper.pdf", "12345"
-            )
+            result = self.downloader.download_pdf_to_temp("https://test.com/paper.pdf", "12345")
 
         # Should still succeed but use default filename due to exception
         self.assertEqual(result, ("/tmp/test.pdf", "test_12345.pdf"))
@@ -507,9 +487,7 @@ class TestBasePaperDownloaderEdgeCases(unittest.TestCase):
         mock_temp_file.__exit__ = Mock(return_value=None)
         mock_tempfile.return_value = mock_temp_file
 
-        with patch.object(
-            self.downloader, "get_default_filename", return_value="default.pdf"
-        ):
+        with patch.object(self.downloader, "get_default_filename", return_value="default.pdf"):
             # Call without assigning to avoid 'unused-variable'
             self.downloader.download_pdf_to_temp("https://test.com/paper.pdf", "12345")
 

aiagents4pharma/talk2scholars/tests/{test_biorxiv_downloader.py → test_utils_biorxiv_downloader.py}

@@ -122,9 +122,7 @@ class TestBiorxivDownloader(unittest.TestCase):
         result = self.downloader.fetch_metadata("10.1101/2023.01.01.123456")
 
         # Verify API call
-        expected_url = (
-            "https://api.biorxiv.org/details/biorxiv/10.1101/2023.01.01.123456/na/json"
-        )
+        expected_url = "https://api.biorxiv.org/details/biorxiv/10.1101/2023.01.01.123456/na/json"
         mock_scraper.get.assert_called_once_with(expected_url, timeout=30)
         mock_response.raise_for_status.assert_called_once()
 
@@ -171,9 +169,7 @@ class TestBiorxivDownloader(unittest.TestCase):
         # Default version
         meta_default = {"collection": [{"title": "Test Paper"}]}
         self.assertEqual(
-            self.downloader.construct_pdf_url(
-                meta_default, "10.1101/2023.01.01.123456"
-            ),
+            self.downloader.construct_pdf_url(meta_default, "10.1101/2023.01.01.123456"),
             "https://www.biorxiv.org/content/10.1101/2023.01.01.123456v1.full.pdf",
         )
 
@@ -195,9 +191,7 @@ class TestBiorxivDownloader(unittest.TestCase):
             b"PDF content chunk 1",
             b"PDF content chunk 2",
         ]
-        mock_pdf_response.headers = {
-            "Content-Disposition": 'attachment; filename="paper.pdf"'
-        }
+        mock_pdf_response.headers = {"Content-Disposition": 'attachment; filename="paper.pdf"'}
 
         mock_scraper.get.side_effect = [mock_landing_response, mock_pdf_response]
 
@@ -209,9 +203,7 @@ class TestBiorxivDownloader(unittest.TestCase):
         mock_tempfile.return_value = mock_temp_file
 
         pdf_url = "https://www.biorxiv.org/content/10.1101/2023.01.01.123456v1.full.pdf"
-        result = self.downloader.download_pdf_to_temp(
-            pdf_url, "10.1101/2023.01.01.123456"
-        )
+        result = self.downloader.download_pdf_to_temp(pdf_url, "10.1101/2023.01.01.123456")
 
         # Verify result
         self.assertEqual(result, ("/tmp/test.pdf", "paper.pdf"))
@@ -263,9 +255,7 @@ class TestBiorxivDownloader(unittest.TestCase):
         mock_scraper.get.return_value = ok
 
         # Case 1: with .full.pdf -> should visit landing
-        pdf_url_full = (
-            "https://www.biorxiv.org/content/10.1101/2023.01.01.123456v1.full.pdf"
-        )
+        pdf_url_full = "https://www.biorxiv.org/content/10.1101/2023.01.01.123456v1.full.pdf"
         self.downloader.visit_landing_page_public(
             mock_scraper, pdf_url_full, "10.1101/2023.01.01.123456"
         )
@@ -324,9 +314,7 @@ class TestBiorxivDownloader(unittest.TestCase):
             ),  # trigger exception path
         ]
         for headers, expected, raise_regex in cases:
-            with self.subTest(
-                headers=headers, expected=expected, raise_regex=raise_regex
-            ):
+            with self.subTest(headers=headers, expected=expected, raise_regex=raise_regex):
                 resp = Mock()
                 resp.headers = headers
                 if raise_regex:
@@ -339,18 +327,14 @@ class TestBiorxivDownloader(unittest.TestCase):
                             "get_default_filename",
                             return_value="default.pdf",
                         ):
-                            got = self.downloader.extract_filename_public(
-                                resp, "10.1101/test"
-                            )
+                            got = self.downloader.extract_filename_public(resp, "10.1101/test")
                 else:
                     with patch.object(
                         self.downloader,
                         "get_default_filename",
                         return_value="default.pdf",
                     ):
-                        got = self.downloader.extract_filename_public(
-                            resp, "10.1101/test"
-                        )
+                        got = self.downloader.extract_filename_public(resp, "10.1101/test")
                 self.assertEqual(got, expected)
 
     def test_extract_paper_metadata_success(self):
@@ -396,18 +380,14 @@ class TestBiorxivDownloader(unittest.TestCase):
         self.assertEqual(result["URL"], "")
         self.assertEqual(result["pdf_url"], "")
         self.assertEqual(result["temp_file_path"], "")
-        self.assertEqual(
-            result["filename"], "10_1101_2023_01_01_123456.pdf"
-        )  # Default filename
+        self.assertEqual(result["filename"], "10_1101_2023_01_01_123456.pdf")  # Default filename
 
     def test_extract_paper_metadata_no_collection(self):
         """Test metadata extraction with missing collection."""
         metadata = {}
 
         with self.assertRaises(RuntimeError) as context:
-            self.downloader.extract_paper_metadata(
-                metadata, "10.1101/2023.01.01.123456", None
-            )
+            self.downloader.extract_paper_metadata(metadata, "10.1101/2023.01.01.123456", None)
 
         self.assertIn("No collection data found", str(context.exception))
 
@@ -415,9 +395,7 @@ class TestBiorxivDownloader(unittest.TestCase):
         """Test basic metadata extraction helper method."""
         paper = self.sample_json_response["collection"][0]
 
-        result = self.downloader.extract_basic_metadata_public(
-            paper, "10.1101/2023.01.01.123456"
-        )
+        result = self.downloader.extract_basic_metadata_public(paper, "10.1101/2023.01.01.123456")
 
         expected = {
             "Title": "Test BioRxiv Paper",
@@ -468,9 +446,7 @@ class TestBiorxivDownloader(unittest.TestCase):
         """Test _add_service_identifier method."""
         entry = {}
 
-        self.downloader.add_service_identifier_public(
-            entry, "10.1101/2023.01.01.123456"
-        )
+        self.downloader.add_service_identifier_public(entry, "10.1101/2023.01.01.123456")
 
         self.assertEqual(entry["DOI"], "10.1101/2023.01.01.123456")
         self.assertEqual(entry["server"], "biorxiv")
@@ -561,9 +537,7 @@ class TestBiorxivDownloaderIntegration(unittest.TestCase):
         pdf_result = self.downloader.download_pdf_to_temp(pdf_url, identifier)
 
         # Step 4: Extract metadata
-        paper_data = self.downloader.extract_paper_metadata(
-            metadata, identifier, pdf_result
-        )
+        paper_data = self.downloader.extract_paper_metadata(metadata, identifier, pdf_result)
 
         # Verify the complete workflow
         self.assertEqual(paper_data["Title"], "Integration Test Paper")
@@ -571,9 +545,7 @@ class TestBiorxivDownloaderIntegration(unittest.TestCase):
         self.assertEqual(paper_data["access_type"], "open_access_downloaded")
         self.assertEqual(paper_data["temp_file_path"], "/tmp/integration.pdf")
 
-        expected_pdf_url = (
-            "https://www.biorxiv.org/content/10.1101/2023.01.01.123456v1.full.pdf"
-        )
+        expected_pdf_url = "https://www.biorxiv.org/content/10.1101/2023.01.01.123456v1.full.pdf"
         self.assertEqual(pdf_url, expected_pdf_url)
 
         # Verify 3 calls: metadata, landing page, PDF

aiagents4pharma/talk2scholars/tests/{test_medrxiv_downloader.py → test_utils_medrxiv_downloader.py}

@@ -89,9 +89,7 @@ class TestMedrxivDownloader(unittest.TestCase):
         result = self.downloader.fetch_metadata("10.1101/2023.01.01.123456")
 
         # Verify API call - should include /medrxiv/ and /na/json
-        expected_url = (
-            "https://api.medrxiv.org/details/medrxiv/10.1101/2023.01.01.123456/na/json"
-        )
+        expected_url = "https://api.medrxiv.org/details/medrxiv/10.1101/2023.01.01.123456/na/json"
         mock_get.assert_called_once_with(expected_url, timeout=30)
         mock_response.raise_for_status.assert_called_once()
 
@@ -133,9 +131,7 @@ class TestMedrxivDownloader(unittest.TestCase):
         )
         # Empty collection
         self.assertEqual(
-            self.downloader.construct_pdf_url(
-                {"collection": []}, "10.1101/2023.01.01.123456"
-            ),
+            self.downloader.construct_pdf_url({"collection": []}, "10.1101/2023.01.01.123456"),
             "",
         )
         # Custom version
@@ -179,9 +175,7 @@ class TestMedrxivDownloader(unittest.TestCase):
         """Test metadata extraction without PDF download."""
         metadata = self.sample_json_response
 
-        with patch.object(
-            self.downloader, "get_default_filename", return_value="default.pdf"
-        ):
+        with patch.object(self.downloader, "get_default_filename", return_value="default.pdf"):
             result = self.downloader.extract_paper_metadata(
                 metadata, "10.1101/2023.01.01.123456", None
             )
@@ -196,9 +190,7 @@ class TestMedrxivDownloader(unittest.TestCase):
         metadata = {}
 
         with self.assertRaises(RuntimeError) as context:
-            self.downloader.extract_paper_metadata(
-                metadata, "10.1101/2023.01.01.123456", None
-            )
+            self.downloader.extract_paper_metadata(metadata, "10.1101/2023.01.01.123456", None)
 
         self.assertIn("No collection data found", str(context.exception))
 
@@ -224,9 +216,7 @@ class TestMedrxivDownloader(unittest.TestCase):
 
         # Missing fields
         paper_missing = {"title": "Test Paper"}  # Missing others
-        got_missing = self.downloader.extract_basic_metadata_public(
-            paper_missing, "10.1101/test"
-        )
+        got_missing = self.downloader.extract_basic_metadata_public(paper_missing, "10.1101/test")
         self.assertEqual(got_missing["Title"], "Test Paper")
         self.assertEqual(got_missing["Authors"], [])
         self.assertEqual(got_missing["Abstract"], "N/A")
@@ -261,9 +251,7 @@ class TestMedrxivDownloader(unittest.TestCase):
         )
 
         # Without result
-        with patch.object(
-            self.downloader, "get_default_filename", return_value="default.pdf"
-        ):
+        with patch.object(self.downloader, "get_default_filename", return_value="default.pdf"):
             expected_without = {
                 "URL": "",
                 "pdf_url": "",
@@ -302,9 +290,7 @@ class TestMedrxivDownloader(unittest.TestCase):
     def test_add_service_identifier(self):
         """Test _add_service_identifier method."""
         entry = {}
-        self.downloader.add_service_identifier_public(
-            entry, "10.1101/2023.01.01.123456"
-        )
+        self.downloader.add_service_identifier_public(entry, "10.1101/2023.01.01.123456")
         self.assertEqual(entry["DOI"], "10.1101/2023.01.01.123456")
         self.assertEqual(entry["server"], "medrxiv")
 
@@ -368,9 +354,7 @@ class TestMedrxivDownloaderIntegration(unittest.TestCase):
         pdf_result = self.downloader.download_pdf_to_temp(pdf_url, identifier)
 
         # Step 4: Extract metadata
-        paper_data = self.downloader.extract_paper_metadata(
-            metadata, identifier, pdf_result
-        )
+        paper_data = self.downloader.extract_paper_metadata(metadata, identifier, pdf_result)
 
         # Verify the complete workflow
         self.assertEqual(paper_data["Title"], "Integration Test Paper")
@@ -384,9 +368,7 @@ class TestMedrxivDownloaderIntegration(unittest.TestCase):
             "https://api.medrxiv.org/details/medrxiv/10.1101/2023.01.01.123456/na/json",
             timeout=30,
         )
-        expected_pdf_url = (
-            "https://www.medrxiv.org/content/10.1101/2023.01.01.123456v2.full.pdf"
-        )
+        expected_pdf_url = "https://www.medrxiv.org/content/10.1101/2023.01.01.123456v2.full.pdf"
         mock_download.assert_called_once_with(expected_pdf_url, identifier)
 
     @patch("requests.get")
@@ -413,25 +395,15 @@ class TestMedrxivDownloaderIntegration(unittest.TestCase):
         with self.assertRaises(RuntimeError) as context:
             self.downloader.fetch_metadata(identifier)
 
-        self.assertIn(
-            "No collection data found in medRxiv API response", str(context.exception)
-        )
+        self.assertIn("No collection data found in medRxiv API response", str(context.exception))
 
     @patch("requests.get")
     def test_multiple_identifiers_workflow(self, mock_get):
         """Test processing multiple identifiers."""
         # Mock different responses for different DOIs
         responses = [
-            {
-                "collection": [
-                    {"title": "Paper 1", "version": "1", "authors": "Author 1"}
-                ]
-            },
-            {
-                "collection": [
-                    {"title": "Paper 2", "version": "2", "authors": "Author 2"}
-                ]
-            },
+            {"collection": [{"title": "Paper 1", "version": "1", "authors": "Author 1"}]},
+            {"collection": [{"title": "Paper 2", "version": "2", "authors": "Author 2"}]},
         ]
 
         mock_responses = []
@@ -448,12 +420,8 @@ class TestMedrxivDownloaderIntegration(unittest.TestCase):
 
         for identifier in identifiers:
             metadata = self.downloader.fetch_metadata(identifier)
-            _ = self.downloader.construct_pdf_url(
-                metadata, identifier
-            )  # ensure path covered
-            paper_data = self.downloader.extract_paper_metadata(
-                metadata, identifier, None
-            )
+            _ = self.downloader.construct_pdf_url(metadata, identifier)  # ensure path covered
+            paper_data = self.downloader.extract_paper_metadata(metadata, identifier, None)
             results[identifier] = paper_data
 
         # Verify both papers were processed
@@ -529,6 +497,4 @@ class TestMedrxivSpecialCases(unittest.TestCase):
         # Should handle Unicode properly
         self.assertEqual(result["Title"], "Título com acentos é símbolos especiais")
         self.assertEqual(result["Authors"], ["José María", "François Müller"])
-        self.assertEqual(
-            result["Abstract"], "Resumo com çaracteres especiais ñ símbolos"
-        )
+        self.assertEqual(result["Abstract"], "Resumo com çaracteres especiais ñ símbolos")

aiagents4pharma/talk2scholars/tests/{test_nvidia_nim_reranker.py → test_utils_nvidia_nim_reranker.py}

@@ -19,7 +19,7 @@ def fixture_chunks():
     return [
         Document(
             page_content=f"chunk {i}",
-            metadata={"paper_id": f"P{i%2}", "relevance_score": 0.9 - 0.01 * i},
+            metadata={"paper_id": f"P{i % 2}", "relevance_score": 0.9 - 0.01 * i},
         )
         for i in range(10)
     ]
@@ -27,9 +27,7 @@ def fixture_chunks():
 
 def test_rerank_chunks_short_input(chunks_fixture):
     """rerank_chunks with fewer chunks than top_k should return original."""
-    result = rerank_chunks(
-        chunks_fixture[:3], "What is cancer?", config=MagicMock(), top_k=5
-    )
+    result = rerank_chunks(chunks_fixture[:3], "What is cancer?", config=MagicMock(), top_k=5)
     assert result == chunks_fixture[:3]
 
 
@@ -65,9 +63,7 @@ def test_rerank_chunks_success(mock_reranker_cls, chunks_fixture):
     mock_config.reranker.api_key = "test_key"
     mock_config.reranker.model = "test_model"
 
-    result = rerank_chunks(
-        chunks_fixture, "Explain mitochondria.", config=mock_config, top_k=5
-    )
+    result = rerank_chunks(chunks_fixture, "Explain mitochondria.", config=mock_config, top_k=5)
 
     assert isinstance(result, list)
     assert result == list(reversed(chunks_fixture))[:5]
@@ -77,9 +73,7 @@ def test_rerank_chunks_success(mock_reranker_cls, chunks_fixture):
 
 
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker.NVIDIARerank")
-def test_rerank_chunks_reranker_fails_raises_and_calls_compress(
-    mock_reranker_cls, chunks_fixture
-):
+def test_rerank_chunks_reranker_fails_raises_and_calls_compress(mock_reranker_cls, chunks_fixture):
     """
     If NVIDIARerank.compress_documents raises RuntimeError:
       - rerank_chunks should propagate the RuntimeError
@@ -94,9 +88,7 @@ def test_rerank_chunks_reranker_fails_raises_and_calls_compress(
     mock_config.reranker.model = "reranker"
 
     with pytest.raises(RuntimeError, match="API failure"):
-        rerank_chunks(
-            chunks_fixture, "How does light affect plants?", config=mock_config, top_k=3
-        )
+        rerank_chunks(chunks_fixture, "How does light affect plants?", config=mock_config, top_k=3)
 
     reranker_instance.compress_documents.assert_called_once_with(
         query="How does light affect plants?", documents=chunks_fixture
@@ -105,9 +97,7 @@ def test_rerank_chunks_reranker_fails_raises_and_calls_compress(
 
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker.logger")
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker.NVIDIARerank")
-def test_rerank_chunks_debug_block_triggered(
-    mock_reranker_cls, mock_logger, chunks_fixture
-):
+def test_rerank_chunks_debug_block_triggered(mock_reranker_cls, mock_logger, chunks_fixture):
     """rerank_chunks should log debug info if debug logging is enabled."""
     mock_logger.isEnabledFor.return_value = True
 

aiagents4pharma/talk2scholars/tests/{test_pdf_answer_formatter.py → test_utils_pdf_answer_formatter.py}

@@ -1,6 +1,7 @@
 """answer_formatter tests."""
 
 from unittest.mock import patch
+
 import pytest
 
 from aiagents4pharma.talk2scholars.tools.pdf.utils.answer_formatter import format_answer

aiagents4pharma/talk2scholars/tests/{test_pdf_batch_processor.py → test_utils_pdf_batch_processor.py}

@@ -1,6 +1,7 @@
 """Tests for the PDF batch processor module."""
 
 from unittest.mock import MagicMock, patch
+
 import pytest
 
 from aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor import (
@@ -22,18 +23,14 @@ def _args_fixture():
     }
 
 
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
-)
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf")
 def test_no_papers_to_add(mock_loader, args_fixture):
     """Test case where no papers are provided to add."""
     add_papers_batch(papers_to_add=[], **args_fixture)
     mock_loader.assert_not_called()
 
 
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
-)
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf")
 def test_all_papers_already_loaded(mock_loader, args_fixture):
     """Test case where all papers are already loaded."""
     args_fixture["loaded_papers"].update(["p1", "p2"])
@@ -44,9 +41,7 @@ def test_all_papers_already_loaded(mock_loader, args_fixture):
     mock_loader.assert_not_called()
 
 
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
-)
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf")
 def test_successful_batch_embedding(mock_loader, args_fixture):
     """Test case where papers are successfully loaded and embedded."""
     mock_loader.return_value = [
@@ -70,9 +65,7 @@ def test_successful_batch_embedding(mock_loader, args_fixture):
     mock_collection.flush.assert_called()
 
 
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
-)
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf")
 def test_empty_chunks_after_loading(mock_loader, args_fixture):
     """Test case where no chunks are returned after loading PDF."""
     mock_loader.return_value = []
@@ -82,9 +75,7 @@ def test_empty_chunks_after_loading(mock_loader, args_fixture):
     args_fixture["vector_store"].add_documents.assert_not_called()
 
 
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf"
-)
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.batch_processor.load_and_split_pdf")
 def test_vector_store_insert_failure(mock_loader, args_fixture):
     """Test case where vector store insertion fails."""
     mock_loader.return_value = [MagicMock(page_content="page")]