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

crossref_local/_server/routes_works.py

@@ -0,0 +1,128 @@
+"""Work search and retrieval endpoints."""
+
+import time
+from typing import Optional
+
+from fastapi import APIRouter, Query, HTTPException
+
+from .._core import fts
+from .._core.db import get_db
+from .._core.models import Work
+from .models import WorkResponse, SearchResponse, BatchRequest, BatchResponse
+
+router = APIRouter(tags=["works"])
+
+
+@router.get("/works", response_model=SearchResponse)
+def search_works(
+    q: str = Query(..., description="Search query (FTS5 syntax supported)"),
+    limit: int = Query(10, ge=1, le=100, description="Max results"),
+    offset: int = Query(0, ge=0, description="Skip first N results"),
+):
+    """
+    Full-text search across works.
+
+    Uses FTS5 index for fast searching across titles, abstracts, and authors.
+    Supports FTS5 query syntax like AND, OR, NOT, "exact phrases".
+
+    Examples:
+        /works?q=machine learning
+        /works?q="neural network" AND hippocampus
+        /works?q=CRISPR&limit=20
+    """
+    start = time.perf_counter()
+
+    try:
+        results = fts.search(q, limit=limit, offset=offset)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Search error: {e}")
+
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    return SearchResponse(
+        query=q,
+        total=results.total,
+        returned=len(results.works),
+        elapsed_ms=round(elapsed_ms, 2),
+        results=[
+            WorkResponse(
+                doi=w.doi,
+                title=w.title,
+                authors=w.authors,
+                year=w.year,
+                journal=w.journal,
+                issn=w.issn,
+                volume=w.volume,
+                issue=w.issue,
+                page=w.page,
+                abstract=w.abstract,
+                citation_count=w.citation_count,
+            )
+            for w in results.works
+        ],
+    )
+
+
+@router.get("/works/{doi:path}", response_model=Optional[WorkResponse])
+def get_work(doi: str):
+    """
+    Get work metadata by DOI.
+
+    Examples:
+        /works/10.1038/nature12373
+        /works/10.1016/j.cell.2020.01.001
+    """
+    db = get_db()
+    metadata = db.get_metadata(doi)
+
+    if metadata is None:
+        raise HTTPException(status_code=404, detail=f"DOI not found: {doi}")
+
+    work = Work.from_metadata(doi, metadata)
+
+    return WorkResponse(
+        doi=work.doi,
+        title=work.title,
+        authors=work.authors,
+        year=work.year,
+        journal=work.journal,
+        issn=work.issn,
+        volume=work.volume,
+        issue=work.issue,
+        page=work.page,
+        abstract=work.abstract,
+        citation_count=work.citation_count,
+    )
+
+
+@router.post("/works/batch", response_model=BatchResponse)
+def get_works_batch(request: BatchRequest):
+    """
+    Get multiple works by DOI.
+
+    Request body: {"dois": ["10.1038/...", "10.1016/..."]}
+    """
+    db = get_db()
+    results = []
+
+    for doi in request.dois:
+        metadata = db.get_metadata(doi)
+        if metadata:
+            work = Work.from_metadata(doi, metadata)
+            results.append(
+                WorkResponse(
+                    doi=work.doi,
+                    title=work.title,
+                    authors=work.authors,
+                    year=work.year,
+                    journal=work.journal,
+                    abstract=work.abstract,
+                    citation_count=work.citation_count,
+                )
+            )
+
+    return BatchResponse(
+        requested=len(request.dois),
+        found=len(results),
+        results=results,
+    )

crossref_local/_server/server.py

@@ -0,0 +1,19 @@
+"""FastAPI server for CrossRef Local with FTS5 search.
+
+This module re-exports from the modular server package for backwards compatibility.
+
+Usage:
+    crossref-local api                    # Run on default port 31291
+    crossref-local api --port 8080        # Custom port
+
+    # Or directly:
+    uvicorn crossref_local.server:app --host 0.0.0.0 --port 31291
+"""
+
+# Re-export from modular server package
+from .server import app, run_server, DEFAULT_PORT, DEFAULT_HOST
+
+__all__ = ["app", "run_server", "DEFAULT_PORT", "DEFAULT_HOST"]
+
+if __name__ == "__main__":
+    run_server()

crossref_local/aio.py

@@ -1,5 +1,5 @@
-"""
-Async API for crossref_local.
+#!/usr/bin/env python3
+"""Async API module for crossref_local.
 
 Provides async versions of all API functions. Uses thread pool execution
 with per-thread database connections for thread safety.
