🎨 Simplified SourceIterator-s

- Using generator functions
- Common generator init and next in base class
- Explicited that error handling should happen in generator

src/importer/sources/lutris_source.py

@@ -1,6 +1,6 @@
 from sqlite3 import connect
 from time import time
-from typing import Optional
+from typing import Optional, Generator
 
 from src import shared
 from src.game import Game
@@ -11,62 +11,50 @@ from src.utils.save_cover import resize_cover, save_cover
 
 class LutrisSourceIterator(SourceIterator):
     source: "LutrisSource"
-    import_steam = False
-    db_connection = None
-    db_cursor = None
-    db_location = None
-    db_games_request = """
-        SELECT id, name, slug, runner, hidden
-        FROM 'games'
-        WHERE
-            name IS NOT NULL
-            AND slug IS NOT NULL
-            AND configPath IS NOT NULL
-            AND installed
-            AND (runner IS NOT "steam" OR :import_steam)
-        ;
-    """
-    db_request_params = None
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.import_steam = shared.schema.get_boolean("lutris-import-steam")
-        self.db_location = self.source.location / "pga.db"
-        self.db_connection = connect(self.db_location)
-        self.db_request_params = {"import_steam": self.import_steam}
-        self.db_cursor = self.db_connection.execute(
-            self.db_games_request, self.db_request_params
-        )
+    def generator_builder(self) -> Optional[Game]:
+        """Generator method producing games"""
 
-    def __next__(self) -> Optional[Game]:
-        row = None
-        try:
-            row = self.db_cursor.__next__()
-        except StopIteration as error:
-            self.db_connection.close()
-            raise error
+        # Query the database
+        request = """
+            SELECT id, name, slug, runner, hidden
+            FROM 'games'
+            WHERE
+                name IS NOT NULL
+                AND slug IS NOT NULL
+                AND configPath IS NOT NULL
+                AND installed
+                AND (runner IS NOT "steam" OR :import_steam)
+            ;
+        """
+        params = {"import_steam": shared.schema.get_boolean("lutris-import-steam")}
+        connection = connect(self.source.location / "pga.db")
+        cursor = connection.execute(request, params)
 
-        # Create game
-        values = {
-            "version": shared.SPEC_VERSION,
-            "added": int(time()),
-            "hidden": row[4],
-            "name": row[1],
-            "source": f"{self.source.id}_{row[3]}",
-            "game_id": self.source.game_id_format.format(
-                game_id=row[2], game_internal_id=row[0]
-            ),
-            "executable": self.source.executable_format.format(game_id=row[2]),
-            "developer": None,  # TODO get developer metadata on Lutris
-        }
-        game = Game(values, allow_side_effects=False)
+        # Create games from the DB results
+        for row in cursor:
+            # Create game
+            values = {
+                "version": shared.SPEC_VERSION,
+                "added": int(time()),
+                "hidden": row[4],
+                "name": row[1],
+                "source": f"{self.source.id}_{row[3]}",
+                "game_id": self.source.game_id_format.format(
+                    game_id=row[2], game_internal_id=row[0]
+                ),
+                "executable": self.source.executable_format.format(game_id=row[2]),
+                "developer": None,  # TODO get developer metadata on Lutris
+            }
+            game = Game(values, allow_side_effects=False)
 
-        # Save official image
-        image_path = self.source.location / "covers" / "coverart" / f"{row[2]}.jpg"
-        if image_path.exists():
-            save_cover(values["game_id"], resize_cover(image_path))
+            # Save official image
+            image_path = self.source.location / "covers" / "coverart" / f"{row[2]}.jpg"
+            if image_path.exists():
+                save_cover(values["game_id"], resize_cover(image_path))
 
-        return game
+            # Produce game
+            yield game
 
 
 class LutrisSource(Source):