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

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/exports/base_exporter.py

@@ -0,0 +1,218 @@
+"""Base exporter class for ebk library exports."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import json
+import shutil
+import re
+from .html_utils import create_safe_filename, sanitize_for_html
+
+
+class BaseExporter(ABC):
+    """
+    Abstract base class for all ebk exporters.
+    
+    Provides common functionality for exporting library data:
+    - Loading metadata
+    - File operations (copy/symlink)
+    - Filename sanitization
+    - Directory management
+    """
+    
+    def __init__(self):
+        """Initialize the base exporter."""
+        self.library_path = None
+        self.output_path = None
+        self.entries = []
+        
+    def load_metadata(self, library_path: Path) -> List[Dict]:
+        """
+        Load metadata from the library.
+        
+        Args:
+            library_path: Path to the ebk library
+            
+        Returns:
+            List of entry dictionaries
+            
+        Raises:
+            FileNotFoundError: If metadata.json doesn't exist
+            json.JSONDecodeError: If metadata is invalid
+        """
+        self.library_path = Path(library_path)
+        metadata_path = self.library_path / "metadata.json"
+        
+        if not metadata_path.exists():
+            raise FileNotFoundError(f"Metadata file not found at {metadata_path}")
+        
+        with open(metadata_path, 'r', encoding='utf-8') as f:
+            self.entries = json.load(f)
+            
+        return self.entries
+    
+    def prepare_output_directory(self, output_path: Path, clean: bool = True):
+        """
+        Prepare the output directory.
+        
+        Args:
+            output_path: Path for output
+            clean: Whether to clean existing directory
+        """
+        self.output_path = Path(output_path)
+        
+        if clean and self.output_path.exists():
+            shutil.rmtree(self.output_path)
+            
+        self.output_path.mkdir(parents=True, exist_ok=True)
+    
+    def copy_entry_files(self, entry: Dict, source_dir: Path, dest_dir: Path):
+        """
+        Copy entry files (ebooks and covers) to destination.
+        
+        Args:
+            entry: Entry dictionary
+            source_dir: Source library directory
+            dest_dir: Destination directory
+        """
+        # Copy ebook files
+        for file_path in entry.get('file_paths', []):
+            src_file = source_dir / file_path
+            if src_file.exists():
+                dest_file = dest_dir / Path(file_path).name
+                shutil.copy2(src_file, dest_file)
+        
+        # Copy cover image
+        cover_path = entry.get('cover_path')
+        if cover_path:
+            src_cover = source_dir / cover_path
+            if src_cover.exists():
+                dest_cover = dest_dir / Path(cover_path).name
+                shutil.copy2(src_cover, dest_cover)
+    
+    def symlink_entry_files(self, entry: Dict, source_dir: Path, dest_dir: Path):
+        """
+        Create symlinks to entry files instead of copying.
+        
+        Args:
+            entry: Entry dictionary
+            source_dir: Source library directory
+            dest_dir: Destination directory
+        """
+        # Symlink ebook files
+        for file_path in entry.get('file_paths', []):
+            src_file = source_dir / file_path
+            if src_file.exists():
+                dest_file = dest_dir / Path(file_path).name
+                if not dest_file.exists():
+                    dest_file.symlink_to(src_file.absolute())
+        
+        # Symlink cover image
+        cover_path = entry.get('cover_path')
+        if cover_path:
+            src_cover = source_dir / cover_path
+            if src_cover.exists():
+                dest_cover = dest_dir / Path(cover_path).name
+                if not dest_cover.exists():
+                    dest_cover.symlink_to(src_cover.absolute())
+    
+    def sanitize_filename(self, name: str, max_length: int = 100) -> str:
+        """
+        Sanitize filename to be filesystem-safe.
+        
+        Args:
+            name: Original filename
+            max_length: Maximum length for filename
+            
+        Returns:
+            Sanitized filename
+        """
+        return create_safe_filename(name, max_length=max_length)
+    
+    def get_readable_name(self, entry: Dict) -> str:
+        """
+        Get a human-readable name for an entry.
+        
+        Args:
+            entry: Entry dictionary
+            
+        Returns:
+            Readable name combining title and author
+        """
+        title = entry.get('title', 'Unknown')
+        creators = entry.get('creators', [])
+        
+        if creators:
+            author = creators[0]
+            if len(creators) > 1:
+                author += " et al."
+            return f"{title} - {author}"
+        
+        return title
+    
+    def write_json(self, data: Any, file_path: Path):
+        """
+        Write JSON data to file with proper encoding.
+        
+        Args:
+            data: Data to serialize
+            file_path: Output file path
+        """
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    
+    def create_readme(self, output_dir: Path, stats: Dict):
+        """
+        Create a README file with export information.
+        
+        Args:
+            output_dir: Output directory
+            stats: Statistics dictionary
+        """
+        readme_path = output_dir / "README.md"
+        
+        content = f"""# EBK Library Export
+
+This directory contains an export of an EBK library.
+
+## Statistics
+- Total entries: {stats.get('total_entries', 0)}
+- Export date: {stats.get('export_date', 'Unknown')}
+- Export type: {stats.get('export_type', 'Unknown')}
+
+## Structure
+{stats.get('structure_description', 'See directory contents for structure.')}
+
+---
+Generated by EBK Library Manager
+"""
+        
+        with open(readme_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+    
+    @abstractmethod
+    def export(self, library_path: Path, output_path: Path, **options):
+        """
+        Export the library.
+        
+        This method must be implemented by subclasses.
+        
+        Args:
+            library_path: Path to source library
+            output_path: Path for output
+            **options: Additional export options
+        """
+        pass
+    
+    def validate_export(self) -> bool:
+        """
+        Validate that the export was successful.
+        
+        Returns:
+            True if validation passes
+        """
+        if not self.output_path or not self.output_path.exists():
+            return False
+            
+        # Check if at least some files were created
+        return any(self.output_path.iterdir())