qBitrr2 5.5.2__py3-none-any.whl → 5.5.3__py3-none-any.whl

qBitrr/arss.py

@@ -620,16 +620,32 @@ class Arr:
                 self.search_api_command = "MissingEpisodeSearch"
 
         if not QBIT_DISABLED and not TAGLESS:
-            self.manager.qbit_manager.client.torrents_create_tags(
-                [
-                    "qBitrr-allowed_seeding",
-                    "qBitrr-ignored",
-                    "qBitrr-imported",
-                    "qBitrr-allowed_stalled",
-                ]
-            )
+            try:
+                self.manager.qbit_manager.client.torrents_create_tags(
+                    [
+                        "qBitrr-allowed_seeding",
+                        "qBitrr-ignored",
+                        "qBitrr-imported",
+                        "qBitrr-allowed_stalled",
+                    ]
+                )
+            except qbittorrentapi.exceptions.APIConnectionError as e:
+                self.logger.warning(
+                    "Could not connect to qBittorrent during initialization for %s: %s. "
+                    "Will retry when process starts.",
+                    self._name,
+                    str(e).split("\n")[0],  # Only log first line of error
+                )
         elif not QBIT_DISABLED and TAGLESS:
-            self.manager.qbit_manager.client.torrents_create_tags(["qBitrr-ignored"])
+            try:
+                self.manager.qbit_manager.client.torrents_create_tags(["qBitrr-ignored"])
+            except qbittorrentapi.exceptions.APIConnectionError as e:
+                self.logger.warning(
+                    "Could not connect to qBittorrent during initialization for %s: %s. "
+                    "Will retry when process starts.",
+                    self._name,
+                    str(e).split("\n")[0],  # Only log first line of error
+                )
         self.search_setup_completed = False
         self.model_file: Model | None = None
         self.series_file_model: Model | None = None
@@ -1257,6 +1273,7 @@ class Arr:
                 object_ids = list(object_id)
                 self.logger.trace("Requeue cache entry list: %s", object_ids)
                 if self.series_search:
+                    series_id = None
                     while True:
                         try:
                             data = self.client.get_series(object_ids[0])
@@ -1283,27 +1300,35 @@ class Arr:
                         ):
                             continue
                         except PyarrResourceNotFound as e:
-                            self.logger.debug(e)
-                            self.logger.error("PyarrResourceNotFound: %s", object_ids[0])
+                            self.logger.warning(
+                                "Series %s not found in Sonarr (likely removed): %s",
+                                object_ids[0],
+                                str(e),
+                            )
+                            break
                     for object_id in object_ids:
                         if object_id in self.queue_file_ids:
                             self.queue_file_ids.remove(object_id)
-                    self.logger.trace("Research series id: %s", series_id)
-                    while True:
-                        try:
-                            self.client.post_command(self.search_api_command, seriesId=series_id)
-                            break
-                        except (
-                            requests.exceptions.ChunkedEncodingError,
-                            requests.exceptions.ContentDecodingError,
-                            requests.exceptions.ConnectionError,
-                            JSONDecodeError,
-                        ):
-                            continue
-                    if self.persistent_queue and series_id:
-                        self.persistent_queue.insert(EntryId=series_id).on_conflict_ignore()
+                    if series_id:
+                        self.logger.trace("Research series id: %s", series_id)
+                        while True:
+                            try:
+                                self.client.post_command(
+                                    self.search_api_command, seriesId=series_id
+                                )
+                                break
+                            except (
+                                requests.exceptions.ChunkedEncodingError,
+                                requests.exceptions.ContentDecodingError,
+                                requests.exceptions.ConnectionError,
+                                JSONDecodeError,
+                            ):
+                                continue
+                        if self.persistent_queue:
+                            self.persistent_queue.insert(EntryId=series_id).on_conflict_ignore()
                 else:
                     for object_id in object_ids:
+                        episode_found = False
                         while True:
                             try:
                                 data = self.client.get_episode(object_id)
@@ -1333,6 +1358,7 @@ class Arr:
                                     )
                                 else:
                                     self.logger.notice("Re-Searching episode: %s", object_id)
