Rework Tagger fork into Curator movie-library manager (PySide6 GUI, pool index, ČSFD import)

2026-06-12 16:01:54 +02:00
parent dd9c7d9ec5
commit 22a14b1e41
52 changed files with 8095 additions and 0 deletions
@@ -0,0 +1,272 @@
+from pathlib import Path
+import shutil
+from .file import File
+from .tag_manager import TagManager
+from .pool_index import PoolIndex
+from .utils import list_files
+from typing import Iterable
+import fnmatch
+from src.core.config import (
+    load_global_config, save_global_config,
+    load_folder_config, save_folder_config
+)
+
+# Top-level folders inside the managed pool
+POOL_MOVIES = "Filmy"
+POOL_SERIES = "Seriály"
+
+# Curator metadata files that must never be treated as content
+METADATA_SUFFIXES = (".!tag", ".!ftag", ".!gtag", ".!index")
+
+
+class FileManager:
+    def __init__(self, tagmanager: TagManager):
+        self.filelist: list[File] = []
+        self.folders: list[Path] = []
+        self.tagmanager = tagmanager
+        self.on_files_changed = None  # callback do GUI
+        self.global_config = load_global_config()
+        self.folder_configs: dict[Path, dict] = {}  # folder -> config
+        self.current_folder: Path | None = None
+        self.index: PoolIndex | None = None  # unified pool metadata index
+
+    # ------------------------------------------------------------------
+    # Pool (single source of truth) and Filmotéka (generated output)
+    # ------------------------------------------------------------------
+
+    @property
+    def pool_dir(self) -> Path | None:
+        value = self.global_config.get("pool_dir")
+        return Path(value) if value else None
+
+    @property
+    def movies_dir(self) -> Path | None:
+        pool = self.pool_dir
+        return pool / POOL_MOVIES if pool else None
+
+    @property
+    def series_dir(self) -> Path | None:
+        pool = self.pool_dir
+        return pool / POOL_SERIES if pool else None
+
+    @property
+    def copyasis_folders(self) -> list[str]:
+        """Names of pool subfolders mirrored 1:1 (copy-as-is) into the output."""
+        return self.global_config.get("copyasis_folders", [POOL_SERIES])
+
+    def set_copyasis_folders(self, names: list[str]) -> None:
+        """Set the copy-as-is subfolder list and persist it."""
+        cleaned = [n.strip() for n in names if n.strip()]
+        self.global_config["copyasis_folders"] = cleaned
+        save_global_config(self.global_config)
+
+    @property
+    def filmoteka_dir(self) -> Path | None:
+        value = self.global_config.get("filmoteka_dir")
+        return Path(value) if value else None
+
+    def set_pool_dir(self, pool_dir: Path) -> None:
+        """Set the managed pool root and create its top-level folders."""
+        pool_dir = Path(pool_dir)
+        (pool_dir / POOL_MOVIES).mkdir(parents=True, exist_ok=True)
+        (pool_dir / POOL_SERIES).mkdir(parents=True, exist_ok=True)
+        self.global_config["pool_dir"] = str(pool_dir)
+        save_global_config(self.global_config)
+
+    def set_filmoteka_dir(self, filmoteka_dir: Path) -> None:
+        """Set the Filmotéka output folder (generated hardlink tree)."""
+        self.global_config["filmoteka_dir"] = str(Path(filmoteka_dir))
+        save_global_config(self.global_config)
+
+    def load_pool_movies(self) -> None:
+        """Reload the movie list from pool/Filmy using the unified pool index."""
+        self.filelist = []
+        movies = self.movies_dir
+        pool = self.pool_dir
+        if not (movies and movies.is_dir() and pool):
+            return
+
+        self.index = PoolIndex(pool)
+        for each in list_files(movies):
+            if each.name.endswith(METADATA_SUFFIXES):
+                continue
+            file_obj = File(each, self.tagmanager, index=self.index)
+            self.filelist.append(file_obj)
+
+    def import_movie(self, source: Path, title: str, csfd_link: str | None = None) -> File:
+        """Copy a video file into pool/Filmy as 'Title.ext', index its metadata.
+
+        The original file is left in place (non-destructive copy).
+        """
+        movies = self.movies_dir
+        pool = self.pool_dir
+        if movies is None or pool is None:
+            raise RuntimeError("Pool není nastaven.")
+        movies.mkdir(parents=True, exist_ok=True)
+
+        if self.index is None:
+            self.index = PoolIndex(pool)
+
+        source = Path(source)
+        safe_title = title.strip() or source.stem
+        target = movies / f"{safe_title}{source.suffix}"
+
+        # Avoid clobbering an existing movie of the same name
+        counter = 1
+        while target.exists():
+            target = movies / f"{safe_title}_{counter}{source.suffix}"
+            counter += 1
+
+        shutil.copy2(source, target)
+
+        file_obj = File(target, self.tagmanager, index=self.index)
+        file_obj.title = safe_title
+        file_obj.csfd_link = csfd_link or None
+        file_obj.save_metadata()
+
+        self.filelist.append(file_obj)
+        if self.on_files_changed:
+            self.on_files_changed(self.filelist)
+        return file_obj
+
+    def append(self, folder: Path) -> None:
+        """Add a folder to scan for files"""
+        self.folders.append(folder)
+        self.current_folder = folder
+
+        # Update global config with last folder
+        self.global_config["last_folder"] = str(folder)
+
+        # Update recent folders list
+        recent = self.global_config.get("recent_folders", [])
+        folder_str = str(folder)
+        if folder_str in recent:
+            recent.remove(folder_str)
+        recent.insert(0, folder_str)
+        self.global_config["recent_folders"] = recent[:10]  # Keep max 10
+
+        save_global_config(self.global_config)
+
+        # Load folder-specific config
+        folder_config = load_folder_config(folder)
+        self.folder_configs[folder] = folder_config
+
+        # Get ignore patterns from folder config
+        ignore_patterns = folder_config.get("ignore_patterns", [])
+
+        for each in list_files(folder):
+            # Skip all Curator metadata files (.!tag / .!ftag / .!gtag / .!index)
+            if each.name.endswith(METADATA_SUFFIXES):
+                continue
+
+            full_path = each.as_posix()
+
+            # Check against ignore patterns
+            if any(
+                fnmatch.fnmatch(each.name, pat) or fnmatch.fnmatch(full_path, pat)
+                for pat in ignore_patterns
+            ):
+                continue
+
+            file_obj = File(each, self.tagmanager)
+            self.filelist.append(file_obj)
+
+    def get_folder_config(self, folder: Path = None) -> dict:
+        """Get config for a folder (or current folder if not specified)"""
+        if folder is None:
+            folder = self.current_folder
+        if folder is None:
+            return {}
+        if folder not in self.folder_configs:
+            self.folder_configs[folder] = load_folder_config(folder)
+        return self.folder_configs[folder]
+
+    def save_folder_config(self, folder: Path = None, config: dict = None):
+        """Save config for a folder"""
+        if folder is None:
+            folder = self.current_folder
+        if folder is None:
+            return
+        if config is None:
+            config = self.folder_configs.get(folder, {})
+        self.folder_configs[folder] = config
+        save_folder_config(folder, config)
+
+    def set_ignore_patterns(self, patterns: list[str], folder: Path = None):
+        """Set ignore patterns for a folder"""
+        config = self.get_folder_config(folder)
+        config["ignore_patterns"] = patterns
+        self.save_folder_config(folder, config)
+
+    def get_ignore_patterns(self, folder: Path = None) -> list[str]:
+        """Get ignore patterns for a folder"""
+        config = self.get_folder_config(folder)
+        return config.get("ignore_patterns", [])
+
+    def assign_tag_to_file_objects(self, files_objs: list[File], tag):
+        """Přiřadí tag (Tag nebo 'category/name' string) ke každému souboru v seznamu."""
+        for f in files_objs:
+            if isinstance(tag, str):
+                if "/" in tag:
+                    category, name = tag.split("/", 1)
+                    tag_obj = self.tagmanager.add_tag(category, name)
+                else:
+                    tag_obj = self.tagmanager.add_tag("default", tag)
+            else:
+                tag_obj = tag
+            if tag_obj not in f.tags:
+                f.tags.append(tag_obj)
+                f.save_metadata()
+        if self.on_files_changed:
+            self.on_files_changed(self.filelist)
+
+    def remove_tag_from_file_objects(self, files_objs: list[File], tag):
+        """Odebere tag (Tag nebo 'category/name') ze všech uvedených souborů."""
+        for f in files_objs:
+            if isinstance(tag, str):
+                if "/" in tag:
+                    category, name = tag.split("/", 1)
+                    from .tag import Tag as TagClass
+                    tag_obj = TagClass(category, name)
+                else:
+                    from .tag import Tag as TagClass
+                    tag_obj = TagClass("default", tag)
+            else:
+                tag_obj = tag
+            if tag_obj in f.tags:
+                f.tags.remove(tag_obj)
+                f.save_metadata()
+        if self.on_files_changed:
+            self.on_files_changed(self.filelist)
+
+    def filter_files_by_tags(self, tags: Iterable):
+        """
+        Vrátí jen soubory, které obsahují všechny zadané tagy.
+        'tags' může být iterace Tag objektů nebo stringů 'category/name'.
+        """
+        tags_list = list(tags) if tags is not None else []
+        if not tags_list:
+            return self.filelist
+
+        target_full_paths = set()
+        from .tag import Tag as TagClass
+        for t in tags_list:
+            if isinstance(t, TagClass):
+                target_full_paths.add(t.full_path)
+            elif isinstance(t, str):
+                target_full_paths.add(t)
+            else:
+                continue
+
+        filtered = []
+        for f in self.filelist:
+            file_tags = {t.full_path for t in f.tags}
+            if all(tag in file_tags for tag in target_full_paths):
+                filtered.append(f)
+        return filtered
+
+    # Legacy property for backwards compatibility
+    @property
+    def config(self):
+        """Legacy: returns global config"""
+        return self.global_config