Update version to 7.6.8 and enhance missing book processing in Readarr by improving logging, switching from author-based to book-based processing, and adding checks for API configuration and stop signals.

Admin9705 · Admin9705 · commit de156e87067d · 2025-06-08T16:09:36.000-04:00
diff --git a/src/primary/apps/readarr/missing.py b/src/primary/apps/readarr/missing.py
@@ -55,16 +55,32 @@ def process_missing_books(
     
     monitored_only = app_settings.get("monitored_only", True)
     skip_future_releases = app_settings.get("skip_future_releases", True)
-    # skip_author_refresh setting removed as it was a performance bottleneck
     hunt_missing_books = app_settings.get("hunt_missing_books", 0)
     
     # Use advanced settings from general.json for command operations
     command_wait_delay = get_advanced_setting("command_wait_delay", 1)
     command_wait_attempts = get_advanced_setting("command_wait_attempts", 600)
 
+    readarr_logger.info(f"Hunt Missing Books: {hunt_missing_books}")
+    readarr_logger.info(f"Monitored Only: {monitored_only}")
+    readarr_logger.info(f"Skip Future Releases: {skip_future_releases}")
+
+    if not api_url or not api_key:
+        readarr_logger.error("API URL or Key not configured in settings. Cannot process missing books.")
+        return False
+
+    # Skip if hunt_missing_books is set to 0
+    if hunt_missing_books <= 0:
+        readarr_logger.info("'hunt_missing_books' setting is 0 or less. Skipping missing book processing.")
+        return False
+
+    # Check for stop signal
+    if stop_check():
+        readarr_logger.info("Stop requested before starting missing books. Aborting...")
+        return False
+
     # Get missing books
     readarr_logger.info("Retrieving wanted/missing books...")
-    readarr_logger.info("Retrieving wanted/missing books...")
 
     # Call the correct function to get missing books
     missing_books_data = readarr_api.get_wanted_missing_books(api_url, api_key, api_timeout, monitored_only)
@@ -75,114 +91,113 @@ def process_missing_books(
         
     readarr_logger.info(f"Found {len(missing_books_data)} missing books.")
 
-    # Group by author ID (optional)
-    books_by_author = {}
+    if not missing_books_data:
+        readarr_logger.info("No missing books found.")
+        return False
+
+    # Check for stop signal after retrieving books
+    if stop_check():
+        readarr_logger.info("Stop requested after retrieving missing books. Aborting...")
+        return False
+
+    # Filter out already processed books using stateful management (now book-based instead of author-based)
+    unprocessed_books = []
     for book in missing_books_data:
-        author_id = book.get("authorId")
-        if author_id:
-            if author_id not in books_by_author:
-                books_by_author[author_id] = []
-            books_by_author[author_id].append(book)
-
-    author_ids = list(books_by_author.keys())
-
-    # Filter out already processed authors using stateful management
-    unprocessed_authors = []
-    for author_id in author_ids:
-        if not is_processed("readarr", instance_name, str(author_id)):
-            unprocessed_authors.append(author_id)
+        book_id = str(book.get("id"))
+        if not is_processed("readarr", instance_name, book_id):
+            unprocessed_books.append(book)
         else:
-            readarr_logger.debug(f"Skipping already processed author ID: {author_id}")
+            readarr_logger.debug(f"Skipping already processed book ID: {book_id}")
 
-    readarr_logger.info(f"Found {len(unprocessed_authors)} unprocessed authors out of {len(author_ids)} total authors with missing books.")
+    readarr_logger.info(f"Found {len(unprocessed_books)} unprocessed missing books out of {len(missing_books_data)} total.")
     
-    if not unprocessed_authors:
-        readarr_logger.info(f"No unprocessed authors found for {instance_name}. All available authors have been processed.")
+    if not unprocessed_books:
+        readarr_logger.info("No unprocessed missing books found. All available books have been processed.")
         return False
 
-    # Always randomly select authors/books to process
-    readarr_logger.info(f"Randomly selecting up to {hunt_missing_books} authors with missing books.")
-    authors_to_process = random.sample(unprocessed_authors, min(hunt_missing_books, len(unprocessed_authors)))
+    # Select individual books to process (fixed: was selecting authors, now selects books)
+    readarr_logger.info(f"Randomly selecting up to {hunt_missing_books} individual books to search.")
+    books_to_process = random.sample(unprocessed_books, min(hunt_missing_books, len(unprocessed_books)))
+
+    readarr_logger.info(f"Selected {len(books_to_process)} individual books to search for missing items.")
+    
+    # Add detailed logging for selected books
+    if books_to_process:
+        readarr_logger.info(f"Books selected for processing in this cycle:")
+        for idx, book in enumerate(books_to_process):
+            book_id = book.get("id")
+            book_title = book.get("title", "Unknown Title")
+            author_id = book.get("authorId", "Unknown")
+            readarr_logger.info(f"  {idx+1}. '{book_title}' (ID: {book_id}, Author ID: {author_id})")
 
-    readarr_logger.info(f"Selected {len(authors_to_process)} authors to search for missing books.")
     processed_count = 0
-    processed_something = False
-    processed_authors = [] # Track author names processed
+    processed_books = [] # Track book titles processed
 
-    for author_id in authors_to_process:
+    # Process each individual book
+    for book in books_to_process:
         if stop_check():
             readarr_logger.info("Stop signal received, aborting Readarr missing cycle.")
             break
 
-        author_info = readarr_api.get_author_details(api_url, api_key, author_id, api_timeout) # Assuming this exists
-        author_name = author_info.get("authorName", f"Author ID {author_id}") if author_info else f"Author ID {author_id}"
-
-        readarr_logger.info(f"Processing missing books for author: \"{author_name}\" (Author ID: {author_id})")
+        book_id = book.get("id")
+        book_title = book.get("title", f"Unknown Book ID {book_id}")
+        author_id = book.get("authorId")
+        
+        # Get author name for logging
+        author_info = readarr_api.get_author_details(api_url, api_key, author_id, api_timeout) if author_id else None
+        author_name = author_info.get("authorName", f"Author ID {author_id}") if author_info else "Unknown Author"
 
-        # Refresh functionality has been removed as it was identified as a performance bottleneck
+        readarr_logger.info(f"Processing missing book: '{book_title}' by {author_name} (Book ID: {book_id})")
 
-        # Search for missing books associated with the author
-        readarr_logger.info(f"  - Searching for missing books...")
-        book_ids_for_author = [book['id'] for book in books_by_author[author_id]] # 'id' is bookId
-        
-        # Create detailed log with book titles
-        book_details = []
-        for book in books_by_author[author_id]:
-            book_title = book.get('title', f"Book ID {book['id']}")
-            book_details.append(f"'{book_title}' (ID: {book['id']})")
-        
-        # Construct detailed log message
-        details_string = ', '.join(book_details)
-        log_message = f"Triggering Book Search for {len(book_details)} books by author '{author_name}': [{details_string}]"
-        readarr_logger.debug(log_message) # Changed level from INFO to DEBUG
+        # Search for this individual book (fixed: was searching all books by author)
+        readarr_logger.info(f"  - Searching for individual book: '{book_title}'...")
         
-        # Mark author as processed BEFORE triggering any searches
-        add_processed_id("readarr", instance_name, str(author_id))
-        readarr_logger.debug(f"Added author ID {author_id} to processed list for {instance_name}")
+        # Mark book as processed BEFORE triggering search to prevent duplicates
+        add_processed_id("readarr", instance_name, str(book_id))
+        readarr_logger.debug(f"Added book ID {book_id} to processed list for {instance_name}")
         
-        # Now trigger the search
-        search_command_result = readarr_api.search_books(api_url, api_key, book_ids_for_author, api_timeout)
+        # Search for the specific book (using book search instead of author search)
+        search_command_result = readarr_api.search_books(api_url, api_key, [book_id], api_timeout)
 
         if search_command_result:
             # Extract command ID if the result is a dictionary, otherwise use the result directly
             command_id = search_command_result.get('id') if isinstance(search_command_result, dict) else search_command_result
-            readarr_logger.info(f"Triggered book search command {command_id} for author {author_name}. Assuming success for now.") # Log only command ID
+            readarr_logger.info(f"Triggered book search command {command_id} for '{book_title}' by {author_name}.")
             increment_stat("readarr", "hunted")
             
-            # Tag the author if enabled
-            if tag_processed_items:
+            # Tag the book's author if enabled (keep author tagging as it's still useful)
+            if tag_processed_items and author_id:
                 try:
                     readarr_api.tag_processed_author(api_url, api_key, api_timeout, author_id)
                     readarr_logger.debug(f"Tagged author {author_id} as processed")
                 except Exception as e:
                     readarr_logger.warning(f"Failed to tag author {author_id}: {e}")
             
-            # Log multiple history entries - one for each book with author info
-            for book in books_by_author[author_id]:
-                book_title = book.get('title', f"Unknown Book ID {book['id']}")
-                # Format includes both author and book info
-                media_name = f"{author_name} - {book_title}"
-                # Log each book as a separate history entry with book_id
-                log_processed_media("readarr", media_name, book['id'], instance_name, "missing")
-                readarr_logger.debug(f"Logged missing book history entry: {media_name} (ID: {book['id']})")
+            # Log history entry for this specific book
+            media_name = f"{author_name} - {book_title}"
+            log_processed_media("readarr", media_name, book_id, instance_name, "missing")
+            readarr_logger.debug(f"Logged missing book history entry: {media_name} (ID: {book_id})")
             
-            readarr_logger.debug(f"Logged history entries for {len(books_by_author[author_id])} books by author: {author_name}")
-            
-            processed_count += 1 # Count processed authors/groups
-            processed_authors.append(author_name) # Add to list of processed authors
-            processed_something = True
-            readarr_logger.info(f"Processed {processed_count}/{len(authors_to_process)} authors/groups for missing books this cycle.")
+            processed_count += 1
+            processed_books.append(f"'{book_title}' by {author_name}")
+            processed_any = True
+            readarr_logger.info(f"Processed {processed_count}/{len(books_to_process)} books for missing search this cycle.")
         else:
-            readarr_logger.error(f"Failed to trigger search for author {author_name}.")
+            readarr_logger.error(f"Failed to trigger search for book '{book_title}' by {author_name}.")
 
         if processed_count >= hunt_missing_books:
-            readarr_logger.info(f"Reached target of {hunt_missing_books} authors/groups processed for this cycle.")
+            readarr_logger.info(f"Reached target of {hunt_missing_books} books processed for this cycle.")
             break
 
-    if processed_authors:
-        authors_list = '", "'.join(processed_authors)
-        readarr_logger.info(f'Completed processing {processed_count} authors/groups for missing books this cycle: "{authors_list}"')
+    if processed_books:
+        # Log first few books, then summarize if there are many
+        if len(processed_books) <= 3:
+            books_list = ', '.join(processed_books)
+            readarr_logger.info(f'Completed processing {processed_count} books for missing search this cycle: {books_list}')
+        else:
+            first_books = ', '.join(processed_books[:3])
+            readarr_logger.info(f'Completed processing {processed_count} books for missing search this cycle: {first_books} and {len(processed_books)-3} others')
     else:
-        readarr_logger.info(f"Completed processing {processed_count} authors/groups for missing books this cycle.")
+        readarr_logger.info(f"Completed processing {processed_count} books for missing search this cycle.")
 
-    return processed_something
+    return processed_any
diff --git a/version.txt b/version.txt
@@ -1 +1 @@
-7.6.7
+7.6.8
