qBitrr2 5.7.0__py3-none-any.whl → 5.8.0__py3-none-any.whl

qBitrr/arss.py

@@ -365,7 +365,7 @@ class Arr:
             f"{name}.EntrySearch.Overseerr.ApprovedOnly", fallback=True
         )
         self.search_requests_every_x_seconds = CONFIG.get(
-            f"{name}.EntrySearch.SearchRequestsEvery", fallback=1800
+            f"{name}.EntrySearch.SearchRequestsEvery", fallback=300
         )
         self._temp_overseer_request_cache: dict[str, set[int | str]] = defaultdict(set)
         if self.ombi_search_requests or self.overseerr_requests:
@@ -465,10 +465,32 @@ class Arr:
                 self.keep_temp_profile,
             )
             self.temp_quality_profile_ids = self.parse_quality_profiles()
+            # Create reverse mapping (temp_id → main_id) for O(1) lookups
+            self.main_quality_profile_ids = {
+                v: k for k, v in self.temp_quality_profile_ids.items()
+            }
+            self.profile_switch_retry_attempts = CONFIG.get(
+                f"{name}.EntrySearch.ProfileSwitchRetryAttempts", fallback=3
+            )
+            self.temp_profile_timeout_minutes = CONFIG.get(
+                f"{name}.EntrySearch.TempProfileResetTimeoutMinutes", fallback=0
+            )
             self.logger.info(
                 "Parsed quality profile mappings: %s",
                 {f"{k}→{v}": f"(main→temp)" for k, v in self.temp_quality_profile_ids.items()},
             )
+            if self.temp_profile_timeout_minutes > 0:
+                self.logger.info(
+                    f"Temp profile timeout enabled: {self.temp_profile_timeout_minutes} minutes"
+                )
+
+            # Check if we should reset all temp profiles on startup
+            force_reset = CONFIG.get(f"{name}.EntrySearch.ForceResetTempProfiles", fallback=False)
+            if force_reset:
+                self.logger.info(
+                    "ForceResetTempProfiles enabled - resetting all temp profiles on startup"
+                )
+                self._reset_all_temp_profiles()
 
         # Cache for valid quality profile IDs to avoid repeated API calls and warnings
         self._quality_profile_cache: dict[int, dict] = {}
@@ -1042,7 +1064,16 @@ class Arr:
                 if not results:
                     break
                 for entry in results:
+                    # NOTE: 'type' field is not documented in official Overseerr API spec
+                    # but exists in practice. May break if Overseerr changes API.
                     type__ = entry.get("type")
+                    if not type__:
+                        self.logger.debug(
+                            "Overseerr request missing 'type' field (entry ID: %s). "
+                            "This may indicate an API change.",
+                            entry.get("id", "unknown"),
+                        )
+                        continue
                     if type__ == "movie":
                         id__ = entry.get("media", {}).get("tmdbId")
                     elif type__ == "tv":
@@ -1052,6 +1083,8 @@ class Arr:
                     if not id__ or type_ != type__:
                         continue
                     media = entry.get("media") or {}
+                    # NOTE: 'status4k' field is not documented in official Overseerr API spec
+                    # but exists for 4K request tracking. Falls back to 'status' for non-4K.
                     status_key = "status4k" if entry.get("is4k") else "status"
                     status_value = _normalize_media_status(media.get(status_key))
                     if entry.get("is4k"):
@@ -1074,7 +1107,7 @@ class Arr:
                         try:
                             if type_ == "movie":
                                 _entry = self.session.get(
-                                    url=f"{self.overseerr_uri}/api/v1/movies/{id__}",
+                                    url=f"{self.overseerr_uri}/api/v1/movie/{id__}",
                                     headers={"X-Api-Key": self.overseerr_api_key},
                                     timeout=5,
                                 )
@@ -2918,6 +2951,10 @@ class Arr:
                             # Only apply temp profiles for truly missing content (no file)
                             # Do NOT apply for quality/custom format unmet or upgrade searches
                             has_file = episode.get("hasFile", False)
+                            profile_switch_timestamp = None
+                            original_profile_for_db = None
+                            current_profile_for_db = None
+
                             self.logger.trace(
                                 "Temp quality profile check for '%s': searched=%s, has_file=%s, current_profile_id=%s, keep_temp=%s",
                                 db_entry.get("title", "Unknown"),
@@ -2928,22 +2965,31 @@ class Arr:
                             )
                             if (
                                 searched
-                                and quality_profile_id in self.temp_quality_profile_ids.values()
+                                and quality_profile_id in self.main_quality_profile_ids.keys()
                                 and not self.keep_temp_profile
                             ):
