jellyplex-sync 0.1.5__py3-none-any.whl

jellyplex_sync/__init__.py

@@ -0,0 +1,25 @@
+from .jellyfin import (
+    JellyfinLibrary,
+)
+from .library import (
+    ACCEPTED_VIDEO_SUFFIXES,
+    MediaLibrary,
+    MovieInfo,
+    VideoInfo,
+)
+from .plex import (
+    PlexLibrary,
+)
+from .sync import (
+    sync,
+)
+
+__all__ = [
+    "ACCEPTED_VIDEO_SUFFIXES",
+    "JellyfinLibrary",
+    "MediaLibrary",
+    "MovieInfo",
+    "PlexLibrary",
+    "VideoInfo",
+    "sync",
+]

jellyplex_sync/cli/sync.py

@@ -0,0 +1,85 @@
+#!/usr/bin/python3
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+
+import jellyplex_sync as jp
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Create a Plex compatible media library from a Jellyfin library."
+    )
+    parser.add_argument(
+        "source",
+        help="Jellyfin media library",
+    )
+    parser.add_argument(
+        "target",
+        help="Plex media library",
+    )
+    parser.add_argument(
+        "--convert-to",
+        type=str,
+        choices=[jp.JellyfinLibrary.shortname(), jp.PlexLibrary.shortname(), "auto"],
+        default="auto",
+        help="Type of library to convert to ('auto' will try to determine source library type)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show actions only, don't execute them",
+    )
+    parser.add_argument(
+        "--delete",
+        action="store_true",
+        help="Remove stray folders from target library",
+    )
+    parser.add_argument(
+        "--create",
+        action="store_true",
+        help="Create missing target library",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Show more information messages",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Show debug messages",
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        stream=sys.stderr,
+        format="%(levelname)s: %(asctime)s -- %(message)s",
+    )
+
+    result = 0
+    try:
+        result = jp.sync(
+            args.source,
+            args.target,
+            dry_run=args.dry_run,
+            delete=args.delete,
+            create=args.create,
+            verbose=args.verbose,
+            debug=args.debug,
+            convert_to=args.convert_to,
+        )
+    except KeyboardInterrupt:
+        logging.info("INTERRUPTED")
+        result = 10
+    except Exception as exc:
+        logging.error("Exception: %s", exc)
+        result = 99
+    sys.exit(result)
+
+
+if __name__ == "__main__":
+    main()

