Fix: Prevent automatic full library scans on every Radarr/Sonarr download

- Updated scan_plex_library to require explicit permission to scan all libraries
- Webhook handlers now only scan if media path is available or library_name is configured
- Added allow_scan_all parameter to control when full library scans are allowed
- API endpoint still allows scanning all libraries when explicitly requested
- Prevents unnecessary full library scans on every download notification

Author: devinvee

arr_queue_utils.py

@@ -31,7 +31,8 @@ def get_queue(arr_url: str, arr_api_key: str, arr_type: str = "sonarr") -> List[
         # Queue response has a 'records' field containing the actual queue items
         return queue_data.get('records', [])
     except Exception as e:
-        logger.error("Error fetching queue from %s at %s: %s", arr_type, arr_url, e)
+        logger.error("Error fetching queue from %s at %s: %s",
+                     arr_type, arr_url, e)
         return []
 
 
@@ -53,7 +54,7 @@ def get_stuck_items(arr_url: str, arr_api_key: str, arr_type: str = "sonarr") ->
     for item in queue:
         status = item.get('status', '').lower()
         status_messages = item.get('statusMessages', [])
-        
+
         # Check if status is "downloadClientUnavailable" or if statusMessages indicate it
         is_stuck = False
         if status == 'downloadclientunavailable':
@@ -103,12 +104,14 @@ def remove_from_queue(arr_url: str, arr_api_key: str, queue_id: int, arr_type: s
             'blocklist': blocklist
         }
 
-        response = requests.delete(api_url, headers=headers, params=params, timeout=10)
+        response = requests.delete(
+            api_url, headers=headers, params=params, timeout=10)
         response.raise_for_status()
 
         return {"success": True, "message": f"Removed queue item {queue_id}"}
     except Exception as e:
-        logger.error("Error removing queue item %s from %s: %s", queue_id, arr_type, e)
+        logger.error("Error removing queue item %s from %s: %s",
+                     queue_id, arr_type, e)
         return {"success": False, "message": f"Error: {str(e)}"}
 
 
@@ -133,22 +136,24 @@ def grab_release(arr_url: str, arr_api_key: str, release: Dict[str, Any], arr_ty
 
         # Use the command API to grab the release
         api_url = f"{arr_url.rstrip('/')}/api/v3/command"
-        headers = {'X-Api-Key': arr_api_key, 'Content-Type': 'application/json'}
+        headers = {'X-Api-Key': arr_api_key,
+                   'Content-Type': 'application/json'}
 
         # For Sonarr, we need episode IDs; for Radarr, we need movie ID
         if arr_type.lower() == 'sonarr':
             episode_data = release.get('episode')
             episode_ids = []
-            
+
             if isinstance(episode_data, dict):
                 # Single episode object
                 ep_id = episode_data.get('id')
                 if ep_id:
                     episode_ids = [ep_id]
             elif isinstance(episode_data, list):
                 # Array of episodes
-                episode_ids = [ep.get('id') for ep in episode_data if ep.get('id')]
-            
+                episode_ids = [ep.get('id')
+                               for ep in episode_data if ep.get('id')]
+
             if not episode_ids:
                 # Fallback: try to get series ID and trigger series search
                 series_id = release.get('series', {}).get('id')
@@ -167,10 +172,10 @@ def grab_release(arr_url: str, arr_api_key: str, release: Dict[str, Any], arr_ty
         else:  # Radarr
             movie_data = release.get('movie')
             movie_id = None
-            
+
             if isinstance(movie_data, dict):
                 movie_id = movie_data.get('id')
-            
+
             if not movie_id:
                 return {"success": False, "message": "No movie ID found in release"}
 
@@ -179,7 +184,8 @@ def grab_release(arr_url: str, arr_api_key: str, release: Dict[str, Any], arr_ty
                 'movieIds': [movie_id]
             }
 
-        response = requests.post(api_url, headers=headers, json=command_data, timeout=10)
+        response = requests.post(
+            api_url, headers=headers, json=command_data, timeout=10)
         response.raise_for_status()
 
         return {"success": True, "message": f"Triggered search for release"}
@@ -206,15 +212,15 @@ def retry_stuck_item(arr_url: str, arr_api_key: str, queue_item: Dict[str, Any],
         return {"success": False, "message": "No queue ID found in item"}
 
     # First, remove from queue (don't blocklist, don't remove from client)
-    remove_result = remove_from_queue(arr_url, arr_api_key, queue_id, arr_type, 
-                                       remove_from_client=False, blocklist=False)
-    
+    remove_result = remove_from_queue(arr_url, arr_api_key, queue_id, arr_type,
+                                      remove_from_client=False, blocklist=False)
+
     if not remove_result.get('success'):
         return remove_result
 
     # Then trigger a new search
     grab_result = grab_release(arr_url, arr_api_key, queue_item, arr_type)
-    
+
     if not grab_result.get('success'):
         return {"success": False, "message": f"Removed from queue but failed to trigger search: {grab_result.get('message')}"}
 
@@ -235,7 +241,7 @@ def monitor_and_retry_stuck_items(arr_url: str, arr_api_key: str, arr_name: str,
         Dict with summary of actions taken
     """
     stuck_items = get_stuck_items(arr_url, arr_api_key, arr_type)
-    
+
     if not stuck_items:
         return {
             "success": True,
@@ -251,7 +257,7 @@ def monitor_and_retry_stuck_items(arr_url: str, arr_api_key: str, arr_name: str,
     for item in stuck_items:
         queue_id = item.get('id')
         title = "Unknown"
-        
+
         if arr_type.lower() == 'sonarr':
             series = item.get('series', {})
             episode = item.get('episode', {})
@@ -260,17 +266,20 @@ def monitor_and_retry_stuck_items(arr_url: str, arr_api_key: str, arr_name: str,
             movie = item.get('movie', {})
             title = movie.get('title', 'Unknown')
 
-        logger.info("Found stuck item in %s: %s (Queue ID: %s)", arr_name, title, queue_id)
-        
+        logger.info("Found stuck item in %s: %s (Queue ID: %s)",
+                    arr_name, title, queue_id)
+
         retry_result = retry_stuck_item(arr_url, arr_api_key, item, arr_type)
-        
+
         if retry_result.get('success'):
             retried_count += 1
-            logger.info("Successfully retried stuck item in %s: %s", arr_name, title)
+            logger.info("Successfully retried stuck item in %s: %s",
+                        arr_name, title)
         else:
             error_msg = f"{title}: {retry_result.get('message', 'Unknown error')}"
             errors.append(error_msg)
-            logger.error("Failed to retry stuck item in %s: %s", arr_name, error_msg)
+            logger.error("Failed to retry stuck item in %s: %s",
+                         arr_name, error_msg)
 
     return {
         "success": True,
@@ -279,4 +288,3 @@ def monitor_and_retry_stuck_items(arr_url: str, arr_api_key: str, arr_name: str,
         "retried_count": retried_count,
         "errors": errors
     }
-

media_watcher_service.py

@@ -429,11 +429,22 @@ async def _process_and_send_buffered_notifications(series_id: str, bot_instance:
 
         # Trigger Plex scan if enabled
         if bot_instance.config.plex.scan_on_notification and bot_instance.config.plex.enabled:
-            logger.info(
-                "Triggering Plex library scan after Sonarr notification")
             # Use series path to find and scan only the relevant library
-            library_name = bot_instance.config.plex.library_name if bot_instance.config.plex.library_name else None
-            await scan_plex_library_async(library_name, series_path)
+            if series_path:
+                logger.info(
+                    f"Triggering Plex library scan after Sonarr notification for path: {series_path}")
+                await scan_plex_library_async(None, series_path)
+            else:
+                # If no path available, check if we should scan a specific library or skip
+                library_name = bot_instance.config.plex.library_name if bot_instance.config.plex.library_name else None
+                if library_name:
+                    logger.info(
+                        f"Triggering Plex library scan after Sonarr notification for library: {library_name}")
+                    await scan_plex_library_async(library_name, None)
+                else:
+                    logger.warning(
+                        "Skipping Plex scan: No series path found and no specific library configured. "
+                        "To avoid scanning all libraries, configure a library_name in settings or ensure Sonarr provides series paths.")
     except Exception as e:
         logger.critical(
             f"CRITICAL ERROR in _process_and_send_buffered_notifications: {e}", exc_info=True)
@@ -503,8 +514,9 @@ async def radarr_webhook_detailed():
         movie_data = payload.get('movie', {})
         movie_file_data = payload.get('movieFile', {})
         remote_movie_data = payload.get('remoteMovie', {})
-        # Extract movie path for Plex scanning
-        movie_path = movie_data.get('path')
+        # Extract movie path for Plex scanning - try multiple sources
+        # movie.path is the movie folder, movieFile.path is the actual file path
+        movie_path = movie_data.get('path') or movie_file_data.get('path')
 
         # Deduplication
         unique_key = (movie_data.get('tmdbId'), movie_file_data.get(
@@ -632,12 +644,24 @@ async def radarr_webhook_detailed():
 
         # Trigger Plex scan if enabled
         if config.plex.scan_on_notification and config.plex.enabled:
-            logger.info(
-                "Triggering Plex library scan after Radarr notification")
             # Use movie path to find and scan only the relevant library
-            library_name = config.plex.library_name if config.plex.library_name else None
-            scan_coro = scan_plex_library_async(library_name, movie_path)
-            asyncio.run_coroutine_threadsafe(scan_coro, bot_instance.loop)
+            if movie_path:
+                logger.info(
+                    f"Triggering Plex library scan after Radarr notification for path: {movie_path}")
+                scan_coro = scan_plex_library_async(None, movie_path)
+                asyncio.run_coroutine_threadsafe(scan_coro, bot_instance.loop)
+            else:
+                # If no path available, check if we should scan a specific library or skip
+                library_name = config.plex.library_name if config.plex.library_name else None
+                if library_name:
+                    logger.info(
+                        f"Triggering Plex library scan after Radarr notification for library: {library_name}")
+                    scan_coro = scan_plex_library_async(library_name, None)
+                    asyncio.run_coroutine_threadsafe(scan_coro, bot_instance.loop)
+                else:
+                    logger.warning(
+                        "Skipping Plex scan: No movie path found and no specific library configured. "
+                        "To avoid scanning all libraries, configure a library_name in settings or ensure Radarr provides movie paths.")
 
         return jsonify({"status": "success"}), 200
     except Exception as e:
@@ -1067,15 +1091,17 @@ def api_plex_scan():
             return jsonify({"success": False, "message": "Bot instance not available"}), 500
 
         # Run scan in async context
+        # Allow scanning all libraries if library_name is None (explicit API request)
+        allow_scan_all = library_name is None
         loop = bot_instance.loop
         if loop.is_running():
             future = asyncio.run_coroutine_threadsafe(
-                scan_plex_library_async(library_name),
+                scan_plex_library_async(library_name, None, allow_scan_all=allow_scan_all),
                 loop
             )
             result = future.result(timeout=10)
         else:
-            result = asyncio.run(scan_plex_library_async(library_name))
+            result = asyncio.run(scan_plex_library_async(library_name, None, allow_scan_all=allow_scan_all))
 
         if result:
             lib_text = library_name if library_name else "all libraries"

plex_utils.py

@@ -79,7 +79,7 @@ def find_plex_library_for_path(media_path: str):
         return None, None
 
 
-def scan_plex_library(library_name: Optional[str] = None, media_path: Optional[str] = None) -> bool:
+def scan_plex_library(library_name: Optional[str] = None, media_path: Optional[str] = None, allow_scan_all: bool = False) -> bool:
     """
     Scans a Plex library. If media_path is provided, performs a partial scan of just that folder.
     Otherwise, uses library_name or scans all libraries.
@@ -130,31 +130,40 @@ def scan_plex_library(library_name: Optional[str] = None, media_path: Optional[s
                 f"Successfully triggered Plex scan for library: {library_name}")
             return True
         else:
-            # Scan all libraries (fallback)
-            sections = plex.library.sections()
-            for section in sections:
-                section.update()
-            logger.info(
-                f"Successfully triggered Plex scan for all libraries ({len(sections)} sections)")
-            return True
+            # Only scan all libraries if explicitly allowed (e.g., from API endpoint)
+            if allow_scan_all:
+                sections = plex.library.sections()
+                for section in sections:
+                    section.update()
+                logger.info(
+                    f"Successfully triggered Plex scan for all libraries ({len(sections)} sections)")
+                return True
+            else:
+                # Don't scan all libraries as fallback - this is too aggressive
+                # Log a warning instead
+                logger.warning(
+                    "Skipping Plex scan: No media_path or library_name provided. "
+                    "To scan, either provide a media_path or configure a library_name.")
+                return False
     except Exception as e:
         logger.error(f"Failed to scan Plex library: {e}", exc_info=True)
         return False
 
 
-async def scan_plex_library_async(library_name: Optional[str] = None, media_path: Optional[str] = None) -> bool:
+async def scan_plex_library_async(library_name: Optional[str] = None, media_path: Optional[str] = None, allow_scan_all: bool = False) -> bool:
     """
     Async wrapper for scanning a Plex library.
     
     Args:
         library_name: Optional name of the library to scan. Ignored if media_path is provided.
         media_path: Optional path to media file/folder. If provided, finds the matching library.
+        allow_scan_all: If True, allows scanning all libraries when no path/library_name provided.
     
     Returns:
         True if scan was successful, False otherwise.
     """
     import asyncio
-    return await asyncio.to_thread(scan_plex_library, library_name, media_path)
+    return await asyncio.to_thread(scan_plex_library, library_name, media_path, allow_scan_all)
 
 
 def get_plex_activities(filter_scans_only: bool = True) -> list: