feat: add settings menu

Author: python357-1

.python-version

@@ -0,0 +1 @@
+3.12.8

requirements.txt

@@ -14,6 +14,9 @@ PySide6==6.8.0.1
 rawpy==0.22.0
 SQLAlchemy==2.0.34
 structlog==24.4.0
-typing_extensions>=3.10.0.0,<=4.11.0
+typing_extensions
 ujson>=5.8.0,<=5.9.0
-vtf2img==0.1.0
+vtf2img==0.1.0
+toml==0.10.2
+appdirs==1.4.4
+pydantic==2.10.4

tagstudio/src/core/driver.py

@@ -1,16 +1,17 @@
 from pathlib import Path
 
 import structlog
-from PySide6.QtCore import QSettings
 from src.core.constants import TS_FOLDER_NAME
-from src.core.enums import SettingItems
 from src.core.library.alchemy.library import LibraryStatus
+from src.core.settings import TSSettings
+from src.core.tscacheddata import TSCachedData
 
 logger = structlog.get_logger(__name__)
 
 
 class DriverMixin:
-    settings: QSettings
+    settings: TSSettings
+    cache: TSCachedData
 
     def evaluate_path(self, open_path: str | None) -> LibraryStatus:
         """Check if the path of library is valid."""
@@ -20,17 +21,15 @@ def evaluate_path(self, open_path: str | None) -> LibraryStatus:
             if not library_path.exists():
                 logger.error("Path does not exist.", open_path=open_path)
                 return LibraryStatus(success=False, message="Path does not exist.")
-        elif self.settings.value(
-            SettingItems.START_LOAD_LAST, defaultValue=True, type=bool
-        ) and self.settings.value(SettingItems.LAST_LIBRARY):
-            library_path = Path(str(self.settings.value(SettingItems.LAST_LIBRARY)))
+        elif self.settings.open_last_loaded_on_startup and self.cache.last_library:
+            library_path = Path(str(self.cache.last_library))
             if not (library_path / TS_FOLDER_NAME).exists():
                 logger.error(
                     "TagStudio folder does not exist.",
                     library_path=library_path,
                     ts_folder=TS_FOLDER_NAME,
                 )
-                self.settings.setValue(SettingItems.LAST_LIBRARY, "")
+                self.cache.last_library = ""
                 # dont consider this a fatal error, just skip opening the library
                 library_path = None
 

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

@@ -53,6 +53,7 @@
     TS_FOLDER_NAME,
 )
 from ...enums import LibraryPrefs
+from ...settings import LibSettings
 from .db import make_tables
 from .enums import MAX_SQL_VARIABLES, FieldTypeEnum, FilterState, SortingModeEnum, TagColor
 from .fields import (
@@ -159,6 +160,7 @@ class Library:
     engine: Engine | None
     folder: Folder | None
     included_files: set[Path] = set()
+    settings: LibSettings | None = None
 
     SQL_FILENAME: str = "ts_library.sqlite"
     JSON_FILENAME: str = "ts_library.json"
@@ -238,8 +240,8 @@ def migrate_json_to_sqlite(self, json_lib: JsonLibrary):
                         )
 
         # Preferences
-        self.set_prefs(LibraryPrefs.EXTENSION_LIST, [x.strip(".") for x in json_lib.ext_list])
-        self.set_prefs(LibraryPrefs.IS_EXCLUDE_LIST, json_lib.is_exclude_list)
+        self.settings.extension_list = [x.strip(".") for x in json_lib.ext_list]
+        self.settings.is_exclude_list = json_lib.is_exclude_list
 
         end_time = time.time()
         logger.info(f"Library Converted! ({format_timespan(end_time-start_time)})")
@@ -258,6 +260,9 @@ def open_library(self, library_dir: Path, storage_path: str | None = None) -> Li
             return self.open_sqlite_library(library_dir, is_new)
         else:
             self.storage_path = library_dir / TS_FOLDER_NAME / self.SQL_FILENAME
+            settings_path = library_dir / TS_FOLDER_NAME / "libsettings.toml"
+
+            self.settings = LibSettings.open(settings_path)
 
             if self.verify_ts_folder(library_dir) and (is_new := not self.storage_path.exists()):
                 json_path = library_dir / TS_FOLDER_NAME / self.JSON_FILENAME
@@ -587,10 +592,9 @@ def search_library(
                     f"SQL Expression Builder finished ({format_timespan(end_time - start_time)})"
                 )
 
-            extensions = self.prefs(LibraryPrefs.EXTENSION_LIST)
-            is_exclude_list = self.prefs(LibraryPrefs.IS_EXCLUDE_LIST)
+            extensions = self.settings.extension_list
 
-            if extensions and is_exclude_list:
+            if extensions and self.settings.is_exclude_list:
                 statement = statement.where(Entry.suffix.notin_(extensions))
             elif extensions:
                 statement = statement.where(Entry.suffix.in_(extensions))

tagstudio/src/core/settings/__init__.py

