fix: remove folder param from all uses of Entry constructor

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

@@ -9,7 +9,7 @@ JSON_FILENAME: str = "ts_library.json"
 
 DB_VERSION_CURRENT_KEY: str = "CURRENT"
 DB_VERSION_INITIAL_KEY: str = "INITIAL"
-DB_VERSION: int = 202
+DB_VERSION: int = 203
 
 TAG_CHILDREN_QUERY = text("""
 WITH RECURSIVE ChildTags AS (

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

@@ -18,7 +18,6 @@ from datetime import UTC, datetime
 from os import makedirs
 from pathlib import Path
 from typing import TYPE_CHECKING
-from uuid import uuid4
 
 import sqlalchemy
 import structlog
@@ -95,7 +94,6 @@ from tagstudio.core.library.alchemy.fields import (
 from tagstudio.core.library.alchemy.joins import TagEntry, TagParent
 from tagstudio.core.library.alchemy.models import (
     Entry,
-    Folder,
     Namespace,
     Tag,
     TagAlias,
@@ -234,7 +232,6 @@ class Library:
 
     library_dir: Path | None = None
     engine: Engine | None = None
-    folder: Folder | None = None
     included_files: set[Path] = set()
 
     def __init__(self) -> None:
@@ -259,7 +256,6 @@ class Library:
         """Migrate JSON library data to the SQLite database."""
         logger.info("Starting Library Conversion...")
         start_time = time.time()
-        folder: Folder = Folder(path=self.library_dir, uuid=str(uuid4()))
 
         # Tags
         for tag in json_lib.tags:
@@ -312,7 +308,6 @@ class Library:
             [
                 Entry(
                     path=entry.path / entry.filename,
-                    folder=folder,
                     fields=[],
                     id=entry.id + 1,  # NOTE: JSON IDs start at 0 instead of 1
                     date_added=datetime.now(),
@@ -479,16 +474,6 @@ class Library:
             session.add(Version(key=DB_VERSION_CURRENT_KEY, value=DB_VERSION))
             session.flush()
 
-            # add folder for current path
-            folder = Folder(
-                path=library_dir,
-                uuid=str(uuid4()),
-            )
-            session.add(folder)
-            session.expunge(folder)
-            session.flush()
-            self.folder = folder
-
             # Generate default .ts_ignore file
             try:
                 ts_ignore_template = (
@@ -584,6 +569,7 @@ class Library:
             (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_db203_migration, 203, None),  # changes: deletes folders
         ]
         for migration, v, iv in migrations:
             if loaded_db_version < v and (iv is None or initial_db_version < iv):
@@ -596,27 +582,11 @@ class Library:
                     session.commit()
                 logger.info(f"[Library][Migration][{v}] Completed DB Migration")
 
-        assert loaded_db_version >= DB_VERSION, (
+        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}")
 
-        with Session(self.engine) as session:
-            # TODO: the folder logic has no use and was never finished, remove it
-            # check if folder matching current path exists already
-            # NOTE: this has been causing new Folders to be created when the library is moved, since
-            # its introduction
-            self.folder = session.scalar(select(Folder).where(Folder.path == library_dir))
-            if not self.folder:
-                folder = Folder(
-                    path=library_dir,
-                    uuid=str(uuid4()),
-                )
-                session.add(folder)
-                session.expunge(folder)
-                session.commit()
-                self.folder = folder
-
         # everything is fine, set the library path
         self.library_dir = library_dir
         return LibraryStatus(success=True, library_path=library_dir)
@@ -906,6 +876,42 @@ class Library:
         session.flush()
         logger.info("[Library][Migration][202] Verified TagParent table data")
 
+    def __apply_db203_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)
+            SELECT id, path, suffix, date_created, date_modified, date_added
+            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:

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

@@ -182,23 +182,11 @@ class Tag(Base):
         return self.name >= other.name
 
 
-class Folder(Base):
-    __tablename__ = "folders"
-
-    # TODO - implement this
-    id: Mapped[int] = mapped_column(primary_key=True)
-    path: Mapped[Path] = mapped_column(PathType, unique=True)
-    uuid: Mapped[str] = mapped_column(unique=True)
-
-
 class Entry(Base):
     __tablename__ = "entries"
 
     id: Mapped[int] = mapped_column(primary_key=True)
 
-    folder_id: Mapped[int] = mapped_column(ForeignKey("folders.id"))
-    folder: Mapped[Folder] = relationship("Folder")
-
     path: Mapped[Path] = mapped_column(PathType, unique=True)
     filename: Mapped[str] = mapped_column()
     suffix: Mapped[str] = mapped_column()
@@ -235,7 +223,6 @@ class Entry(Base):
     def __init__(
         self,
         path: Path,
-        folder: Folder,
         fields: list[BaseField],
         id: int | None = None,
         date_created: dt | None = None,
@@ -244,7 +231,6 @@ class Entry(Base):
     ) -> None:
         super().__init__()
         self.path = path
-        self.folder = folder
         self.id = id  # pyright: ignore[reportAttributeAccessIssue]
         self.filename = path.name
         self.suffix = path.suffix.lstrip(".").lower()

src/tagstudio/core/library/refresh.py

@@ -16,7 +16,6 @@ from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Entry
 from tagstudio.core.library.ignore import PATH_GLOB_FLAGS, Ignore, ignore_to_glob
 from tagstudio.core.utils.silent_subprocess import silent_run  # pyright: ignore
-from tagstudio.core.utils.types import unwrap
 
 logger = structlog.get_logger(__name__)
 
@@ -41,7 +40,6 @@ class RefreshTracker:
             entries = [
                 Entry(
                     path=entry_path,
-                    folder=unwrap(self.library.folder),
                     fields=[],
                     date_added=dt.now(),
                 )

src/tagstudio/core/utils/str_formatting.py

@@ -49,14 +49,3 @@ def is_version_outdated(current: str, latest: str) -> bool:
         return vcur.patch < vlat.patch
     else:
         return vcur.prerelease is not None or vcur.build is not None
-
-
-def format_duration(duration: int | float) -> str:
-    """Format a duration in seconds as M:SS or H:MM:SS."""
-    try:
-        seconds = int(float(duration))
-        hours, seconds = divmod(seconds, 3600)
-        minutes, seconds = divmod(seconds, 60)
-        return f"{hours}:{minutes:02}:{seconds:02}" if hours else f"{minutes}:{seconds:02}"
-    except (OverflowError, ValueError):
-        return "-:--"

src/tagstudio/qt/controllers/preview_thumb_controller.py

@@ -32,6 +32,8 @@ Image.MAX_IMAGE_PIXELS = None
 
 
 class PreviewThumb(PreviewThumbView):
+    __current_file: Path
+
     def __init__(self, library: Library, driver: "QtDriver"):
         super().__init__(library, driver)
 
@@ -112,7 +114,7 @@ class PreviewThumb(PreviewThumbView):
 
     def display_file(self, filepath: Path) -> FileAttributeData:
         """Render a single file preview."""
-        self._current_file = filepath
+        self.__current_file = filepath
 
         ext = filepath.suffix.lower()
 
@@ -148,26 +150,21 @@ class PreviewThumb(PreviewThumbView):
 
     @override
     def _open_file_action_callback(self):
-        if self._current_file:
-            open_file(
-                self._current_file,
-                windows_start_command=self.__driver.settings.windows_start_command,
-            )
+        open_file(
+            self.__current_file, windows_start_command=self.__driver.settings.windows_start_command
+        )
 
     @override
     def _open_explorer_action_callback(self):
-        if self._current_file:
-            open_file(self._current_file, file_manager=True)
+        open_file(self.__current_file, file_manager=True)
 
     @override
     def _delete_action_callback(self):
-        if self._current_file:
-            self.__driver.delete_files_callback(self._current_file)
+        if bool(self.__current_file):
+            self.__driver.delete_files_callback(self.__current_file)
 
     @override
     def _button_wrapper_callback(self):
-        if self._current_file:
-            open_file(
-                self._current_file,
-                windows_start_command=self.__driver.settings.windows_start_command,
-            )
+        open_file(
+            self.__current_file, windows_start_command=self.__driver.settings.windows_start_command
+        )

src/tagstudio/qt/mixed/collage_icon.py

@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import math
+from pathlib import Path
+
+import cv2
+import structlog
+from PIL import Image, ImageChops, UnidentifiedImageError
+from PIL.Image import DecompressionBombError
+from PySide6.QtCore import QObject, Signal
+
+from tagstudio.core.library.alchemy.library import Library
+from tagstudio.core.media_types import MediaCategories
+from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.helpers.file_tester import is_readable_video
+
+logger = structlog.get_logger(__name__)
+
+
+class CollageIconRenderer(QObject):
+    rendered = Signal(Image.Image)
+    done = Signal()
+
+    def __init__(self, library: Library):
+        QObject.__init__(self)
+        self.lib = library
+
+    def render(
+        self,
+        entry_id: int,
+        size: tuple[int, int],
+        data_tint_mode: bool,
+        data_only_mode: bool,
+        keep_aspect: bool,
+    ):
+        entry = unwrap(self.lib.get_entry(entry_id))
+        filepath = unwrap(self.lib.library_dir) / entry.path
+        color: str = ""
+
+        try:
+            if data_tint_mode or data_only_mode:
+                color = "#28bb48" if entry.tags else "#e22c3c"
+
+                if data_only_mode:
+                    pic = Image.new("RGB", size, color)
+                    # collage.paste(pic, (y*thumb_size, x*thumb_size))
+                    self.rendered.emit(pic)
+            if not data_only_mode:
+                logger.info(
+                    "Combining icons",
+                    entry=entry,
+                    color=self.get_file_color(filepath.suffix.lower()),
+                )
+
+                ext: str = filepath.suffix.lower()
+                if MediaCategories.is_ext_in_category(ext, MediaCategories.IMAGE_TYPES):
+                    try:
+                        with Image.open(filepath) as pic:
+                            if keep_aspect:
+                                pic.thumbnail(size)
+                            else:
+                                pic = pic.resize(size)
+                            if data_tint_mode and color:
+                                pic = pic.convert(mode="RGB")
+                                pic = ImageChops.hard_light(pic, Image.new("RGB", size, color))
+                            self.rendered.emit(pic)
+                    except DecompressionBombError as e:
+                        logger.info(f"[ERROR] One of the images was too big ({e})")
+                elif MediaCategories.is_ext_in_category(
+                    ext, MediaCategories.VIDEO_TYPES
+                ) and is_readable_video(filepath):
+                    video = cv2.VideoCapture(str(filepath), cv2.CAP_FFMPEG)
+                    video.set(
+                        cv2.CAP_PROP_POS_FRAMES,
+                        (video.get(cv2.CAP_PROP_FRAME_COUNT) // 2),
+                    )
+                    success, frame = video.read()
+                    # 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
+                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    with Image.fromarray(frame, mode="RGB") as pic:
+                        if keep_aspect:
+                            pic.thumbnail(size)
+                        else:
+                            pic = pic.resize(size)
+                        if data_tint_mode and color:
+                            pic = ImageChops.hard_light(pic, Image.new("RGB", size, color))
+                        self.rendered.emit(pic)
+        except (UnidentifiedImageError, FileNotFoundError):
+            logger.error("Couldn't read entry", entry=entry.path)
+            with Image.open(
+                str(Path(__file__).parents[1] / "resources/qt/images/thumb_broken_512.png")
+            ) as pic:
+                pic.thumbnail(size)
+                if data_tint_mode and color:
+                    pic = pic.convert(mode="RGB")
+                    pic = ImageChops.hard_light(pic, Image.new("RGB", size, color))
+                # collage.paste(pic, (y*thumb_size, x*thumb_size))
+                self.rendered.emit(pic)
+        except KeyboardInterrupt:
+            logger.info("Collage operation cancelled.")
+        except Exception:
+            logger.exception("render failed", entry=entry.path)
+
+        self.done.emit()
+
+    def get_file_color(self, ext: str):
+        if ext.lower() == "gif":
+            return "\033[93m"
+        if MediaCategories.is_ext_in_category(ext, MediaCategories.IMAGE_TYPES):
+            return "\033[37m"
+        elif MediaCategories.is_ext_in_category(ext, MediaCategories.VIDEO_TYPES):
+            return "\033[96m"
+        elif MediaCategories.is_ext_in_category(ext, MediaCategories.PLAINTEXT_TYPES):
+            return "\033[92m"
+        else:
+            return "\033[97m"

src/tagstudio/qt/mixed/file_attributes.py

@@ -7,6 +7,7 @@ import platform
 import typing
 from dataclasses import dataclass
 from datetime import datetime as dt
+from datetime import timedelta
 from pathlib import Path
 
 import structlog
@@ -19,7 +20,6 @@ from tagstudio.core.enums import ShowFilepathOption
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.ignore import Ignore
 from tagstudio.core.media_types import MediaCategories
-from tagstudio.core.utils.str_formatting import format_duration
 from tagstudio.core.utils.types import unwrap
 from tagstudio.qt.models.palette import ColorType, UiColor, get_ui_color
 from tagstudio.qt.translations import Translations
@@ -224,7 +224,15 @@ class FileAttributes(QWidget):
 
             if stats.duration is not None:
                 stats_label_text = add_newline(stats_label_text)
-                stats_label_text += format_duration(stats.duration)
+                try:
+                    dur_str = str(timedelta(seconds=float(stats.duration)))[:-7]
+                    if dur_str.startswith("0:"):
+                        dur_str = dur_str[2:]
+                    if dur_str.startswith("0"):
+                        dur_str = dur_str[1:]
+                except OverflowError:
+                    dur_str = "-:--"
+                stats_label_text += f"{dur_str}"
 
             if font_family:
                 stats_label_text = add_newline(stats_label_text)

src/tagstudio/qt/views/preview_panel_view.py

@@ -51,7 +51,6 @@ class PreviewPanelView(QWidget):
         self._containers = FieldContainers(
             self.lib, driver
         )  # TODO: this should be name mangled, but is still needed on the controller side atm
-        self.__current_stats: FileAttributeData | None = None
 
         preview_section = QWidget()
         preview_layout = QVBoxLayout(preview_section)
@@ -133,7 +132,6 @@ class PreviewPanelView(QWidget):
     def __connect_callbacks(self) -> None:
         self.__add_field_button.clicked.connect(self._add_field_button_callback)
         self.__add_tag_button.clicked.connect(self._add_tag_button_callback)
-        self._thumb.stats_updated.connect(self.__thumb_stats_updated_callback)
 
     def _add_field_button_callback(self) -> None:
         raise NotImplementedError()
@@ -141,25 +139,6 @@ class PreviewPanelView(QWidget):
     def _add_tag_button_callback(self) -> None:
         raise NotImplementedError()
 
-    def __thumb_stats_updated_callback(self, filepath: Path, stats: FileAttributeData) -> None:
-        if len(self._selected) != 1:
-            return
-
-        if filepath != self._thumb.current_file:
-            return
-
-        if self.__current_stats is None:
-            self.__current_stats = FileAttributeData()
-
-        if stats.width is not None:
-            self.__current_stats.width = stats.width
-        if stats.height is not None:
-            self.__current_stats.height = stats.height
-        if stats.duration is not None:
-            self.__current_stats.duration = stats.duration
-
-        self._file_attrs.update_stats(filepath, self.__current_stats)
-
     def _set_selection_callback(self) -> None:
         raise NotImplementedError()
 
@@ -176,7 +155,6 @@ class PreviewPanelView(QWidget):
             # No Items Selected
             if len(selected) == 0:
                 self._thumb.hide_preview()
-                self.__current_stats = None
                 self._file_attrs.update_stats()
                 self._file_attrs.update_date_label()
                 self._containers.hide_containers()
@@ -189,12 +167,9 @@ class PreviewPanelView(QWidget):
                 entry: Entry = unwrap(self.lib.get_entry(entry_id))
 
                 filepath: Path = unwrap(self.lib.library_dir) / entry.path
-                if filepath != self._thumb.current_file:
-                    self.__current_stats = None
 
                 if update_preview:
                     stats: FileAttributeData = self._thumb.display_file(filepath)
-                    self.__current_stats = stats
                     self._file_attrs.update_stats(filepath, stats)
                 self._file_attrs.update_date_label(filepath)
                 self._containers.update_from_entry(entry_id)
@@ -207,7 +182,6 @@ class PreviewPanelView(QWidget):
             elif len(selected) > 1:
                 # items: list[Entry] = [self.lib.get_entry_full(x) for x in self.driver.selected]
                 self._thumb.hide_preview()  # TODO: Render mixed selection
-                self.__current_stats = None
                 self._file_attrs.update_multi_selection(len(selected))
                 self._file_attrs.update_date_label()
                 self._containers.hide_containers()  # TODO: Allow for mixed editing

src/tagstudio/qt/views/preview_thumb_view.py

@@ -34,13 +34,11 @@ class PreviewThumbView(QWidget):
     """The Preview Panel Widget."""
 
     check_ffmpeg = Signal(bool)
-    stats_updated = Signal(Path, FileAttributeData)
 
     __img_button_size: tuple[int, int]
     __image_ratio: float
 
-    _current_file: Path | None
-    __should_render_on_resize: bool
+    __filepath: Path | None
     __rendered_res: tuple[int, int]
 
     def __init__(self, library: Library, driver: "QtDriver") -> None:
@@ -49,8 +47,6 @@ class PreviewThumbView(QWidget):
         self.__img_button_size = (266, 266)
         self.__image_ratio = 1.0
 
-        self.__should_render_on_resize = False
-
         self.__image_layout = QStackedLayout(self)
         self.__image_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
         self.__image_layout.setStackingMode(QStackedLayout.StackingMode.StackAll)
@@ -96,10 +92,6 @@ class PreviewThumbView(QWidget):
         self.__media_player.addAction(open_file_action)
         self.__media_player.addAction(open_explorer_action)
         self.__media_player.addAction(delete_action)
-        # QMediaPlayer loads duration asynchronously after setSource().
-        self.__media_player.player.durationChanged.connect(
-            self.__media_player_duration_changed_callback
-        )
 
         # Need to watch for this to resize the player appropriately.
         self.__media_player.player.hasVideoChanged.connect(
@@ -136,16 +128,6 @@ class PreviewThumbView(QWidget):
     def __media_player_video_changed_callback(self, video: bool) -> None:
         self.__update_image_size((self.size().width(), self.size().height()))
 
-    def __media_player_duration_changed_callback(self, duration_ms: int) -> None:
-        filepath = self.__media_player.filepath
-        if filepath is None or duration_ms <= 0:
-            return
-
-        self.stats_updated.emit(
-            filepath,
-            FileAttributeData(duration=duration_ms // 1000),
-        )
-
     def __thumb_renderer_updated_callback(
         self, _timestamp: float, img: QPixmap, _size: QSize, _path: Path
     ) -> None:
@@ -225,8 +207,7 @@ class PreviewThumbView(QWidget):
             self.__preview_gif.hide()
 
     def __render_thumb(self, filepath: Path) -> None:
-        self.__should_render_on_resize = True
-
+        self.__filepath = filepath
         self.__rendered_res = (
             math.ceil(self.__img_button_size[0] * THUMB_SIZE_FACTOR),
             math.ceil(self.__img_button_size[1] * THUMB_SIZE_FACTOR),
@@ -240,16 +221,17 @@ class PreviewThumbView(QWidget):
             update_on_ratio_change=True,
         )
 
-    def __update_media_player(self, filepath: Path) -> None:
-        """Display either audio or video."""
+    def __update_media_player(self, filepath: Path) -> int:
+        """Display either audio or video.
+
+        Returns the duration of the audio / video.
+        """
         self.__media_player.play(filepath)
+        return self.__media_player.player.duration() * 1000
 
     def _display_video(self, filepath: Path, size: QSize | None) -> FileAttributeData:
-        self.__should_render_on_resize = False
-
         self.__switch_preview(MediaType.VIDEO)
-        self.__update_media_player(filepath)
-        stats = FileAttributeData()
+        stats = FileAttributeData(duration=self.__update_media_player(filepath))
 
         if size is not None:
             stats.width = size.width()
@@ -268,13 +250,10 @@ class PreviewThumbView(QWidget):
     def _display_audio(self, filepath: Path) -> FileAttributeData:
         self.__switch_preview(MediaType.AUDIO)
         self.__render_thumb(filepath)
-        self.__update_media_player(filepath)
-        return FileAttributeData()
+        return FileAttributeData(duration=self.__update_media_player(filepath))
 
     def _display_gif(self, gif_data: bytes, size: tuple[int, int]) -> FileAttributeData | None:
         """Update the animated image preview from a filepath."""
-        self.__should_render_on_resize = False
-
         stats = FileAttributeData()
 
         # Ensure that any movie and buffer from previous animations are cleared.
@@ -317,26 +296,17 @@ class PreviewThumbView(QWidget):
     def hide_preview(self) -> None:
         """Completely hide the file preview."""
         self.__switch_preview(None)
-        self._current_file = None
-        self.__should_render_on_resize = False
+        self.__filepath = None
 
     @override
     def resizeEvent(self, event: QResizeEvent) -> None:
         self.__update_image_size((self.size().width(), self.size().height()))
 
-        if (
-            self._current_file is not None
-            and self.__should_render_on_resize
-            and self.__rendered_res < self.__img_button_size
-        ):
-            self.__render_thumb(self._current_file)
+        if self.__filepath is not None and self.__rendered_res < self.__img_button_size:
+            self.__render_thumb(self.__filepath)
 
         return super().resizeEvent(event)
 
     @property
     def media_player(self) -> MediaPlayer:
         return self.__media_player
-
-    @property
-    def current_file(self) -> Path | None:
-        return self._current_file

tests/conftest.py

@@ -20,7 +20,6 @@ sys.path.insert(0, str(CWD.parent))
 from tagstudio.core.constants import THUMB_CACHE_NAME, TS_FOLDER_NAME
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Entry, Tag
-from tagstudio.core.utils.types import unwrap
 from tagstudio.qt.thumb_grid_layout import ThumbGridLayout
 from tagstudio.qt.ts_qt import QtDriver
 
@@ -36,22 +35,18 @@ def file_mediatypes_library():
 
     status = lib.open_library(Path(""), in_memory=True)
     assert status.success
-    folder = unwrap(lib.folder)
 
     entry1 = Entry(
-        folder=folder,
         path=Path("foo.png"),
         fields=[TextField(name="Title", value="I'm a Test Title")],
     )
 
     entry2 = Entry(
-        folder=folder,
         path=Path("bar.png"),
         fields=[TextField(name="Title", value="I'm a Test Title")],
     )
 
     entry3 = Entry(
-        folder=folder,
         path=Path("baz.apng"),
         fields=[TextField(name="Title", value="I'm a Test Title")],
     )
@@ -87,7 +82,6 @@ def library(request, library_dir: Path):  # pyright: ignore
     lib = Library()
     status = lib.open_library(library_path, in_memory=True)
     assert status.success
-    folder = unwrap(lib.folder)
 
     tag = Tag(
         name="foo",
@@ -116,7 +110,6 @@ def library(request, library_dir: Path):  # pyright: ignore
     # default item with deterministic name
     entry = Entry(
         id=1,
-        folder=folder,
         path=Path("foo.txt"),
         fields=[TextField(name="Title", value="I'm a Test Title")],
     )
@@ -124,7 +117,6 @@ def library(request, library_dir: Path):  # pyright: ignore
 
     entry2 = Entry(
         id=2,
-        folder=folder,
         path=Path("one/two/bar.md"),
         fields=[TextField(name="Title", value="I'm a Test Title")],
     )

tests/macros/test_dupe_files.py

@@ -8,25 +8,21 @@ from tagstudio.core.library.alchemy.fields import BaseField, TextField
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Entry
 from tagstudio.core.library.alchemy.registries.dupe_files_registry import DupeFilesRegistry
-from tagstudio.core.utils.types import unwrap
 
 CWD = Path(__file__).parent
 
 
 def test_refresh_dupe_files(library: Library):
     library.library_dir = Path("/tmp/")
-    folder = unwrap(library.folder)
 
     fields: list[BaseField] = [TextField(name="Title", value="I'm a Test Title")]
 
     entry = Entry(
-        folder=folder,
         path=Path("bar/foo.txt"),
         fields=fields,
     )
 
     entry2 = Entry(
-        folder=folder,
         path=Path("foo/foo.txt"),
         fields=fields,
     )

tests/test_library.py

@@ -77,7 +77,6 @@ def test_library_add_file(library: Library):
     """Check Entry.path handling for insert vs lookup"""
     entry = Entry(
         path=Path("bar.txt"),
-        folder=unwrap(library.folder),
         fields=[TextField(name="Title", value="I'm a Test Title")],
     )
 
@@ -139,8 +138,7 @@ def test_get_entry(library: Library, entry_min: Entry):
 
 
 def test_entries_count(library: Library):
-    folder = unwrap(library.folder)
-    entries = [Entry(path=Path(f"{x}.txt"), folder=folder, fields=[]) for x in range(10)]
+    entries = [Entry(path=Path(f"{x}.txt"), fields=[]) for x in range(10)]
     new_ids = library.add_entries(entries)
     assert len(new_ids) == 10
 
@@ -254,7 +252,6 @@ def test_update_entry_with_multiple_identical_text_fields(library: Library, entr
 def test_mirror_entry_fields(library: Library):
     # Create and add entries with fields
     entry_a = Entry(
-        folder=unwrap(library.folder),
         path=Path("title_and_date.txt"),
         fields=[
             TextField(name="Title", value="I'm a Test Title"),
@@ -262,7 +259,6 @@ def test_mirror_entry_fields(library: Library):
         ],
     )
     entry_b = Entry(
-        folder=unwrap(library.folder),
         path=Path("notes.txt"),
         fields=[
             TextField(name="Notes", value="These are my notes.\nNo peeking!", is_multiline=True),
@@ -270,7 +266,6 @@ def test_mirror_entry_fields(library: Library):
         ],
     )
     entry_c = Entry(
-        folder=unwrap(library.folder),
         path=Path("date_published.txt"),
         fields=[
             DatetimeField(name="Date Published", value="2000-01-01 12:00:00"),
@@ -319,14 +314,11 @@ def test_mirror_entry_fields(library: Library):
 
 
 def test_merge_entries(library: Library):
-    folder = unwrap(library.folder)
-
     tag_0: Tag = unwrap(library.add_tag(Tag(id=1010, name="tag_0")))
     tag_1: Tag = unwrap(library.add_tag(Tag(id=1011, name="tag_1")))
     tag_2: Tag = unwrap(library.add_tag(Tag(id=1012, name="tag_2")))
 
     entry_a = Entry(
-        folder=folder,
         path=Path("a"),
         fields=[
             TextField(name="Author", value="Author McAuthorson"),
@@ -334,7 +326,6 @@ def test_merge_entries(library: Library):
         ],
     )
     entry_b = Entry(
-        folder=folder,
         path=Path("b"),
         fields=[TextField(name="Notes", value="test note", is_multiline=True)],
     )