crossref-local 0.3.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

crossref_local/mcp_server.py

@@ -1,202 +1,8 @@
-"""MCP server for CrossRef Local - Claude integration.
+#!/usr/bin/env python3
+"""Backward compatibility: re-export from _cli.mcp_server."""
 
-This server exposes crossref-local functionality as MCP tools,
-enabling Claude Desktop and other MCP clients to search academic papers.
+from ._cli.mcp_server import mcp, run_server, main
 
-Usage:
-    crossref-local serve                    # stdio (Claude Desktop)
-    crossref-local serve -t http --port 8082  # HTTP transport
-    crossref-local-mcp                      # Direct entry point
-"""
+__all__ = ["mcp", "run_server", "main"]
 
-import json
-from typing import Optional
-
-from fastmcp import FastMCP
-
-from . import search, get, count, info, __version__
-from .impact_factor import ImpactFactorCalculator
-
-# Initialize MCP server
-mcp = FastMCP(
-    name="crossref-local",
-    instructions="Local CrossRef database with 167M+ works and full-text search. "
-    "Use search_works to find papers, get_work for DOI lookup, count_works for counts, "
-    "database_info for stats, and calculate_impact_factor for journal metrics.",
-)
-
-
-@mcp.tool()
-def search_works(
-    query: str,
-    limit: int = 10,
-    offset: int = 0,
-    with_abstracts: bool = False,
-) -> str:
-    """Search for academic works by title, abstract, or authors.
-
-    Uses FTS5 full-text search index for fast searching across 167M+ papers.
-    Supports FTS5 query syntax: AND, OR, NOT, "exact phrases".
-
-    Args:
-        query: Search query (e.g., "machine learning", "CRISPR", "neural network AND hippocampus")
-        limit: Maximum number of results to return (default: 10, max: 100)
-        offset: Skip first N results for pagination (default: 0)
-        with_abstracts: Include abstracts in results (default: False)
-
-    Returns:
-        JSON string with search results including total count and matching works.
-
-    Examples:
-        search_works("machine learning")
-        search_works("CRISPR", limit=20)
-        search_works("neural network AND memory", with_abstracts=True)
-    """
-    results = search(query, limit=min(limit, 100), offset=offset)
-
-    works_data = []
-    for work in results.works:
-        work_dict = {
-            "doi": work.doi,
-            "title": work.title,
-            "authors": work.authors,
-            "year": work.year,
-            "journal": work.journal,
-        }
-        if with_abstracts and work.abstract:
-            work_dict["abstract"] = work.abstract
-        works_data.append(work_dict)
-
-    return json.dumps(
-        {
-            "query": results.query,
-            "total": results.total,
-            "returned": len(works_data),
-            "elapsed_ms": round(results.elapsed_ms, 2),
-            "works": works_data,
-        },
-        indent=2,
-    )
-
-
-@mcp.tool()
-def get_work(doi: str, as_citation: bool = False) -> str:
-    """Get detailed information about a work by DOI.
-
-    Args:
-        doi: Digital Object Identifier (e.g., "10.1038/nature12373")
-        as_citation: Return formatted citation instead of full metadata
-
-    Returns:
-        JSON string with work metadata, or formatted citation string.
-
-    Examples:
-        get_work("10.1038/nature12373")
-        get_work("10.1126/science.aax0758", as_citation=True)
-    """
-    work = get(doi)
-
-    if work is None:
-        return json.dumps({"error": f"DOI not found: {doi}"})
-
-    if as_citation:
-        return work.citation()
-
-    return json.dumps(work.to_dict(), indent=2)
-
-
-@mcp.tool()
-def count_works(query: str) -> str:
-    """Count matching works without fetching results.
-
-    Faster than search when you only need the count.
-
-    Args:
-        query: FTS5 search query
-
-    Returns:
-        JSON string with count.
-
-    Examples:
-        count_works("CRISPR")
-        count_works("machine learning AND deep")
-    """
-    n = count(query)
-    return json.dumps({"query": query, "count": n})
-
-
-@mcp.tool()
-def database_info() -> str:
-    """Get database statistics and status.
-
-    Returns:
-        JSON string with database path, work count, FTS index count, and citation count.
-    """
-    db_info = info()
-    return json.dumps(db_info, indent=2)
-
-
-@mcp.tool()
-def calculate_impact_factor(
-    journal: str,
-    year: int = 2023,
-    window: int = 2,
-) -> str:
-    """Calculate impact factor for a journal.
-
-    Impact factor = citations in target year / articles in window years.
-
-    Args:
-        journal: Journal name or ISSN (e.g., "Nature", "Science", "0028-0836")
-        year: Target year for citation count (default: 2023)
-        window: Number of years for article window (default: 2 for standard IF)
-
-    Returns:
-        JSON string with journal name, article count, citation count, and impact factor.
-
-    Examples:
-        calculate_impact_factor("Nature")
-        calculate_impact_factor("Science", year=2022)
-        calculate_impact_factor("Cell", window=5)  # 5-year impact factor
-    """
-    try:
-        with ImpactFactorCalculator() as calc:
-            result = calc.calculate_impact_factor(
-                journal_identifier=journal,
-                target_year=year,
-                window_years=window,
-            )
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        return json.dumps({"error": str(e)})
-
-
-def run_server(
-    transport: str = "stdio",
-    host: str = "localhost",
-    port: int = 8082,
-) -> None:
-    """Run the MCP server.
-
-    Args:
-        transport: Transport protocol ("stdio", "sse", or "http")
-        host: Host for HTTP/SSE transport
-        port: Port for HTTP/SSE transport
-    """
-    if transport == "stdio":
-        mcp.run(transport="stdio")
-    elif transport == "sse":
-        mcp.run(transport="sse", host=host, port=port)
-    elif transport == "http":
-        mcp.run(transport="streamable-http", host=host, port=port)
-    else:
-        raise ValueError(f"Unknown transport: {transport}")
-
-
-def main():
-    """Entry point for crossref-local-mcp command."""
-    run_server(transport="stdio")
-
-
-if __name__ == "__main__":
-    main()
+# EOF

crossref_local/remote.py

@@ -1,264 +1,8 @@
-"""Remote API client for crossref_local.
+#!/usr/bin/env python3
+"""Backward compatibility: re-export from _remote."""
 
-Connects to a CrossRef Local API server instead of direct database access.
-Use this when the database is on a remote server accessible via HTTP.
-"""
+from ._remote import RemoteClient, DEFAULT_API_URL, get_client, reset_client
 
-import json
-import urllib.request
-import urllib.parse
-import urllib.error
-from typing import List, Optional, Dict, Any
+__all__ = ["RemoteClient", "DEFAULT_API_URL", "get_client", "reset_client"]
 
-from .models import Work, SearchResult
-
-
-class RemoteClient:
-    """
-    HTTP client for CrossRef Local API server.
-
-    Provides the same interface as the local API but connects
-    to a remote server via HTTP.
-
-    Example:
-        >>> client = RemoteClient("http://localhost:3333")
-        >>> results = client.search(title="machine learning", limit=10)
-        >>> work = client.get("10.1038/nature12373")
-    """
-
-    def __init__(self, base_url: str = "http://localhost:3333", timeout: int = 30):
-        """
-        Initialize remote client.
-
-        Args:
-            base_url: API server URL (default: http://localhost:3333)
-            timeout: Request timeout in seconds
-        """
-        self.base_url = base_url.rstrip("/")
-        self.timeout = timeout
-
-    def _request(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict:
-        """Make HTTP GET request to API."""
-        url = f"{self.base_url}{endpoint}"
-        if params:
-            # Filter out None values
-            params = {k: v for k, v in params.items() if v is not None}
-            if params:
-                url = f"{url}?{urllib.parse.urlencode(params)}"
-
-        try:
-            req = urllib.request.Request(url)
-            req.add_header("Accept", "application/json")
-            with urllib.request.urlopen(req, timeout=self.timeout) as response:
-                return json.loads(response.read().decode("utf-8"))
-        except urllib.error.HTTPError as e:
-            if e.code == 404:
-                return None
-            raise ConnectionError(f"API request failed: {e.code} {e.reason}") from e
-        except urllib.error.URLError as e:
-            raise ConnectionError(
-                f"Cannot connect to API at {self.base_url}: {e.reason}"
-            ) from e
-
-    def health(self) -> Dict:
-        """Check API server health."""
-        return self._request("/health")
-
-    def info(self) -> Dict:
-        """Get database/API information."""
-        root = self._request("/")
-        info_data = self._request("/info")
-        return {
-            "api_url": self.base_url,
-            "api_version": root.get("version", "unknown"),
-            "status": root.get("status", "unknown"),
-            "mode": "remote",
-            "works": info_data.get("total_papers", 0) if info_data else 0,
-            "fts_indexed": info_data.get("fts_indexed", 0) if info_data else 0,
-            "citations": info_data.get("citations", 0) if info_data else 0,
-        }
-
-    def search(
-        self,
-        query: Optional[str] = None,
-        doi: Optional[str] = None,
-        title: Optional[str] = None,
-        authors: Optional[str] = None,
-        year: Optional[int] = None,
-        limit: int = 10,
-        offset: int = 0,
-    ) -> SearchResult:
-        """
-        Search for papers.
-
-        Args:
-            query: Full-text search query (searches title by default)
-            doi: Search by DOI
-            title: Search by title (explicit)
-            authors: Search by author name
-            year: Filter by publication year
-            limit: Maximum results (default: 10, max: 100)
-            offset: Skip first N results for pagination
-
-        Returns:
-            SearchResult with matching works
-        """
-        # Use new /works endpoint with FTS5 search
-        search_query = query or title
-
-        params = {
-            "q": search_query,
-            "limit": min(limit, 100),
-            "offset": offset,
-        }
-
-        data = self._request("/works", params)
-
-        if not data:
-            return SearchResult(works=[], total=0, query=query or "", elapsed_ms=0.0)
-
-        works = []
-        for item in data.get("results", []):
-            work = Work(
-                doi=item.get("doi", ""),
-                title=item.get("title", ""),
-                authors=item.get("authors", []),
-                year=item.get("year"),
-                journal=item.get("journal"),
-                volume=item.get("volume"),
-                issue=item.get("issue"),
-                page=item.get("page") or item.get("pages"),
-                abstract=item.get("abstract"),
-                citation_count=item.get("citation_count"),
-            )
-            works.append(work)
-
-        return SearchResult(
-            works=works,
-            total=data.get("total", len(works)),
-            query=query or title or doi or "",
-            elapsed_ms=data.get("elapsed_ms", 0.0),
-        )
-
-    def get(self, doi: str) -> Optional[Work]:
-        """
-        Get a work by DOI.
-
-        Args:
-            doi: Digital Object Identifier
-
-        Returns:
-            Work object or None if not found
-        """
-        # Use /works/{doi} endpoint directly
-        data = self._request(f"/works/{doi}")
-        if not data or "error" in data:
-            return None
-
-        return Work(
-            doi=data.get("doi", doi),
-            title=data.get("title", ""),
-            authors=data.get("authors", []),
-            year=data.get("year"),
-            journal=data.get("journal"),
-            volume=data.get("volume"),
-            issue=data.get("issue"),
-            page=data.get("page"),
-            abstract=data.get("abstract"),
-            citation_count=data.get("citation_count"),
-        )
-
-    def get_many(self, dois: List[str]) -> List[Work]:
-        """
-        Get multiple works by DOI using batch endpoint.
-
-        Args:
-            dois: List of DOIs
-
-        Returns:
-            List of Work objects
-        """
-        # Use batch endpoint if available
-        try:
-            data = {"dois": dois}
-            req_data = json.dumps(data).encode("utf-8")
-            req = urllib.request.Request(
-                f"{self.base_url}/works/batch", data=req_data, method="POST"
-            )
-            req.add_header("Content-Type", "application/json")
-            req.add_header("Accept", "application/json")
-
-            with urllib.request.urlopen(req, timeout=self.timeout) as response:
-                result = json.loads(response.read().decode("utf-8"))
-
-            works = []
-            for item in result.get("results", []):
-                work = Work(
-                    doi=item.get("doi", ""),
-                    title=item.get("title", ""),
-                    authors=item.get("authors", []),
-                    year=item.get("year"),
-                    journal=item.get("journal"),
-                )
-                works.append(work)
-            return works
-        except Exception:
-            # Fallback to individual lookups
-            works = []
-            for doi in dois:
-                work = self.get(doi)
-                if work:
-                    works.append(work)
-            return works
-
-    def exists(self, doi: str) -> bool:
-        """Check if a DOI exists."""
-        return self.get(doi) is not None
-
-    def get_citations(self, doi: str, direction: str = "both") -> Dict:
-        """
-        Get citations for a paper.
-
-        Args:
-            doi: Paper DOI
-            direction: 'citing', 'cited_by', or 'both'
-
-        Returns:
-            Dict with citation information
-        """
-        params = {"doi": doi, "direction": direction}
-        return self._request("/api/citations/", params) or {}
-
-    def get_journal(
-        self, issn: Optional[str] = None, name: Optional[str] = None
-    ) -> Dict:
-        """
-        Get journal information.
-
-        Args:
-            issn: Journal ISSN
-            name: Journal name
-
-        Returns:
-            Dict with journal information
-        """
-        params = {"issn": issn, "name": name}
-        return self._request("/api/journal/", params) or {}
-
-
-# Module-level client for convenience
-_client: Optional[RemoteClient] = None
-
-
-def get_client(base_url: str = "http://localhost:3333") -> RemoteClient:
-    """Get or create singleton remote client."""
-    global _client
-    if _client is None or _client.base_url != base_url:
-        _client = RemoteClient(base_url)
-    return _client
-
-
-def reset_client() -> None:
-    """Reset singleton client."""
-    global _client
-    _client = None
+# EOF