Small pylint code cleanup

Author: ManiMatter

pyproject.toml

@@ -10,6 +10,9 @@ disable = [
     "missing-function-docstring",       # C0116
     "line-too-long",                    # C0301
     "too-few-public-methods",           # R0903
+    "too-many-instance-attributes",     # R0902
+    "too-many-arguments",               # R0913
+    "too-many-positional-arguments",    # R0917
 ]
 
 [tool.pytest.ini_options]

src/utils/common.py

@@ -83,3 +83,21 @@ def wait_and_exit(seconds=30):
     logger.info(f"Decluttarr will wait for {seconds} seconds and then exit.")
     time.sleep(seconds)
     sys.exit()
+
+
+def extract_json_from_response(response, key: str | None = None):
+    try:
+        data = response.json()
+    except ValueError as e:
+        raise ValueError("Response content is not valid JSON") from e
+
+    if key is None:
+        return data
+
+    if not isinstance(data, dict):
+        raise ValueError("Response JSON is not a dictionary, cannot extract key")
+
+    if key not in data:
+        raise ValueError(f"Key '{key}' not found in API response")
+
+    return data[key]

src/utils/queue_manager.py

@@ -1,5 +1,5 @@
 import logging
-from src.utils.common import make_request
+from src.utils.common import make_request, extract_json_from_response
 from src.utils.log_setup import logger
 
 
@@ -29,18 +29,22 @@ async def get_queue_items(self, queue_scope):
             error = f"Invalid queue_scope: {queue_scope}"
             raise ValueError(error)
         if logger.isEnabledFor(logging.DEBUG):
-            logger.debug("queue_manager.py/get_queue_items/queue (%s): %s", queue_scope, self.format_queue(queue_items))
+            logger.debug(
+                "queue_manager.py/get_queue_items/queue (%s): %s",
+                queue_scope,
+                self.format_queue(queue_items),
+            )
         return queue_items
 
     async def _get_queue(self, *, full_queue=False):
         # Step 1: Refresh the queue (now internal)
         await self._refresh_queue()
 
         # Step 2: Get the total number of records
-        record_count = await self._get_total_records(full_queue)
+        total_records_count = await self._get_total_records_count(full_queue)
 
         # Step 3: Get all records using `arr.full_queue_parameter`
-        queue = await self._get_arr_records(full_queue, record_count)
+        queue = await self._get_arr_records(full_queue, total_records_count)
 
         # Step 4: Filter the queue based on delayed items and ignored download clients
         queue = self._filter_out_ignored_statuses(queue)
@@ -63,41 +67,40 @@ async def _refresh_queue(self):
             headers={"X-Api-Key": self.arr.api_key},
         )
 
-    async def _get_total_records(self, full_queue):
+    async def _get_total_records_count(self, full_queue):
         # Get the total number of records from the queue using `arr.full_queue_parameter`
         params = {self.arr.full_queue_parameter: full_queue}
-        response = (
-            await make_request(
-                method="GET",
-                endpoint=f"{self.arr.api_url}/queue",
-                settings=self.settings,
-                params=params,
-                headers={"X-Api-Key": self.arr.api_key},
-            )
-        ).json()
-        return response["totalRecords"]
+        total_records = await self.fetch_queue_field(params, key="totalRecords")
+        return total_records
 
-    async def _get_arr_records(self, full_queue, record_count):
+    async def _get_arr_records(self, full_queue, total_records_count):
         # Get all records based on the count (with pagination) using `arr.full_queue_parameter`
-        if record_count == 0:
+        if total_records_count == 0:
             return []
 
-        params = {"page": "1", "pageSize": record_count}
+        params = {"page": "1", "pageSize": total_records_count}
         if full_queue:
             params |= {self.arr.full_queue_parameter: full_queue}
 
-        records = (
-            await make_request(
-                method="GET",
-                endpoint=f"{self.arr.api_url}/queue",
-                settings=self.settings,
-                params=params,
-                headers={"X-Api-Key": self.arr.api_key},
-            )
-        ).json()
-        return records["records"]
+        records = await self.fetch_queue_field(params, key="records")
+        return records
+
+
+    async def fetch_queue_field(self, params, key: str | None = None):
+        # Gets the response of the /queue endpoint and extracts a specific field from the json response
+        response = await make_request(
+            method="GET",
+            endpoint=f"{self.arr.api_url}/queue",
+            settings=self.settings,
+            params=params,
+            headers={"X-Api-Key": self.arr.api_key},
+        )
+        return extract_json_from_response(response, key=key)
 