@@ -19,210 +19,30 @@ Usage:
     counts = await aio.count_many(["CRISPR", "machine learning"])
 """
 
-import asyncio
-import threading
-from typing import List, Optional
-
-from .models import Work, SearchResult
-from .config import Config
-from .db import Database
-
-
-# Thread-local storage for database connections
-_thread_local = threading.local()
-
-
-def _get_thread_db() -> Database:
-    """Get thread-local database connection."""
-    if not hasattr(_thread_local, 'db'):
-        _thread_local.db = Database(Config.get_db_path())
-    return _thread_local.db
-
-
-def _search_sync(query: str, limit: int, offset: int) -> SearchResult:
-    """Thread-safe sync search."""
-    from . import fts
-    # Use thread-local DB
-    db = _get_thread_db()
-    return fts._search_with_db(db, query, limit, offset)
-
-
-def _count_sync(query: str) -> int:
-    """Thread-safe sync count."""
-    from . import fts
-    db = _get_thread_db()
-    return fts._count_with_db(db, query)
-
-
-def _get_sync(doi: str) -> Optional[Work]:
-    """Thread-safe sync get."""
-    db = _get_thread_db()
-    metadata = db.get_metadata(doi)
-    if metadata:
-        return Work.from_metadata(doi, metadata)
-    return None
-
-
-def _get_many_sync(dois: List[str]) -> List[Work]:
-    """Thread-safe sync get_many."""
-    db = _get_thread_db()
-    works = []
-    for doi in dois:
-        metadata = db.get_metadata(doi)
-        if metadata:
-            works.append(Work.from_metadata(doi, metadata))
-    return works
-
-
-def _exists_sync(doi: str) -> bool:
-    """Thread-safe sync exists."""
-    db = _get_thread_db()
-    row = db.fetchone("SELECT 1 FROM works WHERE doi = ?", (doi,))
-    return row is not None
-
-
-def _info_sync() -> dict:
-    """Thread-safe sync info."""
-    db = _get_thread_db()
-
-    row = db.fetchone("SELECT COUNT(*) as count FROM works")
-    work_count = row["count"] if row else 0
-
-    try:
-        row = db.fetchone("SELECT COUNT(*) as count FROM works_fts")
-        fts_count = row["count"] if row else 0
-    except Exception:
-        fts_count = 0
-
-    try:
-        row = db.fetchone("SELECT COUNT(*) as count FROM citations")
-        citation_count = row["count"] if row else 0
-    except Exception:
-        citation_count = 0
-
-    return {
-        "db_path": str(Config.get_db_path()),
-        "works": work_count,
-        "fts_indexed": fts_count,
-        "citations": citation_count,
-    }
-
-
-async def search(
-    query: str,
-    limit: int = 10,
-    offset: int = 0,
-) -> SearchResult:
-    """
-    Async full-text search across works.
-
-    Args:
-        query: Search query (supports FTS5 syntax)
-        limit: Maximum results to return
-        offset: Skip first N results (for pagination)
-
-    Returns:
-        SearchResult with matching works
-    """
-    return await asyncio.to_thread(_search_sync, query, limit, offset)
-
-
-async def count(query: str) -> int:
-    """
-    Async count matching works without fetching results.
-
-    Args:
-        query: FTS5 search query
-
-    Returns:
-        Number of matching works
-    """
-    return await asyncio.to_thread(_count_sync, query)
-
-
-async def get(doi: str) -> Optional[Work]:
-    """
-    Async get a work by DOI.
-
-    Args:
-        doi: Digital Object Identifier
-
-    Returns:
-        Work object or None if not found
-    """
-    return await asyncio.to_thread(_get_sync, doi)
-
-
-async def get_many(dois: List[str]) -> List[Work]:
-    """
-    Async get multiple works by DOI.
-
-    Args:
-        dois: List of DOIs
-
-    Returns:
-        List of Work objects (missing DOIs are skipped)
-    """
-    return await asyncio.to_thread(_get_many_sync, dois)
-
-
-async def exists(doi: str) -> bool:
-    """
-    Async check if a DOI exists in the database.
-
-    Args:
-        doi: Digital Object Identifier
-
-    Returns:
-        True if DOI exists
-    """
-    return await asyncio.to_thread(_exists_sync, doi)
-
-
-async def info() -> dict:
-    """
-    Async get database information.
-
-    Returns:
-        Dictionary with database stats
-    """
-    return await asyncio.to_thread(_info_sync)
-
-
-async def search_many(queries: List[str], limit: int = 10) -> List[SearchResult]:
-    """
-    Run multiple searches concurrently.
-
-    Args:
-        queries: List of search queries
-        limit: Maximum results per query
-
-    Returns:
-        List of SearchResult objects
-    """
-    tasks = [search(q, limit=limit) for q in queries]
-    return await asyncio.gather(*tasks)
-
-
-async def count_many(queries: List[str]) -> dict:
-    """
-    Count matches for multiple queries concurrently.
-
-    Args:
-        queries: List of search queries
-
-    Returns:
-        Dict mapping query -> count
-
-    Example:
-        >>> counts = await count_many(["CRISPR", "machine learning"])
-        >>> print(counts)
-        {'CRISPR': 45000, 'machine learning': 477922}
-    """
-    tasks = [count(q) for q in queries]
-    results = await asyncio.gather(*tasks)
-    return dict(zip(queries, results))
-
+from ._aio import (
+    SearchResult as _SearchResult,
+    Work as _Work,
+    count as _count,
+    count_many as _count_many,
+    exists as _exists,
+    get as _get,
+    get_many as _get_many,
+    info as _info,
+    search as _search,
+    search_many as _search_many,
+)
+
+# Re-export with clean names
+search = _search
+count = _count
+get = _get
+get_many = _get_many
+exists = _exists
+info = _info
+search_many = _search_many
+count_many = _count_many
+SearchResult = _SearchResult
+Work = _Work
 
 __all__ = [
     "search",
@@ -233,4 +53,8 @@ __all__ = [
     "info",
     "search_many",
     "count_many",
+    "SearchResult",
+    "Work",
 ]
+
+# EOF