crossref-local 0.3.0__py3-none-any.whl

crossref_local/config.py

@@ -0,0 +1,72 @@
+"""Configuration for crossref_local."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+# Default database locations (checked in order)
+DEFAULT_DB_PATHS = [
+    Path("/home/ywatanabe/proj/crossref_local/data/crossref.db"),
+    Path("/mnt/nas_ug/crossref_local/data/crossref.db"),
+    Path.home() / ".crossref_local" / "crossref.db",
+    Path.cwd() / "data" / "crossref.db",
+]
+
+
+def get_db_path() -> Path:
+    """
+    Get database path from environment or auto-detect.
+
+    Priority:
+    1. CROSSREF_LOCAL_DB environment variable
+    2. First existing path from DEFAULT_DB_PATHS
+
+    Returns:
+        Path to the database file
+
+    Raises:
+        FileNotFoundError: If no database found
+    """
+    # Check environment variable first
+    env_path = os.environ.get("CROSSREF_LOCAL_DB")
+    if env_path:
+        path = Path(env_path)
+        if path.exists():
+            return path
+        raise FileNotFoundError(f"CROSSREF_LOCAL_DB path not found: {env_path}")
+
+    # Auto-detect from default locations
+    for path in DEFAULT_DB_PATHS:
+        if path.exists():
+            return path
+
+    raise FileNotFoundError(
+        "CrossRef database not found. Set CROSSREF_LOCAL_DB environment variable "
+        f"or place database at one of: {[str(p) for p in DEFAULT_DB_PATHS]}"
+    )
+
+
+class Config:
+    """Configuration container."""
+
+    _db_path: Optional[Path] = None
+
+    @classmethod
+    def get_db_path(cls) -> Path:
+        """Get or auto-detect database path."""
+        if cls._db_path is None:
+            cls._db_path = get_db_path()
+        return cls._db_path
+
+    @classmethod
+    def set_db_path(cls, path: str | Path) -> None:
+        """Set database path explicitly."""
+        path = Path(path)
+        if not path.exists():
+            raise FileNotFoundError(f"Database not found: {path}")
+        cls._db_path = path
+
+    @classmethod
+    def reset(cls) -> None:
+        """Reset configuration (for testing)."""
+        cls._db_path = None

crossref_local/db.py

@@ -0,0 +1,136 @@
+"""Database connection handling for crossref_local."""
+
+import sqlite3
+import json
+import zlib
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Optional, Generator
+
+from .config import Config
+
+
+class Database:
+    """
+    Database connection manager.
+
+    Supports both direct usage and context manager pattern.
+    """
+
+    def __init__(self, db_path: Optional[str | Path] = None):
+        """
+        Initialize database connection.
+
+        Args:
+            db_path: Path to database. If None, auto-detects.
+        """
+        if db_path:
+            self.db_path = Path(db_path)
+        else:
+            self.db_path = Config.get_db_path()
+
+        self.conn: Optional[sqlite3.Connection] = None
+        self._connect()
+
+    def _connect(self) -> None:
+        """Establish database connection."""
+        self.conn = sqlite3.connect(self.db_path)
+        self.conn.row_factory = sqlite3.Row
+
+    def close(self) -> None:
+        """Close database connection."""
+        if self.conn:
+            self.conn.close()
+            self.conn = None
+
+    def __enter__(self) -> "Database":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    def execute(self, query: str, params: tuple = ()) -> sqlite3.Cursor:
+        """Execute SQL query."""
+        return self.conn.execute(query, params)
+
+    def fetchone(self, query: str, params: tuple = ()) -> Optional[sqlite3.Row]:
+        """Execute query and fetch one result."""
+        cursor = self.execute(query, params)
+        return cursor.fetchone()
+
+    def fetchall(self, query: str, params: tuple = ()) -> list:
+        """Execute query and fetch all results."""
+        cursor = self.execute(query, params)
+        return cursor.fetchall()
+
+    def get_metadata(self, doi: str) -> Optional[dict]:
+        """
+        Get metadata for a DOI.
+
+        Args:
+            doi: DOI string
+
+        Returns:
+            Metadata dictionary or None
+        """
+        row = self.fetchone(
+            "SELECT metadata FROM works WHERE doi = ?",
+            (doi,)
+        )
+        if row and row["metadata"]:
+            return self._decompress_metadata(row["metadata"])
+        return None
+
+    def _decompress_metadata(self, data) -> dict:
+        """Decompress and parse metadata (handles both compressed and plain JSON)."""
+        # If it's already a string, parse directly
+        if isinstance(data, str):
+            return json.loads(data)
+
+        # If bytes, try decompression
+        if isinstance(data, bytes):
+            try:
+                decompressed = zlib.decompress(data)
+                return json.loads(decompressed)
+            except zlib.error:
+                return json.loads(data.decode("utf-8"))
+
+        return data
+
+
+# Singleton connection for convenience functions
+_db: Optional[Database] = None
+
+
+def get_db() -> Database:
+    """Get or create singleton database connection."""
+    global _db
+    if _db is None:
+        _db = Database()
+    return _db
+
+
+def close_db() -> None:
+    """Close singleton database connection."""
+    global _db
+    if _db:
+        _db.close()
+        _db = None
+
+
+@contextmanager
+def connection(db_path: Optional[str | Path] = None) -> Generator[Database, None, None]:
+    """
+    Context manager for database connection.
+
+    Args:
+        db_path: Path to database. If None, auto-detects.
+
+    Yields:
+        Database instance
+    """
+    db = Database(db_path)
+    try:
+        yield db
+    finally:
+        db.close()

crossref_local/fts.py

@@ -0,0 +1,138 @@
+"""Full-text search using FTS5."""
+
+import time
+from typing import List, Optional
+
+from .db import Database, get_db
+from .models import Work, SearchResult
+
+
+def search(
+    query: str,
+    limit: int = 10,
+    offset: int = 0,
+    db: Optional[Database] = None,
+) -> SearchResult:
+    """
+    Full-text search across works.
+
+    Uses FTS5 index for fast searching across titles, abstracts, and authors.
+
+    Args:
+        query: Search query (supports FTS5 syntax like AND, OR, NOT, "phrases")
+        limit: Maximum results to return
+        offset: Skip first N results (for pagination)
+        db: Database connection (uses singleton if not provided)
+
+    Returns:
+        SearchResult with matching works
+
+    Example:
+        >>> results = search("hippocampal sharp wave ripples")
+        >>> print(f"Found {results.total} matches in {results.elapsed_ms:.1f}ms")
+        >>> for work in results:
+        ...     print(f"{work.title} ({work.year})")
+    """
+    if db is None:
+        db = get_db()
+
+    start = time.perf_counter()
+
+    # Get total count
+    count_row = db.fetchone(
+        "SELECT COUNT(*) as total FROM works_fts WHERE works_fts MATCH ?",
+        (query,)
+    )
+    total = count_row["total"] if count_row else 0
+
+    # Get matching works with metadata
+    rows = db.fetchall(
+        """
+        SELECT w.doi, w.metadata
+        FROM works_fts f
+        JOIN works w ON f.rowid = w.rowid
+        WHERE works_fts MATCH ?
+        LIMIT ? OFFSET ?
+        """,
+        (query, limit, offset)
+    )
+
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    # Convert to Work objects
+    works = []
+    for row in rows:
+        metadata = db._decompress_metadata(row["metadata"])
+        works.append(Work.from_metadata(row["doi"], metadata))
+
+    return SearchResult(
+        works=works,
+        total=total,
+        query=query,
+        elapsed_ms=elapsed_ms,
+    )
+
+
+def count(query: str, db: Optional[Database] = None) -> int:
+    """
+    Count matching works without fetching results.
+
+    Args:
+        query: FTS5 search query
+        db: Database connection
+
+    Returns:
+        Number of matching works
+    """
+    if db is None:
+        db = get_db()
+
+    row = db.fetchone(
+        "SELECT COUNT(*) as total FROM works_fts WHERE works_fts MATCH ?",
+        (query,)
+    )
+    return row["total"] if row else 0
+
+
+def search_dois(
+    query: str,
+    limit: int = 1000,
+    db: Optional[Database] = None,
+) -> List[str]:
+    """
+    Search and return only DOIs (faster than full search).
+
+    Args:
+        query: FTS5 search query
+        limit: Maximum DOIs to return
+        db: Database connection
+
+    Returns:
+        List of matching DOIs
+    """
+    if db is None:
+        db = get_db()
+
+    rows = db.fetchall(
+        """
+        SELECT w.doi
+        FROM works_fts f
+        JOIN works w ON f.rowid = w.rowid
+        WHERE works_fts MATCH ?
+        LIMIT ?
+        """,
+        (query, limit)
+    )
+
+    return [row["doi"] for row in rows]
+
+
+# Thread-safe versions for async API
+def _search_with_db(db: Database, query: str, limit: int, offset: int) -> SearchResult:
+    """Search with explicit database connection (for thread-safe async)."""
+    return search(query, limit, offset, db=db)
+
+
+def _count_with_db(db: Database, query: str) -> int:
+    """Count with explicit database connection (for thread-safe async)."""
+    return count(query, db=db)

crossref_local/impact_factor/__init__.py

@@ -0,0 +1,20 @@
+"""
+Impact Factor calculation module.
+
+Calculates journal impact factors from the local CrossRef database
+by analyzing citation patterns.
+
+Usage:
+    >>> from crossref_local.impact_factor import ImpactFactorCalculator
+    >>> with ImpactFactorCalculator() as calc:
+    ...     result = calc.calculate_impact_factor("Nature", target_year=2023)
+    ...     print(f"IF: {result['impact_factor']:.3f}")
+"""
+
+from .calculator import ImpactFactorCalculator
+from .journal_lookup import JournalLookup
+
+__all__ = [
+    "ImpactFactorCalculator",
+    "JournalLookup",
+]