academic-search-mcp 0.1.3__py3-none-any.whl

paper_search_mcp/academic_platforms/pubmed.py

@@ -0,0 +1,159 @@
+# paper_search_mcp/sources/pubmed.py
+from typing import List
+import requests
+from xml.etree import ElementTree as ET
+from datetime import datetime
+from ..paper import Paper
+import os
+
+class PaperSource:
+    """Abstract base class for paper sources"""
+    def search(self, query: str, **kwargs) -> List[Paper]:
+        raise NotImplementedError
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        raise NotImplementedError
+
+    def read_paper(self, paper_id: str, save_path: str) -> str:
+        raise NotImplementedError
+
+class PubMedSearcher(PaperSource):
+    """Searcher for PubMed papers"""
+    SEARCH_URL = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
+    FETCH_URL = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi"
+
+    def search(self, query: str, max_results: int = 10,
+               date_from: str = None, date_to: str = None) -> List[Paper]:
+        """Search PubMed papers.
+
+        Args:
+            query: Search query string
+            max_results: Maximum number of results
+            date_from: Start date in YYYY-MM-DD format (optional)
+            date_to: End date in YYYY-MM-DD format (optional)
+        """
+        search_params = {
+            'db': 'pubmed',
+            'term': query,
+            'retmax': max_results,
+            'retmode': 'xml'
+        }
+
+        # Add date filtering if specified
+        # PubMed uses YYYY/MM/DD format
+        if date_from or date_to:
+            search_params['datetype'] = 'pdat'  # publication date
+            if date_from:
+                search_params['mindate'] = date_from.replace('-', '/')
+            if date_to:
+                search_params['maxdate'] = date_to.replace('-', '/')
+        search_response = requests.get(self.SEARCH_URL, params=search_params)
+        search_root = ET.fromstring(search_response.content)
+        ids = [id.text for id in search_root.findall('.//Id')]
+        
+        fetch_params = {
+            'db': 'pubmed',
+            'id': ','.join(ids),
+            'retmode': 'xml'
+        }
+        fetch_response = requests.get(self.FETCH_URL, params=fetch_params)
+        fetch_root = ET.fromstring(fetch_response.content)
+        
+        papers = []
+        for article in fetch_root.findall('.//PubmedArticle'):
+            try:
+                pmid = article.find('.//PMID').text
+                title = article.find('.//ArticleTitle').text
+                authors = [f"{author.find('LastName').text} {author.find('Initials').text}" 
+                           for author in article.findall('.//Author')]
+                abstract = article.find('.//AbstractText').text if article.find('.//AbstractText') is not None else ''
+                pub_date = article.find('.//PubDate/Year').text
+                published = datetime.strptime(pub_date, '%Y')
+                doi = article.find('.//ELocationID[@EIdType="doi"]').text if article.find('.//ELocationID[@EIdType="doi"]') is not None else ''
+                papers.append(Paper(
+                    paper_id=pmid,
+                    title=title,
+                    authors=authors,
+                    abstract=abstract,
+                    url=f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/",
+                    pdf_url='',  # PubMed 无直接 PDF
+                    published_date=published,
+                    updated_date=published,
+                    source='pubmed',
+                    categories=[],
+                    keywords=[],
+                    doi=doi
+                ))
+            except Exception as e:
+                print(f"Error parsing PubMed article: {e}")
+        return papers
+
+    def download_pdf(self, paper_id: str, save_path: str) -> str:
+        """Attempt to download a paper's PDF from PubMed.
+
+        Args:
+            paper_id: PubMed ID (PMID)
+            save_path: Directory to save the PDF
+
+        Returns:
+            str: Error message indicating PDF download is not supported
+        
+        Raises:
+            NotImplementedError: Always raises this error as PubMed doesn't provide direct PDF access
+        """
+        message = ("PubMed does not provide direct PDF downloads. "
+                  "Please use the paper's DOI or URL to access the publisher's website.")
+        raise NotImplementedError(message)
+
+    def read_paper(self, paper_id: str, save_path: str = "./downloads") -> str:
+        """Attempt to read and extract text from a PubMed paper.
+
+        Args:
+            paper_id: PubMed ID (PMID)
+            save_path: Directory for potential PDF storage (unused)
+
+        Returns:
+            str: Error message indicating PDF reading is not supported
+        """
+        message = ("PubMed papers cannot be read directly through this tool. "
+                  "Only metadata and abstracts are available through PubMed's API. "
+                  "Please use the paper's DOI or URL to access the full text on the publisher's website.")
+        return message
+
+if __name__ == "__main__":
+    # 测试 PubMedSearcher 的功能
+    searcher = PubMedSearcher()
+    
+    # 测试搜索功能
+    print("Testing search functionality...")
+    query = "machine learning"
+    max_results = 5
+    try:
+        papers = searcher.search(query, max_results=max_results)
+        print(f"Found {len(papers)} papers for query '{query}':")
+        for i, paper in enumerate(papers, 1):
+            print(f"{i}. {paper.title}")
+            print(f"   Authors: {', '.join(paper.authors)}")
+            print(f"   DOI: {paper.doi}")
+            print(f"   URL: {paper.url}\n")
+    except Exception as e:
+        print(f"Error during search: {e}")
+    
+    # 测试 PDF 下载功能（会返回不支持的提示）
+    if papers:
+        print("\nTesting PDF download functionality...")
+        paper_id = papers[0].paper_id
+        try:
+            pdf_path = searcher.download_pdf(paper_id, "./downloads")
+        except NotImplementedError as e:
+            print(f"Expected error: {e}")
+    
+    # 测试论文阅读功能（会返回不支持的提示）
+    if papers:
+        print("\nTesting paper reading functionality...")
+        paper_id = papers[0].paper_id
+        try:
+            message = searcher.read_paper(paper_id)
+            print(f"Response: {message}")
+        except Exception as e:
+            print(f"Error during paper reading: {e}")