-                                new_profile_id = list(self.temp_quality_profile_ids.keys())[
-                                    list(self.temp_quality_profile_ids.values()).index(
-                                        quality_profile_id
-                                    )
-                                ]
-                                data: JsonObject = {"qualityProfileId": new_profile_id}
-                                self.logger.info(
-                                    "Upgrading quality profile for '%s': %s (ID:%s) → main profile (ID:%s) [Episode searched, reverting to main]",
-                                    db_entry.get("title", "Unknown"),
-                                    quality_profile_id,
-                                    quality_profile_id,
-                                    new_profile_id,
+                                new_profile_id = self.main_quality_profile_ids.get(
+                                    quality_profile_id
                                 )
+                                if new_profile_id is None:
+                                    self.logger.warning(
+                                        f"Profile ID {quality_profile_id} not found in current temp→main mappings. "
+                                        "Config may have changed. Skipping profile upgrade."
+                                    )
+                                else:
+                                    data: JsonObject = {"qualityProfileId": new_profile_id}
+                                    self.logger.info(
+                                        "Upgrading quality profile for '%s': temp profile (ID:%s) → main profile (ID:%s) [Episode searched, reverting to main]",
+                                        db_entry.get("title", "Unknown"),
+                                        quality_profile_id,
+                                        new_profile_id,
+                                    )
+                                # Reverting to main - clear tracking fields
+                                from datetime import datetime
+
+                                profile_switch_timestamp = datetime.now()
+                                original_profile_for_db = None
+                                current_profile_for_db = None
                             elif (
                                 not searched
                                 and not has_file
@@ -2957,6 +3003,12 @@ class Arr:
                                     quality_profile_id,
                                     new_profile_id,
                                 )
+                                # Downgrading to temp - track original and switch time
+                                from datetime import datetime
+
+                                profile_switch_timestamp = datetime.now()
+                                original_profile_for_db = quality_profile_id
+                                current_profile_for_db = new_profile_id
                             else:
                                 self.logger.trace(
                                     "No quality profile change for '%s': searched=%s, profile_id=%s (in_temps=%s, in_mains=%s)",
@@ -2967,18 +3019,34 @@ class Arr:
                                     quality_profile_id in self.temp_quality_profile_ids.keys(),
                                 )
                             if data:
-                                while True:
+                                profile_update_success = False
+                                for attempt in range(self.profile_switch_retry_attempts):
                                     try:
                                         self.client.upd_episode(episode["id"], data)
+                                        profile_update_success = True
                                         break
                                     except (
                                         requests.exceptions.ChunkedEncodingError,
                                         requests.exceptions.ContentDecodingError,
                                         requests.exceptions.ConnectionError,
                                         JSONDecodeError,
-                                    ):
+                                    ) as e:
+                                        if attempt == self.profile_switch_retry_attempts - 1:
+                                            self.logger.error(
+                                                "Failed to update episode profile after %d attempts: %s",
+                                                self.profile_switch_retry_attempts,
+                                                e,
+                                            )
+                                            break
+                                        time.sleep(1)
                                         continue
 
+                                # If profile update failed, don't track the change
+                                if not profile_update_success:
+                                    profile_switch_timestamp = None
+                                    original_profile_for_db = None
+                                    current_profile_for_db = None
+
                         EntryId = episode.get("id")
                         SeriesTitle = episode.get("series", {}).get("title")
                         SeasonNumber = episode.get("seasonNumber")
@@ -3036,6 +3104,14 @@ class Arr:
                             self.model_file.Reason: reason,
                         }
 