+                                episode_found = True
                                 break
                             except (
                                 requests.exceptions.ChunkedEncodingError,
@@ -1342,24 +1368,37 @@ class Arr:
                                 AttributeError,
                             ):
                                 continue
+                            except PyarrResourceNotFound as e:
+                                self.logger.warning(
+                                    "Episode %s not found in Sonarr (likely removed): %s",
+                                    object_id,
+                                    str(e),
+                                )
+                                break
 
                         if object_id in self.queue_file_ids:
                             self.queue_file_ids.remove(object_id)
-                        while True:
-                            try:
-                                self.client.post_command("EpisodeSearch", episodeIds=[object_id])
-                                break
-                            except (
-                                requests.exceptions.ChunkedEncodingError,
-                                requests.exceptions.ContentDecodingError,
-                                requests.exceptions.ConnectionError,
-                                JSONDecodeError,
-                            ):
-                                continue
-                        if self.persistent_queue:
-                            self.persistent_queue.insert(EntryId=object_id).on_conflict_ignore()
+                        if episode_found:
+                            while True:
+                                try:
+                                    self.client.post_command(
+                                        "EpisodeSearch", episodeIds=[object_id]
+                                    )
+                                    break
+                                except (
+                                    requests.exceptions.ChunkedEncodingError,
+                                    requests.exceptions.ContentDecodingError,
+                                    requests.exceptions.ConnectionError,
+                                    JSONDecodeError,
+                                ):
+                                    continue
+                            if self.persistent_queue:
+                                self.persistent_queue.insert(
+                                    EntryId=object_id
+                                ).on_conflict_ignore()
             elif self.type == "radarr":
                 self.logger.trace("Requeue cache entry: %s", object_id)
+                movie_found = False
                 while True:
                     try:
                         data = self.client.get_movie(object_id)
@@ -1376,6 +1415,7 @@ class Arr:
                             )
                         else:
                             self.logger.notice("Re-Searching movie: %s", object_id)
+                        movie_found = True
                         break
                     except (
                         requests.exceptions.ChunkedEncodingError,
@@ -1385,23 +1425,30 @@ class Arr:
                         AttributeError,
                     ):
                         continue
+                    except PyarrResourceNotFound as e:
+                        self.logger.warning(
+                            "Movie %s not found in Radarr (likely removed): %s", object_id, str(e)
+                        )
+                        break
                 if object_id in self.queue_file_ids:
                     self.queue_file_ids.remove(object_id)
-                while True:
-                    try:
-                        self.client.post_command("MoviesSearch", movieIds=[object_id])
-                        break
-                    except (
-                        requests.exceptions.ChunkedEncodingError,
-                        requests.exceptions.ContentDecodingError,
-                        requests.exceptions.ConnectionError,
-                        JSONDecodeError,
-                    ):
-                        continue
-                if self.persistent_queue:
-                    self.persistent_queue.insert(EntryId=object_id).on_conflict_ignore()
+                if movie_found:
+                    while True:
+                        try:
+                            self.client.post_command("MoviesSearch", movieIds=[object_id])
+                            break
+                        except (
+                            requests.exceptions.ChunkedEncodingError,
+                            requests.exceptions.ContentDecodingError,
+                            requests.exceptions.ConnectionError,
+                            JSONDecodeError,
+                        ):
+                            continue
+                    if self.persistent_queue:
+                        self.persistent_queue.insert(EntryId=object_id).on_conflict_ignore()
             elif self.type == "lidarr":
                 self.logger.trace("Requeue cache entry: %s", object_id)
+                album_found = False
                 while True:
                     try:
                         data = self.client.get_album(object_id)
@@ -1418,6 +1465,7 @@ class Arr:
                             )
                         else:
                             self.logger.notice("Re-Searching album: %s", object_id)
+                        album_found = True
                         break
                     except (
                         requests.exceptions.ChunkedEncodingError,
@@ -1427,21 +1475,27 @@ class Arr:
                         AttributeError,
                     ):
                         continue
