refactor(preview_thumb): mvc split

STYLE.md

@@ -78,5 +78,7 @@ Observe the following key aspects of this example:
   - Defines the interface the callbacks
   - Enforces that UI events be handled
 
+> [!TIP]
+> A good (non-exhaustive) rule of thumb is: If it requires a non-UI import, then it doesn't belong in the `*_view.py` file.
 
 [^1]: For an explanation of the Model-View-Controller (MVC) Model, checkout this article: [MVC Framework Introduction](https://www.geeksforgeeks.org/mvc-framework-introduction/).

src/tagstudio/core/media_types.py

@@ -80,6 +80,21 @@ class MediaCategory:
     name: str
     is_iana: bool = False
 
+    def contains(self, ext: str, mime_fallback: bool = False) -> bool:
+        """Check if an extension is a member of this MediaCategory.
+
+        Args:
+            ext (str): File extension with a leading "." and in all lowercase.
+            mime_fallback (bool): Flag to guess MIME type if no set matches are made.
+        """
+        if ext in self.extensions:
+            return True
+        elif mime_fallback and self.is_iana:
+            mime_type: str | None = mimetypes.guess_type(Path("x" + ext), strict=False)[0]
+            if mime_type is not None and mime_type.startswith(self.media_type.value):
+                return True
+        return False
+
 
 class MediaCategories:
     """Contain pre-made MediaCategory objects as well as methods to interact with them."""
@@ -635,16 +650,11 @@ def get_types(ext: str, mime_fallback: bool = False) -> set[MediaType]:
             mime_fallback (bool): Flag to guess MIME type if no set matches are made.
         """
         media_types: set[MediaType] = set()
-        # mime_guess: bool = False
 
         for cat in MediaCategories.ALL_CATEGORIES:
-            if ext in cat.extensions:
+            if cat.contains(ext, mime_fallback):
                 media_types.add(cat.media_type)
-            elif mime_fallback and cat.is_iana:
-                mime_type: str = mimetypes.guess_type(Path("x" + ext), strict=False)[0]
-                if mime_type and mime_type.startswith(cat.media_type.value):
-                    media_types.add(cat.media_type)
-                    # mime_guess = True
+
         return media_types
 
     @staticmethod
@@ -656,10 +666,4 @@ def is_ext_in_category(ext: str, media_cat: MediaCategory, mime_fallback: bool =
             media_cat (MediaCategory): The MediaCategory to to check for extension membership.
             mime_fallback (bool): Flag to guess MIME type if no set matches are made.
         """
-        if ext in media_cat.extensions:
-            return True
-        elif mime_fallback and media_cat.is_iana:
-            mime_type: str = mimetypes.guess_type(Path("x" + ext), strict=False)[0]
-            if mime_type and mime_type.startswith(media_cat.media_type.value):
-                return True
-        return False
+        return media_cat.contains(ext, mime_fallback)

src/tagstudio/qt/controller/widgets/preview/preview_thumb_controller.py

@@ -0,0 +1,155 @@
+# Licensed under the GPL-3.0 License.
+# Created for TagStudio: https://github.com/CyanVoxel/TagStudio
+
+import io
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import cv2
+import rawpy
+import structlog
+from PIL import Image, UnidentifiedImageError
+from PIL.Image import DecompressionBombError
+from PySide6.QtCore import QSize
+
+from tagstudio.core.library.alchemy.library import Library
+from tagstudio.core.media_types import MediaCategories
+from tagstudio.qt.helpers.file_opener import open_file
+from tagstudio.qt.helpers.file_tester import is_readable_video
+from tagstudio.qt.view.widgets.preview.preview_thumb_view import PreviewThumbView
+from tagstudio.qt.widgets.preview.file_attributes import FileAttributeData
+
+if TYPE_CHECKING:
+    from tagstudio.qt.ts_qt import QtDriver
+
+logger = structlog.get_logger(__name__)
+Image.MAX_IMAGE_PIXELS = None
+
+
+class PreviewThumb(PreviewThumbView):
+    __current_file: Path
+
+    def __init__(self, library: Library, driver: "QtDriver"):
+        super().__init__(library, driver)
+
+        self.__driver: QtDriver = driver
+
+    def __get_image_stats(self, filepath: Path) -> FileAttributeData:
+        """Get width and height of an image as dict."""
+        stats = FileAttributeData()
+        ext = filepath.suffix.lower()
+
+        if MediaCategories.IMAGE_RAW_TYPES.contains(ext, mime_fallback=True):
+            try:
+                with rawpy.imread(str(filepath)) as raw:
+                    rgb = raw.postprocess()
+                    image = Image.new("L", (rgb.shape[1], rgb.shape[0]), color="black")
+                    stats.width = image.width
+                    stats.height = image.height
+            except (
+                rawpy._rawpy._rawpy.LibRawIOError,  # pyright: ignore[reportAttributeAccessIssue]
+                rawpy._rawpy.LibRawFileUnsupportedError,  # pyright: ignore[reportAttributeAccessIssue]
+                FileNotFoundError,
+            ):
+                pass
+        elif MediaCategories.IMAGE_RASTER_TYPES.contains(ext, mime_fallback=True):
+            try:
+                image = Image.open(str(filepath))
+                stats.width = image.width
+                stats.height = image.height
+            except (
+                DecompressionBombError,
+                FileNotFoundError,
+                NotImplementedError,
+                UnidentifiedImageError,
+            ) as e:
+                logger.error("[PreviewThumb] Could not get image stats", filepath=filepath, error=e)
+        elif MediaCategories.IMAGE_VECTOR_TYPES.contains(ext, mime_fallback=True):
+            pass  # TODO
+
+        return stats
+
+    def __get_gif_data(self, filepath: Path) -> tuple[bytes, tuple[int, int]] | None:
+        """Loads an animated image and returns gif data and size, if successful."""
+        ext = filepath.suffix.lower()
+
+        try:
+            image: Image.Image = Image.open(filepath)
+
+            if ext == ".apng":
+                image_bytes_io = io.BytesIO()
+                image.save(
+                    image_bytes_io,
+                    "GIF",
+                    lossless=True,
+                    save_all=True,
+                    loop=0,
+                    disposal=2,
+                )
+                image.close()
+                image_bytes_io.seek(0)
+                return (image_bytes_io.read(), (image.width, image.height))
+            else:
+                image.close()
+                with open(filepath, "rb") as f:
+                    return (f.read(), (image.width, image.height))
+
+        except (UnidentifiedImageError, FileNotFoundError) as e:
+            logger.error("[PreviewThumb] Could not load animated image", filepath=filepath, error=e)
+            return None
+
+    def __get_video_res(self, filepath: str) -> tuple[bool, QSize]:
+        video = cv2.VideoCapture(filepath, cv2.CAP_FFMPEG)
+        success, frame = video.read()
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        image = Image.fromarray(frame)
+        return (success, QSize(image.width, image.height))
+
+    def display_file(self, filepath: Path) -> FileAttributeData:
+        """Render a single file preview."""
+        self.__current_file = filepath
+
+        ext = filepath.suffix.lower()
+
+        # Video
+        if MediaCategories.VIDEO_TYPES.contains(ext, mime_fallback=True) and is_readable_video(
+            filepath
+        ):
+            size: QSize | None = None
+            try:
+                success, size = self.__get_video_res(str(filepath))
+                if not success:
+                    size = None
+            except cv2.error as e:
+                logger.error("[PreviewThumb] Could not play video", filepath=filepath, error=e)
+
+            return self._display_video(filepath, size)
+        # Audio
+        elif MediaCategories.AUDIO_TYPES.contains(ext, mime_fallback=True):
+            return self._display_audio(filepath)
+        # Animated Images
+        elif MediaCategories.IMAGE_ANIMATED_TYPES.contains(ext, mime_fallback=True):
+            if (ret := self.__get_gif_data(filepath)) and (
+                stats := self._display_gif(ret[0], ret[1])
+            ) is not None:
+                return stats
+            else:
+                self._display_image(filepath)
+                return self.__get_image_stats(filepath)
+        # Other Types (Including Images)
+        else:
+            self._display_image(filepath)
+            return self.__get_image_stats(filepath)
+
+    def _open_file_action_callback(self):
+        open_file(self.__current_file)
+
+    def _open_explorer_action_callback(self):
+        open_file(self.__current_file, file_manager=True)
+
+    def _delete_action_callback(self):
+        if bool(self.__current_file):
+            self.__driver.delete_files_callback(self.__current_file)
+
+    def _button_wrapper_callback(self):
+        open_file(self.__current_file)

src/tagstudio/qt/controller/widgets/preview_panel_controller.py

@@ -1,3 +1,6 @@
+# Licensed under the GPL-3.0 License.
+# Created for TagStudio: https://github.com/CyanVoxel/TagStudio
+
 import typing
 from warnings import catch_warnings
 

src/tagstudio/qt/helpers/qbutton_wrapper.py

@@ -13,6 +13,8 @@ class QPushButtonWrapper(QPushButton):
     the warning that is triggered by disconnecting a signal that is not currently connected.
     """
 
+    is_connected: bool
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.is_connected = False

src/tagstudio/qt/ts_qt.py

@@ -879,7 +879,7 @@ def delete_files_callback(self, origin_path: str | Path, origin_id: int | None =
                 for i, tup in enumerate(pending):
                     e_id, f = tup
                     if (origin_path == f) or (not origin_path):
-                        self.main_window.preview_panel.thumb_media_player_stop()
+                        self.main_window.preview_panel.preview_thumb.media_player.stop()
                     if delete_file(self.lib.library_dir / f):
                         self.main_window.status_bar.showMessage(
                             Translations.format(