+                        # Add profile tracking fields if temp profile feature is enabled
+                        if self.use_temp_for_missing and profile_switch_timestamp is not None:
+                            to_update[self.model_file.LastProfileSwitchTime] = (
+                                profile_switch_timestamp
+                            )
+                            to_update[self.model_file.OriginalProfileId] = original_profile_for_db
+                            to_update[self.model_file.CurrentProfileId] = current_profile_for_db
+
                         self.logger.debug(
                             "Updating database entry | %s | S%02dE%03d [Searched:%s][Upgrade:%s][QualityMet:%s][CustomFormatMet:%s]",
                             SeriesTitle.ljust(60, "."),
@@ -3152,46 +3228,42 @@ class Arr:
                             searched = totalEpisodeCount == episodeFileCount
                         else:
                             searched = (episodeCount + monitoredEpisodeCount) == episodeFileCount
+                        # Sonarr series-level temp profile logic
+                        # NOTE: Sonarr only supports quality profiles at the series level (not episode level).
+                        # Individual episodes inherit the series profile. This is intentional and correct.
+                        # If ANY episodes are missing, the entire series uses temp profile to maximize
+                        # the chance of finding missing content (priority #1).
                         if self.use_temp_for_missing:
                             try:
                                 quality_profile_id = db_entry.get("qualityProfileId")
                                 if (
                                     searched
-                                    and quality_profile_id
-                                    in self.temp_quality_profile_ids.values()
+                                    and quality_profile_id in self.main_quality_profile_ids.keys()
                                     and not self.keep_temp_profile
                                 ):
-                                    db_entry["qualityProfileId"] = list(
-                                        self.temp_quality_profile_ids.keys()
-                                    )[
-                                        list(self.temp_quality_profile_ids.values()).index(
-                                            quality_profile_id
-                                        )
-                                    ]
+                                    new_main_id = self.main_quality_profile_ids[quality_profile_id]
+                                    db_entry["qualityProfileId"] = new_main_id
                                     self.logger.debug(
                                         "Updating quality profile for %s to %s",
                                         db_entry["title"],
-                                        db_entry["qualityProfileId"],
+                                        new_main_id,
                                     )
                                 elif (
                                     not searched
                                     and quality_profile_id in self.temp_quality_profile_ids.keys()
                                 ):
-                                    db_entry["qualityProfileId"] = self.temp_quality_profile_ids[
-                                        quality_profile_id
-                                    ]
+                                    new_temp_id = self.temp_quality_profile_ids[quality_profile_id]
+                                    db_entry["qualityProfileId"] = new_temp_id
                                     self.logger.debug(
                                         "Updating quality profile for %s to %s",
                                         db_entry["title"],
-                                        self.temp_quality_profile_ids[
-                                            db_entry["qualityProfileId"]
-                                        ],
+                                        new_temp_id,
                                     )
                             except KeyError:
                                 self.logger.warning(
                                     "Check quality profile settings for %s", db_entry["title"]
                                 )
-                            while True:
+                            for attempt in range(self.profile_switch_retry_attempts):
                                 try:
                                     self.client.upd_series(db_entry)
                                     break
@@ -3200,7 +3272,15 @@ class Arr:
                                     requests.exceptions.ContentDecodingError,
                                     requests.exceptions.ConnectionError,
                                     JSONDecodeError,
-                                ):
+                                ) as e:
+                                    if attempt == self.profile_switch_retry_attempts - 1:
+                                        self.logger.error(
+                                            "Failed to update series profile after %d attempts: %s",
+                                            self.profile_switch_retry_attempts,
+                                            e,
+                                        )
+                                        break
+                                    time.sleep(1)
                                     continue
 
                         Title = seriesMetadata.get("title")
@@ -3324,6 +3404,10 @@ class Arr:
                             self.model_queue.EntryId == db_entry["id"]
                         ).execute()
 
+                    profile_switch_timestamp = None
+                    original_profile_for_db = None
+                    current_profile_for_db = None
+
                     if self.use_temp_for_missing:
                         quality_profile_id = db_entry.get("qualityProfileId")
                         # Only apply temp profiles for truly missing content (no file)
@@ -3331,46 +3415,69 @@ class Arr:
                         has_file = db_entry.get("hasFile", False)
                         if (
                             searched
-                            and quality_profile_id in self.temp_quality_profile_ids.values()
+                            and quality_profile_id in self.main_quality_profile_ids.keys()
                             and not self.keep_temp_profile
                         ):
-                            db_entry["qualityProfileId"] = list(
-                                self.temp_quality_profile_ids.keys()
-                            )[
-                                list(self.temp_quality_profile_ids.values()).index(
-                                    quality_profile_id
-                                )
-                            ]
+                            new_main_id = self.main_quality_profile_ids[quality_profile_id]
+                            db_entry["qualityProfileId"] = new_main_id
                             self.logger.debug(
                                 "Updating quality profile for %s to %s",
                                 db_entry["title"],
-                                db_entry["qualityProfileId"],
+                                new_main_id,
                             )
+                            # Reverting to main - clear tracking fields
+                            from datetime import datetime
+
+                            profile_switch_timestamp = datetime.now()
+                            original_profile_for_db = None
+                            current_profile_for_db = None
                         elif (
                             not searched
                             and not has_file
                             and quality_profile_id in self.temp_quality_profile_ids.keys()
                         ):
