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

src/core/hardlink_manager.py

@@ -0,0 +1,403 @@
+"""
+Hardlink Manager for Curator
+
+Creates directory structure based on file tags and creates hardlinks
+to organize files without duplicating them on disk.
+
+Example:
+    A file with tags "žánr/Komedie", "žánr/Akční", "rok/1988" will create:
+
+    output/
+    ├── žánr/
+    │   ├── Komedie/
+    │   │   └── film.mkv  (hardlink)
+    │   └── Akční/
+    │       └── film.mkv  (hardlink)
+    └── rok/
+        └── 1988/
+            └── film.mkv  (hardlink)
+"""
+import os
+from pathlib import Path
+from typing import List, Tuple, Optional
+from .file import File
+
+
+class HardlinkManager:
+    """Manager for creating hardlink-based directory structures from tagged files."""
+
+    def __init__(self, output_dir: Path):
+        """
+        Initialize HardlinkManager.
+
+        Args:
+            output_dir: Base directory where the tag-based structure will be created
+        """
+        self.output_dir = Path(output_dir)
+        self.created_links: List[Path] = []
+        self.errors: List[Tuple[Path, str]] = []
+
+    def create_structure_for_files(
+        self,
+        files: List[File],
+        categories: Optional[List[str]] = None,
+        dry_run: bool = False
+    ) -> Tuple[int, int]:
+        """
+        Create hardlink structure for given files based on their tags.
+
+        Args:
+            files: List of File objects to process
+            categories: Optional list of categories to include (None = all)
+            dry_run: If True, only simulate without creating actual links
+
+        Returns:
+            Tuple of (successful_links, failed_links)
+        """
+        self.created_links = []
+        self.errors = []
+
+        success_count = 0
+        fail_count = 0
+
+        for file_obj in files:
+            if not file_obj.tags:
+                continue
+
+            for tag in file_obj.tags:
+                # Skip if category filter is set and this category is not included
+                if categories is not None and tag.category not in categories:
+                    continue
+
+                # Create target directory path: output/category/tag_name/
+                target_dir = self.output_dir / tag.category / tag.name
+                target_file = target_dir / file_obj.filename
+
+                try:
+                    if not dry_run:
+                        # Create directory structure
+                        target_dir.mkdir(parents=True, exist_ok=True)
+
+                        # Skip if link already exists
+                        if target_file.exists():
+                            # Check if it's already a hardlink to the same file
+                            if self._is_same_file(file_obj.file_path, target_file):
+                                continue
+                            else:
+                                # Different file exists, add suffix
+                                target_file = self._get_unique_name(target_file)
+
+                        # Create hardlink
+                        os.link(file_obj.file_path, target_file)
+
+                    self.created_links.append(target_file)
+                    success_count += 1
+
+                except OSError as e:
+                    self.errors.append((file_obj.file_path, str(e)))
+                    fail_count += 1
+
+        return success_count, fail_count
+
+    def mirror_as_is(
+        self,
+        source_dir: Path,
+        subfolder: str | None = None,
+        dry_run: bool = False
+    ) -> Tuple[int, int]:
+        """Mirror a "copy-as-is" folder 1:1 into the output as a hardlinked clone.
+
+        Recreates the exact directory hierarchy of ``source_dir`` under
+        ``output_dir/subfolder`` (or directly under ``output_dir`` when
+        ``subfolder`` is None) and hardlinks every file. Curator metadata files
+        (``.!tag`` / ``.!ftag`` / ``.!gtag`` / ``.!index``) are skipped.
+
+        Used for Seriály: the pool structure is the source of truth and is cloned
+        verbatim instead of being rebuilt from tags.
+
+        Returns:
+            Tuple of (successful_links, failed_links)
+        """
+        source_dir = Path(source_dir)
+        if not source_dir.is_dir():
+            return 0, 0
+
+        base = self.output_dir / subfolder if subfolder else self.output_dir
+        success_count = 0
+        fail_count = 0
+
+        for src_file in source_dir.rglob("*"):
+            if not src_file.is_file():
+                continue
+            if src_file.name.endswith((".!tag", ".!ftag", ".!gtag", ".!index")):
+                continue
+
+            target_file = base / src_file.relative_to(source_dir)
+            try:
+                if not dry_run:
+                    target_file.parent.mkdir(parents=True, exist_ok=True)
+                    if target_file.exists():
+                        if self._is_same_file(src_file, target_file):
+                            success_count += 1
+                            continue
+                        target_file.unlink()
+                    os.link(src_file, target_file)
+                self.created_links.append(target_file)
+                success_count += 1
+            except OSError as e:
+                self.errors.append((src_file, str(e)))
+                fail_count += 1
+
+        return success_count, fail_count
+
+    def _is_same_file(self, path1: Path, path2: Path) -> bool:
+        """Check if two paths point to the same file (same inode)."""
+        try:
+            return path1.stat().st_ino == path2.stat().st_ino
+        except OSError:
+            return False
+
+    def _get_unique_name(self, path: Path) -> Path:
+        """Get a unique filename by adding a numeric suffix."""
+        stem = path.stem
+        suffix = path.suffix
+        parent = path.parent
+        counter = 1
+
+        while True:
+            new_name = f"{stem}_{counter}{suffix}"
+            new_path = parent / new_name
+            if not new_path.exists():
+                return new_path
+            counter += 1
+
+    def remove_created_links(self) -> int:
+        """
+        Remove all hardlinks created by the last operation.
+
+        Returns:
+            Number of links removed
+        """
+        removed = 0
+        for link_path in self.created_links:
+            try:
+                if link_path.exists() and link_path.is_file():
+                    link_path.unlink()
+                    removed += 1
+
+                    # Try to remove empty parent directories
+                    self._remove_empty_parents(link_path.parent)
+            except OSError:
+                pass
+
+        self.created_links = []
+        return removed
+
+    def _remove_empty_parents(self, path: Path) -> None:
+        """Remove empty parent directories up to output_dir."""
+        try:
+            while path != self.output_dir and path.is_dir():
+                if any(path.iterdir()):
+                    break  # Directory not empty
+                path.rmdir()
+                path = path.parent
+        except OSError:
+            pass
+
+    def get_preview(self, files: List[File], categories: Optional[List[str]] = None) -> List[Tuple[Path, Path]]:
+        """
+        Get a preview of what links would be created.
+
+        Args:
+            files: List of File objects
+            categories: Optional list of categories to include
+
+        Returns:
+            List of tuples (source_path, target_path)
+        """
+        preview = []
+
+        for file_obj in files:
+            if not file_obj.tags:
+                continue
+
+            for tag in file_obj.tags:
+                if categories is not None and tag.category not in categories:
+                    continue
+
+                target_dir = self.output_dir / tag.category / tag.name
+                target_file = target_dir / file_obj.filename
+
+                preview.append((file_obj.file_path, target_file))
+
+        return preview
+
+    def find_obsolete_links(
+        self,
+        files: List[File],
+        categories: Optional[List[str]] = None
+    ) -> List[Tuple[Path, Path]]:
+        """
+        Find hardlinks in the output directory that no longer match file tags.
+
+        Scans the output directory for hardlinks that point to source files,
+        but whose category/tag path no longer matches the file's current tags.
+
+        Args:
+            files: List of File objects (source files)
+            categories: Optional list of categories to check (None = all)
+
+        Returns:
+            List of tuples (link_path, source_path) for obsolete links
+        """
+        obsolete = []
+
+        if not self.output_dir.exists():
+            return obsolete
+
+        # Build a map of source file inodes to File objects
+        inode_to_file: dict[int, File] = {}
+        for file_obj in files:
+            try:
+                inode = file_obj.file_path.stat().st_ino
+                inode_to_file[inode] = file_obj
+            except OSError:
+                continue
+
+        # Build expected paths for each file based on current tags
+        expected_paths: dict[int, set[Path]] = {}
+        for file_obj in files:
+            try:
+                inode = file_obj.file_path.stat().st_ino
+                expected_paths[inode] = set()
+
+                for tag in file_obj.tags:
+                    if categories is not None and tag.category not in categories:
+                        continue
+                    target = self.output_dir / tag.category / tag.name / file_obj.filename
+                    expected_paths[inode].add(target)
+            except OSError:
+                continue
+
+        # Scan output directory for existing hardlinks
+        for category_dir in self.output_dir.iterdir():
+            if not category_dir.is_dir():
+                continue
+
+            # Filter by categories if specified
+            if categories is not None and category_dir.name not in categories:
+                continue
+
+            for tag_dir in category_dir.iterdir():
+                if not tag_dir.is_dir():
+                    continue
+
+                for link_file in tag_dir.iterdir():
+                    if not link_file.is_file():
+                        continue
+
+                    try:
+                        link_inode = link_file.stat().st_ino
+
+                        # Check if this inode belongs to one of our source files
+                        if link_inode in inode_to_file:
+                            source_file = inode_to_file[link_inode]
+
+                            # Check if this link path is expected
+                            if link_inode in expected_paths:
+                                if link_file not in expected_paths[link_inode]:
+                                    # This link exists but tag was removed
+                                    obsolete.append((link_file, source_file.file_path))
+                    except OSError:
+                        continue
+
+        return obsolete
+
+    def remove_obsolete_links(
+        self,
+        files: List[File],
+        categories: Optional[List[str]] = None,
+        dry_run: bool = False
+    ) -> Tuple[int, List[Path]]:
+        """
+        Remove hardlinks that no longer match file tags.
+
+        Args:
+            files: List of File objects
+            categories: Optional list of categories to check
+            dry_run: If True, only return what would be removed
+
+        Returns:
+            Tuple of (removed_count, list_of_removed_paths)
+        """
+        obsolete = self.find_obsolete_links(files, categories)
+        removed_paths = []
+
+        if dry_run:
+            return len(obsolete), [link for link, _ in obsolete]
+
+        for link_path, _ in obsolete:
+            try:
+                link_path.unlink()
+                removed_paths.append(link_path)
+
+                # Try to remove empty parent directories
+                self._remove_empty_parents(link_path.parent)
+            except OSError:
+                pass
+
+        return len(removed_paths), removed_paths
+
+    def sync_structure(
+        self,
+        files: List[File],
+        categories: Optional[List[str]] = None,
+        dry_run: bool = False
+    ) -> Tuple[int, int, int, int]:
+        """
+        Synchronize hardlink structure with current file tags.
+
+        This will:
+        1. Remove hardlinks for removed tags
+        2. Create new hardlinks for new tags
+
+        Args:
+            files: List of File objects
+            categories: Optional list of categories to sync
+            dry_run: If True, only simulate
+
+        Returns:
+            Tuple of (created, create_failed, removed, remove_failed)
+        """
+        # First find how many obsolete links there are
+        obsolete_count = len(self.find_obsolete_links(files, categories))
+
+        # Remove obsolete links
+        removed, removed_paths = self.remove_obsolete_links(files, categories, dry_run)
+        remove_failed = obsolete_count - removed if not dry_run else 0
+
+        # Then create new links
+        created, create_failed = self.create_structure_for_files(files, categories, dry_run)
+
+        return created, create_failed, removed, remove_failed
+
+
+def create_hardlink_structure(
+    files: List[File],
+    output_dir: Path,
+    categories: Optional[List[str]] = None
+) -> Tuple[int, int, List[Tuple[Path, str]]]:
+    """
+    Convenience function to create hardlink structure.
+
+    Args:
+        files: List of File objects to process
+        output_dir: Base directory for output
+        categories: Optional list of categories to include
+
+    Returns:
+        Tuple of (successful_count, failed_count, errors_list)
+    """
+    manager = HardlinkManager(output_dir)
+    success, fail = manager.create_structure_for_files(files, categories)
+    return success, fail, manager.errors