fix: remove file_renderer.py

The parallel steps can have a race condition if they both have a lock on
the final Ruff installation path.

Initially, the action was reused for formatting and linting as the
ruff-action sets the necessary environment variables and matchers,
responsible for the annotations on the GitHub UI. Though, as it turns
out, this is already done whenever Ruff is installed, there is no
"special magic" whenever execution of the process happens.

So, only use the action for setup once, and in the parallel steps we can
invoke Ruff ourselves.

.github/workflows/checks_python.yml

@@ -210,11 +210,18 @@ jobs:
     steps:
       - *checkout
 
+      - name: Setup Ruff
+        uses: astral-sh/ruff-action@v4.0.0
+        with:
+          # No-op operation, since executing Ruff cannot be disabled for the action.
+          # Note that `--version` has different behavior than `version`, as the
+          # latter will fail if passed any extra args, even if that arg is empty.
+          args: --version
+          src: ''
+
       - parallel:
           - name: Run Ruff linter
-            uses: astral-sh/ruff-action@v4.0.0
+            run: ruff check
 
           - name: Run Ruff formatter
-            uses: astral-sh/ruff-action@v4.0.0
-            with:
-              args: format --check
+            run: ruff format --check

REUSE.toml

@@ -8,7 +8,7 @@ path = [
     "docs/CNAME",
     "docs/assets/**",
     "src/tagstudio/qt/resources.json",
-    "src/tagstudio/resources/icon.*",
+    "src/tagstudio/resources/icon*.*",
     "src/tagstudio/resources/tagstudio.desktop",
     "src/tagstudio/resources/templates/ts_ignore_template.txt",
     "src/tagstudio/resources/templates/ts_ignore_template_blank.txt",

docs/developing.md

@@ -118,7 +118,7 @@ If you choose to manually set up a virtual environment and install dependencies
 !!! Warning "Linux Library Dependencies"
     If developing TagStudio on Linux, certain libraries are required that may not be included with your distribution. A full list of these can be found [here](install.md#linux).
 
-## Nix(OS)
+## Nix & NixOS
 
 If using [Nix](https://nixos.org/), there is a development environment already provided in the [flake](https://wiki.nixos.org/wiki/Flakes) that is accessible with the following command:
 

docs/index.md

@@ -27,12 +27,12 @@ hide:
 
 ![TagStudio screenshot](./assets/tag_bubbles.png)
 
-**TagStudio** is a photo & file organization application with an underlying tag-based system that focuses on giving freedom and flexibility to the user. No proprietary programs or formats, no sea of sidecar files, and no complete upheaval of your filesystem structure.
+<span style="font-family: Bai Jamjuree, Roboto, sans-serif; font-size: 1.1rem; letter-spacing: -0.05rem;"><span style="font-weight: 900;">Tag</span><span style="font-weight: 500;"><i>Studio</i></span></span> is a photo & file organization application with an underlying tag-based system that focuses on giving freedom and flexibility to the user. No proprietary programs or formats, no sea of sidecar files, and no complete upheaval of your filesystem structure.
 
 </div>
 
 <figure markdown="span">
-  [:material-download: Download Latest Release](https://github.com/TagStudioDev/TagStudio/releases){ .md-button .md-button--primary }
+  [:material-github: Download Latest Release](https://github.com/TagStudioDev/TagStudio/releases){ .md-button .md-button--primary }
 </figure>
 
 ## :material-star: Core Features

docs/install.md

@@ -95,9 +95,9 @@ Some external dependencies are required for TagStudio to execute. Below is a tab
     Aborted (core dumped)
     ```
 
-### :material-nix: Nix(OS)
+### :material-nix: Nix & NixOS
 
-For [Nix(OS)](https://nixos.org/), the TagStudio repository includes a [flake](https://wiki.nixos.org/wiki/Flakes) that provides some outputs such as a development shell and package.
+For [Nix](https://nixos.org/), the TagStudio repository includes a [flake](https://wiki.nixos.org/wiki/Flakes) that provides some outputs such as a development shell and package.
 
 Two packages are provided: `tagstudio` and `tagstudio-jxl`. The distinction was made because `tagstudio-jxl` has an extra compilation step for [JPEG-XL](https://jpeg.org/jpegxl) image support. To give either of them a test run, you can execute `nix run github:TagStudioDev/TagStudio#tagstudio`. If you are in a cloned repository and wish to run a package with the context of the repository, you can simply use `nix run` with no arguments.
 
@@ -256,4 +256,4 @@ To generate thumbnails for RAR-based files (like `.cbr`) you'll need an extracto
 
 ### ripgrep
 
-A recommended tool to improve the performance of directory scanning is [`ripgrep`](https://github.com/BurntSushi/ripgrep), a Rust-based directory walker that natively integrates with our [`.ts_ignore`](ignore.md) (`.gitignore`-style) pattern matching system for excluding files and directories. Ripgrep is already pre-installed on some Linux distributions and also available from several package managers.
+A recommended tool to improve the performance of directory scanning is [ripgrep](https://github.com/BurntSushi/ripgrep), a Rust-based directory walker that natively integrates with our [`.ts_ignore`](ignore.md) (`.gitignore`-style) pattern matching system for excluding files and directories. Ripgrep is already pre-installed on some Linux distributions and also available from several package managers.

docs/stylesheets/extra.css

@@ -3,11 +3,14 @@
  * SPDX-License-Identifier: GPL-3.0-only
  */
 /* Dark Theme */
+
 [data-md-color-scheme="slate"] {
+    --md-primary-fg-color: rgb(197, 110, 255);
+    --md-accent-fg-color: rgb(92, 222, 255);
     --md-default-bg-color: #060617;
     --md-default-fg-color: #eae1ff;
-    --md-default-fg-color--light: #b898ff;
-    --md-code-fg-color: #eae1ffcc;
+    --md-default-fg-color--light: #c2a5ff;
+    --md-code-fg-color: #d8c7ffcc;
     --md-code-hl-string-color: rgb(92, 255, 228);
     --md-code-hl-keyword-color: rgb(61, 155, 255);
     --md-code-hl-constant-color: rgb(205, 78, 255);
@@ -17,6 +20,8 @@
 
 /* Light Theme */
 [data-md-color-scheme="default"] {
+    --md-primary-fg-color: #7758ff;
+    --md-accent-fg-color: rgb(22, 166, 255);
     --md-default-fg-color--light: #090a26;
 }
 
@@ -73,6 +78,11 @@ td {
     padding: 0.5em 1em 0.5em 1em !important;
 }
 
+hr {
+    border-bottom-width: 2px !important;
+    border-color: #9988ff50 !important;
+}
+
 .md-typeset ul li ul {
     margin-top: 0;
     margin-bottom: 0.1rem;
@@ -119,6 +129,18 @@ h2,
     margin-right: -0.8rem;
 }
 
+.md-code__nav,
+.md-content__button,
+.headerlink {
+    border-radius: 0.2rem;
+    background: none;
+    color: #9988ff50 !important;
+}
+
+.md-code__nav:hover {
+    background-color: #9988ff50;
+}
+
 figcaption {
     margin-top: 0 !important;
 }
@@ -149,6 +171,51 @@ td code {
     padding: 0 !important;
 }
 
+.admonition {
+    border-radius: 0.4rem !important;
+    border-width: 2px !important;
+}
+
+.highlight > .filename {
+    border-width: 2px !important;
+    border: solid;
+    border-color: #9988ff10 !important;
+    border-radius: 0.4rem 0.4rem 0 0 !important;
+}
+
+code {
+    border-radius: 0.4rem !important;
+    border-width: 2px !important;
+    border: solid;
+    border-color: #9988ff10;
+}
+
+:is(span, ul, li, td, p, a) > code {
+    border-width: 1px !important;
+    border-radius: 0.1rem !important;
+}
+
+.filename + pre > code {
+    border-top-width: 0 !important;
+    border-radius: 0 0 0.4rem 0.4rem !important;
+}
+
+.tabbed-labels.tabbed-labels--linked {
+    padding-left: 0.4rem;
+    padding-right: 0.4rem;
+    box-shadow: none !important;
+}
+
+.admonition-title {
+    font-size: 0.7rem;
+    font-family: "Bai Jamjuree", Roboto, sans-serif;
+    font-weight: 600 !important;
+}
+
+.admonition-title span {
+    margin-top: 0.05rem !important;
+}
+
 /* Matches the palette used by mkdocs-material */
 .priority-high {
     color: #f1185a;

docs/stylesheets/home.css

@@ -29,3 +29,30 @@ h2 {
         margin-right: 0;
     }
 }
+
+.grid.cards > ul > li {
+    border-radius: 0.4rem !important;
+    border-width: 2px !important;
+    border-color: #9988ff20 !important;
+}
+
+.md-button--primary {
+    margin: 1rem;
+    padding: 0.3rem 1.2rem !important;
+    border-radius: 0.4rem !important;
+    font-size: 1rem;
+    font-family: "Bai Jamjuree", Roboto, sans-serif;
+    background: linear-gradient(60deg, rgb(205, 78, 255) 0%, rgb(116, 123, 255) 100%);
+    border-style: solid;
+    border-width: 0 0 2px 0 !important;
+    border-color: #ffffff33 !important;
+}
+
+.md-button--primary:hover {
+    background: linear-gradient(60deg, rgb(205, 78, 255) 30%, rgb(116, 123, 255) 100%);
+    border-color: #ffffff55 !important;
+}
+
+.md-button--primary span {
+    margin-top: 0.1rem !important;
+}

mkdocs.yml

@@ -70,16 +70,16 @@ theme:
     # Palette toggle for light mode
     - media: "(prefers-color-scheme: light)"
       scheme: default
-      primary: purple
-      accent: purple
+      primary: custom
+      accent: custom
       toggle:
         icon: material/lightbulb
         name: Switch to Dark Mode
     # Palette toggle for dark mode
     - media: "(prefers-color-scheme: dark)"
       scheme: slate
-      primary: purple
-      accent: purple
+      primary: custom
+      accent: custom
       toggle:
         icon: material/lightbulb-night-outline
         name: Switch to System Preference

pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "hatchling.build"
 [project]
 name = "TagStudio"
 description = "A User-Focused Photo & File Management System."
-version = "9.6.1"
+version = "9.6.2"
 license = "GPL-3.0-only"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"
@@ -88,7 +88,7 @@ filterwarnings = [
 ignore = [
     ".venv/**",
     "src/tagstudio/core/library/json/",
-    "src/tagstudio/qt/previews/vendored/pydub/",
+    "src/tagstudio/renderers/vendored/pydub/",
 ]
 include = ["src/tagstudio", "tests"]
 # Reference for the settings here: https://github.com/microsoft/pyright/blob/main/docs/configuration.md
@@ -117,7 +117,7 @@ ignore = ["D100", "D101", "D102", "D103", "D104", "D105", "D106", "D107"]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["D", "E402"]
-"src/tagstudio/qt/previews/vendored/**" = ["B", "E", "N", "UP", "SIM115"]
+"src/tagstudio/renderers/vendored/**" = ["B", "E", "N", "UP", "SIM115"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

src/tagstudio/core/constants.py

@@ -3,8 +3,8 @@
 
 from importlib.metadata import version
 
-VERSION: str = version("tagstudio")  # Major.Minor.Patch
-VERSION_BRANCH: str = ""  # Usually "" or "Pre-Release"
+VERSION: str = version("tagstudio")
+BUILD_TYPE: str = ""  # Usually "", "app.nightly", or "app.pre_release"
 COPYRIGHT_YEARS: str = "2021-2026"
 COPYRIGHT: str = f"© {COPYRIGHT_YEARS} Travis Abendshien & TagStudio Contributors"
 COPYRIGHT_COMPACT: str = f"© {COPYRIGHT_YEARS} Travis Abendshien\n& TagStudio Contributors"

src/tagstudio/core/library/alchemy/library.py

@@ -1728,6 +1728,8 @@ class Library:
                     session.flush()
 
                 if aliases is not None:
+                    for a in aliases:
+                        a.tag_id = tag.id
                     self.update_aliases(tag, aliases, session)
                     session.flush()
 

src/tagstudio/core/media_types.py

@@ -105,6 +105,7 @@ class MediaCategories:
     # These sets are used either individually or together to form the final sets
     # for the MediaCategory(s).
     # These sets may be combined and are NOT 1:1 with the final categories.
+    _ADOBE_ILLUSTRATOR_SET: set[str] = {".ai"}
     _ADOBE_PHOTOSHOP_SET: set[str] = {
         ".pdd",
         ".psb",
@@ -304,6 +305,7 @@ class MediaCategories:
         ".nef",
         ".nrw",
         ".orf",
+        ".r3d",
         ".raf",
         ".raw",
         ".rw2",
@@ -580,7 +582,7 @@ class MediaCategories:
     )
     PDF_TYPES = MediaCategory(
         media_type=MediaType.PDF,
-        extensions=_PDF_SET,
+        extensions=_PDF_SET | _ADOBE_ILLUSTRATOR_SET,
         is_iana=False,
         name="pdf",
     )

src/tagstudio/main.py

@@ -10,7 +10,8 @@ import traceback
 
 import structlog
 
-from tagstudio.core.constants import VERSION, VERSION_BRANCH
+from tagstudio.core.constants import BUILD_TYPE, VERSION
+from tagstudio.qt.translations import Translations
 from tagstudio.qt.ts_qt import QtDriver
 
 logger = structlog.get_logger(__name__)
@@ -59,7 +60,7 @@ def main():
         "--version",
         action="version",
         help="Displays TagStudio version information.",
-        version=f"TagStudio v{VERSION} {VERSION_BRANCH}",
+        version=f"TagStudio v{VERSION} {Translations[BUILD_TYPE] if BUILD_TYPE else ''}",
     )
     args = parser.parse_args()
 

src/tagstudio/qt/helpers/file_tester.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 import ffmpeg
 
-from tagstudio.qt.previews.vendored.probe import probe
+from tagstudio.renderers.vendored.probe import probe
 
 
 def is_readable_video(filepath: Path | str):
@@ -23,11 +23,7 @@ def is_readable_video(filepath: Path | str):
             return False
         for stream in result["streams"]:
             # DRM check
-            if stream.get("codec_tag_string") in [
-                "drma",
-                "drms",
-                "drmi",
-            ]:
+            if stream.get("codec_tag_string") in ["drma", "drms", "drmi"]:
                 return False
     except ffmpeg.Error:
         return False

src/tagstudio/qt/mixed/about_modal.py

@@ -19,12 +19,12 @@ from PySide6.QtWidgets import (
 )
 
 from tagstudio.core.constants import (
+    BUILD_TYPE,
     COPYRIGHT,
     DISCORD_URL,
     DOCS_URL,
     GITHUB_REPO_URL,
     VERSION,
-    VERSION_BRANCH,
 )
 from tagstudio.core.ts_core import TagStudioCore
 from tagstudio.core.utils.ffmpeg_status import FfmpegStatus, FfprobeStatus
@@ -42,7 +42,12 @@ from tagstudio.qt.views.stylesheets.stylesheets import form_content_style, heade
 class AboutModal(QWidget):
     """Modal window showing information about the TagStudio application."""
 
-    VERSION_STR: str = f"{Translations['about.version']} {VERSION} {(' (' + VERSION_BRANCH + ')') if VERSION_BRANCH else ''}"  # noqa: E501
+    VERSION_STR: str = " ".join(
+        [
+            f"{Translations['about.version']}",
+            f"{VERSION} {(' (' + Translations[BUILD_TYPE] + ')') if BUILD_TYPE else ''}",
+        ]
+    )
 
     def __init__(self, config_path: Path | str):
         super().__init__()
@@ -196,8 +201,7 @@ class AboutModal(QWidget):
 
         # ripgrep Status
         ripgrep_path_title = QLabel("ripgrep")  # NOTE: Don't localize
-        ripgrep_path_content = ClickableLabel()
-        ripgrep_path_content.setText(f"{ripgrep_status}")  # TODO: Pass in constructor after #1386
+        ripgrep_path_content = ClickableLabel(f"{ripgrep_status}")
         ripgrep_location = RipgrepStatus.which()
         if ripgrep_location:
             ripgrep_path_content.clicked.connect(

src/tagstudio/qt/ts_qt.py

@@ -40,7 +40,7 @@ from PySide6.QtGui import (
 from PySide6.QtWidgets import QApplication, QFileDialog, QMessageBox, QPushButton, QScrollArea
 
 import tagstudio.qt.resources_rc  # noqa: F401  # pyright: ignore[reportUnusedImport]
-from tagstudio.core.constants import TAG_ARCHIVED, TAG_FAVORITE, VERSION, VERSION_BRANCH
+from tagstudio.core.constants import BUILD_TYPE, TAG_ARCHIVED, TAG_FAVORITE, VERSION
 from tagstudio.core.driver import DriverMixin
 from tagstudio.core.enums import AppCacheItems, MacroID, ShowFilepathOption
 from tagstudio.core.library.alchemy.enums import BrowsingState, SortingModeEnum
@@ -203,7 +203,7 @@ class QtDriver(DriverMixin, QObject):
         self.scrollbar_pos = 0
         self.spacing = None
 
-        self.branch: str = (" (" + VERSION_BRANCH + ")") if VERSION_BRANCH else ""
+        self.branch: str = (" (" + Translations[BUILD_TYPE] + ")") if BUILD_TYPE else ""
         self.base_title: str = f"TagStudio Alpha {VERSION}{self.branch}"
         # self.title_text: str = self.base_title
         # self.buffer = {}

src/tagstudio/qt/views/splash.py

@@ -10,7 +10,7 @@ from PySide6.QtCore import QRect, Qt
 from PySide6.QtGui import QColor, QFont, QPainter, QPen, QPixmap
 from PySide6.QtWidgets import QSplashScreen, QWidget
 
-from tagstudio.core.constants import COPYRIGHT, COPYRIGHT_COMPACT, VERSION, VERSION_BRANCH
+from tagstudio.core.constants import BUILD_TYPE, COPYRIGHT, COPYRIGHT_COMPACT, VERSION
 from tagstudio.qt.global_settings import Splash
 from tagstudio.qt.resource_manager import ResourceManager
 from tagstudio.qt.translations import Translations
@@ -21,7 +21,12 @@ logger = structlog.get_logger(__name__)
 class SplashScreen:
     """The custom splash screen widget for TagStudio."""
 
-    VERSION_STR: str = f"{Translations['about.version']} {VERSION} {(' (' + VERSION_BRANCH + ')') if VERSION_BRANCH else ''}"  # noqa: E501
+    VERSION_STR: str = " ".join(
+        [
+            f"{Translations['about.version']}",
+            f"{VERSION} {(' (' + Translations[BUILD_TYPE] + ')') if BUILD_TYPE else ''}",
+        ]
+    )
     DEFAULT_SPLASH = Splash.AURORA
 
     def __init__(

src/tagstudio/renderers/archive.py

@@ -0,0 +1,158 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import tarfile
+import zipfile
+from io import BytesIO
+from pathlib import Path
+from typing import Literal
+
+import py7zr
+import py7zr.io
+import rarfile
+import structlog
+from PIL import Image
+
+from tagstudio.core.media_types import MediaCategories
+from tagstudio.core.utils.types import unwrap
+from tagstudio.renderers.raster_image import image_from_bytes
+
+logger = structlog.get_logger(__name__)
+
+type Archive = zipfile.ZipFile | rarfile.RarFile | SevenZipFile | TarFile
+
+
+class SevenZipFile(py7zr.SevenZipFile):
+    """Wrapper around py7zr.SevenZipFile to mimic zipfile.ZipFile's API."""
+
+    def __init__(self, filepath: Path, mode: Literal["r"]) -> None:
+        super().__init__(filepath, mode)
+
+    def read(self, name: str) -> bytes:
+        # SevenZipFile must be reset after every extraction
+        # See https://py7zr.readthedocs.io/en/stable/api.html#py7zr.SevenZipFile.extract
+        self.reset()
+        factory = py7zr.io.BytesIOFactory(limit=10485760)  # 10 MiB
+        self.extract(targets=[name], factory=factory)
+        return factory.get(name).read()
+
+
+class TarFile:
+    """Wrapper around tarfile.TarFile to mimic zipfile.ZipFile's API."""
+
+    def __init__(self, filepath: Path, mode: Literal["r"]) -> None:
+        self.tar: tarfile.TarFile
+        self.filepath = filepath
+        self.mode: Literal["r"] = mode
+
+    def namelist(self) -> list[str]:
+        return self.tar.getnames()
+
+    def read(self, name: str) -> bytes:
+        return unwrap(self.tar.extractfile(name)).read()
+
+    def __enter__(self) -> "TarFile":
+        self.tar = tarfile.open(name=self.filepath, mode=self.mode).__enter__()
+        return self
+
+    def __exit__(self, *args) -> None:  # pyright: ignore[reportUnknownParameterType, reportMissingParameterType]
+        self.tar.__exit__(*args)
+
+
+def open_archive(filepath: Path, ext: str = "") -> Archive:
+    """Open an archive with its corresponding archiver.
+
+    Args:
+        filepath (Path): The path to the archive.
+        ext (str): The file extension.
+
+    Returns:
+        Archive: The opened archive.
+    """
+    archiver: type[Archive] = zipfile.ZipFile
+    if ext in {".7z", ".cb7", ".s7z"}:
+        archiver = SevenZipFile
+    elif ext in {".cbr", ".rar"}:
+        archiver = rarfile.RarFile
+    elif ext in {".cbt", ".tar", ".tgz"}:
+        archiver = TarFile
+    return archiver(filepath, "r")
+
+
+def first_image_in_archive(archive: Archive) -> Image.Image | None:
+    """Find and extract the first renderable image in the archive.
+
+    Args:
+        archive (Archive): The current archive.
+
+    Returns:
+        Image: The first renderable image in the archive.
+    """
+    for file_name in archive.namelist():  # pyright: ignore[reportUnknownVariableType]
+        ext = Path(file_name).suffix
+        if MediaCategories.IMAGE_RASTER_TYPES.contains(ext):
+            image_data = archive.read(file_name)  # pyright: ignore[reportUnknownVariableType]
+            return image_from_bytes(BytesIO(image_data))
+
+    return None
+
+
+def archive_thumb(
+    filepath: Path, ext: str = "", image_names: list[Path] | list[str] | None = None
+) -> Image.Image | None:
+    """Extract an embedded preview image from an archive.
+
+    Args:
+        filepath (Path): The path to the archive.
+        ext (str): The file extension. Used to help determine more specific archive type.
+        image_names: (list[Path] | list[str] | None): List of embedded image names to search for.
+
+    Returns:
+        Image: The first image found in the archive.
+    """
+    try:
+        with open_archive(filepath, ext) as archive:
+            # If no list of image names to search for was provided, default to the first image.
+            if not image_names:
+                return first_image_in_archive(archive)
+
+            for image_name in image_names:
+                if image_name in archive.namelist():
+                    file_data = archive.read(str(image_name))  # pyright: ignore[reportUnknownVariableType]
+                    return image_from_bytes(BytesIO(file_data))
+
+    except Exception as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+        return None
+
+
+def apple_embedded_thumb(filepath: Path) -> Image.Image | None:
+    """Extract and render an apple embedded thumbnail (iWork, Apple Creative Studio)."""
+    image_names: list[str] = [
+        "preview.jpg",
+        "QuickLook/Preview.heic",
+        "QuickLook/Thumbnail.jpg",
+        "QuickLook/Thumbnail.heic",
+        "QuickLook/Thumbnail.webp",
+        "QuickLook/Icon.webp",
+    ]
+    return archive_thumb(filepath, image_names=image_names)
+
+
+def krita_thumb(filepath: Path) -> Image.Image | None:
+    """Extract and render a thumbnail for a Krita file."""
+    image_names = ["preview.png"]
+    return archive_thumb(filepath, image_names=image_names)
+
+
+def open_doc_thumb(filepath: Path) -> Image.Image | None:
+    """Extract and render a thumbnail for an OpenDocument file."""
+    image_names = ["Thumbnails/thumbnail.png"]
+    return archive_thumb(filepath, image_names=image_names)
+
+
+def powerpoint_thumb(filepath: Path) -> Image.Image | None:
+    """Extract and render a thumbnail for a Microsoft PowerPoint file."""
+    image_names = ["docProps/thumbnail.jpeg"]
+    return archive_thumb(filepath, image_names=image_names)

src/tagstudio/renderers/audio.py

@@ -0,0 +1,149 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import math
+from io import BytesIO
+from pathlib import Path
+from warnings import catch_warnings
+
+import numpy as np
+import structlog
+from mutagen import flac, id3, mp4
+from mutagen._util import MutagenError
+from PIL import Image, ImageDraw
+
+from tagstudio.renderers.vendored.pydub.audio_segment import (
+    _AudioSegment as AudioSegment,  # pyright: ignore[reportPrivateUsage]
+)
+
+logger = structlog.get_logger(__name__)
+
+
+def audio_album_thumb(filepath: Path, ext: str) -> Image.Image | None:
+    """Return an album cover thumb from an audio file if a cover is present.
+
+    Args:
+        filepath (Path): The path of the file.
+        ext (str): The file extension (with leading ".").
+    """
+    image: Image.Image | None = None
+    try:
+        if not filepath.is_file():
+            raise FileNotFoundError
+
+        artwork = None
+        if ext in [".mp3"]:
+            id3_tags: id3.ID3 = id3.ID3(filepath)
+            id3_covers: list = id3_tags.getall("APIC")  # pyright: ignore[reportUnknownVariableType]
+            if id3_covers:
+                artwork = Image.open(BytesIO(id3_covers[0].data))
+        elif ext in [".flac"]:
+            flac_tags: flac.FLAC = flac.FLAC(filepath)
+            flac_covers: list = flac_tags.pictures  # pyright: ignore[reportUnknownVariableType]
+            if flac_covers:
+                artwork = Image.open(BytesIO(flac_covers[0].data))
+        elif ext in [".mp4", ".m4a", ".aac"]:
+            mp4_tags: mp4.MP4 = mp4.MP4(filepath)
+            mp4_covers: list | None = mp4_tags.get("covr")  # pyright: ignore[reportUnknownVariableType]
+            if mp4_covers:
+                artwork = Image.open(BytesIO(mp4_covers[0]))
+        if artwork:
+            image = artwork
+    except (
+        FileNotFoundError,
+        id3.ID3NoHeaderError,  # pyright: ignore[reportPrivateImportUsage]
+        mp4.MP4MetadataError,
+        mp4.MP4StreamInfoError,
+        MutagenError,
+    ) as e:
+        logger.error("Couldn't read album artwork", path=filepath, error=type(e).__name__)
+    return image
+
+
+def audio_waveform_thumb(
+    filepath: Path, ext: str, size: int, pixel_ratio: float
+) -> Image.Image | None:
+    """Render a waveform image from an audio file.
+
+    Args:
+        filepath (Path): The path of the file.
+        ext (str): The file extension (with leading ".").
+        size (tuple[int,int]): The size of the thumbnail.
+        pixel_ratio (float): The screen pixel ratio.
+    """
+    # BASE_SCALE used for drawing on a larger image and resampling down
+    # to provide an antialiased effect.
+    base_scale: int = 2
+    samples_per_bar: int = 3
+    size_scaled: int = size * base_scale
+    allow_small_min: bool = False
+    im: Image.Image | None = None
+
+    try:
+        bar_count: int = min(math.floor((size // pixel_ratio) / 5), 64)
+        audio = AudioSegment.from_file(filepath, ext[1:])  # pyright: ignore[reportUnknownVariableType]
+        data = np.frombuffer(buffer=audio._data, dtype=np.int16)
+        data_indices = np.linspace(1, len(data), num=bar_count * samples_per_bar)
+        bar_margin: float = ((size_scaled / (bar_count * 3)) * base_scale) / 2
+        line_width: float = ((size_scaled - bar_margin) / (bar_count * 3)) * base_scale
+        bar_height: float = (size_scaled) - (size_scaled // bar_margin)
+
+        count: int = 0
+        maximum_item: int = 0
+        max_array: list[int] = []
+        highest_line: int = 0
+
+        for i in range(-1, len(data_indices)):
+            d = data[math.ceil(data_indices[i]) - 1]
+            if count < samples_per_bar:
+                count = count + 1
+                with catch_warnings(record=True):
+                    if abs(d) > maximum_item:
+                        maximum_item = int(abs(d))
+            else:
+                max_array.append(maximum_item)
+
+                if maximum_item > highest_line:
+                    highest_line = maximum_item
+
+                maximum_item = 0
+                count = 1
+
+        line_ratio = max(highest_line / bar_height, 1)
+
+        im = Image.new("RGB", (size_scaled, size_scaled), color="#000000")
+        draw = ImageDraw.Draw(im)
+
+        current_x = bar_margin
+        for item in max_array:
+            item_height = item / line_ratio
+
+            # If small minimums are not allowed, raise all values
+            # smaller than the line width to the same value.
+            if not allow_small_min:
+                item_height = max(item_height, line_width)
+
+            current_y = (bar_height - item_height + (size_scaled // bar_margin)) // 2
+
+            draw.rounded_rectangle(
+                (
+                    current_x,
+                    current_y,
+                    (current_x + line_width),
+                    (current_y + item_height),
+                ),
+                radius=100 * base_scale,
+                fill=("#FF0000"),
+                outline=("#FFFF00"),
+                width=max(math.ceil(line_width / 6), base_scale),
+            )
+
+            current_x = current_x + line_width + bar_margin
+
+        im.resize((size, size), Image.Resampling.BILINEAR)
+
+    except Exception as e:
+        logger.error("Couldn't render waveform", path=filepath.name, error=type(e).__name__)
+
+    return im

src/tagstudio/renderers/blender.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from pathlib import Path
+
+import structlog
+from PIL import Image
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QGuiApplication
+
+from tagstudio.renderers.vendored.blender_renderer import (
+    blend_thumb,  # pyright: ignore[reportUnknownVariableType]
+)
+
+logger = structlog.get_logger(__name__)
+
+
+def blender_thumb(filepath: Path) -> Image.Image | None:
+    """Get an emended thumbnail from a Blender file, if a thumbnail is present.
+
+    Args:
+        filepath (Path): The path of the file.
+    """
+    bg_color: str = (
+        "#1e1e1e"
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else "#FFFFFF"
+    )
+    im: Image.Image | None = None
+    try:
+        if (blend_image := blend_thumb(str(filepath))) is not None:
+            bg = Image.new("RGB", blend_image.size, color=bg_color)
+            bg.paste(blend_image, mask=blend_image.getchannel(3))
+            im = bg
+        else:
+            logger.info(
+                f"[ThumbRenderer][BLENDER][INFO] {filepath.name} "
+                "Doesn't have an embedded thumbnail."
+            )
+    except Exception as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im

src/tagstudio/renderers/clip_studio.py

@@ -0,0 +1,80 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import base64
+import sqlite3
+import struct
+import xml.etree.ElementTree as ET
+from io import BytesIO
+from pathlib import Path
+
+import structlog
+from PIL import Image
+
+logger = structlog.get_logger(__name__)
+
+
+def clip_studio_thumb(filepath: Path) -> Image.Image | None:
+    """Extract the thumbnail from the SQLite database embedded in a .clip file.
+
+    Args:
+        filepath (Path): The path of the .clip file.
+
+    Returns:
+        Image: The embedded thumbnail, if extractable.
+    """
+    im: Image.Image | None = None
+    try:
+        with open(filepath, "rb") as f:
+            blob = f.read()
+            sqlite_index = blob.find(b"SQLite format 3")
+            if sqlite_index == -1:
+                return im
+
+        with sqlite3.connect(":memory:") as conn:
+            conn.deserialize(blob[sqlite_index:])
+            thumbnail = conn.execute("SELECT ImageData FROM CanvasPreview").fetchone()
+            if thumbnail:
+                im = Image.open(BytesIO(thumbnail[0]))
+        conn.close()
+    except Exception as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+
+    return im
+
+
+def pdn_thumb(filepath: Path) -> Image.Image | None:
+    """Extract the base64-encoded thumbnail from a .pdn file header.
+
+    Args:
+        filepath (Path): The path of the .pdn file.
+
+    Returns:
+        Image: the decoded PNG thumbnail or None by default.
+    """
+    im: Image.Image | None = None
+    with open(filepath, "rb") as f:
+        try:
+            # First 4 bytes are the magic number
+            if f.read(4) != b"PDN3":
+                return im
+
+            # Header length is a little-endian 24-bit int
+            header_size = struct.unpack("<i", f.read(3) + b"\x00")[0]
+            thumb_element = ET.fromstring(f.read(header_size)).find("./*thumb")
+            if thumb_element is None:
+                return im
+
+            encoded_png = thumb_element.get("png")
+            if encoded_png:
+                decoded_png = base64.b64decode(encoded_png)
+                im = Image.open(BytesIO(decoded_png))
+                if im.mode == "RGBA":
+                    new_bg = Image.new("RGB", im.size, color="#1e1e1e")
+                    new_bg.paste(im, mask=im.getchannel(3))
+                    im = new_bg
+        except Exception as e:
+            logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+
+    return im

src/tagstudio/renderers/ebook.py

@@ -0,0 +1,73 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import xml.etree.ElementTree as ET
+from io import BytesIO
+from pathlib import Path
+from xml.etree.ElementTree import Element
+
+import structlog
+from PIL import Image
+
+from tagstudio.core.media_types import MediaCategories
+from tagstudio.core.utils.types import unwrap
+from tagstudio.renderers.archive import Archive, first_image_in_archive, open_archive
+from tagstudio.renderers.raster_image import image_from_bytes
+
+logger = structlog.get_logger(__name__)
+
+
+def epub_thumb(filepath: Path, ext: str) -> Image.Image | None:
+    """Extracts the cover specified by ComicInfo.xml or first image found in the ePub file.
+
+    Args:
+        filepath (Path): The path to the ePub file.
+        ext (str): The file extension.
+
+    Returns:
+        Image: The cover specified in ComicInfo.xml,
+        the first image found in the ePub file, or None by default.
+    """
+    im: Image.Image | None = None
+    try:
+        with open_archive(filepath, ext) as archive:
+            if "ComicInfo.xml" in archive.namelist():
+                comic_info = ET.fromstring(archive.read("ComicInfo.xml"))
+                im = _cover_from_comic_info(archive, comic_info, "FrontCover")
+                if not im:
+                    im = _cover_from_comic_info(archive, comic_info, "InnerCover")
+
+            if not im:
+                im = first_image_in_archive(archive)
+    except Exception as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+
+    return im
+
+
+def _cover_from_comic_info(
+    archive: Archive, comic_info: Element, cover_type: str
+) -> Image.Image | None:
+    """Extract the cover specified in ComicInfo.xml.
+
+    Args:
+        archive (Archive): The current ePub file.
+        comic_info (Element): The parsed ComicInfo.xml.
+        cover_type (str): The type of cover to load.
+
+    Returns:
+        Image: The cover specified in ComicInfo.xml.
+    """
+    im: Image.Image | None = None
+
+    cover = comic_info.find(f"./*Page[@Type='{cover_type}']")
+    if cover is not None:
+        pages = [f for f in archive.namelist() if f != "ComicInfo.xml"]  # pyright: ignore[reportUnknownVariableType]
+        page_name = pages[int(unwrap(cover.get("Image")))]  # pyright: ignore[reportUnknownVariableType]
+        ext = Path(page_name).suffix
+        if MediaCategories.IMAGE_RASTER_TYPES.contains(ext):
+            image_data = archive.read(page_name)  # pyright: ignore[reportUnknownVariableType]
+            im = image_from_bytes(BytesIO(image_data))
+
+    return im

src/tagstudio/renderers/font.py

@@ -0,0 +1,108 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import math
+from pathlib import Path
+from typing import cast
+
+import numpy as np
+import structlog
+from PIL import Image, ImageDraw, ImageFont
+
+from tagstudio.core.constants import FONT_SAMPLE_SIZES, FONT_SAMPLE_TEXT
+from tagstudio.qt.helpers.color_overlay import auto_theme_overlay
+from tagstudio.qt.helpers.text_wrapper import wrap_full_text
+
+logger = structlog.get_logger(__name__)
+
+
+def font_small_thumb(filepath: Path, size: int) -> Image.Image | None:
+    """Render a small font preview ("Aa") thumbnail from a font file.
+
+    Args:
+        filepath (Path): The path of the file.
+        size (tuple[int,int]): The size of the thumbnail.
+    """
+    im: Image.Image | None = None
+    try:
+        bg = Image.new("RGB", (size, size), color="#000000")
+        raw = Image.new("RGB", (size * 3, size * 3), color="#000000")
+        draw = ImageDraw.Draw(raw)
+        font = ImageFont.truetype(filepath, size=size)
+        # NOTE: While a stroke effect is desired, the text
+        # method only allows for outer strokes, which looks
+        # a bit weird when rendering fonts.
+        draw.text(
+            (size // 8, size // 8),
+            "Aa",
+            font=font,
+            fill="#FF0000",
+            # stroke_width=math.ceil(size / 96),
+            # stroke_fill="#FFFF00",
+        )
+        # NOTE: Change to getchannel(1) if using an outline.
+        data = np.asarray(raw.getchannel(0))
+
+        m, n = data.shape[:2]
+        col: np.ndarray = cast(np.ndarray, data.any(0))
+        row: np.ndarray = cast(np.ndarray, data.any(1))
+        cropped_data = np.asarray(raw)[
+            row.argmax() : m - row[::-1].argmax(),
+            col.argmax() : n - col[::-1].argmax(),
+        ]
+        cropped_im: Image.Image = Image.fromarray(cropped_data, "RGB")
+
+        margin: int = math.ceil(size // 16)
+
+        orig_x, orig_y = cropped_im.size
+        new_x, new_y = (size, size)
+        if orig_x > orig_y:
+            new_x = size
+            new_y = math.ceil(size * (orig_y / orig_x))
+        elif orig_y > orig_x:
+            new_y = size
+            new_x = math.ceil(size * (orig_x / orig_y))
+
+        cropped_im = cropped_im.resize(
+            size=(new_x - (margin * 2), new_y - (margin * 2)),
+            resample=Image.Resampling.BILINEAR,
+        )
+        bg.paste(
+            cropped_im,
+            box=(margin, margin + ((size - new_y) // 2)),
+        )
+        im = bg
+    except OSError as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im
+
+
+def font_full_preview(filepath: Path, size: int) -> Image.Image | None:
+    """Render a large font preview ("Alphabet") thumbnail from a font file.
+
+    Args:
+        filepath (Path): The path of the file.
+        size (tuple[int,int]): The size of the thumbnail.
+    """
+    # Scale the sample font sizes to the preview image
+    # resolution,assuming the sizes are tuned for 256px.
+    im: Image.Image | None = None
+    try:
+        scaled_sizes: list[int] = [math.floor(x * (size / 256)) for x in FONT_SAMPLE_SIZES]
+        bg = Image.new("RGBA", (size, size), color="#00000000")
+        draw = ImageDraw.Draw(bg)
+        lines_of_padding = 2
+        y_offset = 0.0
+
+        for font_size in scaled_sizes:
+            font = ImageFont.truetype(filepath, size=font_size)
+            text_wrapped: str = wrap_full_text(FONT_SAMPLE_TEXT, font=font, width=size, draw=draw)
+            draw.multiline_text((0, y_offset), text_wrapped, font=font)
+            y_offset += (len(text_wrapped.split("\n")) + lines_of_padding) * draw.textbbox(
+                (0, 0), "A", font=font
+            )[-1]
+        im = auto_theme_overlay(bg, use_alpha=False)
+    except OSError as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im

src/tagstudio/renderers/medibang_paint.py

@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import os
+import struct
+import xml.etree.ElementTree as ET
+import zlib
+from pathlib import Path
+
+import structlog
+from PIL import Image
+
+from tagstudio.core.utils.types import unwrap
+
+logger = structlog.get_logger(__name__)
+
+
+def medibang_paint_thumb(filepath: Path) -> Image.Image | None:
+    """Extract the thumbnail from a .mdp file.
+
+    Args:
+        filepath (Path): The path of the .mdp file.
+
+    Returns:
+        Image: The embedded thumbnail.
+    """
+    im: Image.Image | None = None
+    try:
+        with open(filepath, "rb") as f:
+            magic = struct.unpack("<7sx", f.read(8))[0]
+            if magic != b"mdipack":
+                return im
+
+            bin_header = struct.unpack("<LLL", f.read(12))
+            xml_header = ET.fromstring(f.read(bin_header[1]))
+            mdibin_count = len(xml_header.findall("./*Layer")) + 1
+            for _ in range(mdibin_count):
+                pac_header = struct.unpack("<3sxLLLL48s64s", f.read(132))
+                if not pac_header[6].startswith(b"thumb"):
+                    f.seek(pac_header[3], os.SEEK_CUR)
+                    continue
+
+                thumb_element = unwrap(xml_header.find("Thumb"))
+                dimensions = (
+                    int(unwrap(thumb_element.get("width"))),
+                    int(unwrap(thumb_element.get("height"))),
+                )
+                thumb_blob = f.read(pac_header[3])
+                if pac_header[2] == 1:
+                    thumb_blob = zlib.decompress(thumb_blob, bufsize=pac_header[4])
+
+                im = Image.frombytes("RGBA", dimensions, thumb_blob, "raw", "BGRA")
+                break
+    except Exception as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+
+    return im

src/tagstudio/renderers/pdf.py

@@ -0,0 +1,66 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+# NOTE: This file contains Qt imports because Qt is used as the vector renderer in this case.
+# This is NOT considered part of the Qt frontend, but is technically tangled with the Qt import.
+
+
+from io import BytesIO
+from pathlib import Path
+
+import structlog
+from PIL import Image
+from PySide6.QtCore import QBuffer, QFile, QFileDevice, QIODeviceBase, QSizeF
+from PySide6.QtGui import QImage
+from PySide6.QtPdf import QPdfDocument, QPdfDocumentRenderOptions
+
+from tagstudio.qt.helpers.image_effects import replace_transparent_pixels
+
+logger = structlog.get_logger(__name__)
+
+
+def pdf_thumb(filepath: Path, size: int, ext: str) -> Image.Image | None:
+    """Render a thumbnail for a PDF or Adobe Illustrator file.
+
+    filepath (Path): The path of the file.
+        size (int): The size of the icon.
+        ext (str): The file extension.
+    """
+    im: Image.Image | None = None
+
+    file: QFile = QFile(filepath)
+    success: bool = file.open(QIODeviceBase.OpenModeFlag.ReadOnly, QFileDevice.Permission.ReadUser)
+    if not success:
+        logger.error("Couldn't render thumbnail", filepath=filepath)
+        return im
+    document: QPdfDocument = QPdfDocument()
+    document.load(file)
+    file.close()
+    # Transform page_size in points to pixels with proper aspect ratio
+    page_size: QSizeF = document.pagePointSize(0)
+    ratio_hw: float = page_size.height() / page_size.width()
+    if ratio_hw >= 1:
+        page_size *= size / page_size.height()
+    else:
+        page_size *= size / page_size.width()
+    # Enlarge image for anti-aliasing
+    scale_factor = 2.5 if ext in {".pdf"} else 1
+    page_size *= scale_factor
+    # Render image with no anti-aliasing for speed
+    render_options: QPdfDocumentRenderOptions = QPdfDocumentRenderOptions()
+    render_options.setRenderFlags(
+        QPdfDocumentRenderOptions.RenderFlag.TextAliased
+        | QPdfDocumentRenderOptions.RenderFlag.ImageAliased
+        | QPdfDocumentRenderOptions.RenderFlag.PathAliased
+    )
+    # Convert QImage to PIL Image
+    q_image: QImage = document.render(0, page_size.toSize(), render_options)
+    buffer: QBuffer = QBuffer()
+    buffer.open(QBuffer.OpenModeFlag.ReadWrite)
+    try:
+        q_image.save(buffer, "PNG")  # pyright: ignore
+        im = Image.open(BytesIO(buffer.buffer().data()))
+    finally:
+        buffer.close()
+    # Replace transparent pixels with white (otherwise Background defaults to transparent)
+    return replace_transparent_pixels(im)

src/tagstudio/renderers/raster_image.py

@@ -0,0 +1,126 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import os
+from io import BytesIO
+from pathlib import Path
+
+import cv2
+import numpy as np
+import rawpy
+import structlog
+from PIL import Image, ImageOps, UnidentifiedImageError
+from PIL.Image import DecompressionBombError
+from pillow_heif import register_heif_opener  # pyright: ignore[reportUnknownVariableType]
+from rawpy import (
+    LibRawFileUnsupportedError,  # pyright: ignore[reportPrivateImportUsage]
+    LibRawIOError,  # pyright: ignore[reportPrivateImportUsage]
+)
+
+from tagstudio.core.utils.types import unwrap
+
+logger = structlog.get_logger(__name__)
+
+try:
+    import pillow_jxl  # noqa: F401 # pyright: ignore
+except ImportError as e:
+    logger.error('[ThumbRenderer] Could not import the "pillow_jxl" module', error=e)
+
+register_heif_opener()
+os.environ["OPENCV_IO_ENABLE_OPENEXR"] = "1"
+
+
+def raster_image_thumb(filepath: Path) -> Image.Image | None:
+    """Render a thumbnail for a standard image type.
+
+    Args:
+        filepath (Path): The path of the file.
+    """
+    im: Image.Image | None = None
+    try:
+        with filepath.open("rb") as file:
+            im = image_from_bytes(BytesIO(file.read()))
+    except (
+        FileNotFoundError,
+        UnidentifiedImageError,
+        DecompressionBombError,
+        NotImplementedError,
+    ) as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im
+
+
+def exr_image_thumb(filepath: Path) -> Image.Image | None:
+    """Render a thumbnail for a EXR image type.
+
+    Args:
+        filepath (Path): The path of the file.
+    """
+    im: Image.Image | None = None
+    try:
+        # Load the EXR data to an array and rotate the color space from BGRA -> RGBA
+        raw_array = cv2.imread(str(filepath), cv2.IMREAD_UNCHANGED)
+        assert raw_array is not None
+        raw_array[..., :3] = raw_array[..., 2::-1]
+
+        # Correct the gamma of the raw array
+        gamma = 2.2
+        array_gamma = np.power(np.clip(raw_array, 0, 1), 1 / gamma)
+        array = (array_gamma * 255).astype(np.uint8)
+
+        im = Image.fromarray(array, mode="RGBA")
+
+        # Paste solid background
+        if im.mode == "RGBA":
+            new_bg = Image.new("RGB", im.size, color="#1e1e1e")
+            new_bg.paste(im, mask=im.getchannel(3))
+            im = new_bg
+
+    except Exception as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im
+
+
+def raw_image_thumb(filepath: Path) -> Image.Image | None:
+    """Render a thumbnail for a RAW image type.
+
+    Args:
+        filepath (Path): The path of the file.
+    """
+    im: Image.Image | None = None
+    try:
+        with rawpy.imread(str(filepath)) as raw:
+            rgb = raw.postprocess(use_camera_wb=True)
+            im = Image.frombytes(
+                "RGB",
+                (rgb.shape[1], rgb.shape[0]),
+                rgb,
+                decoder_name="raw",
+            )
+    except (
+        DecompressionBombError,
+        LibRawIOError,
+        LibRawFileUnsupportedError,
+    ) as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im
+
+
+def image_from_bytes(image_data: BytesIO) -> Image.Image:
+    """Load a raster image and add a background if it's transparent.
+
+    Args:
+        image_data (BytesIO): The binary image data.
+
+    Returns:
+        Image.Image: The loaded raster image, with a background if needed.
+    """
+    im: Image.Image = Image.open(image_data)
+    if im.mode != "RGB" and im.mode != "RGBA":
+        im = im.convert(mode="RGBA")
+    if im.mode == "RGBA":
+        new_bg = Image.new("RGB", im.size, color="#1e1e1e")
+        new_bg.paste(im, mask=im.getchannel(3))
+        im = new_bg
+    return unwrap(ImageOps.exif_transpose(im))

src/tagstudio/renderers/source_engine.py

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from pathlib import Path
+
+import srctools
+import structlog
+from PIL import Image
+
+logger = structlog.get_logger(__name__)
+
+
+def vtf_thumb(filepath: Path) -> Image.Image | None:
+    """Extract and render a thumbnail for VTF (Valve Texture Format) images.
+
+    Uses the srctools library for reading VTF files.
+
+    Args:
+        filepath (Path): The path of the file.
+    """
+    im: Image.Image | None = None
+    try:
+        with open(filepath, "rb") as f:
+            vtf = srctools.VTF.read(f)
+            im = vtf.get(frame=0).to_PIL()
+
+    except (ValueError, FileNotFoundError) as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im

src/tagstudio/renderers/text.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from pathlib import Path
+
+import cv2
+import structlog
+from PIL import Image, ImageDraw, UnidentifiedImageError
+from PIL.Image import DecompressionBombError
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QGuiApplication
+
+from tagstudio.core.utils.encoding import detect_char_encoding
+
+logger = structlog.get_logger(__name__)
+
+
+def text_thumb(filepath: Path) -> Image.Image | None:
+    """Render a thumbnail for a plaintext file.
+
+    Args:
+        filepath (Path): The path of the file.
+    """
+    im: Image.Image | None = None
+
+    bg_color: str = (
+        "#1e1e1e"
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else "#FFFFFF"
+    )
+    fg_color: str = (
+        "#FFFFFF"
+        if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+        else "#111111"
+    )
+
+    try:
+        encoding = detect_char_encoding(filepath)
+        with open(filepath, encoding=encoding) as text_file:
+            text = text_file.read(256)
+        bg = Image.new("RGB", (256, 256), color=bg_color)
+        draw = ImageDraw.Draw(bg)
+        draw.text((16, 16), text, fill=fg_color)
+        im = bg
+    except (
+        UnidentifiedImageError,
+        cv2.error,
+        DecompressionBombError,
+        UnicodeDecodeError,
+        OSError,
+        FileNotFoundError,
+    ) as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im

src/tagstudio/renderers/vector_image.py

@@ -0,0 +1,56 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+# NOTE: This file contains Qt imports because Qt is used as the vector renderer in this case.
+# This is NOT considered part of the Qt frontend, but is technically tangled with the Qt import.
+
+from io import BytesIO
+from pathlib import Path
+
+import structlog
+from PIL import (
+    Image,
+    UnidentifiedImageError,
+)
+from PySide6.QtCore import QBuffer, Qt
+from PySide6.QtGui import QImage, QPainter
+from PySide6.QtSvg import QSvgRenderer
+
+logger = structlog.get_logger(__name__)
+
+
+def vector_image_thumb(filepath: Path, size: int) -> Image.Image:
+    """Render a thumbnail for a vector image, such as SVG.
+
+    Args:
+        filepath (Path): The path of the file.
+        size (tuple[int,int]): The size of the thumbnail.
+    """
+    im: Image.Image | None = None
+    # Create an image to draw the svg to and a painter to do the drawing
+    q_image: QImage = QImage(size, size, QImage.Format.Format_ARGB32)
+    q_image.fill("#1e1e1e")
+
+    # Create an svg renderer, then render to the painter
+    svg: QSvgRenderer = QSvgRenderer(str(filepath))
+
+    if not svg.isValid():
+        raise UnidentifiedImageError
+
+    painter: QPainter = QPainter(q_image)
+    svg.setAspectRatioMode(Qt.AspectRatioMode.KeepAspectRatio)
+    svg.render(painter)
+    painter.end()
+
+    # Write the image to a buffer as png
+    buffer: QBuffer = QBuffer()
+    buffer.open(QBuffer.OpenModeFlag.ReadWrite)
+    q_image.save(buffer, "PNG")  # pyright: ignore[reportCallIssue, reportArgumentType]
+
+    # Load the image from the buffer
+    im = Image.new("RGB", (size, size), color="#1e1e1e")
+    im.paste(Image.open(BytesIO(buffer.data().data())))
+    im = im.convert(mode="RGB")
+
+    buffer.close()
+    return im

src/tagstudio/renderers/vendored/blender_renderer.py

@@ -1,11 +1,7 @@
-#!/usr/bin/env python3
+# SPDX-FileCopyrightText: (c) 2017 The Blender Foundation
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only
 
-
-# <pep8 compliant>
-
-
 ## This file is a modified script that gets the thumbnail data stored in a blend file
 
 

src/tagstudio/renderers/vendored/probe.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: (c) 2022  Karl Kroening (kkroening)
+# SPDX-FileCopyrightText: (c) 2022 Karl Kroening (kkroening)
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only
 # Vendored from ffmpeg-python and ffmpeg-python PR#790 by amamic1803

src/tagstudio/renderers/vendored/pydub/audio_segment.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: (c) 2022  James Robert (jiaaro)
+# SPDX-FileCopyrightText: (c) 2022 James Robert (jiaaro), http://jiaaro.com
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only
 # Vendored from pydub
@@ -43,7 +43,7 @@ from pydub.utils import (
 )
 
 from tagstudio.core.utils.silent_subprocess import silent_popen
-from tagstudio.qt.previews.vendored.pydub.utils import _mediainfo_json
+from tagstudio.renderers.vendored.pydub.utils import _mediainfo_json
 
 basestring = str
 xrange = range
@@ -256,7 +256,7 @@ class _AudioSegment:
             self.sample_width = 4
             self.frame_width = self.channels * self.sample_width
 
-        super(_AudioSegment, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     @property
     def raw_data(self):

src/tagstudio/renderers/vendored/pydub/utils.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: (c) 2011 James Robert, http://jiaaro.com
+# SPDX-FileCopyrightText: (c) 2011 James Robert (jiaaro), http://jiaaro.com
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only
 # Vendored from pydub

src/tagstudio/renderers/video.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import math
+from pathlib import Path
+
+import cv2
+import structlog
+from cv2.typing import MatLike
+from PIL import Image, UnidentifiedImageError
+from PIL.Image import DecompressionBombError
+
+from tagstudio.qt.helpers.file_tester import is_readable_video
+
+logger = structlog.get_logger(__name__)
+
+
+def video_thumb(filepath: Path) -> Image.Image | None:
+    """Render a thumbnail for a video file.
+
+    Args:
+        filepath (Path): The path of the file.
+    """
+    im: Image.Image | None = None
+    frame: MatLike | None = None
+    try:
+        if is_readable_video(filepath):
+            video = cv2.VideoCapture(str(filepath), cv2.CAP_FFMPEG)
+            # TODO: Move this check to is_readable_video()
+            if video.get(cv2.CAP_PROP_FRAME_COUNT) <= 0:
+                raise cv2.error("File is invalid or has 0 frames")
+            video.set(
+                cv2.CAP_PROP_POS_FRAMES,
+                (video.get(cv2.CAP_PROP_FRAME_COUNT) // 2),
+            )
+            # NOTE: Depending on the video format, compression, and
+            # frame count, seeking halfway does not work and the thumb
+            # must be pulled from the earliest available frame.
+            max_frame_seek: int = 10
+            for i in range(
+                0,
+                min(max_frame_seek, math.floor(video.get(cv2.CAP_PROP_FRAME_COUNT))),
+            ):
+                success, frame = video.read()
+                if not success:
+                    video.set(cv2.CAP_PROP_POS_FRAMES, i)
+                else:
+                    break
+            if frame is not None:
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                im = Image.fromarray(frame)
+    except (UnidentifiedImageError, cv2.error, DecompressionBombError, OSError) as e:
+        logger.error("Couldn't render thumbnail", filepath=filepath, error=type(e).__name__)
+    return im

src/tagstudio/resources/translations/en.json

@@ -10,6 +10,7 @@
     "about.version.latest": "{built_version} (Latest Release: {latest_version})",
     "about.website": "Website",
     "app.git": "Git Commit",
+    "app.nightly": "Nightly",
     "app.pre_release": "Pre-Release",
     "app.title": "{base_title} - Library '{library_dir}'",
     "color_manager.title": "Manage Tag Colors",