paper_search_mcp/academic_platforms/sci_hub.py

@@ -0,0 +1,178 @@
+"""Sci-Hub downloader integration.
+
+Simple wrapper adapted from scihub.py for downloading PDFs via Sci-Hub.
+"""
+from pathlib import Path
+import re
+import hashlib
+import logging
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup
+
+
+class SciHubFetcher:
+    """Simple Sci-Hub PDF downloader."""
+
+    def __init__(self, base_url: str = "https://sci-hub.se", output_dir: str = "./downloads"):
+        """Initialize with Sci-Hub URL and output directory."""
+        self.base_url = base_url.rstrip("/")
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.session = requests.Session()
+        self.session.headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'DNT': '1',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+        }
+
+    def download_pdf(self, identifier: str) -> Optional[str]:
+        """Download a PDF from Sci-Hub using a DOI, PMID, or URL.
+
+        Args:
+            identifier: DOI, PMID, or URL to the paper
+
+        Returns:
+            Path to saved PDF or None on failure
+        """
+        if not identifier.strip():
+            return None
+
+        try:
+            # Get direct URL to PDF
+            pdf_url = self._get_direct_url(identifier)
+            if not pdf_url:
+                logging.error(f"Could not find PDF URL for identifier: {identifier}")
+                return None
+
+            # Download the PDF
+            response = self.session.get(pdf_url, verify=False, timeout=30)
+            
+            if response.status_code != 200:
+                logging.error(f"Failed to download PDF, status {response.status_code}")
+                return None
+
+            if response.headers.get('Content-Type') != 'application/pdf':
+                logging.error("Response is not a PDF")
+                return None
+
+            # Generate filename and save
+            filename = self._generate_filename(response, identifier)
+            file_path = self.output_dir / filename
+            
+            with open(file_path, 'wb') as f:
+                f.write(response.content)
+                
+            return str(file_path)
+
+        except Exception as e:
+            logging.error(f"Error downloading PDF for {identifier}: {e}")
+            return None
+
+    def _get_direct_url(self, identifier: str) -> Optional[str]:
+        """Get the direct PDF URL from Sci-Hub."""
+        try:
+            # If it's already a direct PDF URL, return it
+            if identifier.endswith('.pdf'):
+                return identifier
+
+            # Search on Sci-Hub
+            search_url = f"{self.base_url}/{identifier}"
+            response = self.session.get(search_url, verify=False, timeout=20)
+            
+            if response.status_code != 200:
+                return None
+
+            soup = BeautifulSoup(response.content, 'html.parser')
+            
+            # Check for article not found
+            if "article not found" in response.text.lower():
+                logging.warning("Article not found on Sci-Hub")
+                return None
+
+            # Look for embed tag with PDF (most common in modern Sci-Hub)
+            embed = soup.find('embed', {'type': 'application/pdf'})
+            logging.debug(f"Found embed tag: {embed}")
+            if embed:
+                src = embed.get('src') if hasattr(embed, 'get') else None
+                logging.debug(f"Embed src: {src}")
+                if src and isinstance(src, str):
+                    if src.startswith('//'):
+                        pdf_url = 'https:' + src
+                        logging.debug(f"Returning PDF URL: {pdf_url}")
+                        return pdf_url
+                    elif src.startswith('/'):
+                        pdf_url = self.base_url + src
+                        logging.debug(f"Returning PDF URL: {pdf_url}")
+                        return pdf_url
+                    else:
+                        logging.debug(f"Returning PDF URL: {src}")
+                        return src
+
+            # Look for iframe with PDF (fallback)
+            iframe = soup.find('iframe')
+            if iframe:
+                src = iframe.get('src') if hasattr(iframe, 'get') else None
+                if src and isinstance(src, str):
+                    if src.startswith('//'):
+                        return 'https:' + src
+                    elif src.startswith('/'):
+                        return self.base_url + src
+                    else:
+                        return src
+
+            # Look for download button with onclick
+            for button in soup.find_all('button'):
+                onclick = button.get('onclick', '') if hasattr(button, 'get') else ''
+                if isinstance(onclick, str) and 'pdf' in onclick.lower():
+                    # Extract URL from onclick JavaScript
+                    url_match = re.search(r"location\.href='([^']+)'", onclick)
+                    if url_match:
+                        url = url_match.group(1)
+                        if url.startswith('//'):
+                            return 'https:' + url
+                        elif url.startswith('/'):
+                            return self.base_url + url
+                        else:
+                            return url
+
+            # Look for direct download links
+            for link in soup.find_all('a'):
+                href = link.get('href', '') if hasattr(link, 'get') else ''
+                if isinstance(href, str) and href and ('pdf' in href.lower() or href.endswith('.pdf')):
+                    if href.startswith('//'):
+                        return 'https:' + href
+                    elif href.startswith('/'):
+                        return self.base_url + href
+                    elif href.startswith('http'):
+                        return href
+
+            return None
+
+        except Exception as e:
+            logging.error(f"Error getting direct URL for {identifier}: {e}")
+            return None
+
+    def _generate_filename(self, response: requests.Response, identifier: str) -> str:
+        """Generate a unique filename for the PDF."""
+        # Try to get filename from URL
+        url_parts = response.url.split('/')
+        if url_parts:
+            name = url_parts[-1]
+            # Remove view parameters
+            name = re.sub(r'#view=(.+)', '', name)
+            if name.endswith('.pdf'):
+                # Generate hash for uniqueness
+                pdf_hash = hashlib.md5(response.content).hexdigest()[:8]
+                base_name = name[:-4]  # Remove .pdf
+                return f"{pdf_hash}_{base_name}.pdf"
+
+        # Fallback: use identifier
+        clean_identifier = re.sub(r'[^\w\-_.]', '_', identifier)
+        pdf_hash = hashlib.md5(response.content).hexdigest()[:8]
+        return f"{pdf_hash}_{clean_identifier}.pdf"