ebk 0.1.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

ebk/config.py

@@ -1,35 +1,273 @@
+"""
+Configuration management for EBK.
+
+Handles loading and saving user configuration from:
+- XDG config directory: ~/.config/ebk/config.json
+- Fallback: ~/.ebk/config.json
+- Legacy: ~/.ebkrc (for backward compatibility)
+"""
+
 import configparser
+import json
 import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, asdict, field
+
+
+@dataclass
+class LLMConfig:
+    """LLM provider configuration."""
+    provider: str = "ollama"
+    model: str = "llama3.2"
+    host: str = "localhost"
+    port: int = 11434
+    api_key: Optional[str] = None
+    temperature: float = 0.7
+    max_tokens: Optional[int] = None
+
+
+@dataclass
+class ServerConfig:
+    """Web server configuration."""
+    host: str = "0.0.0.0"
+    port: int = 8000
+    auto_open_browser: bool = False
+    page_size: int = 50
+
+
+@dataclass
+class CLIConfig:
+    """CLI default options."""
+    verbose: bool = False
+    color: bool = True
+    page_size: int = 50
+
+
+@dataclass
+class LibraryConfig:
+    """Library-related settings."""
+    default_path: Optional[str] = None
+
+
+@dataclass
+class EBKConfig:
+    """Main EBK configuration."""
+    llm: LLMConfig = field(default_factory=LLMConfig)
+    server: ServerConfig = field(default_factory=ServerConfig)
+    cli: CLIConfig = field(default_factory=CLIConfig)
+    library: LibraryConfig = field(default_factory=LibraryConfig)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "llm": asdict(self.llm),
+            "server": asdict(self.server),
+            "cli": asdict(self.cli),
+            "library": asdict(self.library),
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'EBKConfig':
+        """Create from dictionary."""
+        llm_data = data.get("llm", {})
+        server_data = data.get("server", {})
+        cli_data = data.get("cli", {})
+        library_data = data.get("library", {})
+        return cls(
+            llm=LLMConfig(**llm_data),
+            server=ServerConfig(**server_data),
+            cli=CLIConfig(**cli_data),
+            library=LibraryConfig(**library_data),
+        )
+
+
+def get_config_path() -> Path:
+    """
+    Get configuration file path.
+
+    Follows XDG Base Directory specification:
+    1. $XDG_CONFIG_HOME/ebk/config.json (usually ~/.config/ebk/config.json)
+    2. Fallback: ~/.ebk/config.json
+
+    Returns:
+        Path to config file
+    """
+    # Try XDG config directory first
+    xdg_config_home = Path.home() / ".config"
+    if xdg_config_home.exists():
+        config_dir = xdg_config_home / "ebk"
+    else:
+        # Fallback to ~/.ebk
+        config_dir = Path.home() / ".ebk"
+
+    return config_dir / "config.json"
+
+
+def load_config() -> EBKConfig:
+    """
+    Load configuration from file.
+
+    Returns:
+        EBKConfig instance with loaded values or defaults
+    """
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        # Return default config
+        return EBKConfig()
+
+    try:
+        with open(config_path, 'r') as f:
+            data = json.load(f)
+        return EBKConfig.from_dict(data)
+    except (json.JSONDecodeError, OSError) as e:
+        print(f"Warning: Failed to load config from {config_path}: {e}")
+        print("Using default configuration")
+        return EBKConfig()
+
+
+def save_config(config: EBKConfig) -> None:
+    """
+    Save configuration to file.
+
+    Args:
+        config: Configuration to save
+    """
+    config_path = get_config_path()
+
+    # Create directory if it doesn't exist
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write config
+    with open(config_path, 'w') as f:
+        json.dump(config.to_dict(), f, indent=2)
+
+    print(f"Configuration saved to {config_path}")
+
+
+def ensure_config_exists() -> Path:
+    """
+    Ensure configuration file exists, creating with defaults if not.
+
+    Returns:
+        Path to config file
+    """
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        config = EBKConfig()
+        save_config(config)
+        print(f"Created default configuration at {config_path}")
+
+    return config_path
+
+
+def update_config(
+    # LLM settings
+    llm_provider: Optional[str] = None,
+    llm_model: Optional[str] = None,
+    llm_host: Optional[str] = None,
+    llm_port: Optional[int] = None,
+    llm_api_key: Optional[str] = None,
+    llm_temperature: Optional[float] = None,
+    llm_max_tokens: Optional[int] = None,
+    # Server settings
+    server_host: Optional[str] = None,
+    server_port: Optional[int] = None,
+    server_auto_open: Optional[bool] = None,
+    server_page_size: Optional[int] = None,
+    # CLI settings
+    cli_verbose: Optional[bool] = None,
+    cli_color: Optional[bool] = None,
+    cli_page_size: Optional[int] = None,
+    # Library settings
+    library_default_path: Optional[str] = None,
+) -> None:
+    """
+    Update configuration.
 
+    Only updates provided values, leaving others unchanged.
+    """
+    config = load_config()
+
+    # Update LLM config
+    if llm_provider is not None:
+        config.llm.provider = llm_provider
+    if llm_model is not None:
+        config.llm.model = llm_model
+    if llm_host is not None:
+        config.llm.host = llm_host
+    if llm_port is not None:
+        config.llm.port = llm_port
+    if llm_api_key is not None:
+        config.llm.api_key = llm_api_key
+    if llm_temperature is not None:
+        config.llm.temperature = llm_temperature
+    if llm_max_tokens is not None:
+        config.llm.max_tokens = llm_max_tokens
+
+    # Update server config
+    if server_host is not None:
+        config.server.host = server_host
+    if server_port is not None:
+        config.server.port = server_port
+    if server_auto_open is not None:
+        config.server.auto_open_browser = server_auto_open
+    if server_page_size is not None:
+        config.server.page_size = server_page_size
+
+    # Update CLI config
+    if cli_verbose is not None:
+        config.cli.verbose = cli_verbose
+    if cli_color is not None:
+        config.cli.color = cli_color
+    if cli_page_size is not None:
+        config.cli.page_size = cli_page_size
+
+    # Update library config
+    if library_default_path is not None:
+        config.library.default_path = library_default_path
+
+    save_config(config)
+
+
+# Backward compatibility
+def update_llm_config(
+    provider: Optional[str] = None,
+    model: Optional[str] = None,
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+    api_key: Optional[str] = None,
+    temperature: Optional[float] = None,
+    max_tokens: Optional[int] = None
+) -> None:
+    """Update LLM configuration (legacy function)."""
+    update_config(
+        llm_provider=provider,
+        llm_model=model,
+        llm_host=host,
+        llm_port=port,
+        llm_api_key=api_key,
+        llm_temperature=temperature,
+        llm_max_tokens=max_tokens,
+    )
+
+
+# Legacy support for ~/.ebkrc
 def load_ebkrc_config():
     """
-    Loads configuration from ~/.btkrc.
+    Loads configuration from ~/.ebkrc (legacy).
 
-    If using LLM interface, expects a section [llm] with at least 'endpoint' and 'api_key'.
-    If using cloud interface (for generating complex networks), the section [cloud] may be used to specify various parameters.
+    The configuration file can contain various sections for different features.
+    For example, [streamlit] section for dashboard configuration.
     """
     config_path = os.path.expanduser("~/.ebkrc")
     parser = configparser.ConfigParser()
 
     if not os.path.exists(config_path):
-        raise FileNotFoundError(f"Could not find config file at {config_path}")
+        # Config file is optional
+        return parser
 
     parser.read(config_path)
-
-    if "llm" not in parser:
-        raise ValueError(
-            "Config file ~/.btkrc is missing the [llm] section. "
-            "Please add it with 'endpoint' and 'api_key' keys."
-        )
-
-    endpoint = parser["llm"].get("endpoint", "")
-    api_key = parser["llm"].get("api_key", "")
-    model = parser["llm"].get("model", "gpt-3.5-turbo")
-
-    if not endpoint or not api_key or not model:
-        raise ValueError(
-            "Please make sure your [llm] section in ~/.btkrc "
-            "includes 'endpoint', 'api_key', and 'model' keys."
-        )
-    
-    return endpoint, api_key, model
+    return parser

ebk/decorators.py

@@ -0,0 +1,132 @@
+"""Decorators for ebk functionality."""
+
+import functools
+import logging
+from pathlib import Path
+from typing import Callable, Any
+import typer
+from rich.console import Console
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+def handle_library_errors(func: Callable) -> Callable:
+    """
+    Decorator to handle common library operation errors.
+    
+    Reduces code duplication by centralizing error handling for:
+    - FileNotFoundError: Library doesn't exist
+    - PermissionError: No access to files
+    - ValueError: Invalid data or arguments
+    - General exceptions: Unexpected errors
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except FileNotFoundError as e:
+            console.print(f"[bold red]Error:[/bold red] Library or file not found: {e}")
+            raise typer.Exit(code=1)
+        except PermissionError as e:
+            console.print(f"[bold red]Error:[/bold red] Permission denied: {e}")
+            console.print("[yellow]Tip: Check file permissions or run with appropriate privileges[/yellow]")
+            raise typer.Exit(code=1)
+        except ValueError as e:
+            console.print(f"[bold red]Error:[/bold red] Invalid input: {e}")
+            raise typer.Exit(code=1)
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Operation cancelled by user[/yellow]")
+            raise typer.Exit(code=130)
+        except Exception as e:
+            logger.error(f"Unexpected error in {func.__name__}: {e}", exc_info=True)
+            console.print(f"[bold red]Unexpected error:[/bold red] {e}")
+            console.print("[dim]See log file for details[/dim]")
+            raise typer.Exit(code=1)
+    
+    return wrapper
+
+
+def validate_path(path_type: str = "directory") -> Callable:
+    """
+    Decorator to validate and sanitize file paths for security.
+    
+    Args:
+        path_type: Either "directory" or "file"
+    
+    Prevents:
+        - Path traversal attacks
+        - Access to system directories
+        - Symbolic link attacks
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            # Find path arguments (usually first positional arg)
+            if args:
+                path = Path(args[0]).resolve()
+                
+                # Security checks
+                try:
+                    # Ensure path is within current directory or explicitly allowed
+                    cwd = Path.cwd()
+                    home = Path.home()
+                    
+                    # Check if path is trying to escape to system directories
+                    if path.parts[0] in ('/', '\\') and not (
+                        path.is_relative_to(cwd) or 
+                        path.is_relative_to(home)
+                    ):
+                        raise ValueError(f"Access to system path not allowed: {path}")
+                    
+                    # Check for suspicious patterns
+                    suspicious_patterns = ['../', '...', '~/', '/etc/', '/usr/', '/bin/', '/sys/']
+                    path_str = str(path)
+                    for pattern in suspicious_patterns:
+                        if pattern in path_str and not path.is_relative_to(home):
+                            raise ValueError(f"Suspicious path pattern detected: {pattern}")
+                    
+                    # Validate based on type
+                    if path_type == "directory":
+                        if path.exists() and not path.is_dir():
+                            raise ValueError(f"Path exists but is not a directory: {path}")
+                    elif path_type == "file":
+                        if path.exists() and not path.is_file():
+                            raise ValueError(f"Path exists but is not a file: {path}")
+                    
+                    # Replace the path with the resolved, safe version
+                    args = (str(path),) + args[1:]
+                    
+                except ValueError as e:
+                    console.print(f"[bold red]Security Error:[/bold red] {e}")
+                    raise typer.Exit(code=1)
+            
+            return func(*args, **kwargs)
+        
+        return wrapper
+    return decorator
+
+
+def require_confirmation(message: str = "Are you sure you want to continue?") -> Callable:
+    """
+    Decorator to require user confirmation for destructive operations.
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            # Check if --yes flag was passed (common pattern)
+            if kwargs.get('yes', False):
+                return func(*args, **kwargs)
+            
+            # Ask for confirmation
+            console.print(f"[yellow]⚠️  {message}[/yellow]")
+            response = typer.confirm("Continue?")
+            
+            if not response:
+                console.print("[red]Operation cancelled[/red]")
+                raise typer.Exit(code=0)
+            
+            return func(*args, **kwargs)
+        
+        return wrapper
+    return decorator

ebk/extract_metadata.py

@@ -2,7 +2,7 @@ import os
 import xmltodict
 from typing import Dict, Optional
 from slugify import slugify
-import PyPDF2
+import pypdf
 from ebooklib import epub
 
 def extract_metadata_from_opf(opf_file: str) -> Dict:
@@ -32,12 +32,17 @@ def extract_metadata_from_opf(opf_file: str) -> Dict:
     simplified = {
         "title": metadata.get("dc:title", metadata.get("title")),
         "creators": None,
+        "contributors": None,
         "subjects": None,
         "description": metadata.get("dc:description", metadata.get("description")),
         "language": metadata.get("dc:language", metadata.get("language")),
         "date": metadata.get("dc:date", metadata.get("date")),
         "publisher": metadata.get("dc:publisher", metadata.get("publisher")),
-        "identifiers": None
+        "identifiers": None,
+        "rights": metadata.get("dc:rights", metadata.get("rights")),
+        "source": metadata.get("dc:source", metadata.get("source")),
+        "series": None,
+        "series_index": None
     }
 
     # -- Creators
@@ -75,12 +80,64 @@ def extract_metadata_from_opf(opf_file: str) -> Dict:
         text = identifiers.get("#text", "").strip()
         simplified["identifiers"][scheme] = text
 
+    # -- Contributors (editors, translators, etc)
+    contributors_raw = metadata.get("dc:contributor", metadata.get("contributor"))
+    if contributors_raw:
+        simplified["contributors"] = []
+        if isinstance(contributors_raw, list):
+            for contrib in contributors_raw:
+                if isinstance(contrib, dict):
+                    name = contrib.get("#text", "").strip()
+                    role = contrib.get("@opf:role", "contributor")
+                    file_as = contrib.get("@opf:file-as", "")
+                    if name:
+                        simplified["contributors"].append({
+                            "name": name,
+                            "role": role,
+                            "file_as": file_as
+                        })
+                elif isinstance(contrib, str):
+                    simplified["contributors"].append({
+                        "name": contrib.strip(),
+                        "role": "contributor",
+                        "file_as": ""
+                    })
+        elif isinstance(contributors_raw, dict):
+            name = contributors_raw.get("#text", "").strip()
+            role = contributors_raw.get("@opf:role", "contributor")
+            file_as = contributors_raw.get("@opf:file-as", "")
+            if name:
+                simplified["contributors"] = [{
+                    "name": name,
+                    "role": role,
+                    "file_as": file_as
+                }]
+
+    # -- Calibre-specific metadata (series, etc)
+    # Look for meta tags with name attributes
+    meta_tags = metadata.get("meta", [])
+    if not isinstance(meta_tags, list):
+        meta_tags = [meta_tags] if meta_tags else []
+
+    for meta in meta_tags:
+        if isinstance(meta, dict):
+            meta_name = meta.get("@name", "")
+            meta_content = meta.get("@content", "")
+
+            if meta_name == "calibre:series" and meta_content:
+                simplified["series"] = meta_content
+            elif meta_name == "calibre:series_index" and meta_content:
+                try:
+                    simplified["series_index"] = float(meta_content)
+                except (ValueError, TypeError):
+                    pass
+
     return simplified
 
 
 def extract_metadata_from_pdf(pdf_path: str) -> Dict:
     """
-    Extract metadata from a PDF file using PyPDF2.
+    Extract metadata from a PDF file using pypdf.
     Returns a dictionary with the same keys as the OPF-based dict.
     """
 
@@ -94,20 +151,23 @@ def extract_metadata_from_pdf(pdf_path: str) -> Dict:
         "publisher": None,
         "identifiers": None,
         "keywords": None,
+        "creator_application": None,
     }
 
     try:
         with open(pdf_path, "rb") as f:
-            reader = PyPDF2.PdfReader(f)
+            reader = pypdf.PdfReader(f)
             info = reader.metadata or {}
 
-        # NOTE: Depending on PyPDF2 version, metadata keys can differ
+        # NOTE: Depending on pypdf version, metadata keys can differ
         # e.g. info.title vs info.get('/Title')
         pdf_title = info.get("/Title", None) or info.get("title", None)
         pdf_author = info.get("/Author", None) or info.get("author", None)
         pdf_subject = info.get("/Subject", None) or info.get("subject", None)
         pdf_keywords = info.get("/Keywords", None) or info.get("keywords", None)
-        pdf_publisher = info.get("/Producer", None) or info.get("producer", None) or info.get("/Publisher", None) or info.get("publisher", None)
+        pdf_creator = info.get("/Creator", None) or info.get("creator", None)  # Application used
+        pdf_producer = info.get("/Producer", None) or info.get("producer", None)
+        pdf_publisher = info.get("/Publisher", None) or info.get("publisher", None)
         pdf_creation_date = info.get("/CreationDate", None)
 
         if pdf_title:
@@ -130,10 +190,18 @@ def extract_metadata_from_pdf(pdf_path: str) -> Dict:
         metadata["identifiers"] = {"pdf:identifier": pdf_path}
 
         if pdf_keywords:
-            metadata["keywords"] = [kw.strip() for kw in pdf_keywords.split(",")]
+            metadata["keywords"] = [kw.strip() for kw in pdf_keywords.split(",") if kw.strip()]
+
+        # Creator is the application that created the PDF (e.g., LaTeX, Word)
+        if pdf_creator:
+            metadata["creator_application"] = pdf_creator.strip()
 
+        # Publisher: prefer explicit Publisher field, fallback to Producer
         if pdf_publisher:
             metadata["publisher"] = pdf_publisher.strip()
+        elif pdf_producer and not pdf_creator:
+            # Only use producer as publisher if there's no creator app
+            metadata["publisher"] = pdf_producer.strip()
 
         metadata["file_paths"] = [pdf_path]
 
@@ -259,6 +327,7 @@ def extract_metadata(ebook_file: str, opf_file: Optional[str] = None) -> Dict:
     if opf_file and os.path.isfile(opf_file):
         opf_metadata = extract_metadata_from_opf(opf_file)
 
+    ebook_metadata = {}
     _, ext = os.path.splitext(ebook_file.lower())
     if ext == ".pdf":
         ebook_metadata = extract_metadata_from_pdf(ebook_file)