jellyplex_sync/jellyfin.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import logging
+import pathlib
+import re
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from .library import (
+    RESOLUTION_PATTERN,
+    MediaLibrary,
+    MovieInfo,
+    VideoInfo,
+)
+
+log = logging.getLogger(__name__)
+
+
+JELLYFIN_ID_PATTERN = re.compile(r"\[(?P<provider_id>[a-zA-Z]+id-[^\]]+)\]")
+JELLYFIN_MOVIE_PATTERNS = [
+    re.compile(
+        r"^(?P<title>.+?)\s+\((?P<year>\d{4})\)\s* - \s*\[(?P<provider_id>[a-zA-Z]+id-[^\]]+)\]"
+    ),
+    re.compile(
+        r"^(?P<title>.+?)\s+\((?P<year>\d{4})\)\s+\[(?P<provider_id>[a-zA-Z]+id-[^\]]+)\]"
+    ),
+    re.compile(r"^(?P<title>.+?)\s+\((?P<year>\d{4})\)$"),
+    re.compile(r"^(?P<title>.+?)\s+\[(?P<provider_id>[a-zA-Z]+id-[^\]]+)\]"),
+    re.compile(r"^(?P<title>.+?)$"),
+]
+
+
+# FIXME: It's not only a parser for variant strings anymore ...
+class VariantParser(ABC):
+    def __init__(self, library: MediaLibrary):
+        self.library = library
+
+    @abstractmethod
+    def parse(self, variant: str, video: VideoInfo) -> VideoInfo: ...
+
+    @abstractmethod
+    def video_name(self, movie_name: str, video: VideoInfo) -> str: ...
+
+
+class SimpleVariantParser(VariantParser):
+    def parse(self, variant: str, video: VideoInfo) -> VideoInfo:
+        return VideoInfo(
+            extension=video.extension,
+            edition=variant.strip(),
+            resolution=video.resolution,
+            tags=video.tags,
+        )
+
+    def _tags_to_variant(self, video: VideoInfo) -> list[str]:
+        if video.resolution:
+            return [video.resolution]
+        for tag in video.tags or []:
+            if tag.upper() in ("DVD", "4k", "BD"):
+                return [tag.upper()]
+        return []
+
+    def video_name(self, movie_name: str, video: VideoInfo) -> str:
+        parts = [movie_name]
+        variant_parts = self._tags_to_variant(video)
+        if video.edition:
+            variant_parts.append(video.edition)
+        if variant_parts:
+            parts.append(f"- {' '.join(variant_parts)}")
+        return f"{' '.join(parts)}{video.extension}"
+
+
+@dataclass
+class ResParser:
+    pattern: re.Pattern
+    mapping: Callable[[re.Match[str]], list[str | None]] | list[str | None]
+
+
+class SninerVariantParser(SimpleVariantParser):
+    RES_MAP: list[ResParser] = [
+        ResParser(
+            re.compile(r"4k([\.\-]([\w\d]+))?$"),
+            lambda m: ["2160p", m.group(2)] if m.group(1) else ["2160p"],
+        ),
+        ResParser(
+            re.compile(r"BD([\.\-]([\w\d]+))?$"),
+            lambda m: ["1080p", m.group(2)] if m.group(1) else ["1080p"],
+        ),
+        ResParser(
+            re.compile(r"DVD([\.\-]([\w\d]+))?$"),
+            lambda m: [None, "DVD", m.group(2)] if m.group(1) else [None, "DVD"],
+        ),
+        ResParser(RESOLUTION_PATTERN, lambda m: [m.group(0)]),
+    ]
+
+    def _match_resolution(self, word: str) -> tuple[str | None, set[str]]:
+        tags: list[str | None] = []
+        for mapper in self.RES_MAP:
+            match = mapper.pattern.match(word)
+            if match:
+                tags = mapper.mapping(match) if callable(mapper.mapping) else mapper.mapping
+                break
+
+        return tags[0] if tags else None, set(t for t in tags[1:] if t)
+
+    def parse(self, variant: str, video: VideoInfo) -> VideoInfo:
+        edition: str | None = None
+
+        variant_parts = variant.split(" ")
+
+        res, tags = self._match_resolution(variant_parts[0])
+        if res or tags:
+            edition = " ".join(variant_parts[1:])
+        elif len(variant_parts) > 1:
+            res, tags = self._match_resolution(variant_parts[-1])
+            edition = " ".join(variant_parts[:-1]) if res or tags else variant
+        else:
+            edition = variant
+
+        tags = (video.tags or set()).union(tags)
+
+        return VideoInfo(
+            extension=video.extension,
+            edition=edition if edition else None,
+            resolution=res,
+            tags=tags if tags else None,
+        )
+
+    def _tags_to_variant(self, video: VideoInfo) -> list[str]:
+        variant = super()._tags_to_variant(video)
+        if variant:
+            m = re.match(r"(\d{3,4})[pi]$", variant[0], flags=re.IGNORECASE)
+            if m:
+                res = m.group(1)
+                if res == "1080":
+                    return ["BD"]
+                elif res == "2160":
+                    return ["4k"]
+                elif res in ("480", "576"):
+                    return ["DVD"]
+        return variant
+
+
+class JellyfinLibrary(MediaLibrary):
+    def __init__(
+        self, base_dir: pathlib.Path, *, variant_parser: type[VariantParser] | None = None
+    ):
+        super().__init__(base_dir)
+        self.variant_parser = (
+            variant_parser(self) if variant_parser else SninerVariantParser(self)
+        )
+
+    @classmethod
+    def shortname(cls) -> str:
+        return "jellyfin"
+
+    def parse_movie_path(self, path: pathlib.Path) -> MovieInfo | None:
+        name = path.name
+        for regex in JELLYFIN_MOVIE_PATTERNS:
+            match = regex.match(name)
+            if match:
+                title = match.group("title").strip()
+                year = match.group("year") if "year" in match.groupdict() else None
+                provider_id = (
+                    match.group("provider_id") if "provider_id" in match.groupdict() else None
+                )
+                provider = movie_id = None
+                if provider_id:
+                    provider, movie_id = provider_id.split("-", 1)
+                    provider = provider.rstrip("id")
+                return MovieInfo(title=title, year=year, provider=provider, movie_id=movie_id)
+        return None
+
+    def movie_name(self, movie: MovieInfo) -> str:
+        parts = [movie.title]
+        if movie.year:
+            parts.append(f"({movie.year})")
+        if movie.provider and movie.movie_id:
+            parts.append(f"[{movie.provider}id-{movie.movie_id}]")
+        return " ".join(parts)
+
+    def video_name(self, movie: MovieInfo, video: VideoInfo) -> str:
+        return self.variant_parser.video_name(self.movie_name(movie), video)
+
+    def parse_video_path(self, path: pathlib.Path) -> VideoInfo | None:
+        base_name = path.stem
+        video = VideoInfo(extension=path.suffix)
+        parts = base_name.split(" - ")  # <spc><dash><spc> is required by Jellyfin for variants
+        if len(parts) > 1:
+            # Do no take the media id for an edition
+            if JELLYFIN_ID_PATTERN.match(parts[-1]):
+                return video
+            else:
+                # The variant is the substring after the final ' – ' in the filename.
+                variant = parts[-1].strip().lstrip("[").rstrip("]")
+                return self.variant_parser.parse(variant, video)
+        return video