-                            db_entry["qualityProfileId"] = self.temp_quality_profile_ids[
-                                quality_profile_id
-                            ]
+                            new_temp_id = self.temp_quality_profile_ids[quality_profile_id]
+                            db_entry["qualityProfileId"] = new_temp_id
                             self.logger.debug(
                                 "Updating quality profile for %s to %s",
                                 db_entry["title"],
-                                db_entry["qualityProfileId"],
+                                new_temp_id,
                             )
-                        while True:
+                            # Downgrading to temp - track original and switch time
+                            from datetime import datetime
+
+                            profile_switch_timestamp = datetime.now()
+                            original_profile_for_db = quality_profile_id
+                            current_profile_for_db = new_temp_id
+
+                        profile_update_success = False
+                        for attempt in range(self.profile_switch_retry_attempts):
                             try:
                                 self.client.upd_movie(db_entry)
+                                profile_update_success = True
                                 break
                             except (
                                 requests.exceptions.ChunkedEncodingError,
                                 requests.exceptions.ContentDecodingError,
                                 requests.exceptions.ConnectionError,
                                 JSONDecodeError,
-                            ):
+                            ) as e:
+                                if attempt == self.profile_switch_retry_attempts - 1:
+                                    self.logger.error(
+                                        "Failed to update movie profile after %d attempts: %s",
+                                        self.profile_switch_retry_attempts,
+                                        e,
+                                    )
+                                    break
+                                time.sleep(1)
                                 continue
 
+                        # If profile update failed, don't track the change
+                        if not profile_update_success:
+                            profile_switch_timestamp = None
+                            original_profile_for_db = None
+                            current_profile_for_db = None
+
                     title = db_entry["title"]
                     monitored = db_entry["monitored"]
                     tmdbId = db_entry["tmdbId"]
@@ -3423,6 +3530,12 @@ class Arr:
                         self.model_file.QualityProfileName: qualityProfileName,
                     }
 
+                    # Add profile tracking fields if temp profile feature is enabled
+                    if self.use_temp_for_missing and profile_switch_timestamp is not None:
+                        to_update[self.model_file.LastProfileSwitchTime] = profile_switch_timestamp
+                        to_update[self.model_file.OriginalProfileId] = original_profile_for_db
+                        to_update[self.model_file.CurrentProfileId] = current_profile_for_db
+
                     if request:
                         to_update[self.model_file.IsRequest] = request
 
@@ -3870,18 +3983,17 @@ class Arr:
 
                         # Temp profile management for Lidarr artists
                         # Quality profiles in Lidarr are set at artist level, not album level
+                        # NOTE: Lidarr uses sizeOnDisk instead of hasFile because the Lidarr API
+                        # doesn't provide a hasFile boolean at artist level. sizeOnDisk > 0 is
+                        # equivalent to hasFile=True for Lidarr.
                         if self.use_temp_for_missing and quality_profile_id:
                             if (
                                 searched
-                                and quality_profile_id in self.temp_quality_profile_ids.values()
+                                and quality_profile_id in self.main_quality_profile_ids.keys()
                                 and not self.keep_temp_profile
                             ):
                                 # Artist has files, switch from temp back to main profile
-                                main_profile_id = list(self.temp_quality_profile_ids.keys())[
-                                    list(self.temp_quality_profile_ids.values()).index(
-                                        quality_profile_id
-                                    )
-                                ]
+                                main_profile_id = self.main_quality_profile_ids[quality_profile_id]
                                 artistMetadata["qualityProfileId"] = main_profile_id
                                 self.client.upd_artist(artistMetadata)
                                 quality_profile_id = main_profile_id
@@ -4662,42 +4774,70 @@ class Arr:
                 current_time = time.time()
 
                 # Track consecutive database errors for exponential backoff
+                # Initialize tracking on first error ever
+                if not hasattr(self, "_db_first_error_time"):
+                    self._db_first_error_time = current_time
+
+                # Reset if >5min since last error (new error sequence)
                 if (
                     current_time - self._db_last_error_time > 300
                 ):  # Reset if >5min since last error
                     self._db_error_count = 0
+                    self._db_first_error_time = current_time
+
                 self._db_error_count += 1
                 self._db_last_error_time = current_time
 
+                # Check if errors have persisted for more than 5 minutes
+                time_since_first_error = current_time - self._db_first_error_time
+                if time_since_first_error > 300:  # 5 minutes
+                    self.logger.critical(
+                        "Database errors have persisted for %.1f minutes. "
+                        "Signaling coordinated restart of ALL processes for database recovery...",
+                        time_since_first_error / 60,
+                    )
+                    # Signal all processes to restart (shared database affects everyone)
+                    self.manager.qbit_manager.database_restart_event.set()
+                    # Exit this process - main will restart all
+                    sys.exit(1)
+
                 # Calculate exponential backoff: 2min, 5min, 10min, 20min, 30min (max)
                 delay_seconds = min(120 * (2 ** (self._db_error_count - 1)), 1800)
 
                 # Log detailed error information based on error type