-    def _filter_out_ignored_statuses(self, queue, ignored_statuses=("delay","downloadClientUnavailable")):
+
+    def _filter_out_ignored_statuses(
+        self, queue, ignored_statuses=("delay", "downloadClientUnavailable")
+    ):
         """
         All matching items are removed from the queue. However, logging of ignored items
         is limited to one per (download title, protocol, indexer) combination to reduce log noise
@@ -125,14 +128,15 @@ def _filter_out_ignored_statuses(self, queue, ignored_statuses=("delay","downloa
             if status in ignored_statuses:
                 if combination not in seen_combinations:
                     seen_combinations.add(combination)
-                    logger.debug(f"queue_manager.py/_filter_out_ignored_statuses: Ignored queue item: {title} (Status: {status}, Protocol: {protocol}, Indexer: {indexer})")
+                    logger.debug(
+                        f"queue_manager.py/_filter_out_ignored_statuses: Ignored queue item: {title} (Status: {status}, Protocol: {protocol}, Indexer: {indexer})"
+                    )
                 continue
 
             filtered_queue.append(item)
 
         return filtered_queue
 
-
     def _filter_out_ignored_download_clients(self, queue):
         # Filters out ignored download clients
         if queue is None:
@@ -185,9 +189,7 @@ def group_by_download_id(self, queue_items):
                 grouped_dict[download_id] = {
                     "queue_ids": [item_id],
                     **{
-                        key: queue_item[key]
-                        for key in retain_keys
-                        if key in queue_item
+                        key: queue_item[key] for key in retain_keys if key in queue_item
                     },
                 }
 
@@ -199,7 +201,9 @@ def filter_queue_by_status(queue, statuses: list[str]) -> list[dict]:
         return [item for item in queue if item.get("status") in statuses]
 
     @staticmethod
-    def filter_queue_by_status_and_error_message(queue, conditions: list[tuple[str, str]]) -> list[dict]:
+    def filter_queue_by_status_and_error_message(
+        queue, conditions: list[tuple[str, str]]
+    ) -> list[dict]:
         """Filter queue items that match any given (status, errorMessage) pair."""
         queue_items = []
         for item in queue:

src/utils/wanted_manager.py

@@ -1,4 +1,4 @@
-from src.utils.common import make_request
+from src.utils.common import make_request, extract_json_from_response
 
 
 class WantedManager:
@@ -12,39 +12,34 @@ async def get_wanted_items(self, missing_or_cutoff):
 
         missing_or_cutoff: Drives whether missing or cutoff items are retrieved
         """
-        record_count = await self._get_total_records(missing_or_cutoff)
-        return await self._get_arr_records(missing_or_cutoff, record_count)
+        total_records_count = await self._get_total_records_count(missing_or_cutoff)
+        return await self._get_arr_records(missing_or_cutoff, total_records_count)
 
-    async def _get_total_records(self, missing_or_cutoff):
-        # Get the total number of records from wanted
-        response = (
-            await make_request(
-                method="GET",
-                endpoint=f"{self.arr.api_url}/wanted/{missing_or_cutoff}",
-                settings=self.settings,
-                headers={"X-Api-Key": self.arr.api_key},
-            )
-        ).json()
-        return response["totalRecords"]
+    async def _get_total_records_count(self, missing_or_cutoff: str) -> int:
+        total_records = await self.fetch_wanted_field(missing_or_cutoff, key="totalRecords")
+        return total_records
 
-    async def _get_arr_records(self, missing_or_cutoff, record_count):
+    async def _get_arr_records(self, missing_or_cutoff, total_records_count):
         # Get all records based on the count (with pagination)
-        if record_count == 0:
+        if total_records_count == 0:
             return []
 
         sort_key = f"{self.arr.detail_item_key}s.lastSearchTime"
-        params = {"page": "1", "pageSize": record_count, "sortKey": sort_key}
+        params = {"page": "1", "pageSize": total_records_count, "sortKey": sort_key}
 
-        records = (
-            await make_request(
-                method="GET",
-                endpoint=f"{self.arr.api_url}/wanted/{missing_or_cutoff}",
-                settings=self.settings,
-                params=params,
-                headers={"X-Api-Key": self.arr.api_key},
-            )
-        ).json()
-        return records["records"]
+        records = await self.fetch_wanted_field(missing_or_cutoff, params=params, key="records")
+        return records
+
+    async def fetch_wanted_field(self, missing_or_cutoff: str, params: dict | None = None, key: str | None = None):
+        # Gets the response of the /queue endpoint and extracts a specific field from the json response
+        response = await make_request(
+            method="GET",
+            endpoint=f"{self.arr.api_url}/wanted/{missing_or_cutoff}",
+            settings=self.settings,
+            params=params,
+            headers={"X-Api-Key": self.arr.api_key},
+        )
+        return extract_json_from_response(response, key=key)
 
     async def search_items(self, detail_ids):
         """Search items by detail IDs."""

tests/jobs/test_remove_slow.py

@@ -5,7 +5,7 @@
 from src.jobs.remove_slow import RemoveSlow
 
 
-@pytest.mark.asynciox
+@pytest.mark.asyncio
 @pytest.mark.parametrize(
     ("item", "expected_result"),
     [