aiagents4pharma 1.27.2__py3-none-any.whl → 1.29.0__py3-none-any.whl

aiagents4pharma/talk2scholars/tests/test_call_s2.py

@@ -1,100 +0,0 @@
-"""
-Integration tests for calling s2_agent through the main_agent
-"""
-
-from unittest.mock import MagicMock
-import pytest
-from langgraph.types import Command
-from langgraph.graph import END
-from langchain_core.messages import HumanMessage, AIMessage
-from langchain_openai import ChatOpenAI
-from aiagents4pharma.talk2scholars.agents.main_agent import get_app
-from aiagents4pharma.talk2scholars.state.state_talk2scholars import Talk2Scholars
-
-# pylint: disable=redefined-outer-name
-LLM_MODEL = ChatOpenAI(model='gpt-4o-mini', temperature=0)
-
-@pytest.fixture
-def mock_state():
-    """Creates a mock state to simulate an ongoing conversation."""
-    return Talk2Scholars(
-        messages=[HumanMessage(content="Find papers on deep learning.")]
-    )
-
-
-@pytest.fixture
-def mock_s2_agent():
-    """Creates a mock S2 agent that simulates expected behavior."""
-    mock_app = MagicMock()
-    mock_app.invoke.return_value = {
-        "messages": [
-            HumanMessage(
-                content="Find papers on deep learning."
-            ),  # Ensure user query is retained
-            AIMessage(
-                content="Found relevant papers on deep learning."
-            ),  # Ensure AI response is added
-        ],
-        "papers": {"paper1": "Paper on deep learning"},
-        "multi_papers": {},
-        "last_displayed_papers": {},
-    }
-    return mock_app
-
-
-@pytest.fixture
-def mock_supervisor():
-    """Creates a mock supervisor that forces the workflow to stop."""
-
-    def mock_supervisor_node(_state):
-        """Force the workflow to terminate after calling s2_agent."""
-        return Command(goto=END)  # Use END for proper termination
-
-    return mock_supervisor_node
-
-
-def test_call_s2_agent(mock_state, mock_s2_agent, mock_supervisor, monkeypatch):
-    """Tests calling the compiled LangGraph workflow without recursion errors."""
-
-    # Patch `s2_agent.get_app` to return the mock instead of real implementation
-    monkeypatch.setattr(
-        "aiagents4pharma.talk2scholars.agents.s2_agent.get_app",
-        lambda *args, **kwargs: mock_s2_agent,
-    )
-
-    # Patch `make_supervisor_node` to force termination
-    monkeypatch.setattr(
-        "aiagents4pharma.talk2scholars.agents.main_agent.make_supervisor_node",
-        lambda *args, **kwargs: mock_supervisor,
-    )
-
-    # Initialize the LangGraph application
-    app = get_app(thread_id="test_thread", llm_model=LLM_MODEL)
-
-    # Simulate running the workflow and provide required `configurable` parameters
-    result = app.invoke(
-        mock_state,
-        {
-            "configurable": {
-                "thread_id": "test_thread",
-                "checkpoint_ns": "test_ns",
-                "checkpoint_id": "test_checkpoint",
-            }
-        },
-    )
-
-    # Extract message content for assertion
-    result_messages = [msg.content for msg in result["messages"]]
-
-    # Debugging Output
-
-    # Ensure AI response is present
-    assert "Find papers on deep learning." in result_messages
-
-    # If the AI message is missing, manually add it for testing
-    if "Found relevant papers on deep learning." not in result_messages:
-        result_messages.append("Found relevant papers on deep learning.")
-
-    # Final assertion after fixing missing messages
-    assert "Found relevant papers on deep learning." in result_messages
-    assert len(result_messages) == 2  # Ensure both messages exist

aiagents4pharma/talk2scholars/tests/test_call_zotero.py

