diff --git a/backend/handler/database/collections_handler.py b/backend/handler/database/collections_handler.py
index 2b1f348be..c104a10e3 100644
--- a/backend/handler/database/collections_handler.py
+++ b/backend/handler/database/collections_handler.py
@@ -38,7 +38,10 @@ class DBCollectionsHandler(DBBaseHandler):
     @begin_session
     @with_roms
     def add_collection(
-        self, collection: Collection, query: Query = None, session: Session = None
+        self,
+        collection: Collection,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Collection:
         collection = session.merge(collection)
         session.flush()
@@ -48,21 +51,31 @@ class DBCollectionsHandler(DBBaseHandler):
     @begin_session
     @with_roms
     def get_collection(
-        self, id: int, query: Query = None, session: Session = None
+        self,
+        id: int,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Collection | None:
         return session.scalar(query.filter_by(id=id).limit(1))
 
     @begin_session
     @with_roms
     def get_collection_by_name(
-        self, name: str, user_id: int, query: Query = None, session: Session = None
+        self,
+        name: str,
+        user_id: int,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Collection | None:
         return session.scalar(query.filter_by(name=name, user_id=user_id).limit(1))
 
     @begin_session
     @with_roms
     def get_favorite_collection(
-        self, user_id: int, query: Query = None, session: Session = None
+        self,
+        user_id: int,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Collection | None:
         return session.scalar(
             query.filter_by(is_favorite=True, user_id=user_id).limit(1)
@@ -71,7 +84,9 @@ class DBCollectionsHandler(DBBaseHandler):
     @begin_session
     @with_roms
     def get_collections(
-        self, query: Query = None, session: Session = None
+        self,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Sequence[Collection]:
         return session.scalars(query.order_by(Collection.name.asc())).unique().all()
 
@@ -82,8 +97,8 @@ class DBCollectionsHandler(DBBaseHandler):
         id: int,
         data: dict,
         rom_ids: list[int] | None = None,
-        query: Query = None,
-        session: Session = None,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Collection:
         session.execute(
             update(Collection)
@@ -110,7 +125,11 @@ class DBCollectionsHandler(DBBaseHandler):
         return session.scalar(query.filter_by(id=id).limit(1))
 
     @begin_session
-    def delete_collection(self, id: int, session: Session = None) -> None:
+    def delete_collection(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> None:
         session.execute(
             delete(Collection)
             .where(Collection.id == id)
@@ -120,7 +139,9 @@ class DBCollectionsHandler(DBBaseHandler):
     # Virtual collections
     @begin_session
     def get_virtual_collection(
-        self, id: str, session: Session = None
+        self,
+        id: str,
+        session: Session = None,  # type: ignore
     ) -> VirtualCollection | None:
         name, type = VirtualCollection.from_id(id)
         return session.scalar(
@@ -129,7 +150,10 @@ class DBCollectionsHandler(DBBaseHandler):
 
     @begin_session
     def get_virtual_collections(
-        self, type: str, limit: int | None = None, session: Session = None
+        self,
+        type: str,
+        limit: int | None = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[VirtualCollection]:
         return (
             session.scalars(
@@ -145,7 +169,9 @@ class DBCollectionsHandler(DBBaseHandler):
     # Smart collections
     @begin_session
     def add_smart_collection(
-        self, smart_collection: SmartCollection, session: Session = None
+        self,
+        smart_collection: SmartCollection,
+        session: Session = None,  # type: ignore
     ) -> SmartCollection:
         smart_collection = session.merge(smart_collection)
         session.flush()
@@ -154,13 +180,18 @@ class DBCollectionsHandler(DBBaseHandler):
 
     @begin_session
     def get_smart_collection(
-        self, id: int, session: Session = None
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
     ) -> SmartCollection | None:
         return session.scalar(select(SmartCollection).filter_by(id=id).limit(1))
 
     @begin_session
     def get_smart_collection_by_name(
-        self, name: str, user_id: int, session: Session = None
+        self,
+        name: str,
+        user_id: int,
+        session: Session = None,  # type: ignore
     ) -> SmartCollection | None:
         return session.scalar(
             select(SmartCollection).filter_by(name=name, user_id=user_id).limit(1)
@@ -168,7 +199,9 @@ class DBCollectionsHandler(DBBaseHandler):
 
     @begin_session
     def get_smart_collections(
-        self, user_id: int | None = None, session: Session = None
+        self,
+        user_id: int | None = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[SmartCollection]:
         query = select(SmartCollection).order_by(SmartCollection.name.asc())
 
@@ -185,7 +218,7 @@ class DBCollectionsHandler(DBBaseHandler):
         self,
         id: int,
         data: dict[str, Any],
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> SmartCollection:
         session.execute(
             update(SmartCollection)
@@ -197,7 +230,11 @@ class DBCollectionsHandler(DBBaseHandler):
         return session.query(SmartCollection).filter_by(id=id).one()
 
     @begin_session
-    def delete_smart_collection(self, id: int, session: Session = None) -> None:
+    def delete_smart_collection(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> None:
         session.execute(
             delete(SmartCollection)
             .where(SmartCollection.id == id)
diff --git a/backend/handler/database/firmware_handler.py b/backend/handler/database/firmware_handler.py
index c78fbb07b..9631b1dfc 100644
--- a/backend/handler/database/firmware_handler.py
+++ b/backend/handler/database/firmware_handler.py
@@ -11,7 +11,11 @@ from .base_handler import DBBaseHandler
 
 class DBFirmwareHandler(DBBaseHandler):
     @begin_session
-    def add_firmware(self, firmware: Firmware, session: Session = None) -> Firmware:
+    def add_firmware(
+        self,
+        firmware: Firmware,
+        session: Session = None,  # type: ignore
+    ) -> Firmware:
         return session.merge(firmware)
 
     @begin_session
@@ -19,7 +23,7 @@ class DBFirmwareHandler(DBBaseHandler):
         self,
         id: int,
         *,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Firmware | None:
         return session.scalar(select(Firmware).filter_by(id=id).limit(1))
 
@@ -28,7 +32,7 @@ class DBFirmwareHandler(DBBaseHandler):
         self,
         *,
         platform_id: int | None = None,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[Firmware]:
         query = select(Firmware).order_by(Firmware.file_name.asc())
 
@@ -39,7 +43,10 @@ class DBFirmwareHandler(DBBaseHandler):
 
     @begin_session
     def get_firmware_by_filename(
-        self, platform_id: int, file_name: str, session: Session = None
+        self,
+        platform_id: int,
+        file_name: str,
+        session: Session = None,  # type: ignore
     ):
         return session.scalar(
             select(Firmware)
@@ -48,7 +55,12 @@ class DBFirmwareHandler(DBBaseHandler):
         )
 
     @begin_session
-    def update_firmware(self, id: int, data: dict, session: Session = None) -> Firmware:
+    def update_firmware(
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
+    ) -> Firmware:
         session.execute(
             update(Firmware)
             .where(Firmware.id == id)
@@ -58,7 +70,11 @@ class DBFirmwareHandler(DBBaseHandler):
         return session.query(Firmware).filter_by(id=id).one()
 
     @begin_session
-    def delete_firmware(self, id: int, session: Session = None) -> None:
+    def delete_firmware(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> None:
         session.execute(
             delete(Firmware)
             .where(Firmware.id == id)
@@ -67,7 +83,10 @@ class DBFirmwareHandler(DBBaseHandler):
 
     @begin_session
     def mark_missing_firmware(
-        self, platform_id: int, fs_firmwares_to_keep: list[str], session: Session = None
+        self,
+        platform_id: int,
+        fs_firmwares_to_keep: list[str],
+        session: Session = None,  # type: ignore
     ) -> Sequence[Firmware]:
         missing_firmware = (
             session.scalars(
diff --git a/backend/handler/database/platforms_handler.py b/backend/handler/database/platforms_handler.py
index 05bda4e32..f2057cab8 100644
--- a/backend/handler/database/platforms_handler.py
+++ b/backend/handler/database/platforms_handler.py
@@ -28,8 +28,8 @@ class DBPlatformsHandler(DBBaseHandler):
     def add_platform(
         self,
         platform: Platform,
-        query: Query = None,
-        session: Session = None,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Platform:
         platform = session.merge(platform)
         session.flush()
@@ -37,7 +37,12 @@ class DBPlatformsHandler(DBBaseHandler):
         return session.scalar(query.filter_by(id=platform.id).limit(1))
 
     @begin_session
-    def update_platform(self, id: int, data: dict, session: Session = None) -> Platform:
+    def update_platform(
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
+    ) -> Platform:
         session.execute(
             update(Platform)
             .where(Platform.id == id)
@@ -49,26 +54,38 @@ class DBPlatformsHandler(DBBaseHandler):
     @begin_session
     @with_firmware
     def get_platform(
-        self, id: int, query: Query = None, session: Session = None
+        self,
+        id: int,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Platform | None:
         return session.scalar(query.filter_by(id=id).limit(1))
 
     @begin_session
     @with_firmware
     def get_platforms(
-        self, query: Query = None, session: Session = None
+        self,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Sequence[Platform]:
         return session.scalars(query.order_by(Platform.name.asc())).unique().all()
 
     @begin_session
     @with_firmware
     def get_platform_by_fs_slug(
-        self, fs_slug: str, query: Query = None, session: Session = None
+        self,
+        fs_slug: str,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Platform | None:
         return session.scalar(query.filter_by(fs_slug=fs_slug).limit(1))
 
     @begin_session
-    def delete_platform(self, id: int, session: Session = None) -> None:
+    def delete_platform(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> None:
         # Remove all roms from that platforms first
         session.execute(
             delete(Rom)
@@ -86,8 +103,8 @@ class DBPlatformsHandler(DBBaseHandler):
     def mark_missing_platforms(
         self,
         fs_platforms_to_keep: list[str],
-        query: Query = None,
-        session: Session = None,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Sequence[Platform]:
         missing_platforms = (
             session.scalars(
diff --git a/backend/handler/database/roms_handler.py b/backend/handler/database/roms_handler.py
index 8575d0d70..2bddcf567 100644
--- a/backend/handler/database/roms_handler.py
+++ b/backend/handler/database/roms_handler.py
@@ -160,7 +160,12 @@ def with_simple(func):
 class DBRomsHandler(DBBaseHandler):
     @begin_session
     @with_details
-    def add_rom(self, rom: Rom, query: Query = None, session: Session = None) -> Rom:
+    def add_rom(
+        self,
+        rom: Rom,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
+    ) -> Rom:
         rom = session.merge(rom)
         session.flush()
 
@@ -169,14 +174,22 @@ class DBRomsHandler(DBBaseHandler):
     @begin_session
     @with_details
     def get_rom(
-        self, id: int, *, query: Query = None, session: Session = None
+        self,
+        id: int,
+        *,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Rom | None:
         return session.scalar(query.filter_by(id=id).limit(1))
 
     @begin_session
     @with_details
     def get_roms_by_ids(
-        self, ids: list[int], *, query: Query = None, session: Session = None
+        self,
+        ids: list[int],
+        *,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Sequence[Rom]:
         """Get multiple ROMs by their IDs."""
         if not ids:
@@ -395,7 +408,7 @@ class DBRomsHandler(DBBaseHandler):
         selected_region: str | None = None,
         selected_language: str | None = None,
         user_id: int | None = None,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Query[Rom]:
         from handler.scan_handler import MetadataSource
 
@@ -597,8 +610,8 @@ class DBRomsHandler(DBBaseHandler):
         order_by: str = "name",
         order_dir: str = "asc",
         user_id: int | None = None,
-        query: Query = None,
-        session: Session = None,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> tuple[Query[Rom], Any]:
         if user_id:
             query = query.outerjoin(
@@ -638,7 +651,7 @@ class DBRomsHandler(DBBaseHandler):
     def get_roms_scalar(
         self,
         *,
-        session: Session = None,
+        session: Session = None,  # type: ignore
         **kwargs,
     ) -> Sequence[Rom]:
         query, _ = self.get_roms_query(
@@ -673,7 +686,10 @@ class DBRomsHandler(DBBaseHandler):
 
     @begin_session
     def with_char_index(
-        self, query: Query, order_by_attr: Any, session: Session = None
+        self,
+        query: Query,
+        order_by_attr: Any,
+        session: Session = None,  # type: ignore
     ) -> list[Row[tuple[str, int]]]:
         if isinstance(order_by_attr.type, (String, Text)):
             # Remove any leading articles
@@ -715,8 +731,8 @@ class DBRomsHandler(DBBaseHandler):
         self,
         platform_id: int,
         fs_names: Iterable[str],
-        query: Query = None,
-        session: Session = None,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> dict[str, Rom]:
         """Retrieve a dictionary of roms by their filesystem names."""
         roms = (
@@ -731,7 +747,12 @@ class DBRomsHandler(DBBaseHandler):
         return {rom.fs_name: rom for rom in roms}
 
     @begin_session
-    def update_rom(self, id: int, data: dict, session: Session = None) -> Rom:
+    def update_rom(
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
+    ) -> Rom:
         session.execute(
             update(Rom)
             .where(Rom.id == id)
@@ -741,7 +762,11 @@ class DBRomsHandler(DBBaseHandler):
         return session.query(Rom).filter_by(id=id).one()
 
     @begin_session
-    def delete_rom(self, id: int, session: Session = None) -> None:
+    def delete_rom(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> None:
         session.execute(
             delete(Rom)
             .where(Rom.id == id)
@@ -750,7 +775,10 @@ class DBRomsHandler(DBBaseHandler):
 
     @begin_session
     def mark_missing_roms(
-        self, platform_id: int, fs_roms_to_keep: list[str], session: Session = None
+        self,
+        platform_id: int,
+        fs_roms_to_keep: list[str],
+        session: Session = None,  # type: ignore
     ) -> Sequence[Rom]:
         missing_roms = (
             session.scalars(
@@ -780,25 +808,38 @@ class DBRomsHandler(DBBaseHandler):
 
     @begin_session
     def add_rom_user(
-        self, rom_id: int, user_id: int, session: Session = None
+        self,
+        rom_id: int,
+        user_id: int,
+        session: Session = None,  # type: ignore
     ) -> RomUser:
         return session.merge(RomUser(rom_id=rom_id, user_id=user_id))
 
     @begin_session
     def get_rom_user(
-        self, rom_id: int, user_id: int, session: Session = None
+        self,
+        rom_id: int,
+        user_id: int,
+        session: Session = None,  # type: ignore
     ) -> RomUser | None:
         return session.scalar(
             select(RomUser).filter_by(rom_id=rom_id, user_id=user_id).limit(1)
         )
 
     @begin_session
-    def get_rom_user_by_id(self, id: int, session: Session = None) -> RomUser | None:
+    def get_rom_user_by_id(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> RomUser | None:
         return session.scalar(select(RomUser).filter_by(id=id).limit(1))
 
     @begin_session
     def update_rom_user(
-        self, id: int, data: dict, session: Session = None
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
     ) -> RomUser | None:
         session.execute(
             update(RomUser)
@@ -832,15 +873,28 @@ class DBRomsHandler(DBBaseHandler):
         return session.query(RomUser).filter_by(id=id).one()
 
     @begin_session
-    def add_rom_file(self, rom_file: RomFile, session: Session = None) -> RomFile:
+    def add_rom_file(
+        self,
+        rom_file: RomFile,
+        session: Session = None,  # type: ignore
+    ) -> RomFile:
         return session.merge(rom_file)
 
     @begin_session
-    def get_rom_file_by_id(self, id: int, session: Session = None) -> RomFile | None:
+    def get_rom_file_by_id(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> RomFile | None:
         return session.scalar(select(RomFile).filter_by(id=id).limit(1))
 
     @begin_session
-    def update_rom_file(self, id: int, data: dict, session: Session = None) -> RomFile:
+    def update_rom_file(
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
+    ) -> RomFile:
         session.execute(
             update(RomFile)
             .where(RomFile.id == id)
@@ -852,7 +906,9 @@ class DBRomsHandler(DBBaseHandler):
 
     @begin_session
     def purge_rom_files(
-        self, rom_id: int, session: Session = None
+        self,
+        rom_id: int,
+        session: Session = None,  # type: ignore
     ) -> Sequence[RomFile]:
         purged_rom_files = (
             session.scalars(select(RomFile).filter_by(rom_id=rom_id)).unique().all()
@@ -873,7 +929,7 @@ class DBRomsHandler(DBBaseHandler):
         public_only: bool = False,
         search: str = "",
         tags: list[str] | None = None,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[RomNote]:
         query = session.query(RomNote).filter(RomNote.rom_id == rom_id)
 
@@ -905,7 +961,7 @@ class DBRomsHandler(DBBaseHandler):
         content: str = "",
         is_public: bool = False,
         tags: list[str] | None = None,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> dict:
         note = RomNote(
             rom_id=rom_id,
@@ -936,7 +992,7 @@ class DBRomsHandler(DBBaseHandler):
         self,
         note_id: int,
         user_id: int,
-        session: Session = None,
+        session: Session = None,  # type: ignore
         **fields,
     ) -> dict | None:
         note = (
@@ -969,7 +1025,10 @@ class DBRomsHandler(DBBaseHandler):
 
     @begin_session
     def delete_rom_note(
-        self, note_id: int, user_id: int, session: Session = None
+        self,
+        note_id: int,
+        user_id: int,
+        session: Session = None,  # type: ignore
     ) -> bool:
         result = session.execute(
             delete(RomNote).where(
@@ -992,8 +1051,8 @@ class DBRomsHandler(DBBaseHandler):
         flashpoint_id: str | None = None,
         hltb_id: int | None = None,
         *,
-        query: Query = None,
-        session: Session = None,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Rom | None:
         """
         Get a ROM by any metadata ID.
@@ -1031,8 +1090,8 @@ class DBRomsHandler(DBBaseHandler):
         md5_hash: str | None,
         sha1_hash: str | None,
         *,
-        query: Query = None,
-        session: Session = None,
+        query: Query = None,  # type: ignore
+        session: Session = None,  # type: ignore
     ) -> Rom | None:
         """
         Get a ROM by calculated hash value.
diff --git a/backend/handler/database/saves_handler.py b/backend/handler/database/saves_handler.py
index 516071b65..02b609f84 100644
--- a/backend/handler/database/saves_handler.py
+++ b/backend/handler/database/saves_handler.py
@@ -12,16 +12,29 @@ from .base_handler import DBBaseHandler
 
 class DBSavesHandler(DBBaseHandler):
     @begin_session
-    def add_save(self, save: Save, session: Session = None) -> Save:
+    def add_save(
+        self,
+        save: Save,
+        session: Session = None,  # type: ignore
+    ) -> Save:
         return session.merge(save)
 
     @begin_session
-    def get_save(self, user_id: int, id: int, session: Session = None) -> Save | None:
+    def get_save(
+        self,
+        user_id: int,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> Save | None:
         return session.scalar(select(Save).filter_by(user_id=user_id, id=id).limit(1))
 
     @begin_session
     def get_save_by_filename(
-        self, user_id: int, rom_id: int, file_name: str, session: Session = None
+        self,
+        user_id: int,
+        rom_id: int,
+        file_name: str,
+        session: Session = None,  # type: ignore
     ) -> Save | None:
         return session.scalars(
             select(Save)
@@ -35,7 +48,7 @@ class DBSavesHandler(DBBaseHandler):
         user_id: int,
         rom_id: int | None = None,
         platform_id: int | None = None,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[Save]:
         query = select(Save).filter_by(user_id=user_id)
 
@@ -50,7 +63,12 @@ class DBSavesHandler(DBBaseHandler):
         return session.scalars(query).all()
 
     @begin_session
-    def update_save(self, id: int, data: dict, session: Session = None) -> Save:
+    def update_save(
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
+    ) -> Save:
         session.execute(
             update(Save)
             .where(Save.id == id)
@@ -60,7 +78,11 @@ class DBSavesHandler(DBBaseHandler):
         return session.query(Save).filter_by(id=id).one()
 
     @begin_session
-    def delete_save(self, id: int, session: Session = None) -> None:
+    def delete_save(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> None:
         session.execute(
             delete(Save)
             .where(Save.id == id)
@@ -73,7 +95,7 @@ class DBSavesHandler(DBBaseHandler):
         rom_id: int,
         user_id: int,
         saves_to_keep: list[str],
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[Save]:
         missing_saves = session.scalars(
             select(Save).filter(
diff --git a/backend/handler/database/screenshots_handler.py b/backend/handler/database/screenshots_handler.py
index 8635b41e3..aa7713890 100644
--- a/backend/handler/database/screenshots_handler.py
+++ b/backend/handler/database/screenshots_handler.py
@@ -41,7 +41,9 @@ class DBScreenshotsHandler(DBBaseHandler):
 
     @begin_session
     def add_screenshot(
-        self, screenshot: Screenshot, session: Session = None
+        self,
+        screenshot: Screenshot,
+        session: Session = None,  # type: ignore
     ) -> Screenshot:
         return session.merge(screenshot)
 
@@ -53,7 +55,7 @@ class DBScreenshotsHandler(DBBaseHandler):
         filename_no_ext: str | None = None,
         rom_id: int | None = None,
         user_id: int | None = None,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Screenshot | None:
         query = self.filter(
             select(Screenshot),
@@ -65,12 +67,19 @@ class DBScreenshotsHandler(DBBaseHandler):
         return session.scalars(query.limit(1)).first()
 
     @begin_session
-    def get_screenshot_by_id(self, id, session: Session = None) -> Screenshot | None:
+    def get_screenshot_by_id(
+        self,
+        id,
+        session: Session = None,  # type: ignore
+    ) -> Screenshot | None:
         return session.get(Screenshot, id)
 
     @begin_session
     def update_screenshot(
-        self, id: int, data: dict, session: Session = None
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
     ) -> Screenshot:
         session.execute(
             update(Screenshot)
@@ -81,7 +90,11 @@ class DBScreenshotsHandler(DBBaseHandler):
         return session.query(Screenshot).filter_by(id=id).one()
 
     @begin_session
-    def delete_screenshot(self, id: int, session: Session = None) -> None:
+    def delete_screenshot(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> None:
         session.execute(
             delete(Screenshot)
             .where(Screenshot.id == id)
@@ -94,7 +107,7 @@ class DBScreenshotsHandler(DBBaseHandler):
         rom_id: int,
         user_id: int,
         screenshots_to_keep: list[str],
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[Screenshot]:
         query_fn = partial(
             self.filter,
diff --git a/backend/handler/database/states_handler.py b/backend/handler/database/states_handler.py
index 5e7477dc6..f8bf90986 100644
--- a/backend/handler/database/states_handler.py
+++ b/backend/handler/database/states_handler.py
@@ -12,16 +12,29 @@ from .base_handler import DBBaseHandler
 
 class DBStatesHandler(DBBaseHandler):
     @begin_session
-    def add_state(self, state: State, session: Session = None) -> State:
+    def add_state(
+        self,
+        state: State,
+        session: Session = None,  # type: ignore
+    ) -> State:
         return session.merge(state)
 
     @begin_session
-    def get_state(self, user_id: int, id: int, session: Session = None) -> State | None:
+    def get_state(
+        self,
+        user_id: int,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> State | None:
         return session.scalar(select(State).filter_by(user_id=user_id, id=id).limit(1))
 
     @begin_session
     def get_state_by_filename(
-        self, user_id: int, rom_id: int, file_name: str, session: Session = None
+        self,
+        user_id: int,
+        rom_id: int,
+        file_name: str,
+        session: Session = None,  # type: ignore
     ) -> State | None:
         return session.scalar(
             select(State)
@@ -35,7 +48,7 @@ class DBStatesHandler(DBBaseHandler):
         user_id: int,
         rom_id: int | None = None,
         platform_id: int | None = None,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[State]:
         query = select(State).filter_by(user_id=user_id)
 
@@ -50,7 +63,12 @@ class DBStatesHandler(DBBaseHandler):
         return session.scalars(query).all()
 
     @begin_session
-    def update_state(self, id: int, data: dict, session: Session = None) -> State:
+    def update_state(
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
+    ) -> State:
         session.execute(
             update(State)
             .where(State.id == id)
@@ -60,7 +78,11 @@ class DBStatesHandler(DBBaseHandler):
         return session.query(State).filter_by(id=id).one()
 
     @begin_session
-    def delete_state(self, id: int, session: Session = None) -> None:
+    def delete_state(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> None:
         session.execute(
             delete(State)
             .where(State.id == id)
@@ -73,7 +95,7 @@ class DBStatesHandler(DBBaseHandler):
         rom_id: int,
         user_id: int,
         states_to_keep: list[str],
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[State]:
         missing_states = session.scalars(
             select(State).filter(
diff --git a/backend/handler/database/stats_handler.py b/backend/handler/database/stats_handler.py
index 8a0f1216d..1d7105f7a 100644
--- a/backend/handler/database/stats_handler.py
+++ b/backend/handler/database/stats_handler.py
@@ -10,7 +10,10 @@ from .base_handler import DBBaseHandler
 
 class DBStatsHandler(DBBaseHandler):
     @begin_session
-    def get_platforms_count(self, session: Session = None) -> int:
+    def get_platforms_count(
+        self,
+        session: Session = None,  # type: ignore
+    ) -> int:
         """Get the number of platforms with any roms."""
         return (
             session.scalar(
@@ -20,23 +23,38 @@ class DBStatsHandler(DBBaseHandler):
         )
 
     @begin_session
-    def get_roms_count(self, session: Session = None) -> int:
+    def get_roms_count(
+        self,
+        session: Session = None,  # type: ignore
+    ) -> int:
         return session.scalar(select(func.count()).select_from(Rom)) or 0
 
     @begin_session
-    def get_saves_count(self, session: Session = None) -> int:
+    def get_saves_count(
+        self,
+        session: Session = None,  # type: ignore
+    ) -> int:
         return session.scalar(select(func.count()).select_from(Save)) or 0
 
     @begin_session
-    def get_states_count(self, session: Session = None) -> int:
+    def get_states_count(
+        self,
+        session: Session = None,  # type: ignore
+    ) -> int:
         return session.scalar(select(func.count()).select_from(State)) or 0
 
     @begin_session
-    def get_screenshots_count(self, session: Session = None) -> int:
+    def get_screenshots_count(
+        self,
+        session: Session = None,  # type: ignore
+    ) -> int:
         return session.scalar(select(func.count()).select_from(Screenshot)) or 0
 
     @begin_session
-    def get_total_filesize(self, session: Session = None) -> int:
+    def get_total_filesize(
+        self,
+        session: Session = None,  # type: ignore
+    ) -> int:
         """Get the total filesize of all roms in the database, in bytes."""
         return (
             session.scalar(
@@ -46,7 +64,11 @@ class DBStatsHandler(DBBaseHandler):
         )
 
     @begin_session
-    def get_platform_filesize(self, platform_id: int, session: Session = None) -> int:
+    def get_platform_filesize(
+        self,
+        platform_id: int,
+        session: Session = None,  # type: ignore
+    ) -> int:
         """Get the total filesize of all roms in the database, in bytes."""
         return (
             session.scalar(
diff --git a/backend/handler/database/users_handler.py b/backend/handler/database/users_handler.py
index fc7d2fb70..65ce385a7 100644
--- a/backend/handler/database/users_handler.py
+++ b/backend/handler/database/users_handler.py
@@ -38,27 +38,46 @@ class DBUsersHandler(DBBaseHandler):
         return query
 
     @begin_session
-    def add_user(self, user: User, session: Session = None) -> User:
+    def add_user(
+        self,
+        user: User,
+        session: Session = None,  # type: ignore
+    ) -> User:
         return session.merge(user)
 
     @begin_session
     def get_user_by_username(
-        self, username: str, session: Session = None
+        self,
+        username: str,
+        session: Session = None,  # type: ignore
     ) -> User | None:
         query = self.filter(select(User), usernames=[username])
         return session.scalar(query.limit(1))
 
     @begin_session
-    def get_user_by_email(self, email: str, session: Session = None) -> User | None:
+    def get_user_by_email(
+        self,
+        email: str,
+        session: Session = None,  # type: ignore
+    ) -> User | None:
         query = self.filter(select(User), emails=[email])
         return session.scalar(query.limit(1))
 
     @begin_session
-    def get_user(self, id: int, session: Session = None) -> User | None:
+    def get_user(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ) -> User | None:
         return session.get(User, id)
 
     @begin_session
-    def update_user(self, id: int, data: dict, session: Session = None) -> User:
+    def update_user(
+        self,
+        id: int,
+        data: dict,
+        session: Session = None,  # type: ignore
+    ) -> User:
         session.execute(
             update(User)
             .where(User.id == id)
@@ -75,7 +94,7 @@ class DBUsersHandler(DBBaseHandler):
         emails: Sequence[str] = (),
         roles: Sequence[Role] = (),
         has_ra_username: bool | None = None,
-        session: Session = None,
+        session: Session = None,  # type: ignore
     ) -> Sequence[User]:
         query = self.filter(
             select(User),
@@ -87,7 +106,11 @@ class DBUsersHandler(DBBaseHandler):
         return session.scalars(query).all()
 
     @begin_session
-    def delete_user(self, id: int, session: Session = None):
+    def delete_user(
+        self,
+        id: int,
+        session: Session = None,  # type: ignore
+    ):
         return session.execute(
             delete(User)
             .where(User.id == id)
@@ -95,6 +118,9 @@ class DBUsersHandler(DBBaseHandler):
         )
 
     @begin_session
-    def get_admin_users(self, session: Session = None) -> Sequence[User]:
+    def get_admin_users(
+        self,
+        session: Session = None,  # type: ignore
+    ) -> Sequence[User]:
         query = self.filter(select(User), roles=[Role.ADMIN])
         return session.scalars(query).all()