vflow-cli 0.1.3__tar.gz → 0.1.5__tar.gz

{vflow_cli-0.1.3 → vflow_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vflow-cli
-Version: 0.1.3
+Version: 0.1.5
 Summary: The v-flow CLI and Claude skills bundle for automating media backup and processing workflows for videographers.
 Author-email: Kaung <kaungzinye@gmail.com>
 Requires-Python: >=3.8

{vflow_cli-0.1.3 → vflow_cli-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vflow-cli"
-version = "0.1.3"
+version = "0.1.5"
 description = "The v-flow CLI and Claude skills bundle for automating media backup and processing workflows for videographers."
 authors = [{ name = "Kaung", email = "kaungzinye@gmail.com" }]
 readme = "README.md"

{vflow_cli-0.1.3 → vflow_cli-0.1.5}/src/vflow/actions.py

@@ -12,6 +12,8 @@ main.py and tests import ``actions.*``; the real implementations live in:
 from .ingest_service import (  # noqa: F401
     ingest_report,
     ingest_shoot,
+    photo_ingest,
+    card_report,
     prep_shoot,
     pull_shoot,
 )
@@ -25,6 +27,7 @@ from .delivery_service import (  # noqa: F401
 from .backup_service import (  # noqa: F401
     consolidate_files,
     verify_backup,
+    card_verify,
     list_backups,
     restore_folder,
     list_duplicates,

{vflow_cli-0.1.3 → vflow_cli-0.1.5}/src/vflow/backup_service.py

@@ -588,6 +588,140 @@ def restore_folder(
         typer.echo(f"Errors: {errors}", err=True)
 
 
+def card_verify(
+    source_dir: str,
+    archive_path: Path,
+    photo_shoot: Optional[str] = None,
+) -> None:
+    """
+    Verifies card contents against the archive before formatting.
+
+    Videos are checked archive-wide (Video/RAW) by name+size.
+    Photos are checked against the specific Photo/RAW/<photo_shoot> folder only,
+    to avoid Sony filename-recycling false positives.
+    """
+    source_path = Path(source_dir)
+    if not source_path.exists() or not source_path.is_dir():
+        typer.echo(f"Source directory not found: {source_path}", err=True)
+        raise typer.Exit(code=1)
+
+    video_folder = source_path / "private" / "M4ROOT" / "CLIP"
+    photo_folder = source_path / "DCIM" / "100MSDCF"
+
+    video_extensions = {".mp4", ".mov", ".mxf", ".mts", ".avi", ".m4v", ".braw", ".r3d", ".crm"}
+    photo_extensions = {".arw", ".cr2", ".cr3", ".nef", ".dng", ".orf", ".rw2"}
+
+    has_videos = video_folder.exists() and video_folder.is_dir()
+    has_photos = photo_folder.exists() and photo_folder.is_dir()
+
+    typer.echo("\n" + "=" * 70)
+    typer.echo("CARD VERIFY")
+    typer.echo("=" * 70)
+    typer.echo(f"Card: {source_path}")
+
+    overall_pass = True
+
+    # VIDEO VERIFICATION
+    if has_videos:
+        video_files: list[Path] = [
+            f for f in video_folder.rglob("*")
+            if f.is_file() and f.suffix.lower() in video_extensions
+        ]
+
+        archive_video_raw = archive_path / "Video" / "RAW"
+        archive_video_index: set[tuple[str, int]] = set()
+        if archive_video_raw.exists():
+            for f in archive_video_raw.rglob("*"):
+                if f.is_file() and f.suffix.lower() in video_extensions:
+                    try:
+                        archive_video_index.add((f.name, f.stat().st_size))
+                    except (OSError, FileNotFoundError):
+                        pass
+
+        missing_videos: list[str] = []
+        for f in video_files:
+            try:
+                key = (f.name, f.stat().st_size)
+            except (OSError, FileNotFoundError):
+                missing_videos.append(f.name)
+                continue
+            if key not in archive_video_index:
+                missing_videos.append(f.name)
+
+        video_pass = len(missing_videos) == 0
+        if not video_pass:
+            overall_pass = False
+
+        typer.echo(f"\nVIDEOS  (checked archive-wide under Video/RAW)")
+        typer.echo(f"  On card:       {len(video_files)}")
+        typer.echo(f"  In archive:    {len(video_files) - len(missing_videos)}")
+        typer.echo(f"  Missing:       {len(missing_videos)}")
+        typer.echo(f"  Result:        {'PASS' if video_pass else 'FAIL'}")
+        if missing_videos:
+            typer.echo("  Missing files:")
+            for name in missing_videos[:20]:
+                typer.echo(f"    - {name}")
+            if len(missing_videos) > 20:
+                typer.echo(f"    ... and {len(missing_videos) - 20} more.")
+    else:
+        typer.echo(f"\nVIDEOS  — card folder not found, skipping ({video_folder})")
+
+    # PHOTO VERIFICATION
+    if has_photos:
+        if not photo_shoot:
+            typer.echo("\nPHOTOS  — skipped (no --photo-shoot provided)")
+        else:
+            photo_files: list[Path] = [
+                f for f in photo_folder.rglob("*")
+                if f.is_file() and f.suffix.lower() in photo_extensions
+            ]
+
+            shoot_photo_dir = archive_path / "Photo" / "RAW" / photo_shoot
+            shoot_photo_index: set[tuple[str, int]] = set()
+            if shoot_photo_dir.exists():
+                for f in shoot_photo_dir.iterdir():
+                    if f.is_file() and f.suffix.lower() in photo_extensions:
+                        try:
+                            shoot_photo_index.add((f.name, f.stat().st_size))
+                        except (OSError, FileNotFoundError):
+                            pass
+            else:
+                typer.echo(f"\nPHOTOS  — shoot folder not found: {shoot_photo_dir}", err=True)
+                overall_pass = False
+
+            missing_photos: list[str] = []
+            for f in photo_files:
+                try:
+                    key = (f.name, f.stat().st_size)
+                except (OSError, FileNotFoundError):
+                    missing_photos.append(f.name)
+                    continue
+                if key not in shoot_photo_index:
+                    missing_photos.append(f.name)
+
+            photo_pass = len(missing_photos) == 0
+            if not photo_pass:
+                overall_pass = False
+
+            typer.echo(f"\nPHOTOS  (checked against Photo/RAW/{photo_shoot} only)")
+            typer.echo(f"  On card:       {len(photo_files)}")
+            typer.echo(f"  In shoot:      {len(photo_files) - len(missing_photos)}")
+            typer.echo(f"  Missing:       {len(missing_photos)}")
+            typer.echo(f"  Result:        {'PASS' if photo_pass else 'FAIL'}")
+            if missing_photos:
+                typer.echo("  Missing files:")
+                for name in missing_photos[:20]:
+                    typer.echo(f"    - {name}")
+                if len(missing_photos) > 20:
+                    typer.echo(f"    ... and {len(missing_photos) - 20} more.")
+    else:
+        typer.echo(f"\nPHOTOS  — card folder not found, skipping ({photo_folder})")
+
+    typer.echo("\n" + "=" * 70)
+    typer.echo(f"OVERALL: {'PASS — safe to format card' if overall_pass else 'FAIL — do not format, files missing from archive'}")
+    typer.echo("=" * 70 + "\n")
+
+
 def list_duplicates(
     root: Path, max_age_hours: Optional[int] = None
 ) -> list[tuple[tuple[str, int], list[Path]]]:

{vflow_cli-0.1.3 → vflow_cli-0.1.5}/src/vflow/config.py

@@ -42,3 +42,7 @@ def get_location(config: dict, name: str) -> Path:
 def get_setting(config: dict, key: str, default: any = None) -> any:
     """Gets a setting from the config, returning default if not found."""
     return config.get("settings", {}).get(key, default)
+
+def save_config(config: dict) -> None:
+    with open(CONFIG_PATH, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False, allow_unicode=True)

{vflow_cli-0.1.3 → vflow_cli-0.1.5}/src/vflow/ingest_service.py

@@ -592,6 +592,200 @@ def ingest_shoot(
     typer.echo(f"{'=' * 70}\n")
 
 
+def photo_ingest(
+    source_dir: str,
+    shoot_name: str,
+    archive_path: Path,
+) -> None:
+    """
+    Copies new RAW photo files from source_dir to archive_path/Photo/RAW/<shoot_name>.
+    Skips files that already exist in that specific shoot folder by name+size.
+    Preserves timestamps using shutil.copy2.
+    """
+    source_path = Path(source_dir)
+    if not source_path.exists() or not source_path.is_dir():
+        typer.echo(f"Source directory not found: {source_path}", err=True)
+        raise typer.Exit(code=1)
+
+    photo_extensions = {".arw", ".cr2", ".cr3", ".nef", ".dng", ".orf", ".rw2"}
+
+    all_files: list[Path] = []
+    for file_path in source_path.rglob("*"):
+        if file_path.is_file() and file_path.suffix.lower() in photo_extensions:
+            all_files.append(file_path)
+
+    if not all_files:
+        typer.echo("No RAW photo files found in source directory.", err=True)
+        return
+
+    shoot_dir = archive_path / "Photo" / "RAW" / shoot_name
+    try:
+        shoot_dir.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        typer.echo(f"Could not create shoot directory: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    # Build index of files already in this specific shoot folder only (not archive-wide)
+    shoot_index: set[tuple[str, int]] = set()
+    for f in shoot_dir.iterdir():
+        if f.is_file() and f.suffix.lower() in photo_extensions:
+            try:
+                shoot_index.add((f.name, f.stat().st_size))
+            except (OSError, FileNotFoundError):
+                pass
+
+    typer.echo(f"\nSource: {source_path}")
+    typer.echo(f"Destination: {shoot_dir}")
+    typer.echo(f"Found: {len(all_files)} RAW file(s) on card")
+    typer.echo(f"Already in shoot folder: {len(shoot_index)} file(s)")
+
+    copied_count = 0
+    skipped_count = 0
+    error_count = 0
+
+    with typer.progressbar(all_files, label=f"Photo ingest {shoot_name}") as progress:
+        for file_path in progress:
+            try:
+                size = file_path.stat().st_size
+            except (OSError, FileNotFoundError):
+                error_count += 1
+                continue
+
+            key = (file_path.name, size)
+            if key in shoot_index:
+                skipped_count += 1
+                continue
+
+            dest_file = shoot_dir / file_path.name
+            try:
+                shutil.copy2(str(file_path), str(dest_file))
+                shoot_index.add(key)
+                copied_count += 1
+            except Exception as e:
+                typer.echo(f"\n[ERROR] Could not copy {file_path.name}: {e}", err=True)
+                error_count += 1
+
+    typer.echo(f"\n{'=' * 70}")
+    typer.echo("PHOTO INGEST COMPLETE")
+    typer.echo(f"{'=' * 70}")
+    typer.echo(f"Copied:  {copied_count}")
+    typer.echo(f"Skipped: {skipped_count} (already exist in shoot folder)")
+    typer.echo(f"Errors:  {error_count}")
+    typer.echo(f"{'=' * 70}\n")
+
+
+def card_report(
+    source_dir: str,
+    archive_path: Path,
+) -> None:
+    """
+    Reports what's on a card. Auto-detects video (private/M4ROOT/CLIP) and photo
+    (DCIM/100MSDCF) folders, groups files by date, and shows first/last filename,
+    count, and whether videos are already in the archive.
+    """
+    source_path = Path(source_dir)
+    if not source_path.exists() or not source_path.is_dir():
+        typer.echo(f"Source directory not found: {source_path}", err=True)
+        raise typer.Exit(code=1)
+
+    video_folder = source_path / "private" / "M4ROOT" / "CLIP"
+    photo_folder = source_path / "DCIM" / "100MSDCF"
+
+    video_extensions = {".mp4", ".mov", ".mxf", ".mts", ".avi", ".m4v", ".braw", ".r3d", ".crm"}
+    photo_extensions = {".arw", ".cr2", ".cr3", ".nef", ".dng", ".orf", ".rw2"}
+
+    typer.echo("\n" + "=" * 70)
+    typer.echo("CARD REPORT")
+    typer.echo("=" * 70)
+    typer.echo(f"Card: {source_path}")
+
+    # Build archive-wide video index for presence check
+    archive_video_raw = archive_path / "Video" / "RAW"
+    archive_video_index: set[tuple[str, int]] = set()
+    if archive_video_raw.exists():
+        for f in archive_video_raw.rglob("*"):
+            if f.is_file() and f.suffix.lower() in video_extensions:
+                try:
+                    archive_video_index.add((f.name, f.stat().st_size))
+                except (OSError, FileNotFoundError):
+                    pass
+
+    from collections import defaultdict
+
+    # VIDEO SECTION
+    if video_folder.exists() and video_folder.is_dir():
+        video_files: list[Path] = []
+        for f in video_folder.rglob("*"):
+            if f.is_file() and f.suffix.lower() in video_extensions:
+                video_files.append(f)
+
+        typer.echo(f"\nVIDEOS  ({video_folder})")
+        typer.echo("-" * 70)
+
+        if not video_files:
+            typer.echo("  No video files found.")
+        else:
+            by_date: dict = defaultdict(list)
+            for f in video_files:
+                try:
+                    d = _get_media_date(f).date()
+                    by_date[d].append(f)
+                except Exception:
+                    continue
+
+            for d in sorted(by_date.keys()):
+                day_files = sorted(by_date[d], key=lambda f: f.name)
+                count = len(day_files)
+                first = day_files[0].name
+                last = day_files[-1].name
+                on_archive = sum(
+                    1 for f in day_files
+                    if (f.name, f.stat().st_size) in archive_video_index
+                )
+                hdd_label = f"{on_archive}/{count} on HDD" if on_archive > 0 else "NOT on HDD"
+                if first == last:
+                    typer.echo(f"  {d}  {count} file(s)  [{first}]  {hdd_label}")
+                else:
+                    typer.echo(f"  {d}  {count} file(s)  [{first} .. {last}]  {hdd_label}")
+    else:
+        typer.echo(f"\nVIDEOS  — folder not found ({video_folder})")
+
+    # PHOTO SECTION
+    if photo_folder.exists() and photo_folder.is_dir():
+        photo_files: list[Path] = []
+        for f in photo_folder.rglob("*"):
+            if f.is_file() and f.suffix.lower() in photo_extensions:
+                photo_files.append(f)
+
+        typer.echo(f"\nPHOTOS  ({photo_folder})")
+        typer.echo("-" * 70)
+
+        if not photo_files:
+            typer.echo("  No RAW photo files found.")
+        else:
+            by_date_p: dict = defaultdict(list)
+            for f in photo_files:
+                try:
+                    d = _get_media_date(f).date()
+                    by_date_p[d].append(f)
+                except Exception:
+                    continue
+
+            for d in sorted(by_date_p.keys()):
+                day_files = sorted(by_date_p[d], key=lambda f: f.name)
+                count = len(day_files)
+                first = day_files[0].name
+                last = day_files[-1].name
+                if first == last:
+                    typer.echo(f"  {d}  {count} file(s)  [{first}]")
+                else:
+                    typer.echo(f"  {d}  {count} file(s)  [{first} .. {last}]")
+    else:
+        typer.echo(f"\nPHOTOS  — folder not found ({photo_folder})")
+
+    typer.echo("\n" + "=" * 70 + "\n")
+
+
 def prep_shoot(shoot_name: str, laptop_ingest_path: Path, work_ssd_path: Path) -> None:
     """
     Moves a shoot from the ingest area to the working SSD and creates the project structure.

{vflow_cli-0.1.3 → vflow_cli-0.1.5}/src/vflow/main.py

@@ -63,6 +63,57 @@ def ingest_report_cmd(
     laptop_dest = config.get_location(app_config, "laptop")
     actions.ingest_report(source, archive_dest, laptop_path=laptop_dest, priority_day=priority_day, priority_month=priority_month)
 
+@app.command("photo-ingest")
+def photo_ingest_cmd(
+    source: str = typer.Option(..., "--source", "-s", help="Folder containing RAW photo files (e.g., '/Volumes/Untitled/DCIM/100MSDCF')."),
+    shoot: str = typer.Option(..., "--shoot", "-n", help="Name of the shoot folder to create/add to in Photo/RAW (e.g., 'Iceland Trip')."),
+):
+    """
+    Copies new RAW photos from a card or folder into the photo archive.
+
+    Files are compared against the specific shoot folder only (not archive-wide) to
+    avoid Sony filename-recycling false positives. Timestamps are preserved.
+    Supported formats: ARW, CR2, CR3, NEF, DNG, ORF, RW2.
+    """
+    app_config = config.load_config()
+    archive_dest = config.get_location(app_config, "archive_hdd")
+    actions.photo_ingest(source, shoot, archive_dest)
+
+
+@app.command("card-report")
+def card_report_cmd(
+    source: str = typer.Option(..., "--source", "-s", help="Card root directory (e.g., '/Volumes/Untitled')."),
+):
+    """
+    Shows what's on a card, grouped by date.
+
+    Auto-detects the video folder (private/M4ROOT/CLIP) and photo folder (DCIM/100MSDCF).
+    For each section, shows date, first/last filename, count, and whether video files
+    are already in the archive.
+    """
+    app_config = config.load_config()
+    archive_dest = config.get_location(app_config, "archive_hdd")
+    actions.card_report(source, archive_dest)
+
+
+@app.command("card-verify")
+def card_verify_cmd(
+    source: str = typer.Option(..., "--source", "-s", help="Card root directory (e.g., '/Volumes/Untitled')."),
+    photo_shoot: Optional[str] = typer.Option(None, "--photo-shoot", help="Name of the photo shoot in Photo/RAW to verify photos against (required if card has photos)."),
+):
+    """
+    Verifies card contents are safely in the archive before formatting.
+
+    Videos are checked archive-wide (Video/RAW) by name+size.
+    Photos are checked against a specific shoot folder only (Photo/RAW/<photo-shoot>),
+    avoiding Sony filename-recycling false positives across shoots.
+    Reports PASS or FAIL separately for videos and photos.
+    """
+    app_config = config.load_config()
+    archive_dest = config.get_location(app_config, "archive_hdd")
+    actions.card_verify(source, archive_dest, photo_shoot=photo_shoot)
+
+
 @app.command("list-duplicates")
 def list_duplicates_cmd(
     location: str = typer.Option("archive", "--location", "-l", help="Where to scan: 'archive', 'laptop', or 'both'"),
@@ -394,6 +445,56 @@ def copy_meta(
 
 
 
+LOCATION_KEYS = {"laptop", "work_ssd", "archive_hdd"}
+
+@app.command()
+def locations():
+    """Show configured v-flow paths and whether they are currently mounted."""
+    app_config = config.load_config()
+    locs = app_config.get("locations", {})
+    settings = app_config.get("settings", {})
+    typer.echo("Locations:")
+    for key, path in locs.items():
+        mounted = "✓" if Path(path).exists() else "✗ not mounted"
+        typer.echo(f"  {key}: {path}  [{mounted}]")
+    if settings:
+        typer.echo("Settings:")
+        for key, val in settings.items():
+            typer.echo(f"  {key}: {val}")
+
+
+@app.command("set")
+def set_config(
+    key: str = typer.Argument(help="Config key to update. Location keys: laptop, work_ssd, archive_hdd. Settings: settings.<key> (e.g. settings.default_split_gap)."),
+    value: str = typer.Argument(help="New value for the key."),
+):
+    """Update a single config value without re-running setup.
+
+    Examples:
+      v-flow set archive_hdd "/Volumes/Kaung HDD/MediaArchive"
+      v-flow set laptop "/Users/me/Desktop/Ingest"
+      v-flow set settings.default_split_gap 24
+    """
+    app_config = config.load_config()
+
+    if key in LOCATION_KEYS:
+        app_config.setdefault("locations", {})[key] = value
+        typer.echo(f"Set locations.{key} = {value}")
+    elif key.startswith("settings."):
+        setting_key = key[len("settings."):]
+        app_config.setdefault("settings", {})[setting_key] = value
+        typer.echo(f"Set settings.{setting_key} = {value}")
+    else:
+        typer.echo(
+            f"Unknown key '{key}'. Use one of: {', '.join(sorted(LOCATION_KEYS))}, or settings.<key>.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    config.save_config(app_config)
+    typer.echo(f"Config saved to {config.CONFIG_PATH}")
+
+
 @app.command()
 def make_config():
     """

{vflow_cli-0.1.3 → vflow_cli-0.1.5}/src/vflow_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vflow-cli
-Version: 0.1.3
+Version: 0.1.5
 Summary: The v-flow CLI and Claude skills bundle for automating media backup and processing workflows for videographers.
 Author-email: Kaung <kaungzinye@gmail.com>
 Requires-Python: >=3.8