@@ -0,0 +1,4 @@
+from .libsettings import LibSettings
+from .tssettings import TSSettings
+
+__all__ = ["TSSettings", "LibSettings"]

tagstudio/src/core/settings/libsettings.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+import structlog
+import toml
+from pydantic import BaseModel, Field
+
+logger = structlog.get_logger(__name__)
+
+
+class LibSettings(BaseModel):
+    is_exclude_list: bool = Field(default=True)
+    extension_list: list[str] = Field(default=[".json", ".xmp", ".aae"])
+    page_size: int = Field(default=500)
+    db_version: int = Field(default=2)
+    filename: str = Field(default="")
+
+    @staticmethod
+    def open(path_value: Path | str) -> "LibSettings":
+        path: Path = Path(path_value) if not isinstance(path_value, Path) else path_value
+
+        if path.exists():
+            with open(path) as settings_file:
+                filecontents = settings_file.read()
+                if len(filecontents.strip()) != 0:
+                    settings_data = toml.loads(filecontents)
+                    settings_data["filename"] = str(path)
+                    return LibSettings(**settings_data)
+
+        # either settings file did not exist or was empty - either way, use default settings
+        settings = LibSettings(**dict(filename=str(path)))
+        return settings
+
+    def save(self):
+        if not (parent_path := Path(self.filename).parent).exists():
+            parent_path.mkdir()
+
+        with open(self.filename, "w") as settings_file:
+            toml.dump(dict(self), settings_file)

tagstudio/src/core/settings/tssettings.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+import toml
+from pydantic import BaseModel, Field
+
+
+# NOTE: pydantic also has a BaseSettings class (from pydantic-settings) that allows any settings
+# properties to be overwritten with environment variables. as tagstudio is not currently using
+# environment variables, i did not base it on that, but that may be useful in the future.
+class TSSettings(BaseModel):
+    dark_mode: bool = Field(default=False)
+    language: str = Field(default="en")
+
+    # settings from the old SettingItem enum
+    open_last_loaded_on_startup: bool = Field(default=False)
+    show_library_list: bool = Field(default=True)
+    autoplay: bool = Field(default=False)
+    show_filenames_in_grid: bool = Field(default=False)
+
+    filename: str = Field()
+
+    @staticmethod
+    def read_settings(path: Path | str) -> "TSSettings":
+        path_value = Path(path)
+        if path_value.exists():
+            with open(path) as file:
+                filecontents = file.read()
+                if len(filecontents.strip()) != 0:
+                    settings_data = toml.loads(filecontents)
+                    settings = TSSettings(**settings_data)
+                    return settings
+
+        return TSSettings(**dict(filename=str(path)))
+
+    def save(self, path: Path | str | None = None) -> None:
+        path_value: Path = Path(path) if isinstance(path, str) else Path(self.filename)
+
+        if not path_value.parent.exists():
+            path_value.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(path_value, "w") as f:
+            toml.dump(dict(self), f)

tagstudio/src/core/tscacheddata.py

@@ -0,0 +1,53 @@
+from datetime import datetime
+from pathlib import Path
+
+import structlog
+import toml
+from appdirs import user_cache_dir
+from pydantic import BaseModel, ConfigDict, Field
+
+logger = structlog.get_logger(__name__)
+
+cache_dir = Path(user_cache_dir()) / "TagStudio"
+cache_location = cache_dir / "cache.toml"
+
+
+class TSCachedData(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    last_library: str | None = Field(default=None)
+    # a dict of ISO formatted date strings -> paths
+    library_history: dict[str, str] = Field(default_factory=dict[datetime, str])
+
+    path: str = Field()
+
+    @staticmethod
+    def open(path_value: Path | str | None = None) -> "TSCachedData":
+        path: Path | None = None
+        default_cache_location = Path(user_cache_dir()) / "ts_cache.toml"
+        if isinstance(path_value, str):
+            path = Path(path_value)
+        elif isinstance(path_value, Path):
+            path = path_value
+        else:
+            logger.info(
+                "no cache location was specified, using ",
+                default_cache_location=default_cache_location,
+            )
+            path = default_cache_location
+
+        if path.exists():
+            with open(path) as cache_file:
+                filecontents = cache_file.read()
+                if len(filecontents.strip()) != 0:
+                    cache_data = toml.loads(filecontents)
+                    cache_data["path"] = str(path)
+                    logger.info("opening cache file at ", cache_location=path)
+                    return TSCachedData(**cache_data)
+
+        return TSCachedData(**dict(path=str(default_cache_location)))
+
+    def save(self):
+        with open(self.path, "w") as f:
+            file_data = dict(self)
+            file_data.pop("path")
+            toml.dump(file_data, f)

tagstudio/src/qt/modals/file_extension.py

@@ -16,7 +16,6 @@
     QVBoxLayout,
     QWidget,
 )
-from src.core.enums import LibraryPrefs
 from src.core.library import Library
 from src.qt.translations import Translations
 from src.qt.widgets.panel import PanelWidget