+                    except PyarrResourceNotFound as e:
+                        self.logger.warning(
+                            "Album %s not found in Lidarr (likely removed): %s", object_id, str(e)
+                        )
+                        break
                 if object_id in self.queue_file_ids:
                     self.queue_file_ids.remove(object_id)
-                while True:
-                    try:
-                        self.client.post_command("AlbumSearch", albumIds=[object_id])
-                        break
-                    except (
-                        requests.exceptions.ChunkedEncodingError,
-                        requests.exceptions.ContentDecodingError,
-                        requests.exceptions.ConnectionError,
-                        JSONDecodeError,
-                    ):
-                        continue
-                if self.persistent_queue:
-                    self.persistent_queue.insert(EntryId=object_id).on_conflict_ignore()
+                if album_found:
+                    while True:
+                        try:
+                            self.client.post_command("AlbumSearch", albumIds=[object_id])
+                            break
+                        except (
+                            requests.exceptions.ChunkedEncodingError,
+                            requests.exceptions.ContentDecodingError,
+                            requests.exceptions.ConnectionError,
+                            JSONDecodeError,
+                        ):
+                            continue
+                    if self.persistent_queue:
+                        self.persistent_queue.insert(EntryId=object_id).on_conflict_ignore()
 
     def _process_errored(self) -> None:
         # Recheck all torrents marked for rechecking.
@@ -2673,6 +2727,35 @@ class Arr:
                             JSONDecodeError,
                         ):
                             continue
+
+                    # Validate episode object has required fields
+                    if not episode or not isinstance(episode, dict):
+                        self.logger.warning(
+                            "Invalid episode object returned from API for episode ID %s: %s",
+                            db_entry.get("id"),
+                            type(episode).__name__,
+                        )
+                        return
+
+                    required_fields = [
+                        "id",
+                        "seriesId",
+                        "seasonNumber",
+                        "episodeNumber",
+                        "title",
+                        "airDateUtc",
+                        "episodeFileId",
+                    ]
+                    missing_fields = [field for field in required_fields if field not in episode]
+                    if missing_fields:
+                        self.logger.warning(
+                            "Episode %s missing required fields %s. Episode data: %s",
+                            db_entry.get("id"),
+                            missing_fields,
+                            episode,
+                        )
+                        return
+
                     if episode.get("monitored", True) or self.search_unmonitored:
                         while True:
                             try:
@@ -2820,24 +2903,24 @@ class Arr:
                                     ):
                                         continue
 
-                        EntryId = episode["id"]
+                        EntryId = episode.get("id")
                         SeriesTitle = episode.get("series", {}).get("title")
-                        SeasonNumber = episode["seasonNumber"]
-                        Title = episode["title"]
-                        SeriesId = episode["seriesId"]
-                        EpisodeFileId = episode["episodeFileId"]
-                        EpisodeNumber = episode["episodeNumber"]
+                        SeasonNumber = episode.get("seasonNumber")
+                        Title = episode.get("title")
+                        SeriesId = episode.get("seriesId")
+                        EpisodeFileId = episode.get("episodeFileId")
+                        EpisodeNumber = episode.get("episodeNumber")
                         AbsoluteEpisodeNumber = (
-                            episode["absoluteEpisodeNumber"]
+                            episode.get("absoluteEpisodeNumber")
                             if "absoluteEpisodeNumber" in episode
                             else None
                         )
                         SceneAbsoluteEpisodeNumber = (
-                            episode["sceneAbsoluteEpisodeNumber"]
+                            episode.get("sceneAbsoluteEpisodeNumber")
                             if "sceneAbsoluteEpisodeNumber" in episode
                             else None
                         )
-                        AirDateUtc = episode["airDateUtc"]
+                        AirDateUtc = episode.get("airDateUtc")
                         Monitored = episode.get("monitored", True)
                         QualityMet = not QualityUnmet if db_entry["hasFile"] else False
                         customFormatMet = customFormat >= minCustomFormat
@@ -3110,9 +3193,13 @@ class Arr:
                         try:
                             if movieData:
                                 if not movieData.MinCustomFormatScore:
-                                    minCustomFormat = self.client.get_quality_profile(
-                                        db_entry["qualityProfileId"]
-                                    )["minFormatScore"]
+                                    profile = (
+                                        self.client.get_quality_profile(
+                                            db_entry["qualityProfileId"]
+                                        )
+                                        or {}
+                                    )
+                                    minCustomFormat = profile.get("minFormatScore", 0)
                                 else:
                                     minCustomFormat = movieData.MinCustomFormatScore
                                 if db_entry["hasFile"]:
@@ -3125,9 +3212,11 @@ class Arr:
                                 else:
                                     customFormat = 0
                             else:
-                                minCustomFormat = self.client.get_quality_profile(
-                                    db_entry["qualityProfileId"]
-                                )["minFormatScore"]
+                                profile = (
+                                    self.client.get_quality_profile(db_entry["qualityProfileId"])
+                                    or {}
+                                )
+                                minCustomFormat = profile.get("minFormatScore", 0)
                                 if db_entry["hasFile"]:
                                     customFormat = self.client.get_movie_file(
                                         db_entry["movieFile"]["id"]
@@ -3825,8 +3914,29 @@ class Arr:
                 ):
                     continue
         except PyarrResourceNotFound as e:
-            self.logger.error("Connection Error: %s", str(e))
-            raise DelayLoopException(length=300, type=self._name)
+            # Queue item not found - this is expected when Arr has already auto-imported
+            # and removed the item, or if it was manually removed. Clean up internal tracking.
+            self.logger.warning(
+                "Queue item %s not found in Arr (likely already imported/removed): %s",
+                id_,
+                str(e),
+            )
+            # Clean up internal tracking data for this queue entry
+            if id_ in self.requeue_cache:
+                # Remove associated media IDs from queue_file_ids
+                media_ids = self.requeue_cache[id_]
+                if isinstance(media_ids, set):
+                    self.queue_file_ids.difference_update(media_ids)
+                elif media_ids in self.queue_file_ids:
+                    self.queue_file_ids.discard(media_ids)
+                # Remove from requeue_cache
+                del self.requeue_cache[id_]
+            # Remove from cache (downloadId -> queue entry ID mapping)
+            # We need to find and remove the cache entry by value (queue ID)
+            cache_keys_to_remove = [k for k, v in self.cache.items() if v == id_]
+            for key in cache_keys_to_remove:
+                del self.cache[key]
+            return None
         return res
 
     def file_is_probeable(self, file: pathlib.Path) -> bool:
@@ -5978,7 +6088,11 @@ class Arr:
                 class Meta:
                     database = self.db
 
-            self.db.create_tables([Files, Queue, PersistingQueue, Series])
+            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":
@@ -5987,12 +6101,20 @@ class Arr:
                 class Meta:
                     database = self.db
 
-            self.db.create_tables([Files, Queue, PersistingQueue, Artists, Tracks])
+            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)
-            self.db.create_tables([Files, Queue, PersistingQueue])
+            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
 

qBitrr/bundled_data.py

@@ -1,5 +1,5 @@
-version = "5.5.2"
-git_hash = "01d27209"
+version = "5.5.3"
+git_hash = "0af67a21"
 license_text = (
     "Licence can be found on:\n\nhttps://github.com/Feramance/qBitrr/blob/master/LICENSE"
 )

qBitrr/main.py

@@ -476,6 +476,18 @@ class qBitManager:
                 )
             for proc in list(self.child_processes):
                 try:
+                    # Check if process has already been started
+                    if proc.is_alive() or proc.exitcode is not None:
+                        meta = self._process_registry.get(proc, {})
+                        self.logger.warning(
+                            "Skipping start of already-started %s worker for category '%s' (alive=%s, exitcode=%s)",
+                            meta.get("role", "worker"),
+                            meta.get("category", "unknown"),
+                            proc.is_alive(),
+                            proc.exitcode,
+                        )
+                        continue
+
                     proc.start()
                     meta = self._process_registry.get(proc, {})
                     self.logger.debug(