skullbite/cartridges
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Managers refactor (#164)

Browse Source 
The main reason for this is the compositing of both local and online covers with the same logic.  
It was a problem raised in #146 with some covers getting stretched.

Changes:
- Renamed and simplified managers methods
- Created a generic `cover manager`
- Added more retryable errors to `steam api manager`
- Removed `local cover manager` and `online cover manager`
- Reduced dependency on `PIL`
This commit is contained in:
Geoffrey Coulaud
2023-07-31 18:44:18 +02:00
committed by GitHub
parent e4dc1253ae
commit 1aff1347e3
12 changed files with 215 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/main.py
View File

@@ -45,8 +45,7 @@ from src.logging.setup import log_system_info, setup_logging
from src.preferences import PreferencesWindow
from src.store.managers.display_manager import DisplayManager
from src.store.managers.file_manager import FileManager
from src.store.managers.local_cover_manager import LocalCoverManager
from src.store.managers.online_cover_manager import OnlineCoverManager
from src.store.managers.cover_manager import CoverManager
from src.store.managers.sgdb_manager import SGDBManager
from src.store.managers.steam_api_manager import SteamAPIManager
from src.store.store import Store
@@ -97,9 +96,8 @@ class CartridgesApplication(Adw.Application):
self.load_games_from_disk()
# Add rest of the managers for game imports
shared.store.add_manager(LocalCoverManager())
shared.store.add_manager(CoverManager())
shared.store.add_manager(SteamAPIManager())
shared.store.add_manager(OnlineCoverManager())
shared.store.add_manager(SGDBManager())
shared.store.toggle_manager_in_pipelines(FileManager, True)

2
src/store/managers/async_manager.py
View File

@@ -56,7 +56,7 @@ class AsyncManager(Manager):
def _task_thread_func(self, _task, _source_object, data, _cancellable):
"""Task thread entry point"""
game, additional_data, *_rest = data
self.execute_resilient_manager_logic(game, additional_data)
self.run(game, additional_data)
def _task_callback(self, _source_object, _result, data):
"""Method run after the task is done"""

197
src/store/managers/cover_manager.py Normal file
View File

@@ -0,0 +1,197 @@
# local_cover_manager.py
#
# Copyright 2023 Geoffrey Coulaud
# Copyright 2023 kramo
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# SPDX-License-Identifier: GPL-3.0-or-later
from pathlib import Path
from typing import NamedTuple
import requests
from gi.repository import Gio, GdkPixbuf
from requests.exceptions import HTTPError, SSLError
from src import shared
from src.game import Game
from src.store.managers.manager import Manager
from src.store.managers.steam_api_manager import SteamAPIManager
from src.utils.save_cover import resize_cover, save_cover
class ImageSize(NamedTuple):
width: float = 0
height: float = 0
@property
def aspect_ratio(self) -> float:
return self.width / self.height
def __str__(self):
return f"{self.width}x{self.height}"
def __mul__(self, scale: float | int) -> "ImageSize":
return ImageSize(
self.width * scale,
self.height * scale,
)
def __truediv__(self, divisor: float | int) -> "ImageSize":
return self * (1 / divisor)
def __add__(self, other_size: "ImageSize") -> "ImageSize":
return ImageSize(
self.width + other_size.width,
self.height + other_size.height,
)
def __sub__(self, other_size: "ImageSize") -> "ImageSize":
return self + (other_size * -1)
def element_wise_div(self, other_size: "ImageSize") -> "ImageSize":
"""Divide every element of self by the equivalent in the other size"""
return ImageSize(
self.width / other_size.width,
self.height / other_size.height,
)
def element_wise_mul(self, other_size: "ImageSize") -> "ImageSize":
"""Multiply every element of self by the equivalent in the other size"""
return ImageSize(
self.width * other_size.width,
self.height * other_size.height,
)
def invert(self) -> "ImageSize":
"""Invert the element of self"""
return ImageSize(1, 1).element_wise_div(self)
class CoverManager(Manager):
"""
Manager in charge of adding the cover image of the game
Order of priority is:
1. local cover
2. icon cover
3. online cover
"""
run_after = (SteamAPIManager,)
retryable_on = (HTTPError, SSLError, ConnectionError)
def download_image(self, url: str) -> Path:
image_file = Gio.File.new_tmp()[0]
path = Path(image_file.get_path())
with requests.get(url, timeout=5) as cover:
cover.raise_for_status()
path.write_bytes(cover.content)
return path
def is_stretchable(self, source_size: ImageSize, cover_size: ImageSize) -> bool:
is_taller = source_size.aspect_ratio < cover_size.aspect_ratio
if is_taller:
return True
max_stretch = 0.12
resized_height = (1 / source_size.aspect_ratio) * cover_size.width
stretch = 1 - (resized_height / cover_size.height)
return stretch <= max_stretch
def save_composited_cover(
self,
game: Game,
image_path: Path,
scale: float = 1,
blur_size: ImageSize = ImageSize(2, 2),
) -> None:
"""
Save the image composited with a background blur.
If the image is stretchable, just stretch it.
:param game: The game to save the cover for
:param path: Path where the source image is located
:param scale:
Scale of the smalled image side
compared to the corresponding side in the cover
:param blur_size: Size of the downscaled image used for the blur
"""
# Load source image
source = GdkPixbuf.Pixbuf.new_from_file(str(image_path))
source_size = ImageSize(source.get_width(), source.get_height())
cover_size = ImageSize._make(shared.image_size)
# Stretch if possible
if scale == 1 and self.is_stretchable(source_size, cover_size):
save_cover(game.game_id, resize_cover(pixbuf=source))
return
# Create the blurred cover background
# fmt: off
cover = (
source
.scale_simple(*blur_size, GdkPixbuf.InterpType.BILINEAR)
.scale_simple(*cover_size, GdkPixbuf.InterpType.BILINEAR)
)
# fmt: on
# Scale to fit, apply scaling, then center
uniform_scale = scale * min(cover_size.element_wise_div(source_size))
source_in_cover_size = source_size * uniform_scale
source_in_cover_position = (cover_size - source_in_cover_size) / 2
# Center the scaled source image in the cover
source.composite(
cover,
*source_in_cover_position,
*source_in_cover_size,
*source_in_cover_position,
uniform_scale,
uniform_scale,
GdkPixbuf.InterpType.BILINEAR,
255,
)
save_cover(game.game_id, resize_cover(pixbuf=cover))
def main(self, game: Game, additional_data: dict) -> None:
if game.blacklisted:
return
for key in (
"local_image_path",
"local_icon_path",
"online_cover_url",
):
# Get an image path
if not (value := additional_data.get(key)):
continue
if key == "online_cover_url":
image_path = self.download_image(value)
else:
image_path = Path(value)
if not image_path.is_file():
continue
# Icon cover
if key == "local_icon_path":
self.save_composited_cover(
game,
image_path,
scale=0.7,
blur_size=ImageSize(1, 2),
)
return
self.save_composited_cover(game, image_path)

2
src/store/managers/display_manager.py
View File

@@ -30,7 +30,7 @@ class DisplayManager(Manager):
run_after = (SteamAPIManager, SGDBManager)
signals = {"update-ready"}
def manager_logic(self, game: Game, _additional_data: dict) -> None:
def main(self, game: Game, _additional_data: dict) -> None:
if game.get_parent():
game.get_parent().get_parent().remove(game)
if game.get_parent():

2
src/store/managers/file_manager.py
View File

@@ -31,7 +31,7 @@ class FileManager(AsyncManager):
run_after = (SteamAPIManager,)
signals = {"save-ready"}
def manager_logic(self, game: Game, additional_data: dict) -> None:
def main(self, game: Game, additional_data: dict) -> None:
if additional_data.get("skip_save"): # Skip saving when loading games from disk
return

74
src/store/managers/local_cover_manager.py
View File

@@ -1,74 +0,0 @@
# local_cover_manager.py
#
# Copyright 2023 Geoffrey Coulaud
# Copyright 2023 kramo
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# SPDX-License-Identifier: GPL-3.0-or-later
import logging
from gi.repository import GdkPixbuf
from src import shared
from src.game import Game
from src.store.managers.manager import Manager
from src.store.managers.steam_api_manager import SteamAPIManager
from src.utils.save_cover import resize_cover, save_cover
class LocalCoverManager(Manager):
"""Manager in charge of adding the local cover image of the game"""
run_after = (SteamAPIManager,)
def manager_logic(self, game: Game, additional_data: dict) -> None:
if image_path := additional_data.get("local_image_path"):
if not image_path.is_file():
logging.error("Local image path is not a file: %s", image_path)
return
save_cover(game.game_id, resize_cover(image_path))
elif icon_path := additional_data.get("local_icon_path"):
cover_width, cover_height = shared.image_size
dest_width = cover_width * 0.7
dest_height = cover_width * 0.7
dest_x = cover_width * 0.15
dest_y = (cover_height - dest_height) / 2
image = GdkPixbuf.Pixbuf.new_from_file(str(icon_path)).scale_simple(
dest_width, dest_height, GdkPixbuf.InterpType.BILINEAR
)
cover = image.scale_simple(
1, 2, GdkPixbuf.InterpType.BILINEAR
).scale_simple(cover_width, cover_height, GdkPixbuf.InterpType.BILINEAR)
image.composite(
cover,
dest_x,
dest_y,
dest_width,
dest_height,
dest_x,
dest_y,
1,
1,
GdkPixbuf.InterpType.BILINEAR,
255,
)
save_cover(game.game_id, resize_cover(pixbuf=cover))

8
src/store/managers/manager.py
View File

@@ -50,7 +50,7 @@ class Manager(ErrorProducer):
return type(self).__name__
@abstractmethod
def manager_logic(self, game: Game, additional_data: dict) -> None:
def main(self, game: Game, additional_data: dict) -> None:
"""
Manager specific logic triggered by the run method
* Implemented by final child classes
@@ -59,7 +59,7 @@ class Manager(ErrorProducer):
* May raise other exceptions that will be reported
"""
def execute_resilient_manager_logic(self, game: Game, additional_data: dict):
def run(self, game: Game, additional_data: dict):
"""Handle errors (retry, ignore or raise) that occur in the manager logic"""
# Keep track of the number of tries
@@ -106,7 +106,7 @@ class Manager(ErrorProducer):
def try_manager_logic():
try:
self.manager_logic(game, additional_data)
self.main(game, additional_data)
except Exception as error: # pylint: disable=broad-exception-caught
handle_error(error)
@@ -116,5 +116,5 @@ class Manager(ErrorProducer):
self, game: Game, additional_data: dict, callback: Callable[["Manager"], Any]
) -> None:
"""Pass the game through the manager"""
self.execute_resilient_manager_logic(game, additional_data)
self.run(game, additional_data)
callback(self)

126
src/store/managers/online_cover_manager.py
View File

@@ -1,126 +0,0 @@
# online_cover_manager.py
#
# Copyright 2023 Geoffrey Coulaud
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# SPDX-License-Identifier: GPL-3.0-or-later
import logging
from pathlib import Path
import requests
from gi.repository import Gio, GdkPixbuf
from requests.exceptions import HTTPError, SSLError
from PIL import Image
from src import shared
from src.game import Game
from src.store.managers.local_cover_manager import LocalCoverManager
from src.store.managers.manager import Manager
from src.utils.save_cover import resize_cover, save_cover
class OnlineCoverManager(Manager):
"""Manager that downloads game covers from URLs"""
run_after = (LocalCoverManager,)
retryable_on = (HTTPError, SSLError, ConnectionError)
def save_composited_cover(
self,
game: Game,
image_file: Gio.File,
original_width: int,
original_height: int,
target_width: int,
target_height: int,
) -> None:
"""Save the image composited with a background blur to fit the cover size"""
logging.debug(
"Compositing image for %s (%s) %dx%d -> %dx%d",
game.name,
game.game_id,
original_width,
original_height,
target_width,
target_height,
)
# Load game image
image = GdkPixbuf.Pixbuf.new_from_stream(image_file.read())
# Create background blur of the size of the cover
cover = image.scale_simple(2, 2, GdkPixbuf.InterpType.BILINEAR).scale_simple(
target_width, target_height, GdkPixbuf.InterpType.BILINEAR
)
# Center the image above the blurred background
scale = min(target_width / original_width, target_height / original_height)
left_padding = (target_width - original_width * scale) / 2
top_padding = (target_height - original_height * scale) / 2
image.composite(
cover,
# Top left of overwritten area on the destination
left_padding,
top_padding,
# Size of the overwritten area on the destination
original_width * scale,
original_height * scale,
# Offset
left_padding,
top_padding,
# Scale to apply to the resized image
scale,
scale,
# Compositing stuff
GdkPixbuf.InterpType.BILINEAR,
255,
)
# Resize and save the cover
save_cover(game.game_id, resize_cover(pixbuf=cover))
def manager_logic(self, game: Game, additional_data: dict) -> None:
# Ensure that we have a cover to download
cover_url = additional_data.get("online_cover_url")
if not cover_url:
return
# Download cover
image_file = Gio.File.new_tmp()[0]
image_path = Path(image_file.get_path())
with requests.get(cover_url, timeout=5) as cover:
cover.raise_for_status()
image_path.write_bytes(cover.content)
# Get image size
cover_width, cover_height = shared.image_size
with Image.open(image_path) as pil_image:
width, height = pil_image.size
# Composite if the image is shorter and the stretch amount is too high
aspect_ratio = width / height
target_aspect_ratio = cover_width / cover_height
is_taller = aspect_ratio < target_aspect_ratio
resized_height = height / width * cover_width
stretch = 1 - (resized_height / cover_height)
max_stretch = 0.12
if is_taller or stretch <= max_stretch:
save_cover(game.game_id, resize_cover(image_path))
else:
self.save_composited_cover(
game, image_file, width, height, cover_width, cover_height
)

7
src/store/managers/sgdb_manager.py
View File

@@ -24,19 +24,18 @@ from requests.exceptions import HTTPError, SSLError
from src.errors.friendly_error import FriendlyError
from src.game import Game
from src.store.managers.async_manager import AsyncManager
from src.store.managers.local_cover_manager import LocalCoverManager
from src.store.managers.online_cover_manager import OnlineCoverManager
from src.store.managers.steam_api_manager import SteamAPIManager
from src.store.managers.cover_manager import CoverManager
from src.utils.steamgriddb import SGDBAuthError, SGDBHelper
class SGDBManager(AsyncManager):
"""Manager in charge of downloading a game's cover from steamgriddb"""
run_after = (SteamAPIManager, LocalCoverManager, OnlineCoverManager)
run_after = (SteamAPIManager, CoverManager)
retryable_on = (HTTPError, SSLError, ConnectionError, JSONDecodeError)
def manager_logic(self, game: Game, _additional_data: dict) -> None:
def main(self, game: Game, _additional_data: dict) -> None:
try:
sgdb = SGDBHelper()
sgdb.conditionaly_update_cover(game)

5
src/store/managers/steam_api_manager.py
View File

@@ -18,6 +18,7 @@
# SPDX-License-Identifier: GPL-3.0-or-later
from requests.exceptions import HTTPError, SSLError
from urllib3.exceptions import ConnectionError as Urllib3ConnectionError
from src.game import Game
from src.store.managers.async_manager import AsyncManager
@@ -32,7 +33,7 @@ from src.utils.steam import (
class SteamAPIManager(AsyncManager):
"""Manager in charge of completing a game's data from the Steam API"""
retryable_on = (HTTPError, SSLError, ConnectionError)
retryable_on = (HTTPError, SSLError, Urllib3ConnectionError)
steam_api_helper: SteamAPIHelper = None
steam_rate_limiter: SteamRateLimiter = None
@@ -42,7 +43,7 @@ class SteamAPIManager(AsyncManager):
self.steam_rate_limiter = SteamRateLimiter()
self.steam_api_helper = SteamAPIHelper(self.steam_rate_limiter)
def manager_logic(self, game: Game, additional_data: dict) -> None:
def main(self, game: Game, additional_data: dict) -> None:
# Skip non-steam games
appid = additional_data.get("steam_appid", None)
if appid is None:

2
src/store/store.py
View File

@@ -130,7 +130,7 @@ class Store:
# Connect signals
for manager in self.managers.values():
for signal in manager.signals:
game.connect(signal, manager.execute_resilient_manager_logic)
game.connect(signal, manager.run)
# Add the game to the store
if not game.source in self.source_games:

4
src/utils/steamgriddb.py
View File

@@ -103,11 +103,11 @@ class SGDBHelper:
image_trunk = shared.covers_dir / game.game_id
still = image_trunk.with_suffix(".tiff")
uri_kwargs = image_trunk.with_suffix(".gif")
animated = image_trunk.with_suffix(".gif")
prefer_sgdb = shared.schema.get_boolean("sgdb-prefer")
# Do nothing if file present and not prefer SGDB
if not prefer_sgdb and (still.is_file() or uri_kwargs.is_file()):
if not prefer_sgdb and (still.is_file() or animated.is_file()):
return
# Get ID for the game