@@ -43,7 +42,7 @@ def __init__(self, library: "Library"):
         self.root_layout.setContentsMargins(6, 6, 6, 6)
 
         # Create Table Widget --------------------------------------------------
-        self.table = QTableWidget(len(self.lib.prefs(LibraryPrefs.EXTENSION_LIST)), 1)
+        self.table = QTableWidget(len(self.lib.settings.extension_list), 1)
         self.table.horizontalHeader().setVisible(False)
         self.table.verticalHeader().setVisible(False)
         self.table.horizontalHeader().setStretchLastSection(True)
@@ -74,7 +73,7 @@ def __init__(self, library: "Library"):
             lambda text: self.mode_combobox.setItemText(1, text), "ignore_list.mode.exclude"
         )
 
-        is_exclude_list = int(bool(self.lib.prefs(LibraryPrefs.IS_EXCLUDE_LIST)))
+        is_exclude_list = int(bool(self.lib.settings.is_exclude_list))
 
         self.mode_combobox.setCurrentIndex(is_exclude_list)
         self.mode_combobox.currentIndexChanged.connect(lambda i: self.update_list_mode(i))
@@ -97,10 +96,10 @@ def update_list_mode(self, mode: int):
             mode (int): The list mode, given by the index of the mode inside
                 the mode combobox. 1 for "Exclude", 0 for "Include".
         """
-        self.lib.set_prefs(LibraryPrefs.IS_EXCLUDE_LIST, bool(mode))
+        self.lib.settings.is_exclude_list = bool(mode)
 
     def refresh_list(self):
-        for i, ext in enumerate(self.lib.prefs(LibraryPrefs.EXTENSION_LIST)):
+        for i, ext in enumerate(self.lib.settings.extension_list):
             self.table.setItem(i, 0, QTableWidgetItem(ext))
 
     def add_item(self):
@@ -114,4 +113,4 @@ def save(self):
                 extensions.append(ext.text().strip().lstrip(".").lower())
 
         # save preference
-        self.lib.set_prefs(LibraryPrefs.EXTENSION_LIST, extensions)
+        self.lib.settings.extension_list = extensions

tagstudio/src/qt/modals/settings_modal.py

@@ -0,0 +1,73 @@
+import copy
+from pathlib import Path
+from typing import Any
+
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QHBoxLayout,
+    QLabel,
+    QVBoxLayout,
+)
+from src.core.settings import TSSettings
+from src.qt.widgets.panel import PanelWidget
+
+
+class SettingsModal(PanelWidget):
+    def __init__(self, settings: TSSettings):
+        super().__init__()
+        self.tempSettings: TSSettings = copy.deepcopy(settings)
+
+        self.main = QVBoxLayout(self)
+
+        # ---
+        self.language_Label = QLabel()
+        self.language_Value = QComboBox()
+        self.language_Row = QHBoxLayout()
+        self.language_Row.addWidget(self.language_Label)
+        self.language_Row.addWidget(self.language_Value)
+
+        self.language_Label.setText("Language")
+        translations_folder = Path("tagstudio/resources/translations")
+        language_list = [x.stem for x in translations_folder.glob("*.json")]
+        self.language_Value.addItems(language_list)
+        self.language_Value.setCurrentIndex(language_list.index(self.tempSettings.language))
+        self.language_Value.currentTextChanged.connect(
+            lambda text: setattr(self.tempSettings, "language", text)
+        )
+
+        # ---
+        self.show_library_list_Label = QLabel()
+        self.show_library_list_Value = QCheckBox()
+        self.show_library_list_Row = QHBoxLayout()
+        self.show_library_list_Row.addWidget(self.show_library_list_Label)
+        self.show_library_list_Row.addWidget(self.show_library_list_Value)
+        self.show_library_list_Label.setText("Load library list on startup (requires restart):")
+        self.show_library_list_Value.setChecked(self.tempSettings.show_library_list)
+
+        self.show_library_list_Value.stateChanged.connect(
+            lambda state: setattr(self.tempSettings, "show_library_list", bool(state))
+        )
+
+        # ---
+        self.show_filenames_Label = QLabel()
+        self.show_filenames_Value = QCheckBox()
+        self.show_filenames_Row = QHBoxLayout()
+        self.show_filenames_Row.addWidget(self.show_filenames_Label)
+        self.show_filenames_Row.addWidget(self.show_filenames_Value)
+        self.show_filenames_Label.setText("Show filenames in grid (requires restart)")
+        self.show_filenames_Value.setChecked(self.tempSettings.show_filenames_in_grid)
+
+        self.show_filenames_Value.stateChanged.connect(
+            lambda state: setattr(self.tempSettings, "show_filenames_in_grid", bool(state))
+        )
+        # ---
+        self.main.addLayout(self.language_Row)
+        self.main.addLayout(self.show_library_list_Row)
+        self.main.addLayout(self.show_filenames_Row)
+
+    def set_property(self, prop_name: str, value: Any) -> None:
+        setattr(self.tempSettings, prop_name, value)
+
+    def get_content(self):
+        return self.tempSettings