jellyplex-sync 0.3.1__tar.gz → 0.3.2__tar.gz

{jellyplex_sync-0.3.1 → jellyplex_sync-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jellyplex-sync
-Version: 0.3.1
+Version: 0.3.2
 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>
@@ -62,11 +62,12 @@ docker build -t jellyplex-sync .
 
 ## Usage
 
-The CLI is split into three subcommands:
+The CLI is split into four subcommands:
 
 - **`sync`** — mirror a source library into the target layout (the historical operation; this is also the default if you omit the subcommand).
 - **`diff`** — read-only comparison of source and target. No filesystem changes. Useful before deleting your source after a migration.
 - **`plan`** — show the Plan a sync would execute (text or `--json`), without touching either side. Pre-flight check before sync, or machine-readable input for tooling.
+- **`import`** — **(experimental)** import video files from a staging area into a structured library. See below.
 
 ### `sync`
 
@@ -173,6 +174,49 @@ jellyplex-sync plan --json ~/Media/Plex ~/Media/Jellyfin \
     | jq '.movies[].videos[] | select(.disambiguation) | {source, target_name, disambiguation}'
 ```
 
+### `import` (experimental)
+
+> ⚠️ **This subcommand is experimental.** The exact behaviour may change in future releases as real-world use cases become clearer. Always start with `--dry-run`.
+
+```bash
+jellyplex-sync import [OPTIONS] /path/to/staging /path/to/target/library
+```
+
+Imports video files from a staging area — a flat directory (or directory tree) where properly named video files have been dumped without the one-folder-per-movie structure that `sync` expects. Files are grouped by their parsed movie identity (title, year, provider ID) and placed into the correct movie folder in the target library.
+
+Semantically distinct from `sync`:
+
+- `sync` mirrors a structured library; the source stays intact.
+- `import` ingests from an unstructured dump; the source files are **moved** (deleted after successful copy) by default.
+- `import` never removes anything from the target — it only adds.
+
+**Materializer flags** (mutually exclusive):
+
+- `--move` (default) — copy each file to the target, then delete the source.
+- `--copy` — copy files; the source is kept. Safe for a test run without `--dry-run`.
+
+Other flags: `--dry-run`, `--create`, `--source-format`, `--target-format`, `-v`, `--debug`.
+
+#### Limitations
+
+- **Loose non-video files** (posters, `.nfo`, subtitles) in the staging area are not imported — there is no folder to assign them to. The target media server can download its own metadata.
+- **Asset directories** (extras, trailers) in the staging area are not collected.
+- **No `--json` output** yet for import.
+
+#### Example
+
+Move Plex-named video files into a new Jellyfin library:
+
+```bash
+jellyplex-sync import --create /mnt/staging /mnt/library/Jellyfin
+```
+
+Preview first, keeping the source:
+
+```bash
+jellyplex-sync import --copy --dry-run /mnt/staging /mnt/library/Jellyfin
+```
+
 ### JSON output
 
 All three subcommands accept `--json` for machine-readable output. The document goes to **stdout**; logs continue to go to stderr. Under `--json`, INFO logs are suppressed unless you pass `--verbose` or `--debug`, so the output pipes cleanly into tools like `jq` without filtering.

{jellyplex_sync-0.3.1 → jellyplex_sync-0.3.2}/README.md

@@ -46,11 +46,12 @@ docker build -t jellyplex-sync .
 
 ## Usage
 
-The CLI is split into three subcommands:
+The CLI is split into four subcommands:
 
 - **`sync`** — mirror a source library into the target layout (the historical operation; this is also the default if you omit the subcommand).
 - **`diff`** — read-only comparison of source and target. No filesystem changes. Useful before deleting your source after a migration.
 - **`plan`** — show the Plan a sync would execute (text or `--json`), without touching either side. Pre-flight check before sync, or machine-readable input for tooling.
+- **`import`** — **(experimental)** import video files from a staging area into a structured library. See below.
 
 ### `sync`
 
@@ -157,6 +158,49 @@ jellyplex-sync plan --json ~/Media/Plex ~/Media/Jellyfin \
     | jq '.movies[].videos[] | select(.disambiguation) | {source, target_name, disambiguation}'
 ```
 
+### `import` (experimental)
+
+> ⚠️ **This subcommand is experimental.** The exact behaviour may change in future releases as real-world use cases become clearer. Always start with `--dry-run`.
+
+```bash
+jellyplex-sync import [OPTIONS] /path/to/staging /path/to/target/library
+```
+
+Imports video files from a staging area — a flat directory (or directory tree) where properly named video files have been dumped without the one-folder-per-movie structure that `sync` expects. Files are grouped by their parsed movie identity (title, year, provider ID) and placed into the correct movie folder in the target library.
+
+Semantically distinct from `sync`:
+
+- `sync` mirrors a structured library; the source stays intact.
+- `import` ingests from an unstructured dump; the source files are **moved** (deleted after successful copy) by default.
+- `import` never removes anything from the target — it only adds.
+
+**Materializer flags** (mutually exclusive):
+
+- `--move` (default) — copy each file to the target, then delete the source.
+- `--copy` — copy files; the source is kept. Safe for a test run without `--dry-run`.
+
+Other flags: `--dry-run`, `--create`, `--source-format`, `--target-format`, `-v`, `--debug`.
+
+#### Limitations
+
+- **Loose non-video files** (posters, `.nfo`, subtitles) in the staging area are not imported — there is no folder to assign them to. The target media server can download its own metadata.
+- **Asset directories** (extras, trailers) in the staging area are not collected.
+- **No `--json` output** yet for import.
+
+#### Example
+
+Move Plex-named video files into a new Jellyfin library:
+
+```bash
+jellyplex-sync import --create /mnt/staging /mnt/library/Jellyfin
+```
+
+Preview first, keeping the source:
+
+```bash
+jellyplex-sync import --copy --dry-run /mnt/staging /mnt/library/Jellyfin
+```
+
 ### JSON output
 
 All three subcommands accept `--json` for machine-readable output. The document goes to **stdout**; logs continue to go to stderr. Under `--json`, INFO logs are suppressed unless you pass `--verbose` or `--debug`, so the output pipes cleanly into tools like `jq` without filtering.

{jellyplex_sync-0.3.1 → jellyplex_sync-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jellyplex-sync"
-version = "0.3.1"
+version = "0.3.2"
 description = "Convert your media library between Jellyfin and Plex formats by creating a hard-linked mirror"
 authors = [{ name = "Stefan Schönberger", email = "stefan@sniner.dev" }]
 requires-python = ">=3.11"

{jellyplex_sync-0.3.1 → jellyplex_sync-0.3.2}/src/jellyplex_sync/__init__.py

@@ -23,6 +23,7 @@ from .materializer import (
     FileMaterializer,
     ForceCopyMaterializer,
     HardlinkMaterializer,
+    MoveMaterializer,
 )
 from .model import (
     MovieInfo,
@@ -43,6 +44,7 @@ from .sync import (
     DiffEntry,
     DiffResult,
     diff,
+    import_media,
     plan,
     sync,
 )
@@ -61,6 +63,7 @@ __all__ = [
     "FolderClash",
     "ForceCopyMaterializer",
     "HardlinkMaterializer",
+    "MoveMaterializer",
     "IgnoredEntry",
     "JellyfinLibraryReader",
     "JellyfinLibraryWriter",
@@ -80,6 +83,7 @@ __all__ = [
     "VideoInfo",
     "dedupe_drops",
     "diff",
+    "import_media",
     "plan",
     "sync",
 ]

{jellyplex_sync-0.3.1 → jellyplex_sync-0.3.2}/src/jellyplex_sync/cli/sync.py

@@ -7,7 +7,7 @@ import sys
 
 import jellyplex_sync as jp
 
-_SUBCOMMANDS = {"sync", "diff", "plan"}
+_SUBCOMMANDS = {"sync", "diff", "plan", "import"}
 
 
 def _build_parser() -> argparse.ArgumentParser:
@@ -97,6 +97,39 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     _add_io_args(plan_p)
 
+    import_p = sub.add_parser(
+        "import",
+        parents=[common],
+        help="Import video files from a staging area into a structured library.",
+    )
+    _add_io_args(import_p)
+    import_mode = import_p.add_mutually_exclusive_group()
+    import_mode.add_argument(
+        "--move",
+        dest="mode",
+        action="store_const",
+        const="move",
+        help="Move files: copy to target, then delete source (default).",
+    )
+    import_mode.add_argument(
+        "--copy",
+        dest="mode",
+        action="store_const",
+        const="copy",
+        help="Copy files; source is kept. On re-runs skip files whose size and mtime match.",
+    )
+    import_p.set_defaults(mode="move")
+    import_p.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be done, don't change anything on disk.",
+    )
+    import_p.add_argument(
+        "--create",
+        action="store_true",
+        help="Create the target library directory if it doesn't exist.",
+    )
+
     return parser
 
 
@@ -165,6 +198,8 @@ def main() -> None:
         result = _do_diff(args)
     elif args.command == "plan":
         result = _do_plan(args)
+    elif args.command == "import":
+        result = _do_import(args)
     else:
         parser.error(f"unknown command: {args.command!r}")
         result = 2
@@ -271,6 +306,34 @@ def _do_plan(args: argparse.Namespace) -> int:
         return 99
 
 
+def _do_import(args: argparse.Namespace) -> int:
+    from jellyplex_sync.sync import import_media
+
+    if args.mode == "move":
+        materializer = jp.MoveMaterializer()
+    else:
+        materializer = jp.CopyMaterializer()
+
+    try:
+        return import_media(
+            args.source,
+            args.target,
+            dry_run=args.dry_run,
+            create=args.create,
+            verbose=args.verbose,
+            debug=args.debug,
+            source_format=args.source_format,
+            target_format=args.target_format,
+            materializer=materializer,
+        )
+    except KeyboardInterrupt:
+        logging.info("INTERRUPTED")
+        return 10
+    except Exception as exc:
+        logging.error("Exception: %s", exc)
+        return 99
+
+
 def _resolve_formats_for_json(args: argparse.Namespace) -> tuple[str, str]:
     """Re-run the same format resolution `sync()` did so the JSON payload
     reports the formats that were actually used. Returns ('?', '?') if

{jellyplex_sync-0.3.1 → jellyplex_sync-0.3.2}/src/jellyplex_sync/discover.py

@@ -19,7 +19,8 @@ from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import Protocol
 
-from .library import ACCEPTED_VIDEO_SUFFIXES, IgnoredEntry
+from .library import ACCEPTED_VIDEO_SUFFIXES, IgnoredEntry, LibraryReader
+from .model import MovieInfo
 
 
 @dataclass(frozen=True)
@@ -86,3 +87,74 @@ class TwoLevelDiscoverer:
                 asset_dirs=tuple(sorted(assets)),
                 loose_files=tuple(sorted(loose)),
             )
+
+
+def _movie_key(movie: MovieInfo) -> tuple:
+    """Hashable grouping key derived from a MovieInfo. Two videos that
+    parse to the same title, year, and provider IDs end up in the same
+    group — labels and other ephemeral fields are excluded because they
+    vary per video, not per movie."""
+    return (movie.title, movie.year, tuple(sorted(movie.attributes.items())))
+
+
+class FlatDiscoverer:
+    """Discovers movies from individual video files, regardless of
+    directory structure. Every video file under `root` is parsed via
+    the supplied Reader to determine which movie it belongs to; files
+    with the same title, year, and provider IDs are grouped together.
+
+    Designed for staging-area workflows where video files are dumped
+    without the standard one-folder-per-movie layout. Scans
+    recursively, so half-sorted structures (files in random
+    subdirectories) are handled too.
+
+    Takes a `LibraryReader` because grouping requires format-aware
+    parsing — a deliberate trade-off: the TwoLevelDiscoverer is
+    format-agnostic (folders are the grouping), but flat sources
+    need filename parsing to find group boundaries.
+
+    Loose files and asset directories are not collected — in a flat
+    staging area there's no folder to assign them to. The target media
+    server can download its own metadata after the sync."""
+
+    def __init__(self, reader: LibraryReader) -> None:
+        self._reader = reader
+
+    def discover(
+        self,
+        root: pathlib.Path,
+        *,
+        ignored: list[IgnoredEntry] | None = None,
+    ) -> Iterable[DiscoveredGroup]:
+        groups: dict[tuple, list[pathlib.Path]] = {}
+        source_paths: dict[tuple, pathlib.Path] = {}
+
+        for path in sorted(root.rglob("*")):
+            if not path.is_file():
+                continue
+            if path.name.startswith("."):
+                continue
+            if path.suffix.lower() not in ACCEPTED_VIDEO_SUFFIXES:
+                if ignored is not None:
+                    ignored.append(IgnoredEntry(path, "not a video file"))
+                continue
+
+            synthetic_folder = pathlib.Path(root / path.stem)
+            movie = self._reader.parse_movie(synthetic_folder)
+            if movie is None:
+                if ignored is not None:
+                    ignored.append(IgnoredEntry(path, "unparseable video filename"))
+                continue
+
+            key = _movie_key(movie)
+            groups.setdefault(key, []).append(path)
+            if key not in source_paths:
+                source_paths[key] = synthetic_folder
+
+        for key, video_files in groups.items():
+            yield DiscoveredGroup(
+                source_path=source_paths[key],
+                video_files=tuple(sorted(video_files)),
+                asset_dirs=(),
+                loose_files=(),
+            )

{jellyplex_sync-0.3.1 → jellyplex_sync-0.3.2}/src/jellyplex_sync/materializer.py

@@ -146,6 +146,60 @@ class ForceCopyMaterializer:
         )
 
 
+class MoveMaterializer:
+    """Copy bytes from `src` to `dst`, then delete `src` on success.
+
+    Designed for staging-area workflows where the source is a temporary
+    dump and the target is the permanent library. Once the target file
+    is safely written (via `shutil.copy2`), the source is removed.
+
+    Re-run safety: if the target already exists with matching size and
+    mtime, the source is assumed to have been moved in a previous run
+    (or the copy was already successful) and is left alone.
+
+    If the source no longer exists but the target does, the file is
+    treated as already moved and silently skipped.
+    """
+
+    name = "move"
+
+    def materialize(
+        self,
+        src: pathlib.Path,
+        dst: pathlib.Path,
+        *,
+        dry_run: bool = False,
+        verbose: bool = False,
+        events: list[FileEvent] | None = None,
+    ) -> bool:
+        if not src.exists():
+            if dst.exists():
+                if verbose:
+                    log.info("Already moved '%s'", dst.name)
+                if events is not None:
+                    events.append(FileEvent(action="skip", target=dst))
+                return False
+            log.warning("Source '%s' does not exist, skipping", src)
+            return False
+
+        if dst.exists() and _same_size_and_mtime(src, dst):
+            if verbose:
+                log.info("Target '%s' is up to date, removing source", dst.name)
+            if events is not None:
+                events.append(FileEvent(action="skip", target=dst, source=src))
+            if not dry_run:
+                src.unlink()
+            return False
+
+        result = _copy(
+            src, dst, dry_run=dry_run, replaces_existing=dst.exists(), events=events
+        )
+        if result and not dry_run:
+            src.unlink()
+            log.info("Removed source '%s'", src.name)
+        return result
+
+
 def _same_size_and_mtime(a: pathlib.Path, b: pathlib.Path) -> bool:
     a_stat = a.stat()
     b_stat = b.stat()

{jellyplex_sync-0.3.1 → jellyplex_sync-0.3.2}/src/jellyplex_sync/sync.py

@@ -19,7 +19,8 @@ from .library import (
     Reporter,
     dedupe_drops,
 )
-from .materializer import FileMaterializer, HardlinkMaterializer
+from .discover import FlatDiscoverer
+from .materializer import FileMaterializer, HardlinkMaterializer, MoveMaterializer
 from .planner import Planner
 from .plex import PlexLibraryReader, PlexLibraryWriter
 from .realize import Realizer, RealizeStats
@@ -575,3 +576,123 @@ def _print_plan(
 
 def _count_asset_files(asset) -> int:
     return len(asset.files) + sum(_count_asset_files(sf) for sf in asset.subfolders)
+
+
+# ---------------------------------------------------------------------------
+# import: move files from a staging area into a structured library
+# ---------------------------------------------------------------------------
+
+
+def import_media(
+    source: str,
+    target: str,
+    *,
+    dry_run: bool = False,
+    create: bool = False,
+    verbose: bool = False,
+    debug: bool = False,
+    source_format: str | None = None,
+    target_format: str | None = None,
+    reporter: Reporter | None = None,
+    materializer: FileMaterializer | None = None,
+    stats: LibraryStats | None = None,
+) -> int:
+    """Import video files from a staging area into a structured library.
+
+    Unlike `sync`, this uses `FlatDiscoverer` (groups by filename
+    parsing, not folder structure) and defaults to `MoveMaterializer`
+    (copy + delete source). The source can be a flat dump of video
+    files, a partially organised directory tree, or a mix.
+
+    Does not touch existing content in the target — it only adds.
+    """
+    if debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+
+    reporter = reporter or LoggingReporter(verbose=verbose)
+    materializer = materializer or MoveMaterializer()
+    source_path = pathlib.Path(source)
+    target_path = pathlib.Path(target)
+
+    resolved = _resolve_formats(source_path, source_format, target_format)
+    if resolved is None:
+        return 1
+    source_short, target_short = resolved
+
+    source_reader_cls, _ = _LIBRARY_TYPES[source_short]
+    _, target_writer_cls = _LIBRARY_TYPES[target_short]
+    source_reader = source_reader_cls(source_path)
+    target_writer = target_writer_cls(target_path)
+
+    if dry_run:
+        log.info("SOURCE %s (staging)", source_reader.base_dir)
+        log.info("TARGET %s", target_writer.base_dir)
+        log.info("IMPORTING %s → %s", source_short.capitalize(), target_short.capitalize())
+    else:
+        log.info(
+            "Importing from '%s' (%s) into '%s' (%s)",
+            source_reader.base_dir,
+            source_short.capitalize(),
+            target_writer.base_dir,
+            target_short.capitalize(),
+        )
+
+    if not source_reader.base_dir.is_dir():
+        log.error("Source directory '%s' does not exist", source_reader.base_dir)
+        return 1
+
+    if not target_writer.base_dir.is_dir():
+        if create:
+            target_writer.base_dir.mkdir(parents=True)
+        else:
+            log.error("Target directory '%s' does not exist", target_writer.base_dir)
+            return 1
+
+    lib_stats = stats if stats is not None else LibraryStats()
+
+    planner = Planner(
+        reader=source_reader,
+        writer=target_writer,
+        discoverer=FlatDiscoverer(source_reader),
+        reporter=reporter,
+    )
+    plan = planner.plan()
+
+    realize_stats = RealizeStats()
+    Realizer(materializer=materializer).apply(
+        plan,
+        dry_run=dry_run,
+        delete=False,
+        verbose=verbose,
+        stats=realize_stats,
+    )
+
+    lib_stats.movies_total += len(plan.movies)
+    lib_stats.movies_processed += realize_stats.movies_processed
+    lib_stats.items_linked += realize_stats.files_linked
+    lib_stats.ignored.extend(plan.ignored)
+    lib_stats.events.extend(realize_stats.events)
+    lib_stats.clashes.extend(plan.clashes)
+
+    verb = "moved" if isinstance(materializer, MoveMaterializer) else "copied"
+    summary = (
+        f"Summary: {lib_stats.movies_processed} movies imported, "
+        f"{lib_stats.items_linked} files {verb}, "
+        f"{len(lib_stats.ignored)} ignored, "
+        f"{len(lib_stats.clashes)} skipped due to clash."
+    )
+    log.info(summary)
+
+    if lib_stats.ignored:
+        log.info("Ignored item(s) in source (not imported):")
+        for item in lib_stats.ignored:
+            log.info("  '%s' (%s)", item.path.name, item.reason)
+
+    if lib_stats.clashes:
+        log.warning(
+            "%d movie(s) skipped because two or more source files map to the "
+            "same target name. Rename and re-run.",
+            len(lib_stats.clashes),
+        )
+
+    return 0