jellyplex_sync/library.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import logging
+import pathlib
+import re
+from abc import ABC, abstractmethod
+from collections.abc import Generator
+from dataclasses import dataclass
+
+log = logging.getLogger(__name__)
+
+
+ACCEPTED_VIDEO_SUFFIXES = {".mkv", ".m4v"}
+RESOLUTION_PATTERN = re.compile(r"\d{3,4}[pi]$")
+
+
+@dataclass
+class MovieInfo:
+    """Metadata for the whole movie"""
+
+    title: str
+    year: str | None = None
+    provider: str | None = None
+    movie_id: str | None = None
+
+
+@dataclass
+class VideoInfo:
+    """Metadata for a single video file"""
+
+    extension: str
+    edition: str | None = None
+    resolution: str | None = None
+    tags: set[str] | None = None
+
+
+class MediaLibrary(ABC):
+    def __init__(self, base_dir: pathlib.Path):
+        self.base_dir = base_dir.resolve()
+
+    @classmethod
+    @abstractmethod
+    def shortname(cls) -> str: ...
+
+    @abstractmethod
+    def movie_name(self, movie: MovieInfo) -> str: ...
+
+    def movie_path(self, movie: MovieInfo) -> pathlib.Path:
+        return self.base_dir / self.movie_name(movie)
+
+    @abstractmethod
+    def video_name(self, movie: MovieInfo, video: VideoInfo) -> str: ...
+
+    def video_path(self, movie: MovieInfo, video: VideoInfo) -> pathlib.Path:
+        return self.movie_path(movie) / self.video_name(movie, video)
+
+    @abstractmethod
+    def parse_movie_path(self, path: pathlib.Path) -> MovieInfo | None: ...
+
+    @abstractmethod
+    def parse_video_path(self, path: pathlib.Path) -> VideoInfo | None: ...
+
+    def scan(self) -> Generator[tuple[pathlib.Path, MovieInfo], None, None]:
+        for entry in self.base_dir.glob("*"):
+            if not entry.is_dir():
+                continue
+
+            movie = self.parse_movie_path(entry)
+            if not movie:
+                log.warning("Ignoring folder with unparsable name: %s", entry.name)
+                continue
+
+            yield entry, movie

jellyplex_sync/plex.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import logging
+import pathlib
+import re
+from collections.abc import Generator
+
+from .library import (
+    RESOLUTION_PATTERN,
+    MediaLibrary,
+    MovieInfo,
+    VideoInfo,
+)
+
+log = logging.getLogger(__name__)
+
+
+PLEX_MOVIE_PATTERN = re.compile(r"^(?P<title>.+?)\s+\((?P<year>\d{4})\)")
+PLEX_META_BLOCK_PATTERN = re.compile(r"(\{([A-Za-z]+)-([^}]+)\})")
+PLEX_META_INFO_PATTERN = re.compile(r"(\[([^]]+)\])")
+PLEX_METADATA_PROVIDER = {"imdb", "tmdb", "tvdb"}
+
+
+class PlexLibrary(MediaLibrary):
+    @classmethod
+    def shortname(cls) -> str:
+        return "plex"
+
+    def movie_name(self, movie: MovieInfo) -> str:
+        parts = [movie.title]
+        if movie.year:
+            parts.append(f"({movie.year})")
+        if movie.provider and movie.movie_id:
+            parts.append(f"{{{movie.provider}-{movie.movie_id}}}")
+        return " ".join(parts)
+
+    def video_name(self, movie: MovieInfo, video: VideoInfo) -> str:
+        parts = [self.movie_name(movie)]
+        if video.edition:
+            parts.append(f"{{edition-{video.edition}}}")
+        if video.tags:
+            tags = [f"[{t}]" for t in video.tags]
+            parts.append("".join(tags))
+        if video.resolution:
+            parts.append(f"[{video.resolution}]")
+        return f"{' '.join(parts)}{video.extension}"
+
+    def _parse_meta_blocks(self, name: str) -> Generator[tuple[str, str, str], None, None]:
+        # Find all '{KEY-VALUE}' instances
+        for blk, key, val in PLEX_META_BLOCK_PATTERN.findall(name):
+            yield key, val, blk
+
+    def _parse_info_blocks(self, name: str) -> Generator[tuple[str, str], None, None]:
+        # Find all '[METADATA]' instances
+        for blk, info in PLEX_META_INFO_PATTERN.findall(name):
+            yield info, blk
+
+    def parse_movie_path(self, path: pathlib.Path) -> MovieInfo | None:
+        name = path.name
+
+        # Find metadata provider and movie id
+        leftover = name
+        provider = movie_id = None
+        for key, val, blk in self._parse_meta_blocks(name):
+            p = key.lower()
+            if p in PLEX_METADATA_PROVIDER:
+                provider = p.strip()
+                movie_id = val.strip()
+            leftover = leftover.replace(blk, "")
+
+        # Remove additional metadata
+        for _info, blk in self._parse_info_blocks(leftover):
+            leftover = leftover.replace(blk, "")
+
+        # Cleanup remaining text
+        leftover = re.sub(r"\s+", " ", leftover)
+        leftover = leftover.strip()
+
+        # Parse movie title and year
+        match = PLEX_MOVIE_PATTERN.match(leftover)
+        if match:
+            title = match.group("title").strip()
+            year = match.group("year") if "year" in match.groupdict() else None
+        else:
+            title = leftover
+            year = None
+
+        if title:
+            return MovieInfo(title=title, year=year, provider=provider, movie_id=movie_id)
+        else:
+            return None
+
+    def parse_video_path(self, path: pathlib.Path) -> VideoInfo | None:
+        name = path.stem
+        leftover = name
+
+        # Find edition
+        edition: str | None = None
+        for key, val, blk in self._parse_meta_blocks(name):
+            if key.lower() == "edition":
+                edition = val
+            leftover = leftover.replace(blk, "")
+
+        # Find additional metadata
+        tags: set[str] = set()
+        resolution: str | None = None
+        for info, blk in self._parse_info_blocks(leftover):
+            tag = info.strip()
+            if RESOLUTION_PATTERN.match(tag):
+                resolution = tag
+            else:
+                tags.add(tag)
+            leftover = leftover.replace(blk, "")
+
+        # Cleanup remaining text
+        leftover = re.sub(r"\s+", " ", leftover)
+        leftover = leftover.strip()
+
+        return VideoInfo(
+            edition=edition,
+            extension=path.suffix,
+            resolution=resolution,
+            tags=tags if tags else None,
+        )

