aiagents4pharma 1.44.0__py3-none-any.whl → 1.45.1__py3-none-any.whl

aiagents4pharma/talk2scholars/tests/{test_pdf_vector_normalization.py → test_utils_pdf_vector_normalization.py}

@@ -38,7 +38,7 @@ def test_normalize_vectors_batch_normal_case():
         [0.6, 0.8],
         [0.6, 0.8],
     ]
-    for r, e in zip(result, expected):
+    for r, e in zip(result, expected, strict=False):
         assert pytest.approx(r) == e
 
 

aiagents4pharma/talk2scholars/tests/{test_pdf_vector_store.py → test_utils_pdf_vector_store.py}

@@ -180,29 +180,20 @@ def test_load_existing_papers_with_exception(mock_embedding, mock_config):
         patch(f"{MODULE}.log_index_configuration"),
     ):
         mock_singleton = MagicMock()
-        safe_store = MagicMock()
-        safe_collection = MagicMock()
-        safe_collection.num_entities = 0
-        safe_collection.flush.return_value = None
-        safe_store.col = safe_collection
-        safe_store.collection = safe_collection
-        mock_singleton.get_vector_store.return_value = safe_store
-        mock_singleton.get_connection.return_value = None
-        singleton_cls.return_value = mock_singleton
-
-        vs = Vectorstore(embedding_model=mock_embedding, config=mock_config)
-
-        # now replace with failing store
+        # Set up failing store directly for initialization
         bad_collection = MagicMock()
         bad_collection.num_entities = 0
         bad_collection.flush.side_effect = Exception("flush failed")
         bad_store = MagicMock()
         bad_store.col = bad_collection
         bad_store.collection = bad_collection
-        vs.vector_store = bad_store
+        mock_singleton.get_vector_store.return_value = bad_store
+        mock_singleton.get_connection.return_value = None
+        singleton_cls.return_value = mock_singleton
 
+        # Test error propagation through initialization that calls _load_existing_paper_ids
         with pytest.raises(Exception) as excinfo:
-            getattr(vs, "_load_existing_paper_ids")()
+            Vectorstore(embedding_model=mock_embedding, config=mock_config)
         assert "flush failed" in str(excinfo.value)
 
 
@@ -232,10 +223,8 @@ def test_ensure_collection_loaded_with_entities(mock_embedding, mock_config):
         mock_singleton.get_connection.return_value = None
         singleton_cls.return_value = mock_singleton
 
-        vs = Vectorstore(embedding_model=mock_embedding, config=mock_config)
-        vs.vector_store = mock_store
-        getattr(vs, "_ensure_collection_loaded")()
-
+        # Test through initialization which calls _ensure_collection_loaded
+        Vectorstore(embedding_model=mock_embedding, config=mock_config)
         assert mock_collection.load.called
 
 
@@ -255,29 +244,20 @@ def test_ensure_collection_loaded_handles_exception(mock_embedding, mock_config)
         patch(f"{MODULE}.log_index_configuration"),
     ):
         mock_singleton = MagicMock()
-        safe_store = MagicMock()
-        safe_collection = MagicMock()
-        safe_collection.num_entities = 0
-        safe_collection.flush.return_value = None
-        safe_store.col = safe_collection
-        safe_store.collection = safe_collection
-        mock_singleton.get_vector_store.return_value = safe_store
-        mock_singleton.get_connection.return_value = None
-        singleton_cls.return_value = mock_singleton
-
-        vs = Vectorstore(embedding_model=mock_embedding, config=mock_config)
-
-        # override with failing store
+        # Set up failing store directly for initialization
         bad_collection = MagicMock()
         bad_collection.num_entities = 0
         bad_collection.flush.side_effect = Exception("flush error")
         bad_store = MagicMock()
         bad_store.col = bad_collection
         bad_store.collection = bad_collection
-        vs.vector_store = bad_store
+        mock_singleton.get_vector_store.return_value = bad_store
+        mock_singleton.get_connection.return_value = None
+        singleton_cls.return_value = mock_singleton
 
+        # Test error propagation through initialization that calls _ensure_collection_loaded
         with pytest.raises(Exception) as excinfo:
-            getattr(vs, "_ensure_collection_loaded")()
+            Vectorstore(embedding_model=mock_embedding, config=mock_config)
         assert "flush error" in str(excinfo.value)
 
 
@@ -313,9 +293,7 @@ def test_force_cpu_mode_logs_override(mock_config, mock_embedding):
         assert not vs.has_gpu
 
 
-def test_similarity_metric_override(
-    dummy_embedding, dummy_config, dummy_vectorstore_components
-):
+def test_similarity_metric_override(dummy_embedding, dummy_config, dummy_vectorstore_components):
     """
     Test setting of use_cosine from config.similarity_metric.
     """
@@ -338,8 +316,7 @@ def test_load_existing_paper_ids_fallback_to_collection(
             delattr(mock_vector_store, attr)
 
     vs = Vectorstore(dummy_embedding, config=dummy_config)
-    vs.vector_store = mock_vector_store
-    getattr(vs, "_load_existing_paper_ids")()
+    # The loaded_papers is set during initialization via _load_existing_paper_ids
     assert isinstance(vs.loaded_papers, set)
 
 
@@ -356,8 +333,7 @@ def test_load_existing_papers_collection_empty_logs(
     mock_vector_store.col = mock_collection
 
     vs = Vectorstore(dummy_embedding, config=dummy_config)
-    vs.vector_store = mock_vector_store
-    getattr(vs, "_load_existing_paper_ids")()
+    # The loaded_papers is set during initialization via _load_existing_paper_ids
     assert len(vs.loaded_papers) == 0
 
 
@@ -382,16 +358,12 @@ def test_similarity_search_filter_paths(
     assert isinstance(result, list)
 
 
-def test_mmr_search_filter_paths(
-    dummy_embedding, dummy_config, dummy_vectorstore_components
-):
+def test_mmr_search_filter_paths(dummy_embedding, dummy_config, dummy_vectorstore_components):
     """
     Test filter expression generation in max_marginal_relevance_search.
     """
     _, mock_vector_store = dummy_vectorstore_components
-    mock_vector_store.max_marginal_relevance_search.return_value = [
-        Document(page_content="test")
-    ]
+    mock_vector_store.max_marginal_relevance_search.return_value = [Document(page_content="test")]
     vs = Vectorstore(dummy_embedding, config=dummy_config)
     vs.vector_store = mock_vector_store
 
@@ -411,10 +383,10 @@ def test_ensure_collection_loaded_no_col_and_no_collection(
         if hasattr(mock_vector_store, attr):
             delattr(mock_vector_store, attr)
 
-    vs = Vectorstore(dummy_embedding, config=dummy_config)
-    vs.vector_store = mock_vector_store
-    getattr(vs, "_ensure_collection_loaded")()
-    # no exception
+    # Test initialization succeeds without exception
+    Vectorstore(dummy_embedding, config=dummy_config)
+    # Collection loading is handled during initialization via _ensure_collection_loaded
+    # no exception if we got this far
 
 
 def test_ensure_collection_loaded_empty_logs(
@@ -428,7 +400,7 @@ def test_ensure_collection_loaded_empty_logs(
     mock_collection.num_entities = 0
     mock_vector_store.col = mock_collection
 
-    vs = Vectorstore(dummy_embedding, config=dummy_config)
-    vs.vector_store = mock_vector_store
-    getattr(vs, "_ensure_collection_loaded")()
-    # no exception
+    # Test initialization succeeds without exception
+    Vectorstore(dummy_embedding, config=dummy_config)
+    # Collection loading is handled during initialization via _ensure_collection_loaded
+    # no exception if we got this far

aiagents4pharma/talk2scholars/tests/{test_pubmed_downloader.py → test_utils_pubmed_downloader.py}

@@ -139,8 +139,7 @@ class TestPubmedDownloaderBasics(unittest.TestCase):
         """<error> node -> return empty string."""
         resp = Mock()
         resp.text = (
-            '<?xml version="1.0"?><OA><error code="idDoesNotExist">'
-            "Invalid PMC ID</error></OA>"
+            '<?xml version="1.0"?><OA><error code="idDoesNotExist">Invalid PMC ID</error></OA>'
         )
         resp.raise_for_status = Mock()
         mock_get.return_value = resp
@@ -299,10 +298,7 @@ class TestPubmedDownloaderEuropePMC(unittest.TestCase):
         resp.status_code = 200
         mock_head.return_value = resp
         result = self.downloader.try_europe_pmc_public("PMC123456")
-        expected = (
-            "https://www.ebi.ac.uk/europepmc/webservices/rest"
-            "?accid=PMC123456&blobtype=pdf"
-        )
+        expected = "https://www.ebi.ac.uk/europepmc/webservices/rest?accid=PMC123456&blobtype=pdf"
         mock_head.assert_called_once_with(expected, timeout=30)
         self.assertEqual(result, expected)
 
@@ -356,18 +352,14 @@ class TestPubmedDownloaderPMCScrape(unittest.TestCase):
 
         expected_url = "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC123456/"
         expected_headers = {"User-Agent": "Mozilla/5.0 (compatible; test-agent)"}
-        mock_get.assert_called_once_with(
-            expected_url, headers=expected_headers, timeout=30
-        )
-        self.assertEqual(
-            result, "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC123456/pdf/test.pdf"
-        )
+        mock_get.assert_called_once_with(expected_url, headers=expected_headers, timeout=30)
+        self.assertEqual(result, "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC123456/pdf/test.pdf")
 
     @patch("requests.get")
     def test_try_pmc_page_scraping_no_pdf(self, mock_get):
         """Test PMC page scraping with no PDF found."""
         resp = Mock()
-        resp.content = "<html><head></head></html>".encode()
+        resp.content = b"<html><head></head></html>"
         resp.raise_for_status = Mock()
         mock_get.return_value = resp
         self.assertEqual(self.downloader.try_pmc_page_scraping_public("PMC123456"), "")
@@ -486,17 +478,13 @@ class TestPubmedDownloaderConstructAndFallbacks(unittest.TestCase):
         """Test fallback chain through multiple sources."""
         with (
             patch.object(self.downloader, "try_oa_api_public", return_value="") as m_oa,
-            patch.object(
-                self.downloader, "try_europe_pmc_public", return_value=""
-            ) as m_eu,
+            patch.object(self.downloader, "try_europe_pmc_public", return_value="") as m_eu,
             patch.object(
                 self.downloader,
                 "try_pmc_page_scraping_public",
                 return_value="http://test.pdf",
             ) as m_scr,
-            patch.object(
-                self.downloader, "try_direct_pmc_url_public", return_value=""
-            ) as m_dir,
+            patch.object(self.downloader, "try_direct_pmc_url_public", return_value="") as m_dir,
         ):
             out = self.downloader.fetch_pdf_url_with_fallbacks_public("PMC123456")
         self.assertEqual(out, "http://test.pdf")
@@ -509,12 +497,8 @@ class TestPubmedDownloaderConstructAndFallbacks(unittest.TestCase):
         """Test fallback chain with direct PMC success."""
         with (
             patch.object(self.downloader, "try_oa_api_public", return_value="") as m_oa,
-            patch.object(
-                self.downloader, "try_europe_pmc_public", return_value=""
-            ) as m_eu,
-            patch.object(
-                self.downloader, "try_pmc_page_scraping_public", return_value=""
-            ) as m_scr,
+            patch.object(self.downloader, "try_europe_pmc_public", return_value="") as m_eu,
+            patch.object(self.downloader, "try_pmc_page_scraping_public", return_value="") as m_scr,
             patch.object(
                 self.downloader,
                 "try_direct_pmc_url_public",
@@ -532,15 +516,9 @@ class TestPubmedDownloaderConstructAndFallbacks(unittest.TestCase):
         """Test fallback chain when all sources fail."""
         with (
             patch.object(self.downloader, "try_oa_api_public", return_value="") as m_oa,
-            patch.object(
-                self.downloader, "try_europe_pmc_public", return_value=""
-            ) as m_eu,
-            patch.object(
-                self.downloader, "try_pmc_page_scraping_public", return_value=""
-            ) as m_scr,
-            patch.object(
-                self.downloader, "try_direct_pmc_url_public", return_value=""
-            ) as m_dir,
+            patch.object(self.downloader, "try_europe_pmc_public", return_value="") as m_eu,
+            patch.object(self.downloader, "try_pmc_page_scraping_public", return_value="") as m_scr,
+            patch.object(self.downloader, "try_direct_pmc_url_public", return_value="") as m_dir,
         ):
             out = self.downloader.fetch_pdf_url_with_fallbacks_public("PMC123456")
         self.assertEqual(out, "")
@@ -587,9 +565,7 @@ class TestPubmedDownloaderIntegration(unittest.TestCase):
         """Test full workflow from PMID to PDF URL."""
         metadata_response = Mock()
         metadata_response.json.return_value = {
-            "records": [
-                {"pmid": "12345678", "pmcid": "PMC123456", "doi": "10.1234/test"}
-            ]
+            "records": [{"pmid": "12345678", "pmcid": "PMC123456", "doi": "10.1234/test"}]
         }
         metadata_response.raise_for_status = Mock()
 
@@ -631,9 +607,7 @@ class TestPubmedDownloaderIntegration(unittest.TestCase):
         """Test workflow with fallback to alternative sources."""
         metadata_response = Mock()
         metadata_response.json.return_value = {
-            "records": [
-                {"pmid": "12345678", "pmcid": "PMC123456", "doi": "10.1234/test"}
-            ]
+            "records": [{"pmid": "12345678", "pmcid": "PMC123456", "doi": "10.1234/test"}]
         }
         metadata_response.raise_for_status = Mock()
 
@@ -780,9 +754,7 @@ class TestPubmedDownloaderHelpers(unittest.TestCase):
         """Test that placeholder abstracts return empty snippets."""
         self.assertEqual(self.downloader.get_snippet(""), "")
         self.assertEqual(self.downloader.get_snippet("N/A"), "")
-        self.assertEqual(
-            self.downloader.get_snippet("Abstract available in PubMed"), ""
-        )
+        self.assertEqual(self.downloader.get_snippet("Abstract available in PubMed"), "")
 
     def test_get_snippet_non_placeholder_delegates_to_base(self):
         """Test that non-placeholder abstracts delegate to base class."""
@@ -793,9 +765,7 @@ class TestPubmedDownloaderHelpers(unittest.TestCase):
 
     def test_get_paper_identifier_info_without_pmcid_line(self):
         """Test paper identifier info formatting without PMCID."""
-        info = self.downloader.get_paper_identifier_info_public(
-            {"PMID": "999", "PMCID": "N/A"}
-        )
+        info = self.downloader.get_paper_identifier_info_public({"PMID": "999", "PMCID": "N/A"})
         self.assertIn("(PMID: 999)", info)
         self.assertNotIn("PMCID:", info)
 
@@ -861,14 +831,10 @@ class TestPubmedDownloaderMissingLineCoverage(unittest.TestCase):
             patch.object(self.downloader, "_try_pmc_page_scraping", return_value=""),
             patch.object(self.downloader, "_try_direct_pmc_url", return_value=""),
             patch(
-                "aiagents4pharma.talk2scholars.tools.paper_download.utils."
-                "pubmed_downloader.logger"
+                "aiagents4pharma.talk2scholars.tools.paper_download.utils.pubmed_downloader.logger"
             ) as mock_logger,
         ):
-
-            result = self.downloader.fetch_pdf_url_with_fallbacks_production(
-                "PMC123456"
-            )
+            result = self.downloader.fetch_pdf_url_with_fallbacks_production("PMC123456")
 
             self.assertEqual(result, "")
             # Verify the warning log is called
@@ -879,21 +845,15 @@ class TestPubmedDownloaderMissingLineCoverage(unittest.TestCase):
     def test_fetch_pdf_url_with_fallbacks_oa_api_success_early_return(self):
         """Test _fetch_pdf_url_with_fallbacks when OA API succeeds on first try."""
         with (
-            patch.object(
-                self.downloader, "_try_oa_api", return_value="http://oa.pdf"
-            ) as mock_oa,
+            patch.object(self.downloader, "_try_oa_api", return_value="http://oa.pdf") as mock_oa,
             patch.object(self.downloader, "_try_europe_pmc") as mock_eu,
             patch.object(self.downloader, "_try_pmc_page_scraping") as mock_scr,
             patch.object(self.downloader, "_try_direct_pmc_url") as mock_dir,
             patch(
-                "aiagents4pharma.talk2scholars.tools.paper_download.utils."
-                "pubmed_downloader.logger"
+                "aiagents4pharma.talk2scholars.tools.paper_download.utils.pubmed_downloader.logger"
             ) as mock_logger,
         ):
-
-            result = self.downloader.fetch_pdf_url_with_fallbacks_production(
-                "PMC123456"
-            )
+            result = self.downloader.fetch_pdf_url_with_fallbacks_production("PMC123456")
 
             self.assertEqual(result, "http://oa.pdf")
             mock_oa.assert_called_once_with("PMC123456")
@@ -901,9 +861,7 @@ class TestPubmedDownloaderMissingLineCoverage(unittest.TestCase):
             mock_scr.assert_not_called()
             mock_dir.assert_not_called()
             # Verify the initial info log is called
-            mock_logger.info.assert_called_with(
-                "Fetching PDF URL for PMCID: %s", "PMC123456"
-            )
+            mock_logger.info.assert_called_with("Fetching PDF URL for PMCID: %s", "PMC123456")
 
     def test_fetch_pdf_url_with_fallbacks_europe_pmc_success_after_oa_fail(self):
         """Test _fetch_pdf_url_with_fallbacks when Europe PMC succeeds after OA API fails."""
@@ -915,10 +873,7 @@ class TestPubmedDownloaderMissingLineCoverage(unittest.TestCase):
             patch.object(self.downloader, "_try_pmc_page_scraping") as mock_scr,
             patch.object(self.downloader, "_try_direct_pmc_url") as mock_dir,
         ):
-
-            result = self.downloader.fetch_pdf_url_with_fallbacks_production(
-                "PMC123456"
-            )
+            result = self.downloader.fetch_pdf_url_with_fallbacks_production("PMC123456")
 
             self.assertEqual(result, "http://eu.pdf")
             mock_oa.assert_called_once_with("PMC123456")
@@ -932,18 +887,13 @@ class TestPubmedDownloaderMissingLineCoverage(unittest.TestCase):
         """Test _fetch_pdf_url_with_fallbacks when PMC scraping succeeds."""
         with (
             patch.object(self.downloader, "_try_oa_api", return_value="") as mock_oa,
-            patch.object(
-                self.downloader, "_try_europe_pmc", return_value=""
-            ) as mock_eu,
+            patch.object(self.downloader, "_try_europe_pmc", return_value="") as mock_eu,
             patch.object(
                 self.downloader, "_try_pmc_page_scraping", return_value="http://scr.pdf"
             ) as mock_scr,
             patch.object(self.downloader, "_try_direct_pmc_url") as mock_dir,
         ):
-
-            result = self.downloader.fetch_pdf_url_with_fallbacks_production(
-                "PMC123456"
-            )
+            result = self.downloader.fetch_pdf_url_with_fallbacks_production("PMC123456")
 
             self.assertEqual(result, "http://scr.pdf")
             mock_oa.assert_called_once_with("PMC123456")
@@ -955,20 +905,13 @@ class TestPubmedDownloaderMissingLineCoverage(unittest.TestCase):
         """Test _fetch_pdf_url_with_fallbacks when direct PMC succeeds as last resort."""
         with (
             patch.object(self.downloader, "_try_oa_api", return_value="") as mock_oa,
-            patch.object(
-                self.downloader, "_try_europe_pmc", return_value=""
-            ) as mock_eu,
-            patch.object(
-                self.downloader, "_try_pmc_page_scraping", return_value=""
-            ) as mock_scr,
+            patch.object(self.downloader, "_try_europe_pmc", return_value="") as mock_eu,
+            patch.object(self.downloader, "_try_pmc_page_scraping", return_value="") as mock_scr,
             patch.object(
                 self.downloader, "_try_direct_pmc_url", return_value="http://dir.pdf"
             ) as mock_dir,
         ):
-
-            result = self.downloader.fetch_pdf_url_with_fallbacks_production(
-                "PMC123456"
-            )
+            result = self.downloader.fetch_pdf_url_with_fallbacks_production("PMC123456")
 
             self.assertEqual(result, "http://dir.pdf")
             mock_oa.assert_called_once_with("PMC123456")
@@ -1012,8 +955,7 @@ class TestPubmedDownloaderProductionConstructPdfUrl(unittest.TestCase):
         """Test production construct_pdf_url with missing pmcid key."""
         metadata = {"records": [{"doi": "10.1/x"}]}
         with patch(
-            "aiagents4pharma.talk2scholars.tools.paper_download.utils."
-            "pubmed_downloader.logger"
+            "aiagents4pharma.talk2scholars.tools.paper_download.utils.pubmed_downloader.logger"
         ) as mock_logger:
             result = self.downloader.construct_pdf_url(metadata, "12345678")
 
@@ -1027,8 +969,7 @@ class TestPubmedDownloaderProductionConstructPdfUrl(unittest.TestCase):
         """Test production construct_pdf_url with empty pmcid."""
         metadata = {"records": [{"pmcid": "", "doi": "10.1/x"}]}
         with patch(
-            "aiagents4pharma.talk2scholars.tools.paper_download.utils."
-            "pubmed_downloader.logger"
+            "aiagents4pharma.talk2scholars.tools.paper_download.utils.pubmed_downloader.logger"
         ) as mock_logger:
             result = self.downloader.construct_pdf_url(metadata, "12345678")
 
@@ -1042,8 +983,7 @@ class TestPubmedDownloaderProductionConstructPdfUrl(unittest.TestCase):
         """Test production construct_pdf_url with N/A pmcid."""
         metadata = {"records": [{"pmcid": "N/A", "doi": "10.1/x"}]}
         with patch(
-            "aiagents4pharma.talk2scholars.tools.paper_download.utils."
-            "pubmed_downloader.logger"
+            "aiagents4pharma.talk2scholars.tools.paper_download.utils.pubmed_downloader.logger"
         ) as mock_logger:
             result = self.downloader.construct_pdf_url(metadata, "12345678")
 

aiagents4pharma/talk2scholars/tests/{test_read_helper_utils.py → test_utils_read_helper_utils.py}

@@ -27,14 +27,10 @@ dummy_cfg = SimpleNamespace(tools=SimpleNamespace(zotero_read=dummy_zotero_read_
 class TestReadHelperDownloadsFalse(unittest.TestCase):
     """Tests for read_helper download_pdfs=False branches."""
 
-    @patch(
-        "aiagents4pharma.talk2scholars.tools.zotero.utils.zotero_path.get_item_collections"
-    )
+    @patch("aiagents4pharma.talk2scholars.tools.zotero.utils.zotero_path.get_item_collections")
     @patch("aiagents4pharma.talk2scholars.tools.zotero.utils.read_helper.zotero.Zotero")
     @patch("aiagents4pharma.talk2scholars.tools.zotero.utils.read_helper.hydra.compose")
-    @patch(
-        "aiagents4pharma.talk2scholars.tools.zotero.utils.read_helper.hydra.initialize"
-    )
+    @patch("aiagents4pharma.talk2scholars.tools.zotero.utils.read_helper.hydra.initialize")
     def test_download_pdfs_false_branches(
         self,
         mock_hydra_init,

aiagents4pharma/talk2scholars/tests/{test_s2_utils_ext_ids.py → test_utils_s2_utils_ext_ids.py}

@@ -49,9 +49,7 @@ def patch_hydra(monkeypatch):
             ),
         )
     )
-    monkeypatch.setattr(
-        hydra, "initialize", lambda version_base, config_path: DummyHydraContext()
-    )
+    monkeypatch.setattr(hydra, "initialize", lambda version_base, config_path: DummyHydraContext())
     monkeypatch.setattr(hydra, "compose", lambda config_name, overrides: dummy_cfg)
 
 
@@ -69,9 +67,7 @@ def test_multi_helper_pmc_and_doi_ids(monkeypatch):
             }
         ]
     }
-    response = SimpleNamespace(
-        status_code=200, json=lambda: data, raise_for_status=lambda: None
-    )
+    response = SimpleNamespace(status_code=200, json=lambda: data, raise_for_status=lambda: None)
     monkeypatch.setattr(requests, "post", lambda *args, **kwargs: response)
     results = rec.process_recommendations()
     ids_list = results["papers"]["p1"]["paper_ids"]
@@ -91,9 +87,7 @@ def test_search_helper_pmc_and_doi_ids(monkeypatch):
             }
         ]
     }
-    response = SimpleNamespace(
-        status_code=200, json=lambda: data, raise_for_status=lambda: None
-    )
+    response = SimpleNamespace(status_code=200, json=lambda: data, raise_for_status=lambda: None)
     monkeypatch.setattr(requests, "get", lambda *args, **kwargs: response)
     results = sd.process_search()
     ids_list = results["papers"]["s1"]["paper_ids"]
@@ -113,9 +107,7 @@ def test_single_helper_pmc_and_doi_ids(monkeypatch):
             }
         ]
     }
-    response = SimpleNamespace(
-        status_code=200, json=lambda: data, raise_for_status=lambda: None
-    )
+    response = SimpleNamespace(status_code=200, json=lambda: data, raise_for_status=lambda: None)
     monkeypatch.setattr(requests, "get", lambda *args, **kwargs: response)
     results = sp.process_recommendations()
     ids_list = results["papers"]["x1"]["paper_ids"]
@@ -395,9 +387,7 @@ def test_single_helper_create_content_snippet(monkeypatch):
 
 def test_multi_helper_create_content_snippet(monkeypatch):
     """Test that MultiPaperRecData._create_content includes snippets appropriately."""
-    mr = MultiPaperRecData(
-        paper_ids=["a", "b"], limit=2, year="2021", tool_call_id="tid"
-    )
+    mr = MultiPaperRecData(paper_ids=["a", "b"], limit=2, year="2021", tool_call_id="tid")
     mr.filtered_papers = {
         "m1": {"Title": "MTitle1", "Year": "2017", "Abstract": "MOne. MTwo. MThree."},
         "m2": {"Title": "MTitle2", "Year": "2016", "Abstract": ""},

aiagents4pharma/talk2scholars/tests/{test_zotero_human_in_the_loop.py → test_utils_zotero_human_in_the_loop.py}

@@ -3,7 +3,8 @@ Unit tests for Zotero human in the loop in zotero_review.py with structured outp
 """
 
 import unittest
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock, patch
+
 from aiagents4pharma.talk2scholars.tools.zotero.zotero_review import zotero_review
 
 
@@ -185,22 +186,16 @@ class TestZoteroReviewTool(unittest.TestCase):
 
         upd = result.update
         self.assertEqual(upd["zotero_write_approval_status"], {"approved": False})
-        self.assertIn(
-            "Human rejected saving papers to Zotero", upd["messages"][0].content
-        )
+        self.assertIn("Human rejected saving papers to Zotero", upd["messages"][0].content)
         mock_fetch.assert_called_once()
         mock_interrupt.assert_called_once()
 
-    @patch(
-        "aiagents4pharma.talk2scholars.tools.zotero.zotero_review.fetch_papers_for_save"
-    )
+    @patch("aiagents4pharma.talk2scholars.tools.zotero.zotero_review.fetch_papers_for_save")
     @patch("aiagents4pharma.talk2scholars.tools.zotero.zotero_review.interrupt")
     def test_structured_processing_failure(self, mock_interrupt, mock_fetch):
         """Test fallback when structured review processing fails."""
         # Simulate valid fetched papers with multiple entries.
-        papers = {
-            f"p{i}": {"Title": f"Title{i}", "Authors": [f"A{i}"]} for i in range(1, 8)
-        }
+        papers = {f"p{i}": {"Title": f"Title{i}", "Authors": [f"A{i}"]} for i in range(1, 8)}
         mock_fetch.return_value = papers
         mock_interrupt.return_value = "dummy_response"
         # Provide a fake llm_model whose invoke() raises an exception.
@@ -234,9 +229,7 @@ class TestZoteroReviewTool(unittest.TestCase):
 
     @patch(
         "aiagents4pharma.talk2scholars.tools.zotero.zotero_review.fetch_papers_for_save",
-        return_value={
-            "p1": {"Title": "Test Paper", "Authors": ["Alice", "Bob", "Charlie"]}
-        },
+        return_value={"p1": {"Title": "Test Paper", "Authors": ["Alice", "Bob", "Charlie"]}},
     )
     @patch(
         "aiagents4pharma.talk2scholars.tools.zotero.zotero_review.interrupt",