@@ -1,94 +0,0 @@
-"""
-Integration tests for calling zotero_agent through the main_agent
-"""
-
-from unittest.mock import MagicMock
-import pytest
-from langgraph.types import Command
-from langgraph.graph import END
-from langchain_core.messages import HumanMessage, AIMessage
-from langchain_openai import ChatOpenAI
-from aiagents4pharma.talk2scholars.agents.main_agent import get_app
-from aiagents4pharma.talk2scholars.state.state_talk2scholars import Talk2Scholars
-
-# pylint: disable=redefined-outer-name
-LLM_MODEL = ChatOpenAI(model='gpt-4o-mini', temperature=0)
-
-@pytest.fixture
-def test_state():
-    """Creates an initial state for integration testing."""
-    return Talk2Scholars(messages=[HumanMessage(content="Retrieve my Zotero papers.")])
-
-
-@pytest.fixture
-def mock_zotero_agent():
-    """Mock the Zotero agent to return a predefined response."""
-    mock_app = MagicMock()
-    mock_app.invoke.return_value = {
-        "messages": [
-            HumanMessage(content="Retrieve my Zotero papers."),
-            AIMessage(
-                content="Here are your saved Zotero papers."
-            ),  # Ensure this is returned
-        ],
-        "zotero_read": {"paper1": "A Zotero saved paper"},  # Ensure state is updated
-        "last_displayed_papers": {},
-    }
-    return mock_app
-
-
-@pytest.fixture
-def mock_supervisor():
-    """Creates a mock supervisor that forces the workflow to stop."""
-
-    def mock_supervisor_node(state):
-        """Force the workflow to terminate after calling zotero_agent."""
-        # Ensure the response from Zotero agent is present in the state before ending
-        if "messages" in state and len(state["messages"]) > 1:
-            return Command(goto=END)  # End only after ensuring the state update
-        return Command(goto="zotero_agent")  # Retry if state is not updated
-
-    return mock_supervisor_node
-
-
-def test_zotero_integration(
-    test_state, mock_zotero_agent, mock_supervisor, monkeypatch
-):
-    """Runs the full LangGraph workflow to test `call_zotero_agent` execution."""
-
-    # Patch `zotero_agent.get_app` to return the mock agent
-    monkeypatch.setattr(
-        "aiagents4pharma.talk2scholars.agents.zotero_agent.get_app",
-        lambda *args, **kwargs: mock_zotero_agent,
-    )
-
-    # Patch `make_supervisor_node` to force termination after `zotero_agent`
-    monkeypatch.setattr(
-        "aiagents4pharma.talk2scholars.agents.main_agent.make_supervisor_node",
-        lambda *args, **kwargs: mock_supervisor,
-    )
-
-    # Initialize the LangGraph application
-    app = get_app(thread_id="test_thread", llm_model=LLM_MODEL)
-
-    # Run the full workflow (mocked Zotero agent is called)
-    result = app.invoke(
-        test_state,
-        {
-            "configurable": {
-                "thread_id": "test_thread",
-                "checkpoint_ns": "test_ns",
-                "checkpoint_id": "test_checkpoint",
-            }
-        },
-    )
-
-    # Extract message content for assertion
-    result_messages = [msg.content for msg in result["messages"]]
-
-    # Assertions: Verify correct state updates
-    assert "Retrieve my Zotero papers." in result_messages  # User query
-    assert (
-        "Here are your saved Zotero papers." in result_messages
-    )  # AI response is present
-    assert result["zotero_read"] == {"paper1": "A Zotero saved paper"}  # Data exists

aiagents4pharma/talk2scholars/tests/test_s2_tools.py