+                # Use escalating severity: WARNING (1-2 errors), ERROR (3-4), CRITICAL (5+)
+                if self._db_error_count <= 2:
+                    log_func = self.logger.warning
+                elif self._db_error_count <= 4:
+                    log_func = self.logger.error
+                else:
+                    log_func = self.logger.critical
+
                 if "disk i/o error" in error_msg:
-                    self.logger.critical(
-                        "Persistent database I/O error detected (consecutive error #%d). "
-                        "This indicates disk issues, filesystem corruption, or resource exhaustion. "
+                    log_func(
+                        "Database I/O error detected (consecutive error #%d). "
+                        "This may indicate disk issues, filesystem corruption, or resource exhaustion. "
                         "Attempting automatic recovery and retrying in %d seconds...",
                         self._db_error_count,
                         delay_seconds,
                     )
                 elif "database is locked" in error_msg:
-                    self.logger.error(
+                    log_func(
                         "Database locked error (consecutive error #%d). "
                         "Retrying in %d seconds...",
                         self._db_error_count,
                         delay_seconds,
                     )
                 elif "disk image is malformed" in error_msg:
-                    self.logger.critical(
+                    log_func(
                         "Database corruption detected (consecutive error #%d). "
                         "Attempting automatic recovery and retrying in %d seconds...",
                         self._db_error_count,
                         delay_seconds,
                     )
                 else:
-                    self.logger.error(
-                        "Database error (consecutive error #%d): %s. " "Retrying in %d seconds...",
+                    log_func(
+                        "Database error (consecutive error #%d): %s. Retrying in %d seconds...",
                         self._db_error_count,
                         error_msg,
                         delay_seconds,
@@ -6068,27 +6208,30 @@ class Arr:
     def torrent_limit_check(
         self, torrent: qbittorrentapi.TorrentDictionary, seeding_time_limit, ratio_limit
     ) -> bool:
-        if (
+        # -1 = Never remove (regardless of ratio/time limits)
+        if self.seeding_mode_global_remove_torrent == -1:
+            return False
+        # 4 = AND (remove when BOTH ratio AND time limits met)
+        elif (
             self.seeding_mode_global_remove_torrent == 4
             and torrent.ratio >= ratio_limit
             and torrent.seeding_time >= seeding_time_limit
         ):
             return True
-        if self.seeding_mode_global_remove_torrent == 3 and (
+        # 3 = OR (remove when EITHER ratio OR time limit met)
+        elif self.seeding_mode_global_remove_torrent == 3 and (
             torrent.ratio >= ratio_limit or torrent.seeding_time >= seeding_time_limit
         ):
             return True
+        # 2 = Time only (remove when seeding time limit met)
         elif (
             self.seeding_mode_global_remove_torrent == 2
             and torrent.seeding_time >= seeding_time_limit
         ):
             return True
+        # 1 = Ratio only (remove when upload ratio limit met)
         elif self.seeding_mode_global_remove_torrent == 1 and torrent.ratio >= ratio_limit:
             return True
-        elif self.seeding_mode_global_remove_torrent == -1 and (
-            torrent.ratio >= ratio_limit and torrent.seeding_time >= seeding_time_limit
-        ):
-            return True
         else:
             return False
 
@@ -6213,6 +6356,15 @@ class Arr:
             self.files_to_explicitly_delete = iter(_path_filter.copy())
 
     def parse_quality_profiles(self) -> dict[int, int]:
+        """
+        Parse quality profile name mappings into ID mappings.
+
+        Converts the configured profile name mappings (e.g., {"HD-1080p": "SD"})
+        into ID mappings (e.g., {2: 1}) for faster lookups during profile switching.
+
+        Returns:
+            dict[int, int]: Mapping of main_profile_id → temp_profile_id
+        """
         temp_quality_profile_ids: dict[int, int] = {}
 
         self.logger.debug(
@@ -6297,160 +6449,209 @@ class Arr:
 
         return temp_quality_profile_ids
 
-    def register_search_mode(self):
-        if self.search_setup_completed:
-            return
+    def _reset_all_temp_profiles(self):
+        """Reset all items using temp profiles back to their original main profiles on startup."""
+        reset_count = 0
 
-        db1, db2, db3, db4, db5 = self._get_models()
+        try:
+            # Get all items from Arr instance
+            if self._name.lower().startswith("radarr"):
+                items = self.client.get_movie()
+                item_type = "movie"
+            elif self._name.lower().startswith("sonarr") or self._name.lower().startswith(
+                "animarr"
+            ):
+                items = self.client.get_series()
+                item_type = "series"
+            elif self._name.lower().startswith("lidarr"):
+                items = self.client.get_artist()
+                item_type = "artist"
+            else:
+                self.logger.warning(f"Unknown Arr type for temp profile reset: {self._name}")
+                return
 
-        if not (
-            self.search_missing
-            or self.do_upgrade_search
-            or self.quality_unmet_search
-            or self.custom_format_unmet_search
-            or self.ombi_search_requests
-            or self.overseerr_requests
-        ):
-            if db5 and getattr(self, "torrents", None) is None:
-                self.torrent_db = SqliteDatabase(None)
-                self.torrent_db.init(
-                    str(self._app_data_folder.joinpath("Torrents.db")),
-                    pragmas={
-                        "journal_mode": "wal",
-                        "cache_size": -64_000,
-                        "foreign_keys": 1,
-                        "ignore_check_constraints": 0,
-                        "synchronous": 0,
-                        "read_uncommitted": 1,
-                    },
-                    timeout=15,
-                )
+            self.logger.info(f"Checking {len(items)} {item_type}s for temp profile resets...")
+
+            for item in items:
+                profile_id = item.get("qualityProfileId")
 
-                class Torrents(db5):
-                    class Meta:
-                        database = self.torrent_db
+                # Check if item is currently using a temp profile
+                if profile_id in self.main_quality_profile_ids.keys():
+                    # This is a temp profile - get the original main profile
+                    original_id = self.main_quality_profile_ids[profile_id]
+                    item["qualityProfileId"] = original_id
 
-                # Connect with retry logic for transient I/O errors
-                with_database_retry(
-                    lambda: self.torrent_db.connect(),
-                    logger=self.logger,
+                    # Update via API with retry logic
+                    for attempt in range(self.profile_switch_retry_attempts):
+                        try:
+                            if item_type == "movie":
+                                self.client.upd_movie(item)
+                            elif item_type == "series":
+                                self.client.upd_series(item)
+                            elif item_type == "artist":
+                                self.client.upd_artist(item)
+
+                            reset_count += 1
+                            self.logger.info(
+                                f"Reset {item_type} '{item.get('title', item.get('artistName', 'Unknown'))}' "
+                                f"from temp profile (ID:{profile_id}) to main profile (ID:{original_id})"
+                            )
+                            break
+                        except (
+                            requests.exceptions.ChunkedEncodingError,
+                            requests.exceptions.ContentDecodingError,
+                            requests.exceptions.ConnectionError,
+                            JSONDecodeError,
+                        ) as e:
+                            if attempt == self.profile_switch_retry_attempts - 1:
+                                self.logger.error(
+                                    f"Failed to reset {item_type} profile after {self.profile_switch_retry_attempts} attempts: {e}"
+                                )
+                            else:
+                                time.sleep(1)
+                                continue
+
+            if reset_count > 0:
+                self.logger.info(
+                    f"ForceResetTempProfiles: Reset {reset_count} {item_type}s from temp to main profiles"
+                )
+            else:
+                self.logger.info(
+                    f"ForceResetTempProfiles: No {item_type}s found using temp profiles"
                 )
-                self.torrent_db.create_tables([Torrents])
-                self.torrents = Torrents
-            self.search_setup_completed = True
-            return
 
-        self.search_db_file.parent.mkdir(parents=True, exist_ok=True)
-        self.db = SqliteDatabase(None)
-        self.db.init(
-            str(self.search_db_file),
-            pragmas={
-                "journal_mode": "wal",
-                "cache_size": -64_000,
-                "foreign_keys": 1,
-                "ignore_check_constraints": 0,
-                "synchronous": 0,
-                "read_uncommitted": 1,
-            },
-            timeout=15,
-        )
+        except Exception as e:
+            self.logger.error(f"Error during temp profile reset: {e}", exc_info=True)
 
-        class Files(db1):
-            class Meta:
-                database = self.db
+    def _check_temp_profile_timeouts(self):
+        """Check for items with temp profiles that have exceeded the timeout and reset them."""
+        if self.temp_profile_timeout_minutes == 0:
+            return  # Feature disabled
 
-        class Queue(db2):
-            class Meta:
-                database = self.db
+        from datetime import timedelta
 
-        class PersistingQueue(FilesQueued):
-            class Meta:
-                database = self.db
+        timeout_threshold = datetime.now() - timedelta(minutes=self.temp_profile_timeout_minutes)
+        reset_count = 0
 
-        # Connect with retry logic for transient I/O errors
-        with_database_retry(
-            lambda: self.db.connect(),
-            logger=self.logger,
-        )
+        try:
+            # Query database for items with expired temp profiles
+            db1, db2, db3, db4, db5 = self._get_models()
+
+            # Determine which model to use
+            if self._name.lower().startswith("radarr"):
+                model = self.movies_file_model
+                item_type = "movie"
+            elif self._name.lower().startswith("sonarr") or self._name.lower().startswith(
+                "animarr"
+            ):
+                model = self.model_file  # episodes
+                item_type = "episode"
+            elif self._name.lower().startswith("lidarr"):
+                model = self.artists_file_model
+                item_type = "artist"
+            else:
+                return
 
-        if db4:
+            # Find items with temp profiles that have exceeded timeout
+            expired_items = model.select().where(
+                (model.LastProfileSwitchTime.is_null(False))
+                & (model.LastProfileSwitchTime < timeout_threshold)
+                & (model.CurrentProfileId.is_null(False))
+                & (model.OriginalProfileId.is_null(False))
+            )
 
-            class Tracks(db4):
-                class Meta:
-                    database = self.db
+            for db_item in expired_items:
+                entry_id = db_item.EntryId
+                current_profile = db_item.CurrentProfileId
+                original_profile = db_item.OriginalProfileId
+
+                # Verify current profile is still a temp profile in our mappings
+                if current_profile not in self.main_quality_profile_ids.keys():
+                    # Not a temp profile anymore, clear tracking
+                    model.update(
+                        LastProfileSwitchTime=None, CurrentProfileId=None, OriginalProfileId=None
+                    ).where(model.EntryId == entry_id).execute()
+                    continue
 
-            self.track_file_model = Tracks
-        else:
-            self.track_file_model = None
+                # Reset to original profile via Arr API
+                try:
+                    if item_type == "movie":
+                        item = self.client.get_movie(entry_id)
+                        item["qualityProfileId"] = original_profile
+                        self.client.upd_movie(item)
+                    elif item_type == "episode":
+                        # For episodes, we need to update the series
+                        series_id = db_item.SeriesId
+                        series = self.client.get_series(series_id)
+                        series["qualityProfileId"] = original_profile
+                        self.client.upd_series(series)
+                    elif item_type == "artist":
+                        artist = self.client.get_artist(entry_id)
+                        artist["qualityProfileId"] = original_profile
+                        self.client.upd_artist(artist)
+
+                    # Clear tracking fields in database
+                    model.update(
+                        LastProfileSwitchTime=None, CurrentProfileId=None, OriginalProfileId=None
+                    ).where(model.EntryId == entry_id).execute()
+
+                    reset_count += 1
+                    self.logger.info(
+                        f"Timeout reset: {item_type} ID {entry_id} from temp profile (ID:{current_profile}) "
+                        f"to main profile (ID:{original_profile}) after {self.temp_profile_timeout_minutes} minutes"
+                    )
 
-        if db3 and self.type == "sonarr":
+                except Exception as e:
+                    self.logger.error(
+                        f"Failed to reset {item_type} ID {entry_id} after timeout: {e}"
+                    )
 
-            class Series(db3):
-                class Meta:
-                    database = self.db
+            if reset_count > 0:
+                self.logger.info(
+                    f"TempProfileTimeout: Reset {reset_count} {item_type}s from temp to main profiles"
+                )
 
-            try:
-                self.db.create_tables([Files, Queue, PersistingQueue, Series], safe=True)
-            except Exception as e:
-                self.logger.error("Failed to create database tables for Sonarr: %s", e)
-                raise
-            self.series_file_model = Series
-            self.artists_file_model = None
-        elif db3 and self.type == "lidarr":
+        except Exception as e:
+            self.logger.error(f"Error checking temp profile timeouts: {e}", exc_info=True)
 
-            class Artists(db3):
-                class Meta:
-                    database = self.db
+    def register_search_mode(self):
+        """Initialize database models using the single shared database."""
+        if self.search_setup_completed:
+            return
 
-            try:
-                self.db.create_tables([Files, Queue, PersistingQueue, Artists, Tracks], safe=True)
-            except Exception as e:
-                self.logger.error("Failed to create database tables for Lidarr: %s", e)
-                raise
-            self.artists_file_model = Artists
-            self.series_file_model = None  # Lidarr uses artists, not series
-        else:
-            # Radarr or any type without db3/db4 (series/artists/tracks models)
-            try:
-                self.db.create_tables([Files, Queue, PersistingQueue], safe=True)
-            except Exception as e:
-                self.logger.error("Failed to create database tables for Radarr: %s", e)
-                raise
-            self.artists_file_model = None
-            self.series_file_model = None
+        # Import the shared database
+        from qBitrr.database import get_database
 
-        if db5:
-            self.torrent_db = SqliteDatabase(None)
-            self.torrent_db.init(
-                str(self._app_data_folder.joinpath("Torrents.db")),
-                pragmas={
-                    "journal_mode": "wal",
-                    "cache_size": -64_000,
-                    "foreign_keys": 1,
-                    "ignore_check_constraints": 0,
-                    "synchronous": 0,
-                    "read_uncommitted": 1,
-                },
-                timeout=15,
-            )
+        self.db = get_database()
 
-            class Torrents(db5):
-                class Meta:
-                    database = self.torrent_db
+        # Get the appropriate model classes for this Arr type
+        file_model, queue_model, series_or_artist_model, track_model, torrent_model = (
+            self._get_models()
+        )
 
-            # Connect with retry logic for transient I/O errors
-            with_database_retry(
-                lambda: self.torrent_db.connect(),
-                logger=self.logger,
-            )
-            self.torrent_db.create_tables([Torrents])
-            self.torrents = Torrents
-        else:
-            self.torrents = None
+        # Set model references for this instance
+        self.model_file = file_model
+        self.model_queue = queue_model
+        self.persistent_queue = FilesQueued
 
-        self.model_file = Files
-        self.model_queue = Queue
-        self.persistent_queue = PersistingQueue
+        # Set type-specific models
+        if self.type == "sonarr":
+            self.series_file_model = series_or_artist_model
+            self.artists_file_model = None
+            self.track_file_model = None
+        elif self.type == "lidarr":
+            self.series_file_model = None
+            self.artists_file_model = series_or_artist_model
+            self.track_file_model = track_model
+        else:  # radarr
+            self.series_file_model = None
+            self.artists_file_model = None
+            self.track_file_model = None
+
+        # Set torrents model if TAGLESS is enabled
+        self.torrents = torrent_model if TAGLESS else None
+
+        self.logger.debug("Database initialization completed for %s", self._name)
         self.search_setup_completed = True
 
     def _get_models(
@@ -6650,6 +6851,18 @@ class Arr:
 
     def run_search_loop(self) -> NoReturn:
         run_logs(self.logger)
+        self.logger.info(
+            "Search loop starting for %s (SearchMissing=%s, DoUpgradeSearch=%s, "
+            "QualityUnmetSearch=%s, CustomFormatUnmetSearch=%s, "
+            "Overseerr=%s, Ombi=%s)",
+            self._name,
+            self.search_missing,
+            self.do_upgrade_search,
+            self.quality_unmet_search,
+            self.custom_format_unmet_search,
+            self.overseerr_requests,
+            self.ombi_search_requests,
+        )
         try:
             if not (
                 self.search_missing
@@ -6666,6 +6879,7 @@ class Arr:
             totcommands = -1
             self.db_update_processed = False
             event = self.manager.qbit_manager.shutdown_event
+            self.logger.info("Search loop initialized successfully, entering main loop")
             while not event.is_set():
                 if self.loop_completed:
                     years_index = 0
@@ -6684,7 +6898,13 @@ class Arr:
                     self.db_maybe_reset_entry_searched_state()
                     self.refresh_download_queue()
                     self.db_update()
-                    # self.run_request_search()
+
+                    # Check for expired temp profiles if feature is enabled
+                    if self.use_temp_for_missing and self.temp_profile_timeout_minutes > 0:
+                        self._check_temp_profile_timeouts()
+
+                    # Check for new Overseerr/Ombi requests and trigger searches
+                    self.run_request_search()
                     try:
                         if self.search_by_year:
                             if years.index(self.search_current_year) != years_count - 1:
@@ -6807,6 +7027,16 @@ class Arr:
         except KeyboardInterrupt:
             self.logger.hnotice("Detected Ctrl+C - Terminating process")
             sys.exit(0)
+        except Exception as e:
+            self.logger.critical(
+                "Search loop crashed unexpectedly for %s: %s",
+                self._name,
+                e,
+                exc_info=True,
+            )
+            raise
+        finally:
+            self.logger.warning("Search loop terminated for %s", self._name)
 
     def run_torrent_loop(self) -> NoReturn:
         run_logs(self.logger)