crossref-local 0.3.0__py3-none-any.whl

crossref_local/__init__.py

@@ -0,0 +1,78 @@
+"""
+crossref_local - Local CrossRef database with full-text search.
+
+A Python package for querying a local mirror of the CrossRef database
+with 167M+ scholarly works, full-text search, and impact factor calculation.
+
+Sync usage:
+    >>> from crossref_local import search, get
+    >>> results = search("hippocampal sharp wave ripples")
+    >>> work = get("10.1126/science.aax0758")
+
+Async usage:
+    >>> from crossref_local import aio
+    >>> results = await aio.search("machine learning")
+    >>> counts = await aio.count_many(["CRISPR", "neural network"])
+
+Configuration:
+    >>> from crossref_local import configure
+    >>> configure("/path/to/crossref.db")
+
+    Or set CROSSREF_LOCAL_DB environment variable.
+"""
+
+__version__ = "0.3.0"
+
+# Core API
+from .api import (
+    search,
+    count,
+    get,
+    get_many,
+    exists,
+    configure,
+    info,
+)
+
+# Models
+from .models import Work, SearchResult
+
+# Database utilities
+from .db import Database, connection
+
+# Configuration
+from .config import Config
+
+# Async API
+from . import aio
+
+# Citation network
+from .citations import get_citing, get_cited, get_citation_count, CitationNetwork
+
+__all__ = [
+    # Version
+    "__version__",
+    # Core API
+    "search",
+    "count",
+    "get",
+    "get_many",
+    "exists",
+    "configure",
+    "info",
+    # Models
+    "Work",
+    "SearchResult",
+    # Database
+    "Database",
+    "connection",
+    # Config
+    "Config",
+    # Async
+    "aio",
+    # Citations
+    "get_citing",
+    "get_cited",
+    "get_citation_count",
+    "CitationNetwork",
+]

crossref_local/aio.py

@@ -0,0 +1,236 @@
+"""
+Async API for crossref_local.
+
+Provides async versions of all API functions. Uses thread pool execution
+with per-thread database connections for thread safety.
+
+Usage:
+    from crossref_local import aio
+
+    async def main():
+        results = await aio.search("machine learning")
+        work = await aio.get("10.1038/nature12373")
+        n = await aio.count("CRISPR")
+
+    # Or import individual functions
+    from crossref_local.aio import search, get, count
+
+    # Concurrent operations
+    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))
+
+
+__all__ = [
+    "search",
+    "count",
+    "get",
+    "get_many",
+    "exists",
+    "info",
+    "search_many",
+    "count_many",
+]

crossref_local/api.py

@@ -0,0 +1,153 @@
+"""Main API for crossref_local."""
+
+from typing import List, Optional
+
+from .config import Config
+from .db import Database, get_db, close_db, connection
+from .models import Work, SearchResult
+from . import fts
+
+
+def search(
+    query: str,
+    limit: int = 10,
+    offset: int = 0,
+) -> SearchResult:
+    """
+    Full-text search across works.
+
+    Uses FTS5 index for fast searching across titles, abstracts, and authors.
+
+    Args:
+        query: Search query (supports FTS5 syntax)
+        limit: Maximum results to return
+        offset: Skip first N results (for pagination)
+
+    Returns:
+        SearchResult with matching works
+
+    Example:
+        >>> from crossref_local import search
+        >>> results = search("machine learning")
+        >>> print(f"Found {results.total} matches")
+    """
+    return fts.search(query, limit, offset)
+
+
+def count(query: str) -> int:
+    """
+    Count matching works without fetching results.
+
+    Args:
+        query: FTS5 search query
+
+    Returns:
+        Number of matching works
+    """
+    return fts.count(query)
+
+
+def get(doi: str) -> Optional[Work]:
+    """
+    Get a work by DOI.
+
+    Args:
+        doi: Digital Object Identifier
+
+    Returns:
+        Work object or None if not found
+
+    Example:
+        >>> from crossref_local import get
+        >>> work = get("10.1038/nature12373")
+        >>> print(work.title)
+    """
+    db = get_db()
+    metadata = db.get_metadata(doi)
+    if metadata:
+        return Work.from_metadata(doi, metadata)
+    return None
+
+
+def get_many(dois: List[str]) -> List[Work]:
+    """
+    Get multiple works by DOI.
+
+    Args:
+        dois: List of DOIs
+
+    Returns:
+        List of Work objects (missing DOIs are skipped)
+    """
+    db = get_db()
+    works = []
+    for doi in dois:
+        metadata = db.get_metadata(doi)
+        if metadata:
+            works.append(Work.from_metadata(doi, metadata))
+    return works
+
+
+def exists(doi: str) -> bool:
+    """
+    Check if a DOI exists in the database.
+
+    Args:
+        doi: Digital Object Identifier
+
+    Returns:
+        True if DOI exists
+    """
+    db = get_db()
+    row = db.fetchone("SELECT 1 FROM works WHERE doi = ?", (doi,))
+    return row is not None
+
+
+def configure(db_path: str) -> None:
+    """
+    Configure database path.
+
+    Args:
+        db_path: Path to CrossRef SQLite database
+
+    Example:
+        >>> from crossref_local import configure
+        >>> configure("/path/to/crossref.db")
+    """
+    Config.set_db_path(db_path)
+    close_db()  # Reset singleton to use new path
+
+
+def info() -> dict:
+    """
+    Get database information.
+
+    Returns:
+        Dictionary with database stats
+    """
+    db = get_db()
+
+    # Get work count
+    row = db.fetchone("SELECT COUNT(*) as count FROM works")
+    work_count = row["count"] if row else 0
+
+    # Get FTS count
+    try:
+        row = db.fetchone("SELECT COUNT(*) as count FROM works_fts")
+        fts_count = row["count"] if row else 0
+    except Exception:
+        fts_count = 0
+
+    # Get citations count
+    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,
+    }