jellyplex_sync/sync.py

@@ -0,0 +1,396 @@
+from __future__ import annotations
+
+import logging
+import pathlib
+import re
+from collections.abc import Generator
+from dataclasses import dataclass
+
+from . import utils
+from .jellyfin import (
+    JellyfinLibrary,
+)
+from .library import (
+    ACCEPTED_VIDEO_SUFFIXES,
+    MediaLibrary,
+    MovieInfo,
+    VideoInfo,
+)
+from .plex import (
+    PlexLibrary,
+)
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class LibraryStats:
+    movies_total: int = 0
+    movies_processed: int = 0
+    items_removed: int = 0
+
+
+def scan_media_library(
+    source: MediaLibrary,
+    target: MediaLibrary,
+    *,
+    dry_run: bool = False,
+    delete: bool = False,
+    stats: LibraryStats | None = None,
+) -> Generator[tuple[pathlib.Path, pathlib.Path, MovieInfo], None, None]:
+    """Iterate over the source library and determine all movie folders.
+    Yields a tuple for each movie folder:
+        (source: pathlib.Path, destination: pathlib.Path, movie: MovieInfo)
+    """
+    if source is target or source.base_dir == target.base_dir:
+        raise ValueError("Can not transfer library into itself")
+
+    stats = stats or LibraryStats()
+    movies_to_sync: dict[str, tuple[pathlib.Path, MovieInfo] | None] = {}
+    conflicting_source_dirs: dict[str, list[str]] = {}
+
+    # Inspect source libary for movie folders to sync
+    for entry, movie in source.scan():
+        target_name = target.movie_name(movie)
+        if target_name in movies_to_sync:
+            if target_name not in conflicting_source_dirs:
+                item = movies_to_sync[target_name]
+                conflicting_source_dirs[target_name] = [item[0].name] if item else []
+            conflicting_source_dirs[target_name].append(entry.name)
+            movies_to_sync[target_name] = None
+        else:
+            movies_to_sync[target_name] = (entry, movie)
+        stats.movies_total += 1
+
+    # If there are any conflicts we bail out now
+    if conflicting_source_dirs:
+        for dst, src in conflicting_source_dirs.items():
+            quoted = [f"'{s}'" for s in src]
+            log.error(f"Conflicting folders: {', '.join(quoted)} → '{dst}'")
+        log.info("You have to solve the conflicts first to proceed")
+        return
+
+    # Yield items for sync
+    for target_name, item in movies_to_sync.items():
+        if not item:
+            continue
+        stats.movies_processed += 1
+        yield item[0], target.base_dir / target_name, item[1]
+
+    # Remove stray items in target library
+    for entry in target.base_dir.iterdir():
+        if entry.name not in movies_to_sync:
+            if delete:
+                if dry_run:
+                    log.info("DELETE %s", entry)
+                else:
+                    log.info("Removing stray item '%s' in target library", entry.name)
+                    utils.remove(entry)
+                stats.items_removed += 1
+            else:
+                if not dry_run:
+                    log.info("Stray item '%s' found", entry.name)
+
+
+@dataclass
+class AssetStats:
+    files_total: int = 0
+    files_linked: int = 0
+    items_removed: int = 0
+
+
+def process_assets_folder(
+    source_path: pathlib.Path,
+    target_path: pathlib.Path,
+    *,
+    dry_run: bool = False,
+    delete: bool = False,
+    verbose: bool = False,
+    stats: AssetStats | None = None,
+) -> AssetStats:
+    if not source_path.is_dir():
+        raise ValueError(f"{source_path!s} is not a folder")
+
+    if not target_path.exists():
+        if dry_run:
+            log.info("MKDIR  %s", target_path)
+        else:
+            target_path.mkdir(parents=True, exist_ok=True)
+
+    stats = stats or AssetStats()
+    synced_items = {}
+
+    # Hardlink missing files and dive into subfolders
+    for entry in source_path.iterdir():
+        dest = target_path / entry.name
+        if entry.is_dir():
+            process_assets_folder(entry, dest, verbose=verbose, stats=stats, dry_run=dry_run)
+        elif entry.is_file():
+            if dest.exists():
+                if dest.samefile(entry):
+                    if verbose:
+                        log.debug("Target file '%s' already exists, skipping", entry.name)
+                else:
+                    if dry_run:
+                        log.info("RELINK %s", entry)
+                    else:
+                        dest.unlink()
+                        dest.hardlink_to(entry)
+                    stats.files_linked += 1
+            else:
+                if dry_run:
+                    log.info("LINK   %s", dest)
+                else:
+                    dest.hardlink_to(entry)
+                stats.files_linked += 1
+            stats.files_total += 1
+        synced_items[entry.name] = dest
+
+    if delete and target_path.is_dir():
+        # Remove stray items
+        for entry in target_path.iterdir():
+            if entry.name in synced_items:
+                continue
+            log.info("Removing stray item '%s' in target folder", entry.name)
+            if dry_run:
+                log.info("DELETE %s", entry.name)
+            else:
+                utils.remove(entry)
+            stats.items_removed += 1
+
+    return stats
+
+
+@dataclass
+class MovieStats:
+    videos_total: int = 0
+    videos_linked: int = 0
+    items_removed: int = 0
+    asset_items_total: int = 0
+    asset_items_linked: int = 0
+    asset_items_removed: int = 0
+
+
+def process_movie(
+    source: MediaLibrary,
+    target: MediaLibrary,
+    source_path: pathlib.Path,
+    movie: MovieInfo,
+    *,
+    dry_run: bool = False,
+    delete: bool = False,
+    verbose: bool = False,
+) -> MovieStats:
+    target_path = target.movie_path(movie)
+
+    if verbose:
+        log.info("Processing '%s' → '%s'", source_path.name, target_path.name)
+
+    stats = MovieStats()
+
+    videos_to_sync: dict[str, tuple[pathlib.Path, pathlib.Path]] = {}
+    assets_to_sync: dict[str, tuple[pathlib.Path, pathlib.Path]] = {}
+
+    # Scan for video files and assets
+    for entry in source_path.glob("*"):
+        if entry.is_file() and entry.suffix.lower() in ACCEPTED_VIDEO_SUFFIXES:
+            video = source.parse_video_path(entry)
+            video_path = target.video_path(
+                movie,
+                video or VideoInfo(extension=entry.suffix.lower()),
+            )
+            video_name = video_path.name
+            if video_name in videos_to_sync:
+                log.error("Conflicting video file '%s'. Aborting.", entry.name)
+                return MovieStats()
+            videos_to_sync[video_name] = (entry, video_path)
+            stats.videos_total += 1
+        elif entry.is_dir():
+            dir_name = entry.name
+            # TODO: Just a quick fix for selecting and manipulating directories
+            if dir_name.startswith("."):
+                log.debug("Ignoring asset folder '%s'", dir_name)
+                continue
+            assets_to_sync[dir_name] = (entry, target_path / dir_name)
+
+    if not target_path.exists():
+        if dry_run:
+            log.info("MKDIR  %s", target_path)
+        else:
+            target_path.mkdir(parents=True, exist_ok=True)
+
+    # Hardlink missing video files
+    for _video_name, item in videos_to_sync.items():
+        if item[1].exists():
+            if item[1].samefile(item[0]):
+                if verbose:
+                    log.info("Target video file '%s' already exists", item[1].name)
+                continue
+            else:
+                log.info("Replacing video file '%s' → '%s'", item[0].name, item[1].name)
+                if dry_run:
+                    log.info("DELETE %s", item[1])
+                else:
+                    item[1].unlink()
+        if dry_run:
+            log.info("LINK   %s", item[1])
+        else:
+            log.info("Linking video file '%s' → '%s'", item[0].name, item[1].name)
+            item[1].hardlink_to(item[0])
+        stats.videos_linked += 1
+
+    if delete and target_path.is_dir():
+        # Remove stray items
+        for entry in target_path.iterdir():
+            if entry.name in videos_to_sync or entry.name in assets_to_sync:
+                continue
+            if dry_run:
+                log.info("DELETE %s", entry)
+            else:
+                log.info(
+                    "Removing stray item '%s' in movie folder '%s'",
+                    entry.name,
+                    target_path.relative_to(target.base_dir),
+                )
+                utils.remove(entry)
+            stats.items_removed += 1
+
+    # Sync assets folders
+    for _, item in assets_to_sync.items():
+        s = process_assets_folder(
+            item[0],
+            item[1],
+            delete=delete,
+            verbose=verbose,
+            dry_run=dry_run,
+        )
+        stats.asset_items_total += s.files_total
+        stats.asset_items_linked += s.files_linked
+        stats.asset_items_removed += s.items_removed
+
+    return stats
+
+
+def determine_library_type(path: pathlib.Path) -> type[MediaLibrary] | None:
+    plex_hints: int = 0
+    jellyfin_hints: int = 0
+    for entry in path.rglob("*"):
+        if entry.suffix.lower() not in ACCEPTED_VIDEO_SUFFIXES:
+            continue
+        fname = entry.stem
+        # Check for provider id
+        if re.search(r"\[[a-z]+id-[^\]]+\]", fname, flags=re.IGNORECASE):
+            return JellyfinLibrary
+        if re.search(r"\{[a-z]+-[^\}]+\}", fname, flags=re.IGNORECASE):
+            return PlexLibrary
+        # Check for Plex edition
+        if re.search(r"\{edition-[^\}]+\}", fname, flags=re.IGNORECASE):
+            return PlexLibrary
+        # Check for hints
+        variant = fname.split(" - ")
+        if len(variant) > 1 and re.search(r"\(\d{4}\)", variant[-1]) is None:
+            jellyfin_hints += 1
+        if re.search(r"\[\d{3,4}[pi]\]", fname, flags=re.IGNORECASE):
+            plex_hints += 1
+        if re.search(r"\[[a-z0-9\.\,]+\]", fname, flags=re.IGNORECASE):
+            plex_hints += 1
+    if plex_hints > jellyfin_hints:
+        return PlexLibrary
+    elif jellyfin_hints > plex_hints:
+        return JellyfinLibrary
+    return None
+
+
+def sync(
+    source: str,
+    target: str,
+    *,
+    dry_run: bool = False,
+    delete: bool = False,
+    create: bool = False,
+    verbose: bool = False,
+    debug: bool = False,
+    convert_to: str | None = None,
+) -> int:
+    if debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+
+    source_path = pathlib.Path(source)
+    target_path = pathlib.Path(target)
+
+    if not convert_to or convert_to == "auto":
+        source_type = determine_library_type(source_path)
+        if not source_type:
+            log.error(
+                "Unable to determine source library type, please provide --convert-to option"
+            )
+            return 1
+        target_type = PlexLibrary if source_type == JellyfinLibrary else JellyfinLibrary
+    elif convert_to in (JellyfinLibrary.shortname(), PlexLibrary.shortname()):
+        target_type = PlexLibrary if convert_to == PlexLibrary.shortname() else JellyfinLibrary
+        source_type = PlexLibrary if target_type == JellyfinLibrary else JellyfinLibrary
+    else:
+        raise ValueError("Unknown value for parameter 'convert_to'")
+
+    source_lib = source_type(source_path)
+    target_lib = target_type(target_path)
+
+    if dry_run:
+        log.info("SOURCE %s", source_lib.base_dir)
+        log.info("TARGET %s", target_lib.base_dir)
+        log.info(
+            "CONVERTING %s TO %s",
+            source_lib.shortname().capitalize(),
+            target_lib.shortname().capitalize(),
+        )
+    else:
+        log.info(
+            "Syncing '%s' (%s) to '%s' (%s)",
+            source_lib.base_dir,
+            source_lib.shortname().capitalize(),
+            target_lib.base_dir,
+            target_lib.shortname().capitalize(),
+        )
+
+    if not source_lib.base_dir.is_dir():
+        log.error("Source directory '%s' does not exist", source_lib.base_dir)
+        return 1
+
+    if not target_lib.base_dir.is_dir():
+        if create:
+            target_lib.base_dir.mkdir(parents=True)
+        else:
+            log.error("Target directory '%s' does not exist", target_lib.base_dir)
+            return 1
+
+    stat_movies: int = 0
+    stat_items_linked: int = 0
+    stat_items_removed: int = 0
+    lib_stats = LibraryStats()
+
+    for src, _, movie in scan_media_library(
+        source_lib, target_lib, delete=delete, dry_run=dry_run, stats=lib_stats
+    ):
+        s = process_movie(
+            source_lib,
+            target_lib,
+            src,
+            movie,
+            delete=delete,
+            verbose=verbose,
+            dry_run=dry_run,
+        )
+        stat_movies += 1
+        stat_items_linked += s.asset_items_linked + s.videos_linked
+        stat_items_removed += s.asset_items_removed + s.items_removed
+
+    stat_items_removed += lib_stats.items_removed
+
+    summary = (
+        f"Summary: {stat_movies} movies found, "
+        f"{stat_items_linked} files updated, "
+        f"{stat_items_removed} files removed."
+    )
+    logging.info(summary)
+
+    return 0

