aiagents4pharma 1.31.0__py3-none-any.whl → 1.32.0__py3-none-any.whl

{aiagents4pharma-1.31.0.dist-info → aiagents4pharma-1.32.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

aiagents4pharma/talk2scholars/tools/paper_download/abstract_downloader.py

@@ -1,45 +0,0 @@
-"""
-Abstract Base Class for Paper Downloaders.
-
-This module defines the `AbstractPaperDownloader` class, which serves as a
-base class for downloading scholarly papers from different sources
-(e.g., arXiv, PubMed, IEEE Xplore). Any specific downloader should
-inherit from this class and implement its methods.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Any, Dict
-
-
-class AbstractPaperDownloader(ABC):
-    """
-    Abstract base class for scholarly paper downloaders.
-
-    This is designed to be extended for different paper sources
-    like arXiv, PubMed, IEEE Xplore, etc. Each implementation
-    must define methods for fetching metadata and downloading PDFs.
-    """
-
-    @abstractmethod
-    def fetch_metadata(self, paper_id: str) -> Dict[str, Any]:
-        """
-        Fetch metadata for a given paper ID.
-
-        Args:
-            paper_id (str): The unique identifier for the paper.
-
-        Returns:
-            Dict[str, Any]: The metadata dictionary (format depends on the data source).
-        """
-
-    @abstractmethod
-    def download_pdf(self, paper_id: str) -> bytes:
-        """
-        Download the PDF for a given paper ID.
-
-        Args:
-            paper_id (str): The unique identifier for the paper.
-
-        Returns:
-            bytes: The binary content of the downloaded PDF.
-        """

aiagents4pharma/talk2scholars/tools/paper_download/arxiv_downloader.py

@@ -1,115 +0,0 @@
-"""
-Arxiv Paper Downloader
-
-This module provides an implementation of `AbstractPaperDownloader` for arXiv.
-It connects to the arXiv API, retrieves metadata for a research paper, and
-downloads the corresponding PDF.
-
-By using an abstract base class, this implementation is extendable to other
-APIs like PubMed, IEEE Xplore, etc.
-"""
-
-import xml.etree.ElementTree as ET
-from typing import Any, Dict
-import logging
-import hydra
-import requests
-from .abstract_downloader import AbstractPaperDownloader
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-class ArxivPaperDownloader(AbstractPaperDownloader):
-    """
-    Downloader class for arXiv.
-
-    This class interfaces with the arXiv API to fetch metadata
-    and retrieve PDFs of academic papers based on their arXiv IDs.
-    """
-
-    def __init__(self):
-        """
-        Initializes the arXiv paper downloader.
-
-        Uses Hydra for configuration management to retrieve API details.
-        """
-        with hydra.initialize(version_base=None, config_path="../../configs"):
-            cfg = hydra.compose(
-                config_name="config", overrides=["tools/download_arxiv_paper=default"]
-            )
-            self.api_url = cfg.tools.download_arxiv_paper.api_url
-            self.request_timeout = cfg.tools.download_arxiv_paper.request_timeout
-            self.chunk_size = cfg.tools.download_arxiv_paper.chunk_size
-            self.pdf_base_url = cfg.tools.download_arxiv_paper.pdf_base_url
-
-    def fetch_metadata(self, paper_id: str) -> Dict[str, Any]:
-        """
-        Fetch metadata from arXiv for a given paper ID.
-
-        Args:
-            paper_id (str): The arXiv ID of the paper.
-
-        Returns:
-            Dict[str, Any]: A dictionary containing metadata, including the XML response.
-        """
-        logger.info("Fetching metadata from arXiv for paper ID: %s", paper_id)
-        api_url = f"{self.api_url}?search_query=id:{paper_id}&start=0&max_results=1"
-        response = requests.get(api_url, timeout=self.request_timeout)
-        response.raise_for_status()
-        return {"xml": response.text}
-
-    def download_pdf(self, paper_id: str) -> Dict[str, Any]:
-        """
-        Download the PDF of a paper from arXiv.
-
-        This function first retrieves the paper's metadata to locate the PDF link
-        before downloading the file.
-
-        Args:
-            paper_id (str): The arXiv ID of the paper.
-
-        Returns:
-            Dict[str, Any]: A dictionary containing:
-                - `pdf_object`: The binary content of the downloaded PDF.
-                - `pdf_url`: The URL from which the PDF was fetched.
-                - `arxiv_id`: The arXiv ID of the downloaded paper.
-        """
-        metadata = self.fetch_metadata(paper_id)
-
-        # Parse the XML response to locate the PDF link.
-        root = ET.fromstring(metadata["xml"])
-        ns = {"atom": "http://www.w3.org/2005/Atom"}
-        pdf_url = next(
-            (
-                link.attrib.get("href")
-                for entry in root.findall("atom:entry", ns)
-                for link in entry.findall("atom:link", ns)
-                if link.attrib.get("title") == "pdf"
-            ),
-            None,
-        )
-
-        if not pdf_url:
-            raise RuntimeError(f"Failed to download PDF for arXiv ID {paper_id}.")
-
-        logger.info("Downloading PDF from: %s", pdf_url)
-        pdf_response = requests.get(pdf_url, stream=True, timeout=self.request_timeout)
-        pdf_response.raise_for_status()
-        # print (pdf_response)
-
-        # Combine the PDF data from chunks.
-        pdf_object = b"".join(
-            chunk
-            for chunk in pdf_response.iter_content(chunk_size=self.chunk_size)
-            if chunk
-        )
-        # print (pdf_object)
-        print("PDF_URL", pdf_url)
-
-        return {
-            "pdf_object": pdf_object,
-            "pdf_url": pdf_url,
-            "arxiv_id": paper_id,
-        }

aiagents4pharma/talk2scholars/tools/s2/query_results.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-This tool is used to display the table of studies.
-"""
-
-import logging
-from typing import Annotated
-import pandas as pd
-from langchain_experimental.agents import create_pandas_dataframe_agent
-from langchain_core.tools import tool
-from langgraph.prebuilt import InjectedState
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-class NoPapersFoundError(Exception):
-    """Exception raised when no papers are found in the state."""
-
-
-@tool("query_results", parse_docstring=True)
-def query_results(question: str, state: Annotated[dict, InjectedState]) -> str:
-    """
-    Query the last displayed papers from the state. If no papers are found,
-    raises an exception.
-
-    Use this also to get the last displayed papers from the state,
-    and then use the papers to get recommendations for a single paper or
-    multiple papers.
-
-    Args:
-        question (str): The question to ask the agent.
-        state (dict): The state of the agent containing the papers.
-
-    Returns:
-        str: A message with the last displayed papers.
-    """
-    logger.info("Querying last displayed papers with question: %s", question)
-    llm_model = state.get("llm_model")
-    if not state.get("last_displayed_papers"):
-        logger.info("No papers displayed so far, raising NoPapersFoundError")
-        raise NoPapersFoundError(
-            "No papers found. A search needs to be performed first."
-        )
-    context_key = state.get("last_displayed_papers", "pdf_data")
-    dic_papers = state.get(context_key)
-    df_papers = pd.DataFrame.from_dict(dic_papers, orient="index")
-    df_agent = create_pandas_dataframe_agent(
-        llm_model,
-        allow_dangerous_code=True,
-        agent_type="tool-calling",
-        df=df_papers,
-        max_iterations=5,
-        include_df_in_prompt=True,
-        number_of_head_rows=df_papers.shape[0],
-        verbose=True,
-    )
-    llm_result = df_agent.invoke(question, stream_mode=None)
-    return llm_result["output"]