bookcli 0.1.0__py3-none-any.whl

bookcli/config.py

@@ -0,0 +1,72 @@
+"""Configuration management for BookCLI."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict
+from pydantic import BaseModel, Field
+
+from bookcli.settings import CONFIG_PATH, DEFAULT_CONFIG
+
+logger = logging.getLogger(__name__)
+
+
+class ProvidersConfig(BaseModel):
+    """Configuration for individual book search providers."""
+    google_books: bool = True
+    openlibrary: bool = True
+    gutenberg: bool = True
+    internet_archive: bool = True
+
+
+class AppConfig(BaseModel):
+    """Application-wide configuration settings."""
+    download_dir: str
+    cache_ttl_seconds: int = Field(default=86400, ge=0)
+    timeout_seconds: int = Field(default=15, ge=1)
+    theme: str = "dark"
+    providers: ProvidersConfig = Field(default_factory=ProvidersConfig)
+
+
+def load_config() -> AppConfig:
+    """Loads configuration from config.json, merging with default config."""
+    config_dict = DEFAULT_CONFIG.copy()
+
+    if CONFIG_PATH.exists():
+        try:
+            with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+                user_config = json.load(f)
+                # Merge user config with defaults (shallow dict update for top-level keys,
+                # custom merge for nested providers)
+                for key, value in user_config.items():
+                    if key == "providers" and isinstance(value, dict):
+                        # Merge providers dict
+                        for p_key, p_val in value.items():
+                            if p_key in config_dict["providers"]:
+                                config_dict["providers"][p_key] = bool(p_val)
+                    else:
+                        config_dict[key] = value
+        except Exception as e:
+            logger.warning("Failed to load config file: %s. Using default settings.", e)
+
+    # Instantiate and validate through Pydantic
+    try:
+        return AppConfig(**config_dict)
+    except Exception as e:
+        logger.warning("Validation of configuration failed: %s. Using default settings.", e)
+        # Force default settings if validation fails
+        return AppConfig(**DEFAULT_CONFIG)
+
+
+def save_config(config: AppConfig) -> None:
+    """Saves configuration to the config.json file."""
+    try:
+        # Create directory if it doesn't exist
+        CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+        with open(CONFIG_PATH, "w", encoding="utf-8") as f:
+            # We use dump_model to turn it into dict, then standard json dump
+            json.dump(config.model_dump(), f, indent=4)
+        logger.info("Configuration saved successfully to %s", CONFIG_PATH)
+    except Exception as e:
+        logger.error("Failed to save configuration: %s", e)
+        raise e

bookcli/database/__init__.py

@@ -0,0 +1,32 @@
+"""Database connection and query management using aiosqlite."""
+
+import os
+import aiosqlite
+import logging
+from typing import AsyncGenerator
+from contextlib import asynccontextmanager
+from bookcli.database.migrations import run_migrations
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseManager:
+    """Manages SQLite database connections and tables initialization."""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        # Ensure parent directory exists
+        parent_dir = os.path.dirname(db_path)
+        if parent_dir:
+            os.makedirs(parent_dir, exist_ok=True)
+
+    @asynccontextmanager
+    async def connection(self) -> AsyncGenerator[aiosqlite.Connection, None]:
+        """Context manager for obtaining a database connection."""
+        async with aiosqlite.connect(self.db_path) as conn:
+            conn.row_factory = aiosqlite.Row
+            yield conn
+
+    async def initialize(self) -> None:
+        """Runs migrations to initialize database schema."""
+        await run_migrations(self.db_path)

bookcli/database/migrations.py

@@ -0,0 +1,94 @@
+"""Database migrations for BookCLI."""
+
+import logging
+import aiosqlite
+
+logger = logging.getLogger(__name__)
+
+MIGRATIONS = [
+    # Migration 1: Create search_history table
+    """
+    CREATE TABLE IF NOT EXISTS search_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        query TEXT NOT NULL,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+        results_count INTEGER NOT NULL
+    );
+    """,
+    # Migration 2: Create cached_books table
+    """
+    CREATE TABLE IF NOT EXISTS cached_books (
+        id TEXT PRIMARY KEY,
+        provider TEXT NOT NULL,
+        json_data TEXT NOT NULL,
+        cached_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    """,
+    # Migration 3: Create downloads table
+    """
+    CREATE TABLE IF NOT EXISTS downloads (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        status TEXT NOT NULL,
+        downloaded_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        checksum TEXT
+    );
+    """,
+    # Migration 4: Create favorites table
+    """
+    CREATE TABLE IF NOT EXISTS favorites (
+        book_id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        added_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+    """,
+    # Migration 5: Create search_results_session table for short indexing support
+    """
+    CREATE TABLE IF NOT EXISTS search_results_session (
+        result_index INTEGER PRIMARY KEY,
+        book_id TEXT NOT NULL
+    );
+    """
+]
+
+
+async def run_migrations(db_path: str) -> None:
+    """Run all database migrations using aiosqlite."""
+    logger.info("Running database migrations on %s...", db_path)
+    async with aiosqlite.connect(db_path) as db:
+        # Create a migration tracking table if it doesn't exist
+        await db.execute(
+            """
+            CREATE TABLE IF NOT EXISTS schema_version (
+                version INTEGER PRIMARY KEY
+            );
+            """
+        )
+        await db.commit()
+
+        # Get current version
+        async with db.execute("SELECT version FROM schema_version LIMIT 1") as cursor:
+            row = await cursor.fetchone()
+            current_version = row[0] if row else 0
+
+        logger.debug("Current DB schema version: %s", current_version)
+
+        # Run any pending migrations
+        for version, migration_sql in enumerate(MIGRATIONS, start=1):
+            if version > current_version:
+                logger.info("Applying migration version %s...", version)
+                try:
+                    await db.execute(migration_sql)
+                    if current_version == 0 and version == 1:
+                        await db.execute("INSERT INTO schema_version (version) VALUES (?)", (version,))
+                    else:
+                        await db.execute("UPDATE schema_version SET version = ?", (version,))
+                    await db.commit()
+                    current_version = version
+                except Exception as e:
+                    await db.rollback()
+                    logger.error("Failed to apply migration %s: %s", version, e)
+                    raise e
+
+        logger.info("Database migrations completed successfully.")

bookcli/downloader.py

@@ -0,0 +1,130 @@
+"""Downloader service for fetching files asynchronously with resume capability and Rich progress."""
+
+import os
+import hashlib
+import time
+import logging
+from typing import Optional
+import httpx
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    BarColumn,
+    TextColumn,
+    DownloadColumn,
+    TransferSpeedColumn,
+    TimeRemainingColumn
+)
+
+from bookcli.exceptions import DownloadError
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_sha256(file_path: str) -> str:
+    """Calculates the SHA256 checksum of a file."""
+    sha256 = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        while chunk := f.read(8192):
+            sha256.update(chunk)
+    return sha256.hexdigest()
+
+
+async def download_file(
+    url: str,
+    dest_path: str,
+    timeout_seconds: int = 15
+) -> str:
+    """Downloads a file asynchronously from a URL with resume support, showing a Rich progress bar.
+
+    Returns:
+        The SHA256 checksum of the completed file.
+    """
+    part_path = dest_path + ".part"
+    initial_bytes = 0
+
+    if os.path.exists(part_path):
+        initial_bytes = os.path.getsize(part_path)
+        logger.info("Found partial download of size %d bytes. Attempting to resume...", initial_bytes)
+
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    }
+    if initial_bytes > 0:
+        headers["Range"] = f"bytes={initial_bytes}-"
+
+    try:
+        async with httpx.AsyncClient(timeout=timeout_seconds, follow_redirects=True) as client:
+            async with client.stream("GET", url, headers=headers) as response:
+                if response.status_code == 416:
+                    # Range not satisfiable, might mean the file was already fully downloaded
+                    # Let's delete part file and restart or just raise
+                    logger.warning("Range not satisfiable (416). Restarting download.")
+                    if os.path.exists(part_path):
+                        os.remove(part_path)
+                    initial_bytes = 0
+                    # Retry without Range
+                    return await download_file(url, dest_path, timeout_seconds)
+
+                if response.status_code not in (200, 206):
+                    raise DownloadError(
+                        f"Server returned HTTP status code {response.status_code} for download."
+                    )
+
+                is_resume = response.status_code == 206
+                total_bytes = int(response.headers.get("content-length", 0))
+                
+                if is_resume:
+                    total_bytes += initial_bytes
+                    write_mode = "ab"
+                else:
+                    initial_bytes = 0
+                    write_mode = "wb"
+
+                # Ensure destination directory exists
+                os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+
+                filename = os.path.basename(dest_path)
+                
+                # Setup Rich Progress bar
+                with Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    BarColumn(),
+                    DownloadColumn(),
+                    TransferSpeedColumn(),
+                    TimeRemainingColumn(),
+                    transient=True  # Clear the progress bar after completion
+                ) as progress:
+                    
+                    task_desc = f"Downloading {filename}"
+                    task_id = progress.add_task(
+                        task_desc,
+                        total=total_bytes,
+                        completed=initial_bytes
+                    )
+
+                    with open(part_path, write_mode) as f:
+                        async for chunk in response.aiter_bytes(chunk_size=8192):
+                            f.write(chunk)
+                            progress.update(task_id, advance=len(chunk))
+
+        # Rename part file to final file
+        if os.path.exists(dest_path):
+            os.remove(dest_path)
+        os.rename(part_path, dest_path)
+
+        # Calculate Checksum
+        checksum = calculate_sha256(dest_path)
+        logger.info("Download completed successfully. SHA256: %s", checksum)
+        return checksum
+
+    except httpx.RequestError as e:
+        logger.error("Network error during download: %s", e)
+        raise DownloadError(f"Network error while downloading: {e}")
+    except (IOError, OSError) as e:
+        logger.error("Disk I/O error during download: %s", e)
+        raise DownloadError(f"Failed to write downloaded file: {e}")
+    except Exception as e:
+        logger.error("Unexpected error during download: %s", e)
+        raise DownloadError(f"Download failed: {e}")

bookcli/exceptions.py

@@ -0,0 +1,34 @@
+"""Custom exceptions for BookCLI."""
+
+
+class BookCLIError(Exception):
+    """Base exception for BookCLI."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
+        self.message = message
+
+
+class ProviderError(BookCLIError):
+    """Raised when an API request to a provider fails or times out."""
+    pass
+
+
+class DownloadError(BookCLIError):
+    """Raised when downloading a file fails, is interrupted, or checksum fails."""
+    pass
+
+
+class ConfigError(BookCLIError):
+    """Raised when configuration is invalid or cannot be saved."""
+    pass
+
+
+class DatabaseError(BookCLIError):
+    """Raised when a database query or migration fails."""
+    pass
+
+
+class BookNotFoundError(BookCLIError):
+    """Raised when a specific book or file cannot be found in search results, database, or disk."""
+    pass

bookcli/models.py

@@ -0,0 +1,23 @@
+"""Data models for BookCLI."""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class BookMetadata(BaseModel):
+    """Pydantic model representing normalized book metadata across all providers."""
+    id: str = Field(description="Unique identifier, e.g., 'gutenberg:1234' or 'google:abcde'")
+    title: str = Field(description="The primary title of the book")
+    subtitle: Optional[str] = Field(default=None, description="Subtitle if available")
+    authors: List[str] = Field(default_factory=list, description="List of author names")
+    description: Optional[str] = Field(default=None, description="Synopsis or description of the book")
+    language: Optional[str] = Field(default=None, description="Language code (e.g., 'en', 'fr')")
+    publisher: Optional[str] = Field(default=None, description="Publisher name")
+    published_year: Optional[int] = Field(default=None, description="Year of publication")
+    pages: Optional[int] = Field(default=None, description="Number of pages")
+    isbn: Optional[str] = Field(default=None, description="International Standard Book Number")
+    cover_url: Optional[str] = Field(default=None, description="URL of the cover page image")
+    download_url: Optional[str] = Field(default=None, description="Direct legal download link if available")
+    source: str = Field(description="Source provider name (gutenberg, google_books, etc.)")
+    download_availability: bool = Field(default=False, description="Flag indicating if a legal download file is available")
+    file_format: Optional[str] = Field(default=None, description="Format of the downloadable file (epub, pdf, txt, etc.)")

bookcli/opener.py

@@ -0,0 +1,32 @@
+"""OS default application opener service for BookCLI."""
+
+import os
+import sys
+import subprocess
+import logging
+from bookcli.exceptions import BookCLIError
+
+logger = logging.getLogger(__name__)
+
+
+def open_file_in_default_app(file_path: str) -> None:
+    """Opens a file using the operating system's default application."""
+    if not os.path.exists(file_path):
+        raise BookCLIError(f"File not found: {file_path}")
+
+    abs_path = os.path.abspath(file_path)
+    logger.info("Opening file: %s", abs_path)
+
+    try:
+        if sys.platform.startswith("win32"):
+            # Windows
+            os.startfile(abs_path)
+        elif sys.platform.startswith("darwin"):
+            # macOS
+            subprocess.run(["open", abs_path], check=True)
+        else:
+            # Linux / Unix
+            subprocess.run(["xdg-open", abs_path], check=True)
+    except Exception as e:
+        logger.error("Failed to open file %s: %s", abs_path, e)
+        raise BookCLIError(f"Failed to open file in default application: {e}")

bookcli/providers/__init__.py

@@ -0,0 +1 @@
+"""Book providers for BookCLI."""

bookcli/providers/base.py

@@ -0,0 +1,61 @@
+"""Base class and interface for book search and metadata providers."""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional
+from bookcli.models import BookMetadata
+
+
+class BaseProvider(ABC):
+    """Abstract base class representing a book metadata and search provider."""
+
+    def __init__(self, name: str, timeout_seconds: int = 15):
+        self.name = name
+        self.timeout_seconds = timeout_seconds
+
+    @abstractmethod
+    async def search(
+        self,
+        query: str,
+        author: Optional[str] = None,
+        isbn: Optional[str] = None,
+        publisher: Optional[str] = None,
+        subject: Optional[str] = None
+    ) -> List[BookMetadata]:
+        """Searches the provider for books matching the search criteria.
+
+        Args:
+            query: Free-text search query.
+            author: Optional author name to filter/search.
+            isbn: Optional ISBN to search.
+            publisher: Optional publisher to search.
+            subject: Optional subject to search.
+
+        Returns:
+            A list of validated BookMetadata items.
+        """
+        pass
+
+    @abstractmethod
+    async def get_book(self, book_id: str) -> Optional[BookMetadata]:
+        """Fetches detailed metadata for a specific book by ID.
+
+        Args:
+            book_id: Unique identifier for the book.
+
+        Returns:
+            BookMetadata if found, else None.
+        """
+        pass
+
+    @abstractmethod
+    async def download(self, book: BookMetadata, dest_path: str) -> None:
+        """Downloads the book content to the destination path.
+
+        Args:
+            book: The BookMetadata object containing download information.
+            dest_path: Location where the file will be saved.
+
+        Raises:
+            DownloadError: If download fails or is not available.
+        """
+        pass

bookcli/providers/google_books.py

@@ -0,0 +1,202 @@
+"""Google Books API provider implementation."""
+
+import logging
+from typing import List, Optional
+import httpx
+
+from bookcli.exceptions import ProviderError, DownloadError
+from bookcli.models import BookMetadata
+from bookcli.providers.base import BaseProvider
+
+logger = logging.getLogger(__name__)
+
+
+class GoogleBooksProvider(BaseProvider):
+    """Google Books API provider."""
+
+    def __init__(self, timeout_seconds: int = 15):
+        super().__init__(name="google_books", timeout_seconds=timeout_seconds)
+        self.base_url = "https://www.googleapis.com/books/v1/volumes"
+
+    def _build_query(
+        self,
+        query: str,
+        author: Optional[str] = None,
+        isbn: Optional[str] = None,
+        publisher: Optional[str] = None,
+        subject: Optional[str] = None
+    ) -> str:
+        """Constructs the Google Books 'q' parameter query string."""
+        parts = []
+        if query.strip():
+            parts.append(query.strip())
+        if author:
+            parts.append(f"inauthor:{author}")
+        if isbn:
+            parts.append(f"isbn:{isbn}")
+        if publisher:
+            parts.append(f"inpublisher:{publisher}")
+        if subject:
+            parts.append(f"subject:{subject}")
+        return " ".join(parts)
+
+    def _parse_published_year(self, date_str: Optional[str]) -> Optional[int]:
+        """Extracts the year from a Google Books publishedDate (e.g. '2016-11' or '2016')."""
+        if not date_str:
+            return None
+        try:
+            year_part = date_str.split("-")[0]
+            return int(year_part)
+        except (ValueError, IndexError):
+            return None
+
+    def _parse_isbn(self, identifiers: Optional[List[dict]]) -> Optional[str]:
+        """Finds the ISBN_13 or ISBN_10 from the industry identifiers list."""
+        if not identifiers:
+            return None
+        # Prefer ISBN_13
+        for ident in identifiers:
+            if ident.get("type") == "ISBN_13":
+                return ident.get("identifier")
+        # Fallback to ISBN_10
+        for ident in identifiers:
+            if ident.get("type") == "ISBN_10":
+                return ident.get("identifier")
+        # Fallback to any identifier
+        if identifiers:
+            return identifiers[0].get("identifier")
+        return None
+
+    def _map_volume_to_metadata(self, item: dict) -> BookMetadata:
+        """Maps Google Books API volume resource to BookMetadata model."""
+        volume_info = item.get("volumeInfo", {})
+        access_info = item.get("accessInfo", {})
+
+        book_id = f"google:{item.get('id')}"
+        title = volume_info.get("title", "Unknown Title")
+        subtitle = volume_info.get("subtitle")
+        authors = volume_info.get("authors", [])
+        description = volume_info.get("description")
+        language = volume_info.get("language")
+        publisher = volume_info.get("publisher")
+        published_year = self._parse_published_year(volume_info.get("publishedDate"))
+        pages = volume_info.get("pageCount")
+        isbn = self._parse_isbn(volume_info.get("industryIdentifiers"))
+
+        image_links = volume_info.get("imageLinks", {})
+        # Prefer thumbnail, then smallThumbnail
+        cover_url = image_links.get("thumbnail") or image_links.get("smallThumbnail")
+
+        # Determine download availability and format
+        # Check if direct download is allowed legally (public domain or explicitly free)
+        download_available = False
+        download_url = None
+        file_format = None
+
+        epub_info = access_info.get("epub", {})
+        pdf_info = access_info.get("pdf", {})
+
+        # If epub download link is available
+        if epub_info.get("isAvailable") and epub_info.get("downloadLink"):
+            download_available = True
+            download_url = epub_info.get("downloadLink")
+            file_format = "epub"
+        # Otherwise, check pdf
+        elif pdf_info.get("isAvailable") and pdf_info.get("downloadLink"):
+            download_available = True
+            download_url = pdf_info.get("downloadLink")
+            file_format = "pdf"
+
+        # Double check viewability / public domain
+        # If publicDomain is True, but there's no downloadLink, sometimes viewability allows reading
+        # But we only want to support downloading actual files.
+        # So we stick to epub/pdf downloadLink availability.
+
+        return BookMetadata(
+            id=book_id,
+            title=title,
+            subtitle=subtitle,
+            authors=authors,
+            description=description,
+            language=language,
+            publisher=publisher,
+            published_year=published_year,
+            pages=pages,
+            isbn=isbn,
+            cover_url=cover_url,
+            download_url=download_url,
+            source=self.name,
+            download_availability=download_available,
+            file_format=file_format
+        )
+
+    async def search(
+        self,
+        query: str,
+        author: Optional[str] = None,
+        isbn: Optional[str] = None,
+        publisher: Optional[str] = None,
+        subject: Optional[str] = None
+    ) -> List[BookMetadata]:
+        """Searches Google Books API."""
+        q_param = self._build_query(query, author, isbn, publisher, subject)
+        if not q_param:
+            return []
+
+        params = {
+            "q": q_param,
+            "maxResults": 20,
+        }
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout_seconds) as client:
+                response = await client.get(self.base_url, params=params)
+                if response.status_code != 200:
+                    raise ProviderError(f"Google Books API returned status {response.status_code}")
+                
+                data = response.json()
+                items = data.get("items", [])
+                
+                results = []
+                for item in items:
+                    try:
+                        results.append(self._map_volume_to_metadata(item))
+                    except Exception as parse_err:
+                        logger.warning("Error parsing Google Book volume: %s", parse_err)
+                return results
+
+        except httpx.RequestError as e:
+            logger.error("HTTP error searching Google Books: %s", e)
+            raise ProviderError(f"Network error querying Google Books API: {e}")
+        except Exception as e:
+            logger.error("Error searching Google Books: %s", e)
+            raise ProviderError(f"Google Books search failed: {e}")
+
+    async def get_book(self, book_id: str) -> Optional[BookMetadata]:
+        """Fetches detailed volume metadata by volume ID."""
+        # Strips prefix e.g., google:abcde -> abcde
+        actual_id = book_id.split(":", 1)[-1]
+        url = f"{self.base_url}/{actual_id}"
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout_seconds) as client:
+                response = await client.get(url)
+                if response.status_code == 404:
+                    return None
+                if response.status_code != 200:
+                    raise ProviderError(f"Google Books API returned status {response.status_code}")
+                
+                return self._map_volume_to_metadata(response.json())
+        except httpx.RequestError as e:
+            raise ProviderError(f"Network error getting Google Book: {e}")
+        except Exception as e:
+            raise ProviderError(f"Google Books retrieval failed: {e}")
+
+    async def download(self, book: BookMetadata, dest_path: str) -> None:
+        """Downloads the Google Book. Delegates to central downloader."""
+        if not book.download_availability or not book.download_url:
+            raise DownloadError("No legal download URL available for this Google Book.")
+        
+        # Import dynamically to avoid circular dependencies
+        from bookcli.downloader import download_file
+        await download_file(book.download_url, dest_path, self.timeout_seconds)