jellyplex_sync/utils.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import logging
+import os
+import pathlib
+import shutil
+
+log = logging.getLogger(__name__)
+
+
+def remove(item: pathlib.Path) -> None:
+    if item.is_file() or item.is_symlink():
+        item.unlink()
+    elif item.is_dir():
+        shutil.rmtree(item)
+    else:
+        log.warning("Will not remove '%s'", item)
+
+
+def common_path(p1: pathlib.Path, p2: pathlib.Path) -> pathlib.Path | None:
+    try:
+        return pathlib.Path(os.path.commonpath([p1.resolve(), p2.resolve()]))
+    except ValueError:
+        return None

jellyplex_sync-0.1.5.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.3
+Name: jellyplex-sync
+Version: 0.1.5
+Summary: Convert your media library between Jellyfin and Plex formats by creating a hard-linked mirror
+Author: Stefan Schönberger
+Author-email: Stefan Schönberger <stefan@sniner.dev>
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Bidirectional Movie Library Sync for Plex and Jellyfin
+
+Can't decide between Jellyfin and Plex? This tool might help. It synchronizes your **movie library** between Jellyfin and Plex formats in **both directions** — without duplicating any files. Instead, it uses **hardlinks** to mirror your collection efficiently, saving storage while keeping both libraries in sync.
+
+> **Warning:** This script will **overwrite the entire target directory**. Do not store or edit anything manually in the target library path. The source library is treated as the **only source of truth**, and any unmatched content in the target folder may be deleted without warning.
+
+> **Note:** This tool is only useful if your media library is well-maintained and each movie resides in its own folder.
+
+## Overview
+
+The script scans the source library, parses each movie folder for metadata (title, year, optional provider ID), and reproduces the same directory structure in the target location. Rather than copying video files, it creates hard links to avoid extra storage usage. Asset folders (e.g., `extras`, `subtitles`) are also mirrored. With `--delete`, any files or folders in the target that are no longer present in the source will be removed.
+
+> ⚠️ **Important:** This script is designed exclusively for **movie libraries**. It does **not** support TV shows or miniseries. However, this is usually not a limitation in practice: for shows, Jellyfin and Plex use very similar directory structures, so you can typically point both apps to the same library without issues.
+
+> ⚠️ **Unraid:** This script is not compatible with Unraid User Scripts. If you do not want to use the container image, there is an older release in branch `unraid_user_scripts`. Switch to this branch and use the single-file script - but please don't forget to install the Python Plugin in Unraid first.
+
+## Docker Image
+
+If you want to build the docker image locally:
+
+```bash
+cd .../jellyplex-sync
+docker build -t jellyplex .
+```
+
+To run the docker container with the demo library in the project folder:
+
+```bash
+docker run --rm -it -v .:/mnt jellyplex /mnt/DEMO_PLEX_LIBRARY/Movies /mnt/DEMO_PLEX_LIBRARY/Jellyfin
+```
+
+## Usage
+
+Originally, this script was designed for use in Unraid as a standalone file. That version is still available in the `unraid_user_scripts` branch. On Unraid, the recommended way to run the script is via the Docker image. However, if you prefer to install the Python package locally (i.e. not on Unraid), the following examples show how you can use it as a CLI tool.
+
+### Docker usage
+
+To use the published container image without installing anything locally:
+
+```bash
+docker run --rm -it -v /your/media:/mnt ghcr.io/sniner/jellyplex-sync:latest /mnt/source /mnt/target
+```
+
+Example using the demo library included in the repo:
+
+```bash
+docker run --rm -it -v .:/mnt ghcr.io/sniner/jellyplex-sync:latest /mnt/DEMO_PLEX_LIBRARY/Movies /mnt/DEMO_PLEX_LIBRARY/Jellyfin
+```
+
+> Note: Make sure to adjust the volume mount (`-v`) so that both source and target paths are accessible inside the container. They must also reside within the same bind mount, otherwise hard links between source and target will not work.
+
+### Media server integration
+
+If you're using Unraid, you can add the included `jellyplex-sync.sh` script to the User Scripts plugin as a new custom script. This helper script pulls the latest container image (`ghcr.io/sniner/jellyplex-sync:latest`), removes any outdated images, and then runs the main sync operation.
+
+At the very bottom of the script, you'll find the actual command that runs the container. Make sure to adjust the source and target paths to match your own media library structure.
+
+> ⚠️ Important: The script runs in `--dry-run` mode by default. This means it won't make any changes yet — it will only show what would happen. Once you're confident everything is working as expected, you can remove the `--dry-run` flag to perform real changes.
+
+Although tailored for Unraid, this script can also be used on other NAS systems or Linux servers — simply schedule it as a cronjob to automate regular syncs or run it manually on demand. Docker must be installed for the script to work, as it relies on the containerized version of the tool.
+
+### Python CLI usage
+
+If you install the Python package locally, you can run the tool as follows:
+
+```bash
+jellyplex-sync [OPTIONS] /path/to/jellyfin/library /path/to/plex/library
+```
+
+### Options
+
+- `--create`
+  Create the target directory if it does not exist.
+
+- `--delete`
+  Remove movie folders and stray files in the target that are not present in the source.
+
+- `--verbose`
+  Show informational messages about each operation.
+
+- `--debug`
+  Enable debug-level logging for detailed parsing and linking steps.
+
+- `--dry-run`
+  Show what would be done, without performing any actual changes. No files will be created, deleted, or linked.
+
+- `--convert-to=...`
+  Choose between `jellyfin`, `plex` or `auto` (which is the default): `jellyfin` assumes the source library is in Plex format and creates a Jellyfin-compatible mirror. `plex` does the opposite. And `auto` inspects the source library and selects the appropriate conversion automatically.
+
+## Examples
+
+Mirror a Jellyfin library into an empty Plex structure:
+
+```bash
+jellyplex-sync --create ~/Media/Jellyfin ~/Media/Plex
+```
+
+Mirror and remove anything in the Plex folder that no longer exists in Jellyfin:
+
+```bash
+jellyplex-sync --delete ~/Media/Jellyfin ~/Media/Plex
+```
+
+Verbose output with full debug information:
+
+```bash
+jellyplex-sync --verbose --debug --delete --create ~/Media/Jellyfin ~/Media/Plex
+```
+
+## Behavior
+
+* **Hard links**: Video files are linked, not copied. This preserves disk space and ensures both libraries reflect the same physical files.
+
+* **Asset folders**: Subdirectories (e.g., `other`, `interviews`) are processed recursively with the same hard-link logic. NB: rename `extras` folder to `other` in your Jellyfin library, because Plex does not recognize `extras`.
+
+* **Stray items**: When `--delete` is used, any unexpected files or folders in the target library will be removed.
+
+## Jellyfin movie library outline
+
+This is the expected folder structure in your Jellyfin movie library. The script relies on it being consistent:
+
+```
+Movies
+├── A Bridge Too Far (1977) [imdbid-tt0075784]
+│   ├── A Bridge Too Far (1977) [imdbid-tt0075784].mkv
+│   └── trailers
+│       └── A Bridge Too Far.mkv
+└── Das Boot (1981) [imdbid-tt0082096]
+    ├── Das Boot (1981) [imdbid-tt0082096] - Director's Cut.mkv
+    ├── Das Boot (1981) [imdbid-tt0082096] - Theatrical Cut.mkv
+    └── other
+        ├── Production Photos.mkv
+        └── Making of.mkv
+```
+
+Each movie must reside in its own folder, with optional subfolders for extras. Different editions (e.g., Director's Cut, Theatrical Cut) must be named accordingly.
+
+### Special filename handling
+
+Jellyfin doesn't distinguish between editions (e.g., Director's Cut) and versions (e.g., 1080p vs. 4K). To work around this, I appended tags like "DVD", "BD", or "4K" to filenames in my personal library, ensuring the highest quality appears first and is selected by default in Jellyfin. Plex, on the other hand, supports editions natively and handles different versions via naming patterns and its internal version management. These specific tags are converted into Plex versions, while all other suffixes are treated as editions.
+
+This naming convention is something I came up with for my personal library — it's not part of any official Jellyfin standard. If your setup uses a different scheme, you may want to adjust the parsing behavior by switching to a different VariantParser, such as the simpler SimpleVariantParser.
+
+## Plex movie library outline
+
+Plex follows a more structured naming convention than Jellyfin. While Jellyfin typically appends edition or variant information using a ` - ` (space-hyphen-space) pattern, Plex supports additional metadata inside **curly braces** for editions and **square brackets** for versions or other details.
+
+Unlike Jellyfin, Plex’s naming system allows you to embed extra tags such as release source (`[BluRay]`), quality (`[4K]`), or codec (`[HEVC]`) directly in the filename. These tags are ignored by the default Plex scanners during media recognition, but remain visible in the interface — which makes them useful for organizing your collection without affecting playback or matching.
+
+> Note: This behavior applies to Plex's default scanner. If you use custom scanners or agents, they may treat these tags differently.
+
+I originally started with a Jellyfin-style library and converted it to be Plex-compatible. Over time, I came to prefer Plex's more expressive naming conventions and switched my personal collection to follow the Plex format. I now use Jellyfin mainly as a fallback for long-term archival and offline use.
+
+This is the expected folder structure in Plex format (with some demo tags):
+
+```
+Movies
+├── A Bridge Too Far (1977) {imdb-tt0075784}
+│   ├── A Bridge Too Far (1977) {imdb-tt0075784}.mkv
+│   └── trailers
+│       └── A Bridge Too Far.mkv
+└── Das Boot (1981) {imdb-tt0082096}
+    ├── Das Boot (1981) {imdb-tt0082096} {edition-Director's Cut} [1080p].mkv
+    ├── Das Boot (1981) {imdb-tt0082096} {edition-Theatrical Cut} [1080p][remux].mkv
+    └── other
+        ├── Production Photos.mkv
+        └── Making of.mkv
+```
+
+## License
+
+This project is licensed under the [BSD 2-Clause License](./LICENSE).
+
+## Disclaimer
+
+This is a private project written for personal use. It doesn't cover all use cases or environments. Use at your own risk. Contributions or forks are welcome if you want to adapt it to your own setup.

jellyplex_sync-0.1.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+jellyplex_sync/__init__.py,sha256=QhKzlkwLoMbGrYGaI6s8-glJ0EMJE0mf7grJX3_70tg,374
+jellyplex_sync/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jellyplex_sync/cli/sync.py,sha256=W3xJ9m5STLMvVfJmHLFkxPHd6mG8BGlwsOj0-SSIGmE,2102
+jellyplex_sync/jellyfin.py,sha256=xbH2EQAOFqcdte45D1xvoGGcO98EeyXO31nOnUYFX1Y,6822
+jellyplex_sync/library.py,sha256=AVh-XHOfnRKBnyVm0ELxaelraM7yxdQg352QP8Einwk,1901
+jellyplex_sync/plex.py,sha256=9HXiJA7jUp2nSqwpS3mxl_BTqc7CFoLJD1uhgnqKv00,3996
+jellyplex_sync/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jellyplex_sync/sync.py,sha256=bwAqB-t5-zPZICewn6z9Fz7clkf7JY8HX1HZkljAyM0,12911
+jellyplex_sync/utils.py,sha256=KFOJIKzC-d89QLy6h6qlyjpJ9q40CYjVEUQnMjfaKtc,553
+jellyplex_sync-0.1.5.dist-info/WHEEL,sha256=i9aSRDivn5iP9LaR1BLQX2GNAuriQWPsFwbbWygTX2k,81
+jellyplex_sync-0.1.5.dist-info/entry_points.txt,sha256=it5BeVJB-vjkxcgsY_voLpACQh37mksrOS_5jpQuOvo,65
+jellyplex_sync-0.1.5.dist-info/METADATA,sha256=TXjUGzGuF3oNXOx4ovJl4StaU-tWLU8150QLILgbLFQ,10433
+jellyplex_sync-0.1.5.dist-info/RECORD,,

jellyplex_sync-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.15
+Root-Is-Purelib: true
+Tag: py3-none-any

jellyplex_sync-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+jellyplex-sync = jellyplex_sync.cli.sync:main
+