- Wait for commands to complete to avoid overloading the command queue

- Add a minimum donwload queue size to avoid overloading the download queue
- fix to only scan individual movie instead of all movies

Author: zpatten

api.py

@@ -9,7 +9,7 @@
 import datetime
 from typing import List, Dict, Any, Optional, Union
 from utils.logger import logger, debug_log
-from config import API_KEY, API_URL, API_TIMEOUT, MONITORED_ONLY, SKIP_FUTURE_RELEASES
+from config import API_KEY, API_URL, API_TIMEOUT, MONITORED_ONLY, SKIP_FUTURE_RELEASES, COMMAND_WAIT_DELAY, COMMAND_WAIT_ATTEMPTS
 
 # Create a session for reuse
 session = requests.Session()
@@ -40,6 +40,44 @@ def radarr_request(endpoint: str, method: str = "GET", data: Dict = None) -> Opt
         logger.error(f"API request error: {e}")
         return None
 
+def wait_for_command(command_id: int):
+    logger.debug(f"Waiting for command {command_id} to complete...")
+    attempts = 0
+    while True:
+        try:
+            time.sleep(COMMAND_WAIT_DELAY)
+            response = radarr_request(f"command/{command_id}")
+            logger.debug(f"Command {command_id} Status: {response['status']}")
+        except Exception as error:
+            logger.error(f"Error fetching command status on attempt {attempts + 1}: {error}")
+            return False
+
+        attempts += 1
+
+        if response['status'].lower() in ['complete', 'completed'] or attempts >= COMMAND_WAIT_ATTEMPTS:
+            break
+
+    if response['status'].lower() not in ['complete', 'completed']:
+        logger.warning(f"Command {command_id} did not complete within the allowed attempts.")
+        return False
+
+    time.sleep(0.5)
+
+    return response['status'].lower() in ['complete', 'completed']
+
+def get_download_queue_size() -> Optional[int]:
+    """
+    GET /api/v3/queue
+    Returns total number of items in the queue with the status 'downloading'.
+    """
+    response = radarr_request("queue?status=downloading")
+    total_records = response.get("totalRecords", 0)
+    if not isinstance(total_records, int):
+        total_records = 0
+    logger.debug(f"Download Queue Size: {total_records}")
+
+    return total_records
+
 def get_movies() -> List[Dict]:
     """Get all movies from Radarr (full list)"""
     result = radarr_request("movie")
@@ -117,20 +155,23 @@ def refresh_movie(movie_id: int) -> Optional[Dict]:
         "name": "RefreshMovie",
         "movieIds": [movie_id]
     }
-    return radarr_request("command", method="POST", data=data)
+    response = radarr_request("command", method="POST", data=data)
+    return wait_for_command(response['id'])
 
 def movie_search(movie_id: int) -> Optional[Dict]:
     """Search for a movie by ID"""
     data = {
         "name": "MoviesSearch",
         "movieIds": [movie_id]
     }
-    return radarr_request("command", method="POST", data=data)
+    response = radarr_request("command", method="POST", data=data)
+    return wait_for_command(response['id'])
 
 def rescan_movie(movie_id: int) -> Optional[Dict]:
     """Rescan movie files"""
     data = {
         "name": "RescanMovie",
-        "movieIds": [movie_id]
+        "movieId": movie_id
     }
-    return radarr_request("command", method="POST", data=data)
+    response = radarr_request("command", method="POST", data=data)
+    return wait_for_command(response['id'])

config.py

@@ -46,6 +46,27 @@
     STATE_RESET_INTERVAL_HOURS = 168
     print(f"Warning: Invalid STATE_RESET_INTERVAL_HOURS value, using default: {STATE_RESET_INTERVAL_HOURS}")
 
