Translated using Weblate (Chinese (Simplified Han script))

Currently translated at 79.3% (335 of 422 strings)

Co-authored-by: Hosted Weblate <hosted@weblate.org>
Co-authored-by: ？？？ <2807603108@qq.com>
Translate-URL: https://hosted.weblate.org/projects/tagstudio/strings/zh_Hans/
Translation: TagStudio/Application Strings

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 & NixOS
+## Nix(OS)
 
 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)
 
-<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.
+**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.
 
 </div>
 
 <figure markdown="span">
-  [:material-github: Download Latest Release](https://github.com/TagStudioDev/TagStudio/releases){ .md-button .md-button--primary }
+  [:material-download: 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 & NixOS
+### :material-nix: Nix(OS)
 
-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.
+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.
 
 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,14 +3,11 @@
  * 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: #c2a5ff;
-    --md-code-fg-color: #d8c7ffcc;
+    --md-default-fg-color--light: #b898ff;
+    --md-code-fg-color: #eae1ffcc;
     --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);
@@ -20,8 +17,6 @@
 
 /* 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;
 }
 
@@ -78,11 +73,6 @@ 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;
@@ -129,18 +119,6 @@ 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;
 }
@@ -171,51 +149,6 @@ 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,30 +29,3 @@ 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: custom
-      accent: custom
+      primary: purple
+      accent: purple
       toggle:
         icon: material/lightbulb
         name: Switch to Dark Mode
     # Palette toggle for dark mode
     - media: "(prefers-color-scheme: dark)"
       scheme: slate
-      primary: custom
-      accent: custom
+      primary: purple
+      accent: purple
       toggle:
         icon: material/lightbulb-night-outline
         name: Switch to System Preference

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

@@ -4,11 +4,6 @@
 
 from sqlalchemy import text
 
-from tagstudio.core.library.alchemy.fields import (
-    DatetimeFieldTemplate,
-    TextFieldTemplate,
-)
-
 SQL_FILENAME: str = "ts_library.sqlite"
 JSON_FILENAME: str = "ts_library.json"
 
@@ -37,15 +32,3 @@ WITH RECURSIVE ChildTags AS (
 )
 SELECT tag_id FROM ChildTags;
 """)
-
-
-DEFAULT_FIELD_TEMPLATES = (
-    TextFieldTemplate(name="Title"),
-    TextFieldTemplate(name="Author"),
-    TextFieldTemplate(name="Artist"),
-    TextFieldTemplate(name="URL"),
-    TextFieldTemplate(name="Description", is_multiline=True),
-    TextFieldTemplate(name="Notes", is_multiline=True),
-    TextFieldTemplate(name="Comments", is_multiline=True),
-    DatetimeFieldTemplate(name="Date"),
-)

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

@@ -6,9 +6,12 @@ from pathlib import Path
 from typing import override
 
 import structlog
-from sqlalchemy import Dialect, String, TypeDecorator
+from sqlalchemy import Dialect, Engine, String, TypeDecorator, create_engine, text
+from sqlalchemy.exc import OperationalError
 from sqlalchemy.orm import DeclarativeBase
 
+from tagstudio.core.constants import RESERVED_TAG_END
+
 logger = structlog.getLogger(__name__)
 
 
@@ -31,3 +34,38 @@ class PathType(TypeDecorator):
 
 class Base(DeclarativeBase):
     type_annotation_map = {Path: PathType}
+
+
+def make_engine(connection_string: str) -> Engine:
+    return create_engine(connection_string)
+
+
+def make_tables(engine: Engine) -> None:
+    logger.info("[Library] Creating DB tables...")
+    with engine.connect() as conn:
+        # TODO: this should instead be migrations that create the exact tables that were added in
+        # the respective DB versions
+        Base.metadata.create_all(conn)
+        conn.commit()
+
+        # TODO: this needs to be a migration
+        # tag IDs < 1000 are reserved
+        # create tag and delete it to bump the autoincrement sequence
+        # TODO - find a better way
+        # is this the better way?
+        result = conn.execute(text("SELECT SEQ FROM sqlite_sequence WHERE name='tags'"))
+        autoincrement_val = result.scalar()
+        if not autoincrement_val or autoincrement_val <= RESERVED_TAG_END:
+            try:
+                conn.execute(
+                    text(
+                        "INSERT INTO tags "
+                        "(id, name, color_namespace, color_slug, is_category, is_hidden) VALUES "
+                        f"({RESERVED_TAG_END}, 'temp', NULL, NULL, false, false)"
+                    )
+                )
+                conn.execute(text(f"DELETE FROM tags WHERE id = {RESERVED_TAG_END}"))
+                conn.commit()
+            except OperationalError as e:
+                logger.error("Could not initialize built-in tags", error=e)
+                conn.rollback()

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

@@ -2,6 +2,11 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 
+# NOTE: This file contains necessary use of deprecated first-party code until that
+# code is removed in a future version (prefs).
+# pyright: reportDeprecated=false
+
+
 import re
 import shutil
 import sys
@@ -16,6 +21,7 @@ from typing import TYPE_CHECKING
 
 import sqlalchemy
 import structlog
+import ujson
 from humanfriendly import format_timespan  # pyright: ignore[reportUnknownVariableType]
 from sqlalchemy import (
     URL,
@@ -38,7 +44,7 @@ from sqlalchemy import (
     update,
 )
 from sqlalchemy.dialects import sqlite
-from sqlalchemy.exc import IntegrityError, OperationalError
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import (
     InstanceState,
     Session,
@@ -66,13 +72,16 @@ from tagstudio.core.library.alchemy.constants import (
     DB_VERSION,
     DB_VERSION_CURRENT_KEY,
     DB_VERSION_INITIAL_KEY,
-    DEFAULT_FIELD_TEMPLATES,
     JSON_FILENAME,
     SQL_FILENAME,
     TAG_CHILDREN_QUERY,
 )
-from tagstudio.core.library.alchemy.db import Base as ModelBase
-from tagstudio.core.library.alchemy.enums import MAX_SQL_VARIABLES, BrowsingState, SortingModeEnum
+from tagstudio.core.library.alchemy.db import make_tables
+from tagstudio.core.library.alchemy.enums import (
+    MAX_SQL_VARIABLES,
+    BrowsingState,
+    SortingModeEnum,
+)
 from tagstudio.core.library.alchemy.fields import (
     LEGACY_FIELD_MAP,
     BaseField,
@@ -83,7 +92,6 @@ from tagstudio.core.library.alchemy.fields import (
     TextFieldTemplate,
 )
 from tagstudio.core.library.alchemy.joins import TagEntry, TagParent
-from tagstudio.core.library.alchemy.migrations import DBMigrations, MigrationError
 from tagstudio.core.library.alchemy.models import (
     Entry,
     Namespace,
@@ -96,6 +104,7 @@ from tagstudio.core.library.alchemy.visitors import SQLBoolExpressionBuilder
 from tagstudio.core.library.ignore import migrate_ext_list
 from tagstudio.core.library.json.library import Library as JsonLibrary
 from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.translations import Translations
 
 if TYPE_CHECKING:
     from sqlalchemy import Select
@@ -161,6 +170,20 @@ def get_default_tags() -> tuple[Tag, ...]:
     return archive_tag, favorite_tag, meta_tag
 
 
+def get_default_field_templates() -> tuple[BaseFieldTemplate, ...]:
+    """Return the default field templates for a new TagStudio library."""
+    title = TextFieldTemplate(name="Title")
+    author = TextFieldTemplate(name="Author")
+    artist = TextFieldTemplate(name="Artist")
+    url = TextFieldTemplate(name="URL")
+    description = TextFieldTemplate(name="Description", is_multiline=True)
+    notes = TextFieldTemplate(name="Notes", is_multiline=True)
+    comments = TextFieldTemplate(name="Comments", is_multiline=True)
+    date = DatetimeFieldTemplate(name="Date")
+
+    return title, author, artist, url, description, notes, comments, date
+
+
 # The difference in the number of default JSON tags vs default tags in the current version.
 DEFAULT_TAG_DIFF: int = len(get_default_tags()) - len([TAG_ARCHIVED, TAG_FAVORITE])
 
@@ -408,41 +431,21 @@ class Library:
         self, library_dir: Path, in_memory: bool, sql_filename: str = SQL_FILENAME
     ) -> LibraryStatus:
         self.engine = self.__get_engine(library_dir, in_memory, sql_filename)
+        loaded_db_version: int = 0
 
         logger.info(
             "[Library] Opening SQLite Library",
             library_dir=library_dir,
         )
 
-        logger.info("[Library] Creating DB tables...")
-        with self.engine.connect() as conn:
-            ModelBase.metadata.create_all(conn)
-            conn.commit()
-
-            # TODO - find a better way
-            # is this the better way?
-            # Could we perhaps update the row we are reading from here?
-            result = conn.execute(text("SELECT SEQ FROM sqlite_sequence WHERE name='tags'"))
-            autoincrement_val = result.scalar()
-            if not autoincrement_val or autoincrement_val <= RESERVED_TAG_END:
-                try:
-                    conn.execute(
-                        text(
-                            "INSERT INTO tags "
-                            "(id, name, color_namespace, color_slug, is_category, is_hidden) "
-                            f"VALUES ({RESERVED_TAG_END}, 'temp', NULL, NULL, false, false)"
-                        )
-                    )
-                    conn.execute(text(f"DELETE FROM tags WHERE id = {RESERVED_TAG_END}"))
-                    conn.commit()
-                except OperationalError as e:
-                    logger.error("Could not initialize built-in tags", error=e)
-                    conn.rollback()
+        logger.info(f"[Library] Library DB version: {loaded_db_version}")
+        make_tables(self.engine)
 
         with Session(self.engine) as session:
             # Add default tag color namespaces.
             namespaces = default_color_groups.namespaces()
 
+            # TODO: are all of these commits necessary?
             session.add_all(namespaces)
             session.flush()
 
@@ -462,7 +465,7 @@ class Library:
             session.flush()
 
             # Add default field templates
-            for template in DEFAULT_FIELD_TEMPLATES:
+            for template in get_default_field_templates():
                 session.add(template)
             session.flush()
 
@@ -503,25 +506,414 @@ class Library:
     def open_sqlite_library(
         self, library_dir: Path, in_memory: bool, sql_filename: str = SQL_FILENAME
     ) -> LibraryStatus:
-        logger.info("[Library] Opening SQLite Library", library_dir=library_dir)
-
         self.engine = self.__get_engine(library_dir, in_memory, sql_filename)
+        loaded_db_version: int = 0
+        initial_db_version: int = DB_VERSION
 
-        try:
-            migrations = DBMigrations(library_dir, self.engine)
+        logger.info(
+            "[Library] Opening SQLite Library",
+            library_dir=library_dir,
+        )
 
-            # save backup if patches will be applied
-            if migrations.required:
-                Library.save_library_backup_to_disk(library_dir)
+        # Don't check DB version when creating new library
+        loaded_db_version = self.get_version(DB_VERSION_CURRENT_KEY)
+        initial_db_version = self.get_version(DB_VERSION_INITIAL_KEY)
 
-            migrations.run()
-        except MigrationError as e:
-            return LibraryStatus(success=False, message=e.args[0])
+        # ======================== Library Database Version Checking =======================
+        # DB_VERSION 6 is the first supported SQLite DB version.
+        # If the DB_VERSION is >= 100, that means it's a compound major + minor version.
+        #   - Dividing by 100 and flooring gives the major (breaking changes) version.
+        #   - If a DB has major version higher than the current program, don't load it.
+        #   - If only the minor version is higher, it's still allowed to load.
+        if loaded_db_version < 6 or (
+            loaded_db_version >= 100 and loaded_db_version // 100 > DB_VERSION // 100
+        ):
+            mismatch_text = Translations["status.library_version_mismatch"]
+            found_text = Translations["status.library_version_found"]
+            expected_text = Translations["status.library_version_expected"]
+            return LibraryStatus(
+                success=False,
+                message=(
+                    f"{mismatch_text}\n"
+                    f"{found_text} v{loaded_db_version}, "
+                    f"{expected_text} v{DB_VERSION}"
+                ),
+            )
+
+        logger.info(f"[Library] Library DB version: {loaded_db_version}")
+        # TODO: this is very sketchy; blindly creating all tables the newest DB version should have
+        # without considering what version the DB is currently on and then doing all of the
+        # migrations after that seems like it could cause problems in some scenarios.
+        # instead only have this on creation and create new tables as part of migrations
+        # Note: this actually produces an error and fails to initialise built-in tags when opening
+        # a library that doesn't yet have the is_hidden property on the tags table
+        make_tables(self.engine)
+
+        # save backup if patches will be applied
+        if loaded_db_version < DB_VERSION:
+            self.library_dir = library_dir
+            self.save_library_backup_to_disk()
+            self.library_dir = None
+
+        # migrate DB step by step from one version to the next
+        # (migration_method, db_version, initial_db_version)
+        migrations = [
+            (self.__apply_db7_migration, 7, None),  # changes: value_type, tags
+            (self.__apply_db8_migration, 8, None),  # changes: tag_colors
+            (self.__apply_db9_migration, 9, None),  # changes: entries
+            (self.__apply_db100_migration, 100, None),  # changes: tag_parents
+            (self.__apply_db101_migration, 101, None),  # changes: versions
+            (self.__apply_db102_migration, 102, None),  # changes: tag_parents
+            (self.__apply_db103_migration, 103, None),  # changes: tags
+            (self.__apply_db104_migration, 104, None),  # changes: deletes preferences
+            (self.__apply_db200_migration, 200, None),  # changes: field tables
+            (self.__apply_db201_migration, 201, 200),  # changes: field tables
+            (self.__apply_db202_migration, 202, None),  # changes: tag_parents
+            (self.__apply_db300_migration, 300, None),  # changes: deletes folders
+        ]
+        for migration, v, iv in migrations:
+            if loaded_db_version < v and (iv is None or initial_db_version < iv):
+                logger.info(f"[Library][Migration][{v}] Starting DB Migration")
+                with Session(self.engine) as session:
+                    # any error causes transaction to rollback
+                    migration(session, library_dir)
+                    loaded_db_version = v
+                    self.set_version(session, DB_VERSION_CURRENT_KEY, v)
+                    session.commit()
+                logger.info(f"[Library][Migration][{v}] Completed DB Migration")
+
+        assert loaded_db_version >= DB_VERSION, (
+            "Ran all migrations, but the DB is still not on the newest version"
+        )
+        logger.info(f"[Library] Library migrated to DB version {DB_VERSION}")
 
         # everything is fine, set the library path
         self.library_dir = library_dir
         return LibraryStatus(success=True, library_path=library_dir)
 
+    def __apply_db7_migration(self, session: Session, _library_dir: Path):
+        """Migrate DB from DB_VERSION 6 to 7."""
+        logger.info("[Library][Migration][7] Applying patches to DB_VERSION: 6 library...")
+        # Repair tags that may have a disambiguation_id pointing towards a deleted tag.
+        # TODO: combine into single sql statement
+        all_tag_ids = session.scalars(text("SELECT DISTINCT id FROM tags")).all()
+        disam_stmt = (
+            update(Tag)
+            .where(Tag.disambiguation_id.not_in(all_tag_ids))
+            .values(disambiguation_id=None)
+        )
+        session.execute(disam_stmt)
+        session.flush()
+
+    def __apply_db8_migration(self, session: Session, library_dir: Path):
+        """Migrate DB from DB_VERSION 7 to 8."""
+        # Add the missing color_border column to the TagColorGroups table.
+        session.execute(
+            text("ALTER TABLE tag_colors ADD COLUMN color_border BOOLEAN DEFAULT FALSE NOT NULL")
+        )
+        session.flush()
+        logger.info("[Library][Migration][8] Added color_border column to tag_colors table")
+
+        # collect new default tag colors
+        tag_colors: list[TagColorGroup] = [
+            color
+            for color in default_color_groups.shades()
+            if color.slug in ["burgundy", "dark-teal", "dark_lavender"]
+        ]
+
+        # Add any new default colors introduced in DB_VERSION 8
+        for color in tag_colors:
+            session.add(color)
+        session.flush()
+        logger.info(
+            "[Library][Migration][8] Migrated tag colors to DB_VERSION 8+",
+            color_name=tag_colors,
+        )
+
+        # Update Neon colors to use the the color_border property
+        for color in default_color_groups.neon():
+            neon_stmt = (
+                update(TagColorGroup)
+                .where(
+                    and_(
+                        TagColorGroup.namespace == color.namespace,
+                        TagColorGroup.slug == color.slug,
+                    )
+                )
+                .values(
+                    slug=color.slug,
+                    namespace=color.namespace,
+                    name=color.name,
+                    primary=color.primary,
+                    secondary=color.secondary,
+                    color_border=color.color_border,
+                )
+            )
+            session.execute(neon_stmt)
+        session.flush()
+
+    def __apply_db9_migration(self, session: Session, library_dir: Path):
+        """Migrate DB from DB_VERSION 8 to 9."""
+        # Apply database schema changes
+        add_filename_column = text(
+            "ALTER TABLE entries ADD COLUMN filename TEXT NOT NULL DEFAULT ''"
+        )
+        session.execute(add_filename_column)
+        session.flush()
+        logger.info("[Library][Migration][9] Added filename column to entries table")
+
+        # Populate the new filename column.
+        for entry in self.__all_entries(session):
+            entry.filename = entry.path.name
+            session.merge(entry)
+        session.flush()
+        logger.info("[Library][Migration][9] Populated filename column in entries table")
+
+    def __apply_db100_migration(self, session: Session, library_dir: Path):
+        """Migrate DB to DB_VERSION 100."""
+        # Repair parent-child tag relationships that are the wrong way around.
+        stmt = update(TagParent).values(
+            parent_id=TagParent.child_id,
+            child_id=TagParent.parent_id,
+        )
+        session.execute(stmt)
+        session.flush()
+        logger.info("[Library][Migration][100] Refactored TagParent table")
+
+    def __apply_db101_migration(self, session: Session, library_dir: Path):
+        """Migrate DB to DB_VERSION 101."""
+        # Ensure version rows are present
+        session.add(Version(key=DB_VERSION_INITIAL_KEY, value=100))
+        session.flush()
+
+    def __apply_db102_migration(self, session: Session, library_dir: Path):
+        """Migrate DB to DB_VERSION 102."""
+        # delete TagParents with a dangling parent reference
+        stmt = delete(TagParent).where(TagParent.parent_id.not_in(select(Tag.id).distinct()))
+        session.execute(stmt)
+        session.flush()
+        logger.info("[Library][Migration][102] Verified TagParent table data")
+
+    def __apply_db103_migration(self, session: Session, library_dir: Path):
+        """Migrate DB from DB_VERSION 102 to 103."""
+        # add the new hidden column for tags
+        session.execute(text("ALTER TABLE tags ADD COLUMN is_hidden BOOLEAN NOT NULL DEFAULT 0"))
+        session.flush()
+        logger.info("[Library][Migration][103] Added is_hidden column to tags table")
+
+        # mark the "Archived" tag as hidden
+        session.query(Tag).filter(Tag.id == TAG_ARCHIVED).update({"is_hidden": True})
+        session.flush()
+        logger.info("[Library][Migration][103] Updated archived tag to be hidden")
+
+    def __apply_db104_migration(self, session: Session, library_dir: Path):
+        """Migrate DB from DB_VERSION 103 to 104."""
+        # Convert file extension list to ts_ignore file, if a .ts_ignore file does not exist
+        self.__migrate_sql_to_ts_ignore(session, library_dir)
+        session.execute(text("DROP TABLE preferences"))
+        session.flush()
+
+    def __migrate_sql_to_ts_ignore(self, session: Session, library_dir: Path):
+        # Do not continue if existing '.ts_ignore' file is found
+        ts_ignore = library_dir / TS_FOLDER_NAME / IGNORE_NAME
+        if Path(ts_ignore).exists():
+            return
+
+        # Load legacy extension data
+        extensions: list[str] = ujson.loads(
+            unwrap(
+                session.scalar(text("SELECT value FROM preferences WHERE key = 'EXTENSION_LIST'"))
+            )
+        )
+        is_exclude_list: bool = unwrap(
+            session.scalar(text("SELECT value FROM preferences WHERE key = 'IS_EXCLUDE_LIST'"))
+        )
+
+        with open(ts_ignore, "w") as f:
+            f.write(migrate_ext_list(extensions, is_exclude_list))
+
+    def __apply_db200_migration(self, session: Session, library_dir: Path):
+        """Migrate DB to DB_VERSION 200."""
+        # Drop unused 'boolean_fields' and 'value_type' tables
+        logger.info("[Library][Migration][200] Dropping boolean_fields and value_type tables...")
+        session.execute(text("DROP TABLE boolean_fields"))
+        session.execute(text("DROP TABLE value_type"))
+
+        # Add 'name' column to text_fields and datetime_fields tables
+        logger.info("[Library][Migration][200] Adding name columns to field tables...")
+        stmt = text('ALTER TABLE text_fields ADD COLUMN name VARCHAR DEFAULT ""')
+        session.execute(stmt)
+        stmt = text('ALTER TABLE datetime_fields ADD COLUMN name VARCHAR DEFAULT ""')
+        session.execute(stmt)
+
+        # Drop unnecessary 'position' columns
+        logger.info("[Library][Migration][200] Dropping position columns to field tables...")
+        session.execute(text("ALTER TABLE datetime_fields DROP COLUMN position"))
+        session.execute(text("ALTER TABLE text_fields DROP COLUMN position"))
+
+        # Add 'is_multiline' column to text_fields table
+        logger.info("[Library][Migration][200] Adding is_multiline column to text_fields...")
+        stmt = text("ALTER TABLE text_fields ADD COLUMN is_multiline BOOLEAN NOT NULL DEFAULT 0")
+        session.execute(stmt)
+        session.flush()
+
+        # Move values from old `type_key` columns into new `name` columns
+        logger.info("[Library][Migration][200] Moving values from type_key columns to name...")
+        session.execute(text("UPDATE text_fields SET name = type_key"))
+        session.execute(text("UPDATE datetime_fields SET name = type_key"))
+        session.flush()
+
+        # Change `name` values to title case
+        logger.info("[Library][Migration][200] Normalizing TextField names...")
+        for text_field in session.execute(select(TextField)).scalars():
+            # NOTE: The only exception to the "Title Case" conversion is the "URL" field.
+            text_field.name = text_field.name.title().replace("Url", "URL").replace("_", " ")
+        logger.info("[Library][Migration][200] Normalizing DatetimeField names...")
+        for datetime_field in session.execute(select(DatetimeField)).scalars():
+            datetime_field.name = datetime_field.name.title().replace("_", " ")
+        session.flush()
+
+        # Add correct `is_multiline` values to text_fields table
+        logger.info("[Library][Migration][200] Updating is_multiline for legacy TEXT_BOXes...")
+        text_boxes = [
+            x.get("name") for x in LEGACY_FIELD_MAP.values() if x.get("is_multiline") is True
+        ]
+        update_stmt = (
+            update(TextField).where(TextField.name.in_(text_boxes)).values(is_multiline=True)
+        )
+        session.execute(update_stmt)
+        session.flush()
+
+        # Repair legacy "Description" fields to use is_multiline = True
+        logger.info("[Library][Migration][200] Repairing legacy Description fields...")
+        desc_stmt = (
+            update(TextField)
+            .where(TextField.name == "Description" and TextField.is_multiline == False)  # noqa: E712
+            .values(is_multiline=True)
+        )
+        session.execute(desc_stmt)
+
+        # Repair legacy "Comments" fields to use is_multiline = True
+        logger.info("[Library][Migration][200] Repairing legacy Comment fields...")
+        comm_stmt = (
+            update(TextField)
+            .where(TextField.name == "Comments" and TextField.is_multiline == False)  # noqa: E712
+            .values(is_multiline=True)
+        )
+        session.execute(comm_stmt)
+
+        # Add default field templates
+        logger.info("[Library][Migration][200] Adding default field templates...")
+        for template in get_default_field_templates():
+            session.add(template)
+        session.flush()
+
+        # DB indices for improved performance
+        session.execute(
+            text("CREATE INDEX IF NOT EXISTS idx_tags_name_shorthand ON tags (name, shorthand)")
+        )
+        session.execute(
+            text("CREATE INDEX IF NOT EXISTS idx_tag_parents_child_id ON tag_parents (child_id)")
+        )
+        session.execute(
+            text("CREATE INDEX IF NOT EXISTS idx_tag_entries_entry_id ON tag_entries (entry_id)")
+        )
+
+    def __apply_db201_migration(self, session: Session, library_dir: Path):
+        """Migrate DB to DB_VERSION 201."""
+        create_text_fields_table = text("""
+        CREATE TABLE text_fields_new (
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            name VARCHAR NOT NULL,
+            entry_id INTEGER NOT NULL,
+            value VARCHAR,
+            is_multiline BOOLEAN NOT NULL,
+            FOREIGN KEY(entry_id) REFERENCES entries (id)
+        )
+        """)
+        create_datetime_fields_table = text("""
+        CREATE TABLE datetime_fields_new (
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            name VARCHAR NOT NULL,
+            entry_id INTEGER NOT NULL,
+            value VARCHAR,
+            FOREIGN KEY(entry_id) REFERENCES entries (id)
+        )
+        """)
+
+        logger.info("[Library][Migration][201] Dropping type_key from text_fields table...")
+        session.execute(create_text_fields_table)
+        session.flush()
+        session.execute(
+            text("""
+                INSERT INTO text_fields_new (id, name, entry_id, value, is_multiline)
+                SELECT id, name, entry_id, value, is_multiline
+                FROM text_fields
+            """)
+        )
+        session.execute(text("DROP TABLE text_fields"))
+        session.execute(text("ALTER TABLE text_fields_new RENAME TO text_fields"))
+
+        logger.info("[Library][Migration][201] Dropping type_key from datetime_fields table...")
+        session.execute(create_datetime_fields_table)
+        session.flush()
+        session.execute(
+            text("""
+                INSERT INTO datetime_fields_new (id, name, entry_id, value)
+                SELECT id, name, entry_id, value
+                FROM datetime_fields
+            """)
+        )
+        session.execute(text("DROP TABLE datetime_fields"))
+        session.execute(text("ALTER TABLE datetime_fields_new RENAME TO datetime_fields"))
+
+        session.flush()
+
+    def __apply_db202_migration(self, session: Session, library_dir: Path):
+        """Migrate DB to DB_VERSION 202."""
+        stmt = delete(TagParent).where(TagParent.child_id.not_in(select(Tag.id).distinct()))
+        session.execute(stmt)
+        session.flush()
+        logger.info("[Library][Migration][202] Verified TagParent table data")
+
+    def __apply_db300_migration(self, session: Session, library_dir: Path):
+        ## remove folder_id column from entries table
+        # create new table in the desired scheme (without folder_id column)
+        session.execute(
+            text("""
+        CREATE TABLE entries_new (
+            id INTEGER NOT NULL,
+            path VARCHAR NOT NULL,
+            suffix VARCHAR NOT NULL,
+            date_created DATETIME,
+            date_modified DATETIME,
+            date_added DATETIME,
+            filename TEXT NOT NULL DEFAULT '',
+            PRIMARY KEY (id),
+            UNIQUE (path)
+        )
+        """)
+        )
+        session.flush()
+        # transfer data to new table
+        session.execute(
+            text("""
+            INSERT INTO entries_new (id, path, suffix, date_created, date_modified, date_added,
+                                     filename)
+            SELECT id, path, suffix, date_created, date_modified, date_added, filename
+            FROM entries
+        """)
+        )
+        # delete old table
+        session.execute(text("DROP TABLE entries"))
+        # rename new table to old table
+        session.execute(text("ALTER TABLE entries_new RENAME TO entries"))
+        session.flush()
+
+        ## drop table "folders"
+        session.execute(text("DROP TABLE folders"))
+        session.flush()
+
     @property
     def field_templates(self) -> Sequence[BaseFieldTemplate]:
         with Session(self.engine) as session:
@@ -669,8 +1061,7 @@ class Library:
         with Session(self.engine) as session:
             return unwrap(session.scalar(select(func.count(Entry.id))))
 
-    @staticmethod
-    def _all_entries(session: Session, with_joins: bool = False) -> Iterator[Entry]:
+    def __all_entries(self, session: Session, with_joins: bool = False) -> Iterator[Entry]:
         """Load entries without joins."""
         stmt = select(Entry)
         if with_joins:
@@ -699,7 +1090,7 @@ class Library:
     def all_entries(self, with_joins: bool = False) -> Iterator[Entry]:
         """Load entries without joins."""
         with Session(self.engine) as session:
-            return Library._all_entries(session, with_joins)
+            return self.__all_entries(session, with_joins)
 
     @property
     def tags(self) -> list[Tag]:
@@ -1337,8 +1728,6 @@ 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()
 
@@ -1447,17 +1836,16 @@ class Library:
                 session.rollback()
                 return None
 
-    @staticmethod
-    def save_library_backup_to_disk(library_dir: Path) -> Path:
-        assert isinstance(library_dir, Path)
-        makedirs(str(library_dir / TS_FOLDER_NAME / BACKUP_FOLDER_NAME), exist_ok=True)
+    def save_library_backup_to_disk(self) -> Path:
+        assert isinstance(self.library_dir, Path)
+        makedirs(str(self.library_dir / TS_FOLDER_NAME / BACKUP_FOLDER_NAME), exist_ok=True)
 
         filename = f"ts_library_backup_{datetime.now(UTC).strftime('%Y_%m_%d_%H%M%S')}.sqlite"
 
-        target_path = library_dir / TS_FOLDER_NAME / BACKUP_FOLDER_NAME / filename
+        target_path = self.library_dir / TS_FOLDER_NAME / BACKUP_FOLDER_NAME / filename
 
         shutil.copy2(
-            library_dir / TS_FOLDER_NAME / SQL_FILENAME,
+            self.library_dir / TS_FOLDER_NAME / SQL_FILENAME,
             target_path,
         )
 
@@ -1749,12 +2137,8 @@ class Library:
         Args:
             key(str): The key for the name of the version type to set.
         """
-        return Library._get_version(self.engine, key)
-
-    @staticmethod
-    def _get_version(engine, key: str) -> int:
-        with Session(engine) as session:
-            engine = sqlalchemy.inspect(engine)
+        with Session(self.engine) as session:
+            engine = sqlalchemy.inspect(self.engine)
             try:
                 # "Version" table added in DB_VERSION 101
                 if engine and engine.has_table("versions"):
@@ -1774,6 +2158,17 @@ class Library:
             except Exception:
                 return 0
 
+    def set_version(self, session: Session, key: str, value: int) -> None:
+        """Set a version value to the DB.
+
+        Args:
+            session(Session): The SQLAlchemy DB Session to use.
+            key(str): The key for the name of the version type to set.
+            value(int): The version value to set.
+        """
+        # Insert if key has no value yet, otherwise update the value
+        session.merge(Version(key=key, value=value))
+
     def mirror_entry_fields(self, entries: list[Entry]) -> None:
         """Mirror fields among multiple Entry items."""
         all_fields: set[BaseField] = set()

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

@@ -1,551 +0,0 @@
-# SPDX-FileCopyrightText: (c) TagStudio Contributors
-# SPDX-License-Identifier: MIT
-
-
-from collections.abc import Callable
-from pathlib import Path
-from typing import override
-
-import structlog
-import ujson
-from sqlalchemy import Engine, and_, delete, select, text, update
-from sqlalchemy.orm import Session
-
-from tagstudio.core.constants import IGNORE_NAME, TAG_ARCHIVED, TS_FOLDER_NAME
-from tagstudio.core.library.alchemy import default_color_groups
-from tagstudio.core.library.alchemy.constants import (
-    DB_VERSION,
-    DB_VERSION_CURRENT_KEY,
-    DB_VERSION_INITIAL_KEY,
-    DEFAULT_FIELD_TEMPLATES,
-)
-from tagstudio.core.library.alchemy.fields import LEGACY_FIELD_MAP, DatetimeField, TextField
-from tagstudio.core.library.alchemy.joins import TagParent
-from tagstudio.core.library.alchemy.models import Tag, TagColorGroup, Version
-from tagstudio.core.library.ignore import migrate_ext_list
-from tagstudio.core.utils.types import unwrap
-from tagstudio.qt.translations import Translations
-
-logger = structlog.get_logger(__name__)
-
-
-class MigrationError(Exception):
-    pass
-
-
-class DBMigration:
-    version: int = None  # pyright: ignore[reportAssignmentType]
-    initial_version: int | None = None
-
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log: Callable[[str], str]):
-        raise NotImplementedError
-
-
-class DBMigrations:
-    def __init__(self, library_dir: Path, engine: Engine) -> None:
-        from tagstudio.core.library.alchemy.library import Library
-
-        self.library_dir = library_dir
-        self.engine = engine
-
-        # Don't check DB version when creating new library
-        self.loaded_db_version = Library._get_version(engine, DB_VERSION_CURRENT_KEY)
-        self.initial_db_version = Library._get_version(engine, DB_VERSION_INITIAL_KEY)
-
-        # ======================== Library Database Version Checking =======================
-        # DB_VERSION 6 is the first supported SQLite DB version.
-        # If the DB_VERSION is >= 100, that means it's a compound major + minor version.
-        #   - Dividing by 100 and flooring gives the major (breaking changes) version.
-        #   - If a DB has major version higher than the current program, don't load it.
-        #   - If only the minor version is higher, it's still allowed to load.
-        if self.loaded_db_version < 6 or (
-            self.loaded_db_version >= 100 and self.loaded_db_version // 100 > DB_VERSION // 100
-        ):
-            mismatch_text = Translations["status.library_version_mismatch"]
-            found_text = Translations["status.library_version_found"]
-            expected_text = Translations["status.library_version_expected"]
-            raise MigrationError(
-                f"{mismatch_text}\n"
-                f"{found_text} v{self.loaded_db_version}, "
-                f"{expected_text} v{DB_VERSION}"
-            )
-
-        logger.info(
-            f"[Library][Migration] Starting with library DB version: {self.loaded_db_version}"
-        )
-
-    @property
-    def required(self) -> bool:
-        return self.loaded_db_version < DB_VERSION
-
-    def run(self):
-
-        # migrate DB step by step from one version to the next
-        # (migration_method, db_version, initial_db_version)
-        migrations: list[type[DBMigration]] = [
-            MigrationTo7,  # changes: value_type, tags
-            MigrationTo8,  # changes: tag_colors
-            MigrationTo9,  # changes: entries
-            MigrationTo100,  # changes: tag_parents
-            MigrationTo101,  # changes: versions
-            MigrationTo102,  # changes: tag_parents
-            MigrationTo103,  # changes: tags
-            MigrationTo104,  # changes: deletes preferences
-            MigrationTo200,  # changes: field tables
-            MigrationTo201,  # changes: field tables
-            MigrationTo202,  # changes: tag_parents
-            MigrationTo300,  # changes: deletes folders
-        ]
-        with Session(self.engine) as session:
-            for migration in migrations:
-                if self.loaded_db_version < migration.version and (
-                    migration.initial_version is None
-                    or self.initial_db_version < migration.initial_version
-                ):
-                    logger.info(f"[Library][Migration][{migration.version}] Starting DB Migration")
-                    # any error causes transaction to rollback
-                    migration.run(
-                        session,
-                        self.library_dir,
-                        lambda msg, v=migration.version: f"[Library][Migration][{v}] {msg}",
-                    )
-                    self.loaded_db_version = migration.version
-                    try:
-                        self.__set_version(session, DB_VERSION_CURRENT_KEY, migration.version)
-                    except Exception as e:
-                        logger.info(
-                            f"[Library][Migration][{migration.version}] "
-                            "Couldn't update version, continuing without commit",
-                            error=e,
-                        )
-                        session.flush()
-                    else:
-                        session.commit()
-                logger.info(f"[Library][Migration][{migration.version}] Completed DB Migration")
-
-        assert self.loaded_db_version >= DB_VERSION, (
-            "Ran all migrations, but the DB is still not on the newest version"
-        )
-        logger.info(f"[Library][Migration] Library migrated to DB version {DB_VERSION}")
-
-    def __set_version(self, session: Session, key: str, value: int) -> None:
-        """Set a version value to the DB.
-
-        Args:
-            session(Session): The SQLAlchemy DB Session to use.
-            key(str): The key for the name of the version type to set.
-            value(int): The version value to set.
-        """
-        # Insert if key has no value yet, otherwise update the value
-        session.merge(Version(key=key, value=value))
-
-
-class MigrationTo7(DBMigration):
-    version = 7
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB from DB_VERSION 6 to 7."""
-        logger.info(fmt_log("Applying patches to DB_VERSION: 6 library..."))
-        # Repair tags that may have a disambiguation_id pointing towards a deleted tag.
-        # TODO: combine into single sql statement
-        all_tag_ids = session.scalars(text("SELECT DISTINCT id FROM tags")).all()
-        disam_stmt = (
-            update(Tag)
-            .where(Tag.disambiguation_id.not_in(all_tag_ids))
-            .values(disambiguation_id=None)
-        )
-        session.execute(disam_stmt)
-        session.flush()
-
-
-class MigrationTo8(DBMigration):
-    version = 8
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB from DB_VERSION 7 to 8."""
-        # Add the missing color_border column to the TagColorGroups table.
-        session.execute(
-            text("ALTER TABLE tag_colors ADD COLUMN color_border BOOLEAN DEFAULT FALSE NOT NULL")
-        )
-        session.flush()
-        logger.info(fmt_log("Added color_border column to tag_colors table"))
-
-        # collect new default tag colors
-        tag_colors: list[TagColorGroup] = [
-            color
-            for color in default_color_groups.shades()
-            if color.slug in ["burgundy", "dark-teal", "dark_lavender"]
-        ]
-
-        # Add any new default colors introduced in DB_VERSION 8
-        for color in tag_colors:
-            session.add(color)
-        session.flush()
-        logger.info(
-            fmt_log("Migrated tag colors to DB_VERSION 8+"),
-            color_name=tag_colors,
-        )
-
-        # Update Neon colors to use the the color_border property
-        for color in default_color_groups.neon():
-            neon_stmt = (
-                update(TagColorGroup)
-                .where(
-                    and_(
-                        TagColorGroup.namespace == color.namespace,
-                        TagColorGroup.slug == color.slug,
-                    )
-                )
-                .values(
-                    slug=color.slug,
-                    namespace=color.namespace,
-                    name=color.name,
-                    primary=color.primary,
-                    secondary=color.secondary,
-                    color_border=color.color_border,
-                )
-            )
-            session.execute(neon_stmt)
-        session.flush()
-
-
-class MigrationTo9(DBMigration):
-    version = 9
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB from DB_VERSION 8 to 9."""
-        # Apply database schema changes
-        add_filename_column = text(
-            "ALTER TABLE entries ADD COLUMN filename TEXT NOT NULL DEFAULT ''"
-        )
-        session.execute(add_filename_column)
-        session.flush()
-        logger.info(fmt_log("Added filename column to entries table"))
-
-        # Populate the new filename column.
-        from tagstudio.core.library.alchemy.library import Library
-
-        for entry in Library._all_entries(session):
-            entry.filename = entry.path.name
-            session.merge(entry)
-        session.flush()
-        logger.info(fmt_log("Populated filename column in entries table"))
-
-
-class MigrationTo100(DBMigration):
-    version = 100
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB to DB_VERSION 100."""
-        # Repair parent-child tag relationships that are the wrong way around.
-        stmt = update(TagParent).values(
-            parent_id=TagParent.child_id,
-            child_id=TagParent.parent_id,
-        )
-        session.execute(stmt)
-        session.flush()
-        logger.info(fmt_log("Refactored TagParent table"))
-
-
-class MigrationTo101(DBMigration):
-    version = 101
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB to DB_VERSION 101."""
-        # Create versions table
-        session.execute(
-            text("""
-        CREATE TABLE versions (
-            "key" VARCHAR NOT NULL PRIMARY KEY,
-            value INTEGER NOT NULL
-        )
-        """)
-        )
-        session.flush()
-        # Ensure version rows are present
-        session.add(Version(key=DB_VERSION_INITIAL_KEY, value=100))
-        session.flush()
-        logger.info(fmt_log("Created versions table"))
-
-
-class MigrationTo102(DBMigration):
-    version = 102
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB to DB_VERSION 102."""
-        # delete TagParents with a dangling parent reference
-        stmt = delete(TagParent).where(TagParent.parent_id.not_in(select(Tag.id).distinct()))
-        session.execute(stmt)
-        session.flush()
-        logger.info(fmt_log("Verified TagParent table data"))
-
-
-class MigrationTo103(DBMigration):
-    version = 103
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB from DB_VERSION 102 to 103."""
-        # add the new hidden column for tags
-        session.execute(text("ALTER TABLE tags ADD COLUMN is_hidden BOOLEAN NOT NULL DEFAULT 0"))
-        session.flush()
-        logger.info(fmt_log("Added is_hidden column to tags table"))
-
-        # mark the "Archived" tag as hidden
-        session.query(Tag).filter(Tag.id == TAG_ARCHIVED).update({"is_hidden": True})
-        session.flush()
-        logger.info(fmt_log("Updated archived tag to be hidden"))
-
-
-class MigrationTo104(DBMigration):
-    version = 104
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB from DB_VERSION 103 to 104."""
-        # Convert file extension list to ts_ignore file, if a .ts_ignore file does not exist
-        cls.__migrate_sql_to_ts_ignore(session, library_dir)
-        session.execute(text("DROP TABLE preferences"))
-        session.flush()
-
-    @classmethod
-    def __migrate_sql_to_ts_ignore(cls, session: Session, library_dir: Path):
-        # Do not continue if existing '.ts_ignore' file is found
-        ts_ignore = library_dir / TS_FOLDER_NAME / IGNORE_NAME
-        if Path(ts_ignore).exists():
-            return
-
-        # Load legacy extension data
-        extensions: list[str] = ujson.loads(
-            unwrap(
-                session.scalar(text("SELECT value FROM preferences WHERE key = 'EXTENSION_LIST'"))
-            )
-        )
-        is_exclude_list: bool = unwrap(
-            session.scalar(text("SELECT value FROM preferences WHERE key = 'IS_EXCLUDE_LIST'"))
-        )
-
-        with open(ts_ignore, "w") as f:
-            f.write(migrate_ext_list(extensions, is_exclude_list))
-
-
-class MigrationTo200(DBMigration):
-    version = 200
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB to DB_VERSION 200."""
-        # Drop unused 'boolean_fields' and 'value_type' tables
-        logger.info(fmt_log("Dropping boolean_fields and value_type tables..."))
-        session.execute(text("DROP TABLE boolean_fields"))
-        session.execute(text("DROP TABLE value_type"))
-
-        # Add 'name' column to text_fields and datetime_fields tables
-        logger.info(fmt_log("Adding name columns to field tables..."))
-        stmt = text('ALTER TABLE text_fields ADD COLUMN name VARCHAR DEFAULT ""')
-        session.execute(stmt)
-        stmt = text('ALTER TABLE datetime_fields ADD COLUMN name VARCHAR DEFAULT ""')
-        session.execute(stmt)
-
-        # Drop unnecessary 'position' columns
-        logger.info(fmt_log("Dropping position columns to field tables..."))
-        session.execute(text("ALTER TABLE datetime_fields DROP COLUMN position"))
-        session.execute(text("ALTER TABLE text_fields DROP COLUMN position"))
-
-        # Add 'is_multiline' column to text_fields table
-        logger.info(fmt_log("Adding is_multiline column to text_fields..."))
-        stmt = text("ALTER TABLE text_fields ADD COLUMN is_multiline BOOLEAN NOT NULL DEFAULT 0")
-        session.execute(stmt)
-        session.flush()
-
-        # Move values from old `type_key` columns into new `name` columns
-        logger.info(fmt_log("Moving values from type_key columns to name..."))
-        session.execute(text("UPDATE text_fields SET name = type_key"))
-        session.execute(text("UPDATE datetime_fields SET name = type_key"))
-        session.flush()
-
-        # Change `name` values to title case
-        logger.info(fmt_log("Normalizing TextField names..."))
-        for text_field in session.execute(select(TextField)).scalars():
-            # NOTE: The only exception to the "Title Case" conversion is the "URL" field.
-            text_field.name = text_field.name.title().replace("Url", "URL").replace("_", " ")
-        logger.info(fmt_log("Normalizing DatetimeField names..."))
-        for datetime_field in session.execute(select(DatetimeField)).scalars():
-            datetime_field.name = datetime_field.name.title().replace("_", " ")
-        session.flush()
-
-        # Add correct `is_multiline` values to text_fields table
-        logger.info(fmt_log("Updating is_multiline for legacy TEXT_BOXes..."))
-        text_boxes = [
-            x.get("name") for x in LEGACY_FIELD_MAP.values() if x.get("is_multiline") is True
-        ]
-        update_stmt = (
-            update(TextField).where(TextField.name.in_(text_boxes)).values(is_multiline=True)
-        )
-        session.execute(update_stmt)
-        session.flush()
-
-        # Repair legacy "Description" fields to use is_multiline = True
-        logger.info(fmt_log("Repairing legacy Description fields..."))
-        desc_stmt = (
-            update(TextField)
-            .where(TextField.name == "Description" and TextField.is_multiline == False)  # noqa: E712
-            .values(is_multiline=True)
-        )
-        session.execute(desc_stmt)
-
-        # Repair legacy "Comments" fields to use is_multiline = True
-        logger.info(fmt_log("Repairing legacy Comment fields..."))
-        comm_stmt = (
-            update(TextField)
-            .where(TextField.name == "Comments" and TextField.is_multiline == False)  # noqa: E712
-            .values(is_multiline=True)
-        )
-        session.execute(comm_stmt)
-
-        # Add default field templates
-        logger.info(fmt_log("Adding default field templates..."))
-        for template in DEFAULT_FIELD_TEMPLATES:
-            session.add(template)
-        session.flush()
-
-        # DB indices for improved performance
-        session.execute(
-            text("CREATE INDEX IF NOT EXISTS idx_tags_name_shorthand ON tags (name, shorthand)")
-        )
-        session.execute(
-            text("CREATE INDEX IF NOT EXISTS idx_tag_parents_child_id ON tag_parents (child_id)")
-        )
-        session.execute(
-            text("CREATE INDEX IF NOT EXISTS idx_tag_entries_entry_id ON tag_entries (entry_id)")
-        )
-
-
-class MigrationTo201(DBMigration):
-    version = 201
-    initial_version = 200
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB to DB_VERSION 201."""
-        create_text_fields_table = text("""
-        CREATE TABLE text_fields_new (
-            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-            name VARCHAR NOT NULL,
-            entry_id INTEGER NOT NULL,
-            value VARCHAR,
-            is_multiline BOOLEAN NOT NULL,
-            FOREIGN KEY(entry_id) REFERENCES entries (id)
-        )
-        """)
-        create_datetime_fields_table = text("""
-        CREATE TABLE datetime_fields_new (
-            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-            name VARCHAR NOT NULL,
-            entry_id INTEGER NOT NULL,
-            value VARCHAR,
-            FOREIGN KEY(entry_id) REFERENCES entries (id)
-        )
-        """)
-
-        logger.info(fmt_log("Dropping type_key from text_fields table..."))
-        session.execute(create_text_fields_table)
-        session.flush()
-        session.execute(
-            text("""
-                INSERT INTO text_fields_new (id, name, entry_id, value, is_multiline)
-                SELECT id, name, entry_id, value, is_multiline
-                FROM text_fields
-            """)
-        )
-        session.execute(text("DROP TABLE text_fields"))
-        session.execute(text("ALTER TABLE text_fields_new RENAME TO text_fields"))
-
-        logger.info(fmt_log("Dropping type_key from datetime_fields table..."))
-        session.execute(create_datetime_fields_table)
-        session.flush()
-        session.execute(
-            text("""
-                INSERT INTO datetime_fields_new (id, name, entry_id, value)
-                SELECT id, name, entry_id, value
-                FROM datetime_fields
-            """)
-        )
-        session.execute(text("DROP TABLE datetime_fields"))
-        session.execute(text("ALTER TABLE datetime_fields_new RENAME TO datetime_fields"))
-
-        session.flush()
-
-
-class MigrationTo202(DBMigration):
-    version = 202
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        """Migrate DB to DB_VERSION 202."""
-        stmt = delete(TagParent).where(TagParent.child_id.not_in(select(Tag.id).distinct()))
-        session.execute(stmt)
-        session.flush()
-        logger.info(fmt_log("Verified TagParent table data"))
-
-
-class MigrationTo300(DBMigration):
-    version = 300
-
-    @override
-    @classmethod
-    def run(cls, session: Session, library_dir: Path, fmt_log):
-        ## remove folder_id column from entries table
-        # create new table in the desired scheme (without folder_id column)
-        session.execute(
-            text("""
-        CREATE TABLE entries_new (
-            id INTEGER NOT NULL,
-            path VARCHAR NOT NULL,
-            suffix VARCHAR NOT NULL,
-            date_created DATETIME,
-            date_modified DATETIME,
-            date_added DATETIME,
-            filename TEXT NOT NULL DEFAULT '',
-            PRIMARY KEY (id),
-            UNIQUE (path)
-        )
-        """)
-        )
-        session.flush()
-        # transfer data to new table
-        session.execute(
-            text("""
-            INSERT INTO entries_new (id, path, suffix, date_created, date_modified, date_added,
-                                     filename)
-            SELECT id, path, suffix, date_created, date_modified, date_added, filename
-            FROM entries
-        """)
-        )
-        # delete old table
-        session.execute(text("DROP TABLE entries"))
-        # rename new table to old table
-        session.execute(text("ALTER TABLE entries_new RENAME TO entries"))
-        session.flush()
-
-        ## drop table "folders"
-        session.execute(text("DROP TABLE folders"))
-        session.flush()

src/tagstudio/qt/ts_qt.py

@@ -837,7 +837,7 @@ class QtDriver(DriverMixin, QObject):
         logger.info("Backing Up Library...")
         self.main_window.status_bar.showMessage(Translations["status.library_backup_in_progress"])
         start_time = time.time()
-        target_path = Library.save_library_backup_to_disk(unwrap(self.lib.library_dir))
+        target_path = self.lib.save_library_backup_to_disk()
         end_time = time.time()
         self.main_window.status_bar.showMessage(
             Translations.format(

src/tagstudio/resources/translations/es.json

@@ -1,5 +1,5 @@
 {
-    "about.app_cache_path": "Ruta caché aplicación",
+    "about.app_cache_path": "Ruta de la Caché de la Aplicación",
     "about.config_path": "Ruta de Configuración",
     "about.description": "TagStudio es una aplicación para organizar fotografías y archivos que utiliza un sistema de etiquetas subyacentes centrado en dar libertad y flexibilidad al usuario. Sin programas ni formatos propios, ni un mar de archivos y sin trastornar completamente la estructura de tu sistema de archivos.",
     "about.documentation": "Documentación",
@@ -8,14 +8,14 @@
     "about.title": "Acerca de TagStudio",
     "about.version": "Versión",
     "about.version.latest": "{built_version} (Última versión: {latest_version})",
-    "about.website": "Página web",
+    "about.website": "Página Web",
     "app.git": "Commit de Git",
     "app.pre_release": "Pre-Lanzamiento",
     "app.title": "{base_title} - Biblioteca '{library_dir}'",
-    "color.color_border": "Usar color secundario para el Borde",
+    "color.color_border": "Usar Color Secundario para Borde",
     "color.confirm_delete": "¿Estás seguro de que quieres eliminar el color \"{color_name}\"?",
     "color.delete": "Eliminar Etiqueta",
-    "color.import_pack": "Importar paquete de colores",
+    "color.import_pack": "Importar Paquete de Colores",
     "color.name": "Nombre",
     "color.namespace.delete.prompt": "¿Estás seguro de que quieres eliminar el espacio de nombres de este color? ¡Esto eliminará todos los colores en el espacio de nombres junto con él!",
     "color.namespace.delete.title": "Eliminar el espacio de nombres de color",
@@ -25,7 +25,7 @@
     "color.primary_required": "Color primario (Obligatorio)",
     "color.secondary": "Color secundario",
     "color.title.no_color": "Sin color",
-    "color_manager.title": "Administrar los colores de las etiquetas",
+    "color_manager.title": "Administrar Colores de Etiquetas",
     "dependency.missing.title": "{dependency} no encontrada",
     "drop_import.description": "Los siguientes archivos igualan con las rutas de archivos que ya existen en la biblioteca",
     "drop_import.duplicates_choice.plural": "Los siguientes {count} archivos igualan con las rutas de archivos que ya existen en la biblioteca.",
@@ -227,12 +227,12 @@
     "language.tr": "Turco",
     "language.zh_Hans": "Chino (simplificado)",
     "language.zh_Hant": "Chino (tradicional)",
-    "library.missing": "Falta la ubicación",
+    "library.missing": "Falta la Ubicación de la Biblioteca",
     "library.name": "Biblioteca",
     "library.refresh.scanning.plural": "Escaneando directorios en busca de nuevos archivos...\n{searched_count} archivos buscados, {found_count} nuevos archivos encontrados",
     "library.refresh.scanning.singular": "Escaneando directorios en busca de nuevos archivos...\n{searched_count} Archivos buscados, {found_count} Nuevos archivos encontrados",
-    "library.refresh.scanning_preparing": "Buscar archivos nuevos en los directorios...\nPreparando...",
-    "library.refresh.title": "Refrescar directorios",
+    "library.refresh.scanning_preparing": "Buscando archivos nuevos en los directorios...\nPreparando...",
+    "library.refresh.title": "Refrescando directorios",
     "library.scan_library.title": "Escaneando la biblioteca",
     "library_info.cleanup": "Limpieza",
     "library_info.cleanup.backups": "Reespaldos de la Librería:",
@@ -387,7 +387,7 @@
     "tag.is_category": "Es categoría",
     "tag.is_hidden": "Está oculto",
     "tag.name": "Nombre",
-    "tag.new": "Nueva etiqueta",
+    "tag.new": "Nueva Etiqueta",
     "tag.parent_tags": "Etiquetas principales",
     "tag.parent_tags.add": "Añadir etiquetas principales",
     "tag.parent_tags.description": "Esta etiqueta se puede tratar como sustituto de cualquiera de las etiquetas padre en las búsquedas.",
@@ -417,7 +417,7 @@
     "view.size.1": "Pequeño",
     "view.size.2": "Medio",
     "view.size.3": "Grande",
-    "view.size.4": "Extra grande",
+    "view.size.4": "Extra Grande",
     "window.message.error_opening_library": "Error abriendo la biblioteca.",
     "window.title.error": "Error",
     "window.title.open_create_library": "Abrir/Crear biblioteca"

src/tagstudio/resources/translations/fr.json

@@ -4,6 +4,7 @@
     "about.description": "TagStudio est une application d'organisation de photos et de fichiers avec un système de tags qui met en avant la liberté et flexibilité à l'utilisateur. Pas de programmes ou de formats propriétaires, pas la moindre trace de fichiers secondaires, et pas de bouleversement complet de la structure de votre système de fichiers.",
     "about.documentation": "Documentation",
     "about.module.found": "Trouvé",
+    "about.modules.title": "Modules optionnels",
     "about.title": "À propos de TagStudio",
     "about.version": "Version",
     "about.version.latest": "{built_version} (Dernière version : {latest_version})",
@@ -196,6 +197,36 @@
     "json_migration.title.new_lib": "<h2>Bibliothèque v9.5+</h2>",
     "json_migration.title.old_lib": "<h2>Bibliothèque v9.4</h2>",
     "landing.open_create_library": "Ouvrir/Créer une Bibliothèque {shortcut}",
+    "language.am": "Amharic",
+    "language.ceb": "Cébuano",
+    "language.cs": "Tchèque",
+    "language.da": "Danois",
+    "language.de": "Allemand",
+    "language.el": "Grec",
+    "language.en": "Anglais",
+    "language.es": "Espagnol",
+    "language.fi": "Finnois",
+    "language.fil": "Philippin",
+    "language.fr": "Français",
+    "language.hu": "Hongrois",
+    "language.is": "Islandais",
+    "language.it": "Italien",
+    "language.ja": "Japonais",
+    "language.nb_NO": "Norvégien (Bokmål)",
+    "language.nl": "Néerlandais",
+    "language.pl": "Polonais",
+    "language.pt": "Portugais",
+    "language.pt_BR": "Portugais (Brésil)",
+    "language.qpv": "Viossa",
+    "language.ro": "Roumain",
+    "language.ru": "Russe",
+    "language.sv": "Suédois",
+    "language.ta": "Tamil",
+    "language.th": "Thaï",
+    "language.tok": "Toki Pona",
+    "language.tr": "Turc",
+    "language.zh_Hans": "Chinois (Simplifier)",
+    "language.zh_Hant": "Chinois (Traditionnelle)",
     "library.missing": "Emplacement Manquant",
     "library.name": "Bibliothèque",
     "library.refresh.scanning.plural": "Analyse du Répertoire pour de Nouveaux Fichiers...\n{searched_count} Fichiers Trouvées, {found_count} Nouveaux Fichiers",
@@ -277,6 +308,8 @@
     "select.all": "Tout Sélectionner",
     "select.clear": "Effacer la Sélection",
     "select.inverse": "Inverser la Sélection",
+    "settings.appearance": "Apparence",
+    "settings.cached_thumb_resolution.label": "Résolution des vignettes mises en cache",
     "settings.clear_thumb_cache.title": "Effacer le cache des vignettes",
     "settings.dateformat.english": "Anglais",
     "settings.dateformat.international": "International",
@@ -292,6 +325,8 @@
     "settings.infinite_scroll": "Défilement continu",
     "settings.language": "Langage",
     "settings.library": "Paramètres de la Bibliothèque",
+    "settings.localization": "Localisation",
+    "settings.media": "Médias",
     "settings.open_library_on_start": "Ouvrir la Bibliothèque au Démarrage",
     "settings.page_size": "Entités par page",
     "settings.restart_required": "Veuillez redémarré TagStudio pour que les changements prenne effet.",

src/tagstudio/resources/translations/hu.json

@@ -10,6 +10,7 @@
     "about.version.latest": "{built_version} (legújabb kiadás: {latest_version})",
     "about.website": "Honlap",
     "app.git": "Git-véglegesítés",
+    "app.nightly": "Napi",
     "app.pre_release": "Kísérleti verzió",
     "app.title": "{base_title} – Könyvtár: „{library_dir}”",
     "color.color_border": "Másodlagos szín használata keretszínként",

src/tagstudio/resources/translations/zh_Hans.json

@@ -1,9 +1,11 @@
 {
+    "about.app_cache_path": "TagStudio缓存路径",
     "about.config_path": "配置路径",
     "about.description": "TagStudio是一款照片和文件组织应用程序，采用基于标签的系统，旨在为用户提供自由和灵活性。该应用程序不使用专有程序或格式，不会产生大量的辅助文件，也不会对您的文件系统结构造成彻底的颠覆。",
     "about.documentation": "文档",
     "about.module.found": "存在",
     "about.title": "关于 TagStudio",
+    "about.version": "版本",
     "about.website": "网站",
     "app.git": "Git 提交更新",
     "app.pre_release": "预发布版本",