fix: fix around 200 ruff errors

src/controllers/actions.py

@@ -1,15 +1,9 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
-import pydantic
 from fastapi import APIRouter, Request
-from program.content.overseerr import Overseerr
-from program.indexers.trakt import TraktIndexer, get_imdbid_from_tmdb
-from program.media.item import MediaItem, Show
-from requests import RequestException
+from program.media.item import MediaItem
 from utils.logger import logger
 
-from .models.overseerr import OverseerrWebhook
-
 router = APIRouter(
     prefix="/actions",
     responses={404: {"description": "Not found"}},
@@ -21,7 +15,7 @@ async def request(request: Request, imdb_id: str) -> Dict[str, Any]:
     try:
         new_item = MediaItem({"imdb_id": imdb_id, "requested_by": "manually"})
         request.app.program.add_to_queue(new_item)
-    except Exception as e:
+    except Exception:
         logger.error(f"Failed to create item from imdb_id: {imdb_id}")
         return {"success": False, "message": "Failed to create item from imdb_id"}
 

src/controllers/default.py

@@ -1,16 +1,15 @@
 import time
 
+import program.db.db_functions as DB
 import requests
 from fastapi import APIRouter, HTTPException, Request
-from program.media.item import MediaItem
 from program.content.trakt import TraktContent
+from program.db.db import db
+from program.media.item import Episode, MediaItem, Movie, Season, Show
 from program.media.state import States
 from program.scrapers import Scraping
 from program.settings.manager import settings_manager
-from program.media.item import Episode, MediaItem, Movie, Season, Show
-from program.db.db import db
-from sqlalchemy import select, func
-import program.db.db_functions as DB
+from sqlalchemy import func, select
 
 router = APIRouter(
     responses={404: {"description": "Not found"}},
@@ -102,12 +101,12 @@ async def trakt_oauth_callback(code: str, request: Request):
 
 
 @router.get("/stats")
-async def get_stats(request: Request):
+async def get_stats(_: Request):
     payload = {}
     with db.Session() as session:
 
-        movies_symlinks = session.execute(select(func.count(Movie._id)).where(Movie.symlinked == True)).scalar_one()
-        episodes_symlinks = session.execute(select(func.count(Episode._id)).where(Episode.symlinked == True)).scalar_one()
+        movies_symlinks = session.execute(select(func.count(Movie._id)).where(Movie.symlinked is True)).scalar_one()
+        episodes_symlinks = session.execute(select(func.count(Episode._id)).where(Episode.symlinked is True)).scalar_one()
         total_symlinks = movies_symlinks + episodes_symlinks
 
         total_movies = session.execute(select(func.count(Movie._id))).scalar_one()

src/controllers/items.py

@@ -1,14 +1,14 @@
 from typing import List, Optional
 
 import Levenshtein
+import program.db.db_functions as DB
 from fastapi import APIRouter, HTTPException, Request
 from program.db.db import db
-from sqlalchemy import select, func
-import program.db.db_functions as DB
-from program.media.item import Episode, MediaItem, Movie, Season, Show
+from program.media.item import Episode, MediaItem, Season
 from program.media.state import States
 from program.symlink import Symlinker
 from pydantic import BaseModel
+from sqlalchemy import func, select
 from utils.logger import logger
 
 router = APIRouter(
@@ -36,7 +36,7 @@ async def get_states():
     description="Fetch media items with optional filters and pagination",
 )
 async def get_items(
-    request: Request,
+    _: Request,
     limit: Optional[int] = 50,
     page: Optional[int] = 1,
     type: Optional[str] = None,
@@ -115,7 +115,7 @@ async def get_items(
 
 
 @router.get("/extended/{item_id}")
-async def get_extended_item_info(request: Request, item_id: str):
+async def get_extended_item_info(_: Request, item_id: str):
     with db.Session() as session:
         item = DB._get_item_from_db(session, MediaItem({"imdb_id":str(item_id)}))
         if item is None:
@@ -199,12 +199,12 @@ async def remove_item(
         }
     except Exception as e:
         logger.error(f"Failed to remove item with {id_type} {item_id or imdb_id}: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error")
+        raise HTTPException from e(status_code=500, detail="Internal server error")
 
 
 @router.get("/imdb/{imdb_id}")
 async def get_imdb_info(
-    request: Request,
+    _: Request,
     imdb_id: str,
     season: Optional[int] = None,
     episode: Optional[int] = None,

src/controllers/settings.py

@@ -97,7 +97,7 @@ async def set_settings(settings: List[SetSettings]):
         settings_manager.load(settings_dict=updated_settings.model_dump())
         settings_manager.save()  # Ensure the changes are persisted
     except ValidationError as e:
-        raise HTTPException(
+        raise HTTPException from e(
             status_code=400,
             detail=f"Failed to update settings: {str(e)}",
         )

src/controllers/webhooks.py

@@ -3,8 +3,8 @@
 import pydantic
 from fastapi import APIRouter, Request
 from program.content.overseerr import Overseerr
-from program.indexers.trakt import TraktIndexer, get_imdbid_from_tmdb
-from program.media.item import MediaItem, Show
+from program.indexers.trakt import get_imdbid_from_tmdb
+from program.media.item import MediaItem
 from requests import RequestException
 from utils.logger import logger
 
@@ -38,7 +38,7 @@ async def overseerr(request: Request) -> Dict[str, Any]:
     if not imdb_id:
         try:
             imdb_id = get_imdbid_from_tmdb(req.media.tmdbId)
-        except RequestException as e:
+        except RequestException:
             logger.error(f"Failed to get imdb_id from TMDB: {req.media.tmdbId}")
             return {"success": False, "message": "Failed to get imdb_id from TMDB", "title": req.subject}
         if not imdb_id:
@@ -59,7 +59,7 @@ async def overseerr(request: Request) -> Dict[str, Any]:
     try:
         new_item = MediaItem({"imdb_id": imdb_id, "requested_by": "overseerr"})
         request.app.program.add_to_queue(new_item)
-    except Exception as e:
+    except Exception:
         logger.error(f"Failed to create item from imdb_id: {imdb_id}")
         return {"success": False, "message": "Failed to create item from imdb_id", "title": req.subject}
 

src/main.py

@@ -7,14 +7,14 @@
 import traceback
 
 import uvicorn
+from controllers.actions import router as actions_router
 from controllers.default import router as default_router
 from controllers.items import router as items_router
 
 # from controllers.metrics import router as metrics_router
 from controllers.settings import router as settings_router
 from controllers.tmdb import router as tmdb_router
 from controllers.webhooks import router as webhooks_router
-from controllers.actions import router as actions_router
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from program import Program
@@ -99,8 +99,8 @@ def run_in_thread(self):
             self.should_exit = True
             sys.exit(0)
 
-def signal_handler(sig, frame):
-    logger.log('PROGRAM','Exiting Gracefully.')
+def signal_handler():
+    logger.log("PROGRAM","Exiting Gracefully.")
     app.program.stop()
     sys.exit(0)
 

src/program/content/__init__.py

@@ -1,5 +0,0 @@
-from .listrr import Listrr
-from .mdblist import Mdblist
-from .overseerr import Overseerr
-from .plex_watchlist import PlexWatchlist
-from .trakt import TraktContent

src/program/content/mdblist.py

@@ -5,8 +5,8 @@
 from program.media.item import MediaItem
 from program.settings.manager import settings_manager
 from utils.logger import logger
-from utils.request import get, ping
 from utils.ratelimiter import RateLimiter, RateLimitExceeded
+from utils.request import get, ping
 
 
 class Mdblist:

src/program/content/overseerr.py

@@ -44,8 +44,8 @@ def validate(self) -> bool:
                 )
                 return False
             return response.is_ok
-        except (ConnectionError, RetryError, MaxRetryError, NewConnectionError) as e:
-            logger.error(f"Overseerr URL is not reachable, or it timed out")
+        except (ConnectionError, RetryError, MaxRetryError, NewConnectionError):
+            logger.error("Overseerr URL is not reachable, or it timed out")
             return False
         except Exception as e:
             logger.error(f"Unexpected error during Overseerr validation: {str(e)}")
@@ -71,7 +71,7 @@ def run(self):
             logger.error(f"Unexpected error during fetching requests: {str(e)}")
             return
 
-        if not response.is_ok or not hasattr(response.data, 'pageInfo') or getattr(response.data.pageInfo, 'results', 0) == 0:
+        if not response.is_ok or not hasattr(response.data, "pageInfo") or getattr(response.data.pageInfo, "results", 0) == 0:
             return
 
         # Lets look at approved items only that are only in the pending state
@@ -117,13 +117,13 @@ def get_imdb_id(self, data) -> str:
             )
         except (ConnectionError, RetryError, MaxRetryError) as e:
             logger.error(f"Failed to fetch media details from overseerr: {str(e)}")
-            return
+            return None
         except Exception as e:
             logger.error(f"Unexpected error during fetching media details: {str(e)}")
-            return
+            return None
 
         if not response.is_ok or not hasattr(response.data, "externalIds"):
-            return
+            return None
 
         imdb_id = getattr(response.data.externalIds, "imdbId", None)
         if imdb_id:

src/program/content/trakt.py

@@ -1,16 +1,14 @@
 """Trakt content module"""
 import re
 import time
-from types import SimpleNamespace
-from urllib.parse import urlencode, urlparse
+from urllib.parse import urlencode
 
-import regex
 from program.media.item import MediaItem, Movie, Show
 from program.settings.manager import settings_manager
 from requests import RequestException
 from utils.logger import logger
-from utils.request import get, post
 from utils.ratelimiter import RateLimiter
+from utils.request import get, post
 
 
 class TraktContent:
@@ -43,7 +41,7 @@ def validate(self) -> bool:
                 logger.error("Trakt API key is not set.")
                 return False
             response = get(f"{self.api_url}/lists/2", additional_headers=self.headers)
-            if not getattr(response.data, 'name', None):
+            if not getattr(response.data, "name", None):
                 logger.error("Invalid user settings received from Trakt.")
                 return False
             return True
@@ -222,8 +220,7 @@ def perform_oauth_flow(self) -> str:
             "client_id": self.settings.oauth_client_id,
             "redirect_uri": self.settings.oauth_redirect_uri,
         }
-        auth_url = f"{self.api_url}/oauth/authorize?{urlencode(params)}"
-        return auth_url
+        return f"{self.api_url}/oauth/authorize?{urlencode(params)}"
 
     def handle_oauth_callback(self, code: str) -> bool:
         """Handle the OAuth callback and exchange the code for an access token."""
@@ -358,6 +355,6 @@ def _resolve_short_url(short_url) -> str or None:
         return None
 
 patterns: dict[str, re.Pattern] = {
-    "user_list": re.compile(r'https://trakt.tv/users/([^/]+)/lists/([^/]+)'),
-    "short_list": re.compile(r'https://trakt.tv/lists/\d+')
+    "user_list": re.compile(r"https://trakt.tv/users/([^/]+)/lists/([^/]+)"),
+    "short_list": re.compile(r"https://trakt.tv/lists/\d+")
 }

src/program/db/__init__.py

@@ -1 +0,0 @@
-from .db import db

src/program/db/db.py

@@ -1,20 +1,22 @@
-from sqla_wrapper import Alembic, SQLAlchemy
+import os
+
+from alembic.autogenerate import compare_metadata
+from alembic.runtime.migration import MigrationContext
 from program.settings.manager import settings_manager
+from sqla_wrapper import Alembic, SQLAlchemy
 from utils import data_dir_path
 
 db = SQLAlchemy(settings_manager.settings.database.host)
 
 script_location = data_dir_path / "alembic/"
 
-import os
+
 if not os.path.exists(script_location):
     os.makedirs(script_location)
 
 alembic = Alembic(db, script_location)
 alembic.init(script_location)
 
-from alembic.autogenerate import compare_metadata
-from alembic.runtime.migration import MigrationContext
 
 # https://stackoverflow.com/questions/61374525/how-do-i-check-if-alembic-migrations-need-to-be-generated
 def need_upgrade_check() -> bool:
@@ -24,10 +26,11 @@ def need_upgrade_check() -> bool:
         diff = compare_metadata(mc, db.Model.metadata)
     return diff != []
 
+
 def run_migrations() -> None:
     try:
         if need_upgrade_check():
             alembic.revision("auto-upg")
             alembic.upgrade()
-    except:
-        alembic.upgrade()
+    except Exception as _:
+        alembic.upgrade()

src/program/db/db_functions.py

@@ -1,9 +1,11 @@
 import os
+
 from program.media.item import Episode, MediaItem, Movie, Season, Show
-from sqlalchemy import select, func
+from program.types import Event
+from sqlalchemy import func, select
 from sqlalchemy.orm import joinedload
 from utils.logger import logger
-from program.types import Event
+
 from .db import db
 
 
@@ -16,7 +18,7 @@ def _ensure_item_exists_in_db(item:MediaItem) -> bool:
 def _get_item_type_from_db(item: MediaItem) -> str:
     with db.Session() as session:
         if item._id is None:
-            return session.execute(select(MediaItem.type).where( (MediaItem.imdb_id==item.imdb_id ) & ( (MediaItem.type == 'show') | (MediaItem.type == 'movie') ) )).scalar_one() 
+            return session.execute(select(MediaItem.type).where( (MediaItem.imdb_id==item.imdb_id ) & ( (MediaItem.type == "show") | (MediaItem.type == "movie") ) )).scalar_one() 
         return session.execute(select(MediaItem.type).where(MediaItem._id==item._id)).scalar_one()
 
 def _store_item(item: MediaItem):
@@ -55,8 +57,7 @@ def _get_item_from_db(session, item: MediaItem):
             return None
 
 def _check_for_and_run_insertion_required(session, item: MediaItem) -> None:
-    if _ensure_item_exists_in_db(item) == False:
-        if isinstance(item, (Show, Movie, Season, Episode)):
+    if _ensure_item_exists_in_db(item) is False and isinstance(item, (Show, Movie, Season, Episode)):
             item.store_state()
             session.add(item)
             session.commit()
@@ -82,7 +83,7 @@ def _run_thread_with_db_item(fn, service, program, input_item: MediaItem | None)
                                 all_media_items = False
 
                         program._remove_from_running_items(item, service.__name__)
-                        if all_media_items == True:
+                        if all_media_items is True:
                             for i in res:
                                 program._push_event_queue(Event(emitted_by="_run_thread_with_db_item", item=i))
                         session.commit()
@@ -118,7 +119,6 @@ def _run_thread_with_db_item(fn, service, program, input_item: MediaItem | None)
 
 reset = os.getenv("HARD_RESET", None)
 if reset is not None and reset.lower() in ["true","1"]:
-    print("Hard reset detected, dropping all tables") # Logging isn't initialized here yet.
     def run_delete(_type):
         with db.Session() as session:
             all = session.execute(select(_type).options(joinedload("*"))).unique().scalars().all()

src/program/downloaders/__init__.py

@@ -1,9 +1,10 @@
-from .realdebrid import RealDebridDownloader
-from .alldebrid import AllDebridDownloader
-from .torbox import TorBoxDownloader
 from program.media.item import MediaItem
 from utils.logger import logger
 
+from .alldebrid import AllDebridDownloader
+from .realdebrid import RealDebridDownloader
+from .torbox import TorBoxDownloader
+
 
 class Downloader:
     def __init__(self):