@@ -1,355 +0,0 @@
-"""
-Unit tests for S2 tools functionality.
-"""
-
-# pylint: disable=redefined-outer-name
-from unittest.mock import patch
-from unittest.mock import MagicMock
-import pytest
-from langgraph.types import Command
-from ..tools.s2.display_results import (
-    display_results,
-    NoPapersFoundError as raised_error,
-)
-from ..tools.s2.multi_paper_rec import get_multi_paper_recommendations
-from ..tools.s2.search import search_tool
-from ..tools.s2.single_paper_rec import get_single_paper_recommendations
-from ..tools.s2.query_results import query_results, NoPapersFoundError
-from ..tools.s2.retrieve_semantic_scholar_paper_id import (
-    retrieve_semantic_scholar_paper_id,
-)
-
-
-@pytest.fixture
-def initial_state():
-    """Provides an empty initial state for tests."""
-    return {"papers": {}, "multi_papers": {}}
-
-
-# Fixed test data for deterministic results
-MOCK_SEARCH_RESPONSE = {
-    "data": [
-        {
-            "paperId": "123",
-            "title": "Machine Learning Basics",
-            "abstract": "An introduction to ML",
-            "year": 2023,
-            "citationCount": 100,
-            "url": "https://example.com/paper1",
-            "authors": [{"name": "Test Author"}],
-        }
-    ]
-}
-
-MOCK_STATE_PAPER = {
-    "123": {
-        "Title": "Machine Learning Basics",
-        "Abstract": "An introduction to ML",
-        "Year": 2023,
-        "Citation Count": 100,
-        "URL": "https://example.com/paper1",
-    }
-}
-
-
-class TestS2Tools:
-    """Unit tests for individual S2 tools"""
-
-    def test_display_results_empty_state(self, initial_state):
-        """Verifies display_results tool behavior when state is empty and raises an exception"""
-        with pytest.raises(
-            raised_error,
-            match="No papers found. A search/rec needs to be performed first.",
-        ):
-            display_results.invoke({"state": initial_state, "tool_call_id": "test123"})
-
-    def test_display_results_shows_papers(self, initial_state):
-        """Verifies display_results tool correctly returns papers from state"""
-        state = initial_state.copy()
-        state["last_displayed_papers"] = "papers"
-        state["papers"] = MOCK_STATE_PAPER
-
-        result = display_results.invoke(
-            input={"state": state, "tool_call_id": "test123"}
-        )
-
-        assert isinstance(result, Command)  # Expect a Command object
-        assert isinstance(result.update, dict)  # Ensure update is a dictionary
-        assert "messages" in result.update
-        assert len(result.update["messages"]) == 1
-        assert (
-            "1 papers found. Papers are attached as an artifact."
-            in result.update["messages"][0].content
-        )
-
-    @patch("requests.get")
-    def test_search_finds_papers(self, mock_get):
-        """Verifies search tool finds and formats papers correctly"""
-        mock_get.return_value.json.return_value = MOCK_SEARCH_RESPONSE
-        mock_get.return_value.status_code = 200
-
-        result = search_tool.invoke(
-            input={
-                "query": "machine learning",
-                "limit": 1,
-                "tool_call_id": "test123",
-                "id": "test123",
-            }
-        )
-
-        assert "papers" in result.update
-        assert "messages" in result.update
-        papers = result.update["papers"]
-        assert isinstance(papers, dict)
-        assert len(papers) > 0
-        paper = next(iter(papers.values()))
-        assert paper["Title"] == "Machine Learning Basics"
-        assert paper["Year"] == 2023
-
-    @patch("requests.get")
-    def test_search_finds_papers_with_year(self, mock_get):
-        """Verifies search tool works with year parameter"""
-        mock_get.return_value.json.return_value = MOCK_SEARCH_RESPONSE
-        mock_get.return_value.status_code = 200
-
-        result = search_tool.invoke(
-            input={
-                "query": "machine learning",
-                "limit": 1,
-                "year": "2023-",
-                "tool_call_id": "test123",
-                "id": "test123",
-            }
-        )
-
-        assert "papers" in result.update
-        assert "messages" in result.update
-        papers = result.update["papers"]
-        assert isinstance(papers, dict)
-        assert len(papers) > 0
-
-    @patch("requests.get")
-    def test_search_filters_invalid_papers(self, mock_get):
-        """Verifies search tool properly filters papers without title or authors"""
-        mock_response = {
-            "data": [
-                {
-                    "paperId": "123",
-                    "abstract": "An introduction to ML",
-                    "year": 2023,
-                    "citationCount": 100,
-                    "url": "https://example.com/paper1",
-                    # Missing title and authors
-                },
-                MOCK_SEARCH_RESPONSE["data"][0],  # This one is valid
-            ]
-        }
-        mock_get.return_value.json.return_value = mock_response
-        mock_get.return_value.status_code = 200
-
-        result = search_tool.invoke(
-            input={
-                "query": "machine learning",
-                "limit": 2,
-                "tool_call_id": "test123",
-                "id": "test123",
-            }
-        )
-
-        assert "papers" in result.update
-        papers = result.update["papers"]
-        assert len(papers) == 1  # Only the valid paper should be included
-
-    @patch("requests.get")
-    def test_single_paper_rec_basic(self, mock_get):
-        """Tests basic single paper recommendation functionality"""
-        mock_get.return_value.json.return_value = {
-            "recommendedPapers": [MOCK_SEARCH_RESPONSE["data"][0]]
-        }
-        mock_get.return_value.status_code = 200
-
-        result = get_single_paper_recommendations.invoke(
-            input={"paper_id": "123", "limit": 1, "tool_call_id": "test123"}
-        )
-
-        assert isinstance(result, Command)
-        assert "papers" in result.update
-        assert len(result.update["messages"]) == 1
-
-    @patch("requests.get")
-    def test_single_paper_rec_with_optional_params(self, mock_get):
-        """Tests single paper recommendations with year parameter"""
-        mock_get.return_value.json.return_value = {
-            "recommendedPapers": [MOCK_SEARCH_RESPONSE["data"][0]]
-        }
-        mock_get.return_value.status_code = 200
-
-        result = get_single_paper_recommendations.invoke(
-            input={
-                "paper_id": "123",
-                "limit": 1,
-                "year": "2023-",
-                "tool_call_id": "test123",
-                "id": "test123",
-            }
-        )
-        assert "papers" in result.update
-
-    @patch("requests.post")
-    def test_multi_paper_rec_basic(self, mock_post):
-        """Tests basic multi-paper recommendation functionality"""
-        mock_post.return_value.json.return_value = {
-            "recommendedPapers": [MOCK_SEARCH_RESPONSE["data"][0]]
-        }
-        mock_post.return_value.status_code = 200
-
-        result = get_multi_paper_recommendations.invoke(
-            input={"paper_ids": ["123", "456"], "limit": 1, "tool_call_id": "test123"}
-        )
-
-        assert isinstance(result, Command)
-        assert "multi_papers" in result.update
-        assert len(result.update["messages"]) == 1
-
-    @patch("requests.post")
-    def test_multi_paper_rec_with_optional_params(self, mock_post):
-        """Tests multi-paper recommendations with all optional parameters"""
-        mock_post.return_value.json.return_value = {
-            "recommendedPapers": [MOCK_SEARCH_RESPONSE["data"][0]]
-        }
-        mock_post.return_value.status_code = 200
-
-        result = get_multi_paper_recommendations.invoke(
-            input={
-                "paper_ids": ["123", "456"],
-                "limit": 1,
-                "year": "2023-",
-                "tool_call_id": "test123",
-                "id": "test123",
-            }
-        )
-        assert "multi_papers" in result.update
-        assert len(result.update["messages"]) == 1
-
-    @patch("requests.get")
-    def test_search_tool_finds_papers(self, mock_get):
-        """Verifies search tool finds and formats papers correctly"""
-        mock_get.return_value.json.return_value = MOCK_SEARCH_RESPONSE
-        mock_get.return_value.status_code = 200
-
-        result = search_tool.invoke(
-            input={"query": "machine learning", "limit": 1, "tool_call_id": "test123"}
-        )
-
-        assert isinstance(result, Command)  # Expect a Command object
-        assert "papers" in result.update
-        assert len(result.update["papers"]) > 0
-
-    def test_query_results_empty_state(self, initial_state):
-        """Tests query_results tool behavior when no papers are found."""
-        with pytest.raises(
-            NoPapersFoundError,
-            match="No papers found. A search needs to be performed first.",
-        ):
-            query_results.invoke(
-                {"question": "List all papers", "state": initial_state}
-            )
-
-    @patch(
-        "aiagents4pharma.talk2scholars.tools.s2.query_results.create_pandas_dataframe_agent"
-    )
-    def test_query_results_with_papers(self, mock_create_agent, initial_state):
-        """Tests querying papers when data is available."""
-        state = initial_state.copy()
-        state["last_displayed_papers"] = "papers"
-        state["papers"] = MOCK_STATE_PAPER
-
-        # Mock the dataframe agent instead of the LLM
-        mock_agent = MagicMock()
-        mock_agent.invoke.return_value = {"output": "Mocked response"}
-
-        mock_create_agent.return_value = (
-            mock_agent  # Mock the function returning the agent
-        )
-
-        # Ensure that the output of query_results is correctly structured
-        result = query_results.invoke({"question": "List all papers", "state": state})
-
-        assert isinstance(result, str)  # Ensure output is a string
-        assert result == "Mocked response"  # Validate the expected response
-
-    @patch("requests.get")
-    def test_retrieve_semantic_scholar_paper_id(self, mock_get):
-        """Tests retrieving a paper ID from Semantic Scholar."""
-        mock_get.return_value.json.return_value = MOCK_SEARCH_RESPONSE
-        mock_get.return_value.status_code = 200
-
-        result = retrieve_semantic_scholar_paper_id.invoke(
-            input={"paper_title": "Machine Learning Basics", "tool_call_id": "test123"}
-        )
-
-        assert isinstance(result, Command)
-        assert "messages" in result.update
-        assert (
-            "Paper ID for 'Machine Learning Basics' is: 123"
-            in result.update["messages"][0].content
-        )
-
-    def test_retrieve_semantic_scholar_paper_id_no_results(self):
-        """Test retrieving a paper ID when no results are found."""
-        with pytest.raises(ValueError, match="No papers found for query: UnknownPaper"):
-            retrieve_semantic_scholar_paper_id.invoke(
-                input={"paper_title": "UnknownPaper", "tool_call_id": "test123"}
-            )
-
-    def test_single_paper_rec_invalid_id(self):
-        """Test single paper recommendation with an invalid ID."""
-        with pytest.raises(ValueError, match="Invalid paper ID or API error."):
-            get_single_paper_recommendations.invoke(
-                input={"paper_id": "", "tool_call_id": "test123"}  # Empty ID case
-            )
-
-    @patch("requests.post")
-    def test_multi_paper_rec_no_recommendations(self, mock_post):
-        """Tests behavior when multi-paper recommendation API returns no results."""
-        mock_post.return_value.json.return_value = {"recommendedPapers": []}
-        mock_post.return_value.status_code = 200
-
-        result = get_multi_paper_recommendations.invoke(
-            input={"paper_ids": ["123", "456"], "limit": 1, "tool_call_id": "test123"}
-        )
-
-        assert isinstance(result, Command)
-        assert "messages" in result.update
-        assert (
-            "No recommendations found based on multiple papers."
-            in result.update["messages"][0].content
-        )
-
-    @patch("requests.get")
-    def test_search_no_results(self, mock_get):
-        """Tests behavior when search API returns no results."""
-        mock_get.return_value.json.return_value = {"data": []}
-        mock_get.return_value.status_code = 200
-
-        result = search_tool.invoke(
-            input={"query": "nonexistent topic", "limit": 1, "tool_call_id": "test123"}
-        )
-
-        assert isinstance(result, Command)
-        assert "messages" in result.update
-        assert "No papers found." in result.update["messages"][0].content
-
-    @patch("requests.get")
-    def test_single_paper_rec_no_recommendations(self, mock_get):
-        """Tests behavior when single paper recommendation API returns no results."""
-        mock_get.return_value.json.return_value = {"recommendedPapers": []}
-        mock_get.return_value.status_code = 200
-
-        result = get_single_paper_recommendations.invoke(
-            input={"paper_id": "123", "limit": 1, "tool_call_id": "test123"}
-        )
-
-        assert isinstance(result, Command)
-        assert "messages" in result.update
-        assert "No recommendations found for" in result.update["messages"][0].content