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

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")]

aiagents4pharma/talk2scholars/tests/{test_pdf_collection_manager.py → test_utils_pdf_collection_manager.py}

@@ -1,12 +1,12 @@
 """collection_manager for managing Milvus collections for PDF chunks."""
 
-from unittest.mock import MagicMock, patch
 from dataclasses import dataclass, field
+from unittest.mock import MagicMock, patch
+
 import pytest
 
 from aiagents4pharma.talk2scholars.tools.pdf.utils import collection_manager
 
-
 # -- Fixtures --
 
 
@@ -39,13 +39,20 @@ def index_params():
 
 
 def set_collection_cache(key, value):
-    """Set a mocked collection into the cache."""
-    getattr(collection_manager, "_collection_cache")[key] = value
+    """Set a mocked collection into the cache without replacing the whole attribute."""
+    cache = getattr(collection_manager, "_collection_cache", None)
+    if cache is None:
+        cache = {}
+        # Still need to attach it once if it doesn't exist
+        object.__setattr__(collection_manager, "_collection_cache", cache)
+    cache[key] = value
 
 
 def clear_collection_cache(key):
     """Remove a mocked collection from the cache."""
-    getattr(collection_manager, "_collection_cache").pop(key, None)
+    cache = getattr(collection_manager, "_collection_cache", None)
+    if cache is not None:
+        cache.pop(key, None)
 
 
 # -- Tests --
@@ -124,9 +131,7 @@ def test_debug_collection_state_failure(mock_utility, mock_collection_cls, reque
     mock_collection.indexes = []
     mock_collection.num_entities = 10
 
-    mock_collection.schema = property(
-        lambda _: (_ for _ in ()).throw(Exception("bad schema"))
-    )
+    mock_collection.schema = property(lambda _: (_ for _ in ()).throw(Exception("bad schema")))
 
     result = collection_manager.ensure_collection_exists(
         "bad_collection", config, index, has_gpu=True
@@ -145,6 +150,24 @@ def test_ensure_collection_exception(mock_utility, mock_collection_cls, request)
     mock_collection_cls.return_value = MagicMock()
 
     with pytest.raises(RuntimeError, match="milvus failure"):
-        collection_manager.ensure_collection_exists(
-            "fail_collection", config, index, has_gpu=False
-        )
+        collection_manager.ensure_collection_exists("fail_collection", config, index, has_gpu=False)
+
+
+def test_set_collection_cache_initializes_when_missing(monkeypatch):
+    """Ensure set_collection_cache initializes the cache when attribute is absent."""
+    # Remove the attribute if present (avoids W0212 and stays lint-clean)
+    monkeypatch.delattr(collection_manager, "_collection_cache", raising=False)
+
+    key = "init_case"
+    val = MagicMock()
+
+    # This should go through the None-branch and attach the cache via object.__setattr__
+    set_collection_cache(key, val)
+
+    # Verify cache got created and populated
+    cache = getattr(collection_manager, "_collection_cache", None)
+    assert isinstance(cache, dict)
+    assert cache.get(key) is val
+
+    # Cleanup
+    clear_collection_cache(key)

aiagents4pharma/talk2scholars/tests/{test_pdf_document_processor.py → test_utils_pdf_document_processor.py}

@@ -1,6 +1,7 @@
 """Unit tests for PDF document processing utilities."""
 
 from unittest.mock import MagicMock, patch
+
 import pytest
 
 from aiagents4pharma.talk2scholars.tools.pdf.utils.document_processor import (
@@ -26,9 +27,7 @@ def _base_args_params():
     "aiagents4pharma.talk2scholars.tools.pdf.utils.document_processor."
     "RecursiveCharacterTextSplitter"
 )
-def test_load_and_split_pdf_success(
-    mock_splitter_cls, mock_loader_cls, base_args_params
-):
+def test_load_and_split_pdf_success(mock_splitter_cls, mock_loader_cls, base_args_params):
     """load_and_split_pdf should load and split PDF correctly."""
     mock_doc = MagicMock()
     mock_doc.metadata = {"page": 1}

aiagents4pharma/talk2scholars/tests/{test_pdf_generate_answer.py → test_utils_pdf_generate_answer.py}

@@ -1,6 +1,7 @@
 """generate_answer tests for the PDF tool"""
 
 from unittest.mock import MagicMock
+
 import pytest
 
 from aiagents4pharma.talk2scholars.tools.pdf.utils.generate_answer import (
@@ -60,16 +61,12 @@ def test_generate_answer_success(chunks_fixture):
 def test_generate_answer_raises_for_none_config(chunks_fixture):
     """generate_answer should raise ValueError for None config."""
     mock_llm = MagicMock()
-    with pytest.raises(
-        ValueError, match="Configuration for generate_answer is required."
-    ):
+    with pytest.raises(ValueError, match="Configuration for generate_answer is required."):
         generate_answer("Why?", chunks_fixture, mock_llm, config=None)
 
 
 def test_generate_answer_raises_for_missing_template(chunks_fixture):
     """generate_answer should raise ValueError for missing prompt_template in config."""
     mock_llm = MagicMock()
-    with pytest.raises(
-        ValueError, match="The prompt_template is missing from the configuration."
-    ):
+    with pytest.raises(ValueError, match="The prompt_template is missing from the configuration."):
         generate_answer("Why?", chunks_fixture, mock_llm, config={})

aiagents4pharma/talk2scholars/tests/{test_pdf_gpu_detection.py → test_utils_pdf_gpu_detection.py}

@@ -4,7 +4,6 @@ import subprocess
 from types import SimpleNamespace
 from unittest.mock import MagicMock, patch
 
-
 from aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection import (
     detect_nvidia_gpu,
     get_optimal_index_config,
@@ -23,9 +22,7 @@ def test_detect_nvidia_gpu_force_cpu_from_config():
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.subprocess.run")
 def test_detect_nvidia_gpu_success(mock_run):
     """detect_nvidia_gpu should return True if NVIDIA GPUs are detected."""
-    mock_run.return_value = MagicMock(
-        returncode=0, stdout="NVIDIA A100\nNVIDIA RTX 3090"
-    )
+    mock_run.return_value = MagicMock(returncode=0, stdout="NVIDIA A100\nNVIDIA RTX 3090")
 
     assert detect_nvidia_gpu() is True
     mock_run.assert_called_once()
@@ -44,9 +41,7 @@ def test_detect_nvidia_gpu_no_output(mock_run):
 
 def test_get_optimal_index_config_gpu():
     """get_optimal_index_config should return GPU_CAGRA for GPU setup."""
-    index_params, search_params = get_optimal_index_config(
-        has_gpu=True, embedding_dim=768
-    )
+    index_params, search_params = get_optimal_index_config(has_gpu=True, embedding_dim=768)
 
     assert index_params["index_type"] == "GPU_CAGRA"
     assert "cache_dataset_on_device" in index_params["params"]
@@ -55,9 +50,7 @@ def test_get_optimal_index_config_gpu():
 
 def test_get_optimal_index_config_cpu():
     """get_optimal_index_config should return IVF_FLAT for CPU setup."""
-    index_params, search_params = get_optimal_index_config(
-        has_gpu=False, embedding_dim=768
-    )
+    index_params, search_params = get_optimal_index_config(has_gpu=False, embedding_dim=768)
 
     assert index_params["index_type"] == "IVF_FLAT"
     assert index_params["params"]["nlist"] == 96  # 768 / 8 = 96
@@ -121,9 +114,7 @@ def test_detect_nvidia_gpu_timeout_raises_false(mock_run, mock_logger):
 
     result = detect_nvidia_gpu()
     assert result is False
-    mock_logger.info.assert_called_with(
-        "NVIDIA GPU detection failed: %s", mock_run.side_effect
-    )
+    mock_logger.info.assert_called_with("NVIDIA GPU detection failed: %s", mock_run.side_effect)
 
 
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.gpu_detection.logger")
@@ -135,6 +126,4 @@ def test_detect_nvidia_gpu_file_not_found_raises_false(mock_run, mock_logger):
 
     result = detect_nvidia_gpu()
     assert result is False
-    mock_logger.info.assert_called_with(
-        "NVIDIA GPU detection failed: %s", mock_run.side_effect
-    )
+    mock_logger.info.assert_called_with("NVIDIA GPU detection failed: %s", mock_run.side_effect)

aiagents4pharma/talk2scholars/tests/{test_pdf_rag_pipeline.py → test_utils_pdf_rag_pipeline.py}

@@ -1,6 +1,7 @@
 """pdf rag pipeline tests."""
 
 from unittest.mock import MagicMock, patch
+
 import pytest
 from langchain_core.documents import Document
 
@@ -25,18 +26,13 @@ def _base_config_fixture():
 def _mock_docs_fixture():
     """Simulates PDF document chunks."""
     return [
-        Document(page_content=f"chunk {i}", metadata={"paper_id": f"P{i % 2}"})
-        for i in range(10)
+        Document(page_content=f"chunk {i}", metadata={"paper_id": f"P{i % 2}"}) for i in range(10)
     ]
 
 
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.rerank_chunks")
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.retrieve_relevant_chunks"
-)
-def test_rag_pipeline_gpu_path(
-    mock_retrieve, mock_rerank, base_config_fixture, mock_docs_fixture
-):
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.retrieve_relevant_chunks")
+def test_rag_pipeline_gpu_path(mock_retrieve, mock_rerank, base_config_fixture, mock_docs_fixture):
     """test RAG pipeline with GPU path."""
     mock_retrieve.return_value = mock_docs_fixture
     mock_rerank.return_value = mock_docs_fixture[:5]
@@ -55,12 +51,8 @@ def test_rag_pipeline_gpu_path(
 
 
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.rerank_chunks")
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.retrieve_relevant_chunks"
-)
-def test_rag_pipeline_cpu_path(
-    mock_retrieve, mock_rerank, base_config_fixture, mock_docs_fixture
-):
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.retrieve_relevant_chunks")
+def test_rag_pipeline_cpu_path(mock_retrieve, mock_rerank, base_config_fixture, mock_docs_fixture):
     """rag pipeline with CPU path."""
     mock_retrieve.return_value = mock_docs_fixture
     mock_rerank.return_value = mock_docs_fixture[:5]
@@ -79,9 +71,7 @@ def test_rag_pipeline_cpu_path(
 
 
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.rerank_chunks")
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.retrieve_relevant_chunks"
-)
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.rag_pipeline.retrieve_relevant_chunks")
 def test_rag_pipeline_empty_results(mock_retrieve, mock_rerank, base_config_fixture):
     """rag pipeline with no results."""
     mock_retrieve.return_value = []

aiagents4pharma/talk2scholars/tests/{test_pdf_retrieve_chunks.py → test_utils_pdf_retrieve_chunks.py}

@@ -21,8 +21,7 @@ def mock_vector_store():
 def mock_chunks():
     """Fixture to simulate PDF chunks."""
     return [
-        Document(page_content=f"chunk {i}", metadata={"paper_id": f"P{i%2}"})
-        for i in range(5)
+        Document(page_content=f"chunk {i}", metadata={"paper_id": f"P{i % 2}"}) for i in range(5)
     ]
 
 
@@ -74,9 +73,7 @@ def test_retrieve_chunks_with_filter(mock_logger, request):
     mock_logger.debug = MagicMock()
     vector_store.max_marginal_relevance_search.return_value = chunks
 
-    results = retrieve_relevant_chunks(
-        vector_store, query="filter test", paper_ids=["P1"], top_k=3
-    )
+    results = retrieve_relevant_chunks(vector_store, query="filter test", paper_ids=["P1"], top_k=3)
     assert results == chunks
     args, kwargs = vector_store.max_marginal_relevance_search.call_args
     assert len(args) == 0
@@ -115,9 +112,7 @@ def test_retrieve_chunks_default_search_params(mock_logger, request):
     )
 
     assert results == chunks
-    mock_logger.debug.assert_any_call(
-        "Using default search parameters (no hardware optimization)"
-    )
+    mock_logger.debug.assert_any_call("Using default search parameters (no hardware optimization)")
 
 
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.retrieve_chunks.logger")
@@ -191,7 +186,5 @@ def test_retrieve_chunks_with_scores_not_implemented(mock_logger, request):
         retrieve_relevant_chunks_with_scores(
             vector_store=vector_store, query="fail test", top_k=1, score_threshold=0.0
         )
-    assert "Vector store does not support similarity_search_with_score" in str(
-        excinfo.value
-    )
+    assert "Vector store does not support similarity_search_with_score" in str(excinfo.value)
     mock_logger.debug.assert_called_with("GPU-accelerated similarity search enabled")

aiagents4pharma/talk2scholars/tests/{test_pdf_singleton_manager.py → test_utils_pdf_singleton_manager.py}

@@ -1,6 +1,9 @@
-"""Tests for singleton_manager: manages vector store connections and event loops."""
+"""
+Tests for singleton_manager: manages vector store connections and event loops.
+"""
 
 from unittest.mock import MagicMock, patch
+
 import pytest
 from pymilvus.exceptions import MilvusException
 
@@ -19,21 +22,21 @@ def test_singleton_instance_identity():
     assert a is b
 
 
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.singleton_manager.detect_nvidia_gpu"
-)
-def test_detect_gpu_once(mock_detect):
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.singleton_manager.detect_nvidia_gpu")
+def test_detect_gpu_once(mock_detect, monkeypatch):
     """Ensure GPU detection is cached."""
     mock_detect.return_value = True
     singleton = VectorstoreSingleton()
-    setattr(singleton, "_gpu_detected", None)
+
+    # Reset GPU detection cache safely
+    monkeypatch.setattr(VectorstoreSingleton, "_gpu_detected", None, raising=False)
 
     result = singleton.detect_gpu_once()
     assert result is True
 
+    # Second call should use cached value; detect_nvidia_gpu called only once
     result2 = singleton.detect_gpu_once()
     assert result2 is True
-
     mock_detect.assert_called_once()
 
 
@@ -63,20 +66,20 @@ def test_get_connection_creates_connection(_, mock_db, mock_conns):
 
 
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.singleton_manager.Milvus")
-def test_get_vector_store_creates_if_missing(mock_milvus):
+def test_get_vector_store_creates_if_missing(mock_milvus, monkeypatch):
     """get_vector_store should create a new vector store if missing."""
     singleton = VectorstoreSingleton()
-    setattr(singleton, "_vector_stores", {})
-    setattr(singleton, "_event_loops", {})
+
+    # Clear caches safely
+    monkeypatch.setattr(VectorstoreSingleton, "_vector_stores", {}, raising=False)
+    monkeypatch.setattr(VectorstoreSingleton, "_event_loops", {}, raising=False)
 
     mock_embed = MagicMock()
     connection_args = {"host": "localhost", "port": 19530}
 
     vs = singleton.get_vector_store("collection1", mock_embed, connection_args)
 
-    vector_stores = getattr(singleton, "_vector_stores")
-    assert vs is vector_stores["collection1"]
-    assert "collection1" in vector_stores
+    assert vs is not None
     mock_milvus.assert_called_once()
 
 
@@ -114,17 +117,15 @@ def test_get_vectorstore_force_new(mock_vectorstore_cls):
     assert vs1 != vs2
 
 
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.singleton_manager.connections.connect"
-)
-@patch(
-    "aiagents4pharma.talk2scholars.tools.pdf.utils.singleton_manager.connections.has_connection"
-)
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.singleton_manager.connections.connect")
+@patch("aiagents4pharma.talk2scholars.tools.pdf.utils.singleton_manager.connections.has_connection")
 @patch("aiagents4pharma.talk2scholars.tools.pdf.utils.singleton_manager.db")
-def test_get_connection_milvus_error(_, mock_has_connection, mock_connect):
+def test_get_connection_milvus_error(_, mock_has_connection, mock_connect, monkeypatch):
     """get_connection should raise MilvusException on connection failure."""
     manager = VectorstoreSingleton()
-    setattr(manager, "_connections", {})
+
+    # Reset connections cache safely
+    monkeypatch.setattr(VectorstoreSingleton, "_connections", {}, raising=False)
 
     mock_has_connection.return_value = False
     mock_connect.side_effect = MilvusException("Connection failed")
@@ -133,10 +134,12 @@ def test_get_connection_milvus_error(_, mock_has_connection, mock_connect):
         manager.get_connection("localhost", 19530, "test_db")
 
 
-def test_get_event_loop_creates_new_loop_on_closed():
+def test_get_event_loop_creates_new_loop_on_closed(monkeypatch):
     """Ensure get_event_loop creates a new loop if current one is closed."""
     manager = VectorstoreSingleton()
-    setattr(manager, "_event_loops", {})
+
+    # Clear event loops safely
+    monkeypatch.setattr(VectorstoreSingleton, "_event_loops", {}, raising=False)
 
     mock_loop = MagicMock()
     mock_loop.is_closed.return_value = True