Merge branch 'main' into main

Author: crocodilestick

CONTRIBUTORS

@@ -313,7 +313,6 @@ Copyright (C) 2024-2026 Calibre-Web Automated contributors
 - zelazna (1 commits)
 - zhiyue (1 commits)
 # Fork Contributors (crocodilestick/calibre-web-automated)
-
 - crocodilestick (931 commits)
 - jmarmstrong1207 (73 commits)
 - demitrix (30 commits)

README.md

@@ -46,11 +46,14 @@ Calibre-Web Automated aims to be an all-in-one solution, combining the modern li
 
 ## _Affiliated Projects_ 👬
 
-### Calibre-Web Automated Book Downloader
+### Shelfmark: Book Downloader
 
 - An intuitive web interface for searching and requesting book downloads, designed to work seamlessly with Calibre-Web-Automated. This project streamlines the process of downloading books and preparing them for integration into your Calibre library
 
-[<img src="https://raw.githubusercontent.com/vadret/android/master/assets/get-github.png" alt="Get it on GitHub" height="80">](https://github.com/calibrain/calibre-web-automated-book-downloader)
+> [!IMPORTANT]  
+> CWA does not approve of or support piracy of copyrighted materials and is not responsible for user behaviour
+
+[<img src="https://raw.githubusercontent.com/vadret/android/master/assets/get-github.png" alt="Get it on GitHub" height="80">](https://github.com/calibrain/shelfmark)
 
 ___
 

cps/static/css/fonts/GrandHotel-Regular.ttf

@@ -15,10 +15,11 @@
 for newly added books.
 
 Usage:
-    python generate_book_checksums.py [--library-path /path/to/calibre/library] [--force]
+    python generate_book_checksums.py [--library-path /path/to/calibre/library] [--books-path /path/to/books] [--force]
 
 Options:
     --library-path  Path to Calibre library directory (defaults to /calibre-library)
+    --books-path    Path to books directory (defaults to config_calibre_split_dir setting with --library-path fallback)
     --force         Regenerate checksums even if they already exist
     --batch-size    Number of books to process before committing (default: 100)
 """
@@ -32,11 +33,12 @@
 # Import the centralized partial MD5 calculation function
 sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
 from cps.progress_syncing.checksums import calculate_koreader_partial_md5, store_checksum, CHECKSUM_VERSION
-def generate_checksums(library_path: str, force: bool = False, batch_size: int = 100):
+def generate_checksums(library_path: str, books_path: str = None, force: bool = False, batch_size: int = 100):
     """Generate checksums for all books in the library
 
     Args:
-        library_path: Path to Calibre library directory
+        library_path: Path to Calibre library directory (contains metadata.db)
+        books_path: Path to books directory (if different from library_path in split mode)
         force: If True, regenerate checksums even if they exist
         batch_size: Number of books to process before committing
     """
@@ -46,7 +48,14 @@ def generate_checksums(library_path: str, force: bool = False, batch_size: int =
         print(f"ERROR: Calibre database not found at {metadata_db}")
         sys.exit(1)
 
+    # Use books_path if provided and valid, otherwise fall back to library_path
+    base_path = books_path if (books_path and os.path.exists(books_path)) else library_path
+
     print(f"Connecting to Calibre library at: {library_path}")
+    if base_path != library_path:
+        print(f"Books path (split library mode): {base_path}")
+    else:
+        print(f"Books path: {base_path}")
     print(f"Force regenerate: {force}")
     print(f"Batch size: {batch_size}")
     print(f"Checksum version: {CHECKSUM_VERSION}")
@@ -98,7 +107,7 @@ def generate_checksums(library_path: str, force: bool = False, batch_size: int =
             processed += 1
 
             # Construct full file path
-            file_path = os.path.join(library_path, book_path, f"{format_name}.{format_ext.lower()}")
+            file_path = os.path.join(base_path, book_path, f"{format_name}.{format_ext.lower()}")
 
             if not os.path.exists(file_path):
                 print(f"[{processed}/{total}] SKIP: File not found - {title} ({format_ext})")
@@ -152,6 +161,42 @@ def generate_checksums(library_path: str, force: bool = False, batch_size: int =
         conn.close()
 
 
+def get_books_path():
+    """
+    Get the split library books path from app.db if split mode is enabled.
+    
+    Returns:
+        The books path from config_calibre_split_dir if it exists and is valid,
+        otherwise None to indicate the library path should be used.
+    """
+    try:
+        conn = sqlite3.connect("/config/app.db", timeout=30)
+        cur = conn.cursor()
+
+        # Check if split mode is enabled and get split path
+        result = cur.execute('SELECT config_calibre_split, config_calibre_split_dir FROM settings LIMIT 1;').fetchone()
+        
+        if not result:
+            return None
+            
+        split_enabled, split_path = result
+        
+        # Only return split path if split mode is enabled, path is not NULL, and path exists
+        if split_enabled and split_path and os.path.exists(split_path):
+            return split_path
+            
+        return None
+
+    except sqlite3.Error as e:
+        # Log warning but don't crash - fall back to library path
+        print(f"WARNING: Could not read split library setting from app.db: {e}")
+        print(f"WARNING: Falling back to --library-path for books location")
+        return None
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+
 def main():
     parser = argparse.ArgumentParser(
         description='Generate KOReader sync checksums for books in Calibre library',
@@ -164,6 +209,12 @@ def main():
         help='Path to Calibre library directory (default: /calibre-library)'
     )
 
+    parser.add_argument(
+        '--books-path',
+        default=get_books_path(),
+        help='Path to books directory (default: config_calibre_split_dir setting or --library-path)'
+    )
+
     parser.add_argument(
         '--force',
         action='store_true',
@@ -185,7 +236,7 @@ def main():
         sys.exit(1)
 
     try:
-        generate_checksums(args.library_path, args.force, args.batch_size)
+        generate_checksums(args.library_path, args.books_path, args.force, args.batch_size)
     except KeyboardInterrupt:
         print("\n\nInterrupted by user. Exiting...")
         sys.exit(130)

scripts/generate_book_checksums.py

@@ -316,6 +316,183 @@ def test_handles_missing_files_gracefully(self, tmp_path):
         assert result.returncode == 0
         assert "SKIP" in result.stdout or "not found" in result.stdout.lower()
 
+    def test_split_library_with_separate_paths(self, tmp_path):
+        """Test checksum generation with split library (separate metadata and books)."""
+        # Create separate directories for metadata and books
+        metadata_dir = tmp_path / "metadata"
+        books_dir = tmp_path / "books"
+        
+        metadata_dir.mkdir()
+        books_dir.mkdir()
+        
+        # Create metadata.db in metadata_dir
+        create_minimal_calibre_library(metadata_dir)
+        
+        # Add book to metadata.db
+        db_path = metadata_dir / "metadata.db"
+        conn = sqlite3.connect(db_path)
+        cur = conn.cursor()
+        
+        cur.execute("""
+            INSERT INTO books (title, sort, path, has_cover)
+            VALUES ('Split Library Book', 'Split Library Book', 'split_book', 0)
+        """)
+        book_id = cur.lastrowid
+        
+        cur.execute("""
+            INSERT INTO data (book, format, name)
+            VALUES (?, 'EPUB', 'split_book')
+        """, (book_id,))
+        
+        conn.commit()
+        conn.close()
+        
+        # Create actual book file in books_dir (NOT metadata_dir)
+        book_folder = books_dir / "split_book"
+        book_folder.mkdir()
+        (book_folder / "split_book.epub").write_bytes(b"Test EPUB content for split library testing")
+        
+        # Run script with separate books-path
+        script_path = scripts_dir / "generate_book_checksums.py"
+        result = subprocess.run(
+            [sys.executable, str(script_path),
+             "--library-path", str(metadata_dir),
+             "--books-path", str(books_dir)],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        assert result.returncode == 0
+        assert "Split Library Book" in result.stdout
+        assert "✓" in result.stdout
+        assert "split library mode" in result.stdout.lower()
+        
+        # Verify checksum was stored in metadata.db
+        conn = sqlite3.connect(db_path)
+        cur = conn.cursor()
+        checksum = cur.execute("""
+            SELECT checksum FROM book_format_checksums
+            WHERE book = ? AND format = 'EPUB'
+        """, (book_id,)).fetchone()
+        conn.close()
+        
+        assert checksum is not None
+        assert len(checksum[0]) == 32  # Valid MD5
+
+    def test_books_path_falls_back_to_library_path(self, tmp_path):
+        """Test that invalid books-path falls back to library-path."""
+        library_path = tmp_path / "library"
+        create_minimal_calibre_library(library_path)
+        add_book_to_library(library_path, "Fallback Test Book", ["EPUB"])
+        
+        # Pass nonexistent books-path
+        script_path = scripts_dir / "generate_book_checksums.py"
+        result = subprocess.run(
+            [sys.executable, str(script_path),
+             "--library-path", str(library_path),
+             "--books-path", "/nonexistent/path"],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        # Should succeed by falling back to library_path
+        assert result.returncode == 0
+        assert "Fallback Test Book" in result.stdout
+        assert "✓" in result.stdout
+
+    def test_books_path_with_none_value(self, tmp_path):
+        """Test that None books-path uses library-path."""
+        library_path = tmp_path / "library"
+        create_minimal_calibre_library(library_path)
+        add_book_to_library(library_path, "Normal Mode Book", ["EPUB"])
+        
+        # Run without --books-path argument (default behavior)
+        script_path = scripts_dir / "generate_book_checksums.py"
+        result = subprocess.run(
+            [sys.executable, str(script_path),
+             "--library-path", str(library_path)],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        # Should succeed using library_path for books
+        assert result.returncode == 0
+        assert "Normal Mode Book" in result.stdout
+        assert "✓" in result.stdout
+        # Should NOT show split library mode message
+        assert "Books path: " in result.stdout
+
+    def test_split_library_with_multiple_formats(self, tmp_path):
+        """Test split library with book having multiple formats."""
+        metadata_dir = tmp_path / "metadata"
+        books_dir = tmp_path / "books"
+        
+        metadata_dir.mkdir()
+        books_dir.mkdir()
+        
+        create_minimal_calibre_library(metadata_dir)
+        
+        # Add book with multiple formats
+        db_path = metadata_dir / "metadata.db"
+        conn = sqlite3.connect(db_path)
+        cur = conn.cursor()
+        
+        cur.execute("""
+            INSERT INTO books (title, sort, path, has_cover)
+            VALUES ('Multi Format Book', 'Multi Format Book', 'multi_format', 0)
+        """)
+        book_id = cur.lastrowid
+        
+        # Add multiple formats
+        for fmt in ['EPUB', 'MOBI', 'PDF']:
+            cur.execute("""
+                INSERT INTO data (book, format, name)
+                VALUES (?, ?, 'multi_format')
+            """, (book_id, fmt))
+        
+        conn.commit()
+        conn.close()
+        
+        # Create actual book files in books_dir
+        book_folder = books_dir / "multi_format"
+        book_folder.mkdir()
+        (book_folder / "multi_format.epub").write_bytes(b"EPUB content")
+        (book_folder / "multi_format.mobi").write_bytes(b"MOBI content")
+        (book_folder / "multi_format.pdf").write_bytes(b"PDF content")
+        
+        # Run script
+        script_path = scripts_dir / "generate_book_checksums.py"
+        result = subprocess.run(
+            [sys.executable, str(script_path),
+             "--library-path", str(metadata_dir),
+             "--books-path", str(books_dir)],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        assert result.returncode == 0
+        
+        # Verify all three formats got checksums
+        conn = sqlite3.connect(db_path)
+        cur = conn.cursor()
+        checksums = cur.execute("""
+            SELECT format, checksum FROM book_format_checksums
+            WHERE book = ?
+            ORDER BY format
+        """, (book_id,)).fetchall()
+        conn.close()
+        
+        assert len(checksums) == 3
+        assert all(len(checksum[1]) == 32 for checksum in checksums)
+        formats = [c[0] for c in checksums]
+        assert 'EPUB' in formats
+        assert 'MOBI' in formats
+        assert 'PDF' in formats
+
     def test_batch_size_parameter(self, tmp_path):
         """Test that batch-size parameter is respected."""
         library_path = tmp_path / "test_library"