+# Delay in seconds between checking the status of a command (default 1 second)
+try:
+    COMMAND_WAIT_DELAY = int(os.environ.get("COMMAND_WAIT_DELAY", "1"))
+except ValueError:
+    COMMAND_WAIT_DELAY = 1
+    print(f"Warning: Invalid COMMAND_WAIT_DELAY value, using default: {COMMAND_WAIT_DELAY}")
+
+# Number of attempts to wait for a command to complete before giving up (default 600 attempts)
+try:
+    COMMAND_WAIT_ATTEMPTS = int(os.environ.get("COMMAND_WAIT_ATTEMPTS", "600"))
+except ValueError:
+    COMMAND_WAIT_ATTEMPTS = 600
+    print(f"Warning: Invalid COMMAND_WAIT_ATTEMPTS value, using default: {COMMAND_WAIT_ATTEMPTS}")
+
+# Minimum size of the download queue before starting a hunt (default -1)
+try:
+    MINIMUM_DOWNLOAD_QUEUE_SIZE = int(os.environ.get("MINIMUM_DOWNLOAD_QUEUE_SIZE", "-1"))
+except ValueError:
+    MINIMUM_DOWNLOAD_QUEUE_SIZE = -1
+    print(f"Warning: Invalid MINIMUM_DOWNLOAD_QUEUE_SIZE value, using default: {MINIMUM_DOWNLOAD_QUEUE_SIZE}")
+
 # Selection Settings
 RANDOM_SELECTION = os.environ.get("RANDOM_SELECTION", "true").lower() == "true"
 MONITORED_ONLY = os.environ.get("MONITORED_ONLY", "true").lower() == "true"
@@ -65,7 +86,9 @@ def log_configuration(logger):
     logger.info(f"Missing Content Configuration: HUNT_MISSING_MOVIES={HUNT_MISSING_MOVIES}")
     logger.info(f"Upgrade Configuration: HUNT_UPGRADE_MOVIES={HUNT_UPGRADE_MOVIES}")
     logger.info(f"State Reset Interval: {STATE_RESET_INTERVAL_HOURS} hours")
+    logger.info(f"Minimum Download Queue Size: {MINIMUM_DOWNLOAD_QUEUE_SIZE}")
     logger.info(f"MONITORED_ONLY={MONITORED_ONLY}, RANDOM_SELECTION={RANDOM_SELECTION}")
     logger.info(f"SKIP_FUTURE_RELEASES={SKIP_FUTURE_RELEASES}")
     logger.info(f"HUNT_MODE={HUNT_MODE}, SLEEP_DURATION={SLEEP_DURATION}s")
+    logger.info(f"COMMAND_WAIT_DELAY={COMMAND_WAIT_DELAY}, COMMAND_WAIT_ATTEMPTS={COMMAND_WAIT_ATTEMPTS}")
     logger.debug(f"API_KEY={API_KEY}")

main.py

@@ -7,10 +7,11 @@
 import time
 import sys
 from utils.logger import logger
-from config import HUNT_MODE, SLEEP_DURATION, log_configuration
+from config import HUNT_MODE, SLEEP_DURATION, MINIMUM_DOWNLOAD_QUEUE_SIZE, log_configuration
 from missing import process_missing_movies
 from upgrade import process_cutoff_upgrades
 from state import check_state_reset, calculate_reset_time
+from api import get_download_queue_size
 
 def main_loop() -> None:
     """Main processing loop for Huntarr-Radarr"""
@@ -23,15 +24,22 @@ def main_loop() -> None:
         # Track if any processing was done in this cycle
         processing_done = False
 
-        # Process movies based on HUNT_MODE
-        if HUNT_MODE in ["missing", "both"]:
-            if process_missing_movies():
-                processing_done = True
-                
-        if HUNT_MODE in ["upgrade", "both"]:
-            if process_cutoff_upgrades():
-                processing_done = True
+        # Check if we should ignore the download queue size or if we are below the minimum queue size
+        download_queue_size = get_download_queue_size()
+        if MINIMUM_DOWNLOAD_QUEUE_SIZE < 0 or (MINIMUM_DOWNLOAD_QUEUE_SIZE >= 0 and download_queue_size <= MINIMUM_DOWNLOAD_QUEUE_SIZE):
 
+            # Process movies based on HUNT_MODE
+            if HUNT_MODE in ["missing", "both"]:
+                if process_missing_movies():
+                    processing_done = True
+                    
+            if HUNT_MODE in ["upgrade", "both"]:
+                if process_cutoff_upgrades():
+                    processing_done = True
+            
+        else:
+            logger.info(f"Download queue size ({download_queue_size}) is above the minimum threshold ({MINIMUM_DOWNLOAD_QUEUE_SIZE}).  Skipped processing.")
+
         # Calculate time until the next reset
         calculate_reset_time()
 

missing.py

@@ -58,19 +58,15 @@ def process_missing_movies() -> bool:
         # Refresh
         logger.info(" - Refreshing movie...")
         refresh_res = refresh_movie(movie_id)
-        if not refresh_res or 'id' not in refresh_res:
+        if not refresh_res:
             logger.warning(f"WARNING: Refresh command failed for {title}. Skipping.")
-            time.sleep(10)
             continue
 
-        logger.info(f"Refresh command accepted (ID: {refresh_res.get('id')}). Waiting 5s...")
-        time.sleep(5)
-        
         # Search
         logger.info(f" - Searching for \"{title}\"...")
         search_res = movie_search(movie_id)
-        if search_res and 'id' in search_res:
-            logger.info(f"Search command accepted (ID: {search_res.get('id')}).")
+        if search_res:
+            logger.info(f"Search command completed successfully.")
             processing_done = True
         else:
             logger.warning("WARNING: Movie search failed.")
@@ -79,8 +75,8 @@ def process_missing_movies() -> bool:
         # Rescan
         logger.info(" - Rescanning movie folder...")
         rescan_res = rescan_movie(movie_id)
-        if rescan_res and 'id' in rescan_res:
-            logger.info(f"Rescan command accepted (ID: {rescan_res.get('id')}).")
+        if rescan_res:
+            logger.info(f"Rescan command completed successfully.")
         else:
             logger.warning("WARNING: Rescan command not available or failed.")
 

upgrade.py

@@ -57,26 +57,24 @@ def process_cutoff_upgrades() -> bool:
         # Refresh
         logger.info(" - Refreshing movie information...")
         refresh_res = refresh_movie(movie_id)
-        if not refresh_res or 'id' not in refresh_res:
+        if not refresh_res:
             logger.warning("WARNING: Refresh command failed. Skipping this movie.")
-            time.sleep(10)
             continue
 
-        logger.info(f"Refresh command accepted (ID: {refresh_res.get('id')}). Waiting 5s...")
-        time.sleep(5)
+        logger.info(f"Refresh command completed successfully.")
 
         # Search
         logger.info(" - Searching for quality upgrade...")
         search_res = movie_search(movie_id)
-        if search_res and 'id' in search_res:
-            logger.info(f"Search command accepted (ID: {search_res.get('id')}).")
+        if search_res:
+            logger.info(f"Search command completed successfully.")
             processing_done = True
 
             # Rescan
             logger.info(" - Rescanning movie folder...")
             rescan_res = rescan_movie(movie_id)
-            if rescan_res and 'id' in rescan_res:
-                logger.info(f"Rescan command accepted (ID: {rescan_res.get('id')}).")
+            if rescan_res:
+                logger.info(f"Rescan command completed successfully.")
             else:
                 logger.warning("WARNING: Rescan command not available or failed.")
 
@@ -86,7 +84,6 @@ def process_cutoff_upgrades() -> bool:
             logger.info(f"Processed {movies_processed}/{HUNT_UPGRADE_MOVIES} upgrade movies this cycle.")
         else:
             logger.warning(f"WARNING: Search command failed for movie ID {movie_id}.")
-            time.sleep(10)
 
     logger.info(f"Completed processing {movies_processed} upgrade movies for this cycle.")
     truncate_processed_list(PROCESSED_UPGRADE_FILE)