vflow-cli 0.1.1__py3-none-any.whl

vflow/config.py

@@ -0,0 +1,44 @@
+import yaml
+from pathlib import Path
+import typer
+
+CONFIG_PATH = Path.home() / ".vflow_config.yml"
+
+def load_config():
+    """Loads the configuration from the user's home directory."""
+    if not CONFIG_PATH.exists():
+        typer.echo(f"Configuration file not found at: {CONFIG_PATH}")
+        typer.echo("Please create this file with your storage locations.")
+        raise typer.Exit(code=1)
+    
+    with open(CONFIG_PATH, "r") as f:
+        try:
+            config = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            typer.echo(f"Error parsing configuration file: {e}")
+            raise typer.Exit(code=1)
+    
+    # Basic validation
+    if "locations" not in config or not isinstance(config["locations"], dict):
+        typer.echo("Configuration file must contain a 'locations' dictionary.")
+        raise typer.Exit(code=1)
+        
+    return config
+
+def get_location(config: dict, name: str) -> Path:
+    """Gets a specific location from the config and ensures it exists."""
+    path_str = config["locations"].get(name)
+    if not path_str:
+        typer.echo(f"Location '{name}' not defined in config file.")
+        raise typer.Exit(code=1)
+        
+    path = Path(path_str)
+    if not path.exists() or not path.is_dir():
+        typer.echo(f"The directory for location '{name}' does not exist: {path}")
+        raise typer.Exit(code=1)
+        
+    return 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)

vflow/core/__init__.py

@@ -0,0 +1,6 @@
+"""
+Core internal helpers for v-flow.
+
+This module exposes small, reusable utilities that are shared across the
+different action and service modules.
+"""

vflow/core/date_utils.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+from typing import Optional, Tuple
+import re
+
+
+def parse_shoot_date_range(shoot_name: str) -> Optional[Tuple[date, date]]:
+    """
+    Parse a shoot name to extract date range.
+    Returns (start_date, end_date) or None if no date found.
+
+    Supports formats:
+    - YYYY-MM-DD_ShootName (single date)
+    - YYYY-MM-DD_to_YYYY-MM-DD_ShootName (date range)
+    """
+    # Pattern for date range: YYYY-MM-DD_to_YYYY-MM-DD_ShootName
+    range_pattern = r"^(\d{4}-\d{2}-\d{2})_to_(\d{4}-\d{2}-\d{2})_(.+)$"
+    match = re.match(range_pattern, shoot_name)
+    if match:
+        try:
+            start = datetime.strptime(match.group(1), "%Y-%m-%d").date()
+            end = datetime.strptime(match.group(2), "%Y-%m-%d").date()
+            return (start, end)
+        except ValueError:
+            pass
+
+    # Pattern for single date: YYYY-MM-DD_ShootName
+    single_pattern = r"^(\d{4}-\d{2}-\d{2})_(.+)$"
+    match = re.match(single_pattern, shoot_name)
+    if match:
+        try:
+            shoot_date = datetime.strptime(match.group(1), "%Y-%m-%d").date()
+            return (shoot_date, shoot_date)
+        except ValueError:
+            pass
+
+    return None
+
+
+def format_shoot_name(
+    start_date: date, end_date: date, name_suffix: str = "Ingest"
+) -> str:
+    """
+    Format a shoot name from a date range.
+    If start and end are the same, use single date format.
+    """
+    if start_date == end_date:
+        return f"{start_date.strftime('%Y-%m-%d')}_{name_suffix}"
+    else:
+        return (
+            f"{start_date.strftime('%Y-%m-%d')}_to_"
+            f"{end_date.strftime('%Y-%m-%d')}_{name_suffix}"
+        )
+
+
+def date_in_range(check_date: date, start_date: date, end_date: date) -> bool:
+    """Check if a date falls within a date range (inclusive)."""
+    return start_date <= check_date <= end_date
+
+
+def cluster_files_by_date(
+    files_with_dates: list[Tuple[object, datetime]], gap_hours: int
+) -> list[list[object]]:
+    """
+    Group files into clusters based on a time gap threshold.
+    files_with_dates: List of tuples (file_path, file_date)
+    gap_hours: Minimum gap in hours to trigger a split
+
+    Returns a list of lists, where each inner list contains file paths for one cluster.
+    """
+    if not files_with_dates:
+        return []
+
+    # Sort by date
+    sorted_files = sorted(files_with_dates, key=lambda x: x[1])
+
+    clusters: list[list[object]] = []
+    current_cluster: list[object] = []
+
+    if not sorted_files:
+        return []
+
+    # Start first cluster
+    current_cluster.append(sorted_files[0][0])
+    last_date = sorted_files[0][1]
+
+    for i in range(1, len(sorted_files)):
+        file_path, file_date = sorted_files[i]
+
+        # Calculate difference in hours
+        # Ensure we are comparing datetimes
+        if isinstance(file_date, date) and not isinstance(file_date, datetime):
+            # Fallback if we only have dates (assume midnight)
+            file_date = datetime.combine(file_date, datetime.min.time())
+        if isinstance(last_date, date) and not isinstance(last_date, datetime):
+            last_date = datetime.combine(last_date, datetime.min.time())
+
+        diff = file_date - last_date
+        diff_hours = diff.total_seconds() / 3600
+
+        if diff_hours >= gap_hours:
+            # Gap exceeded, start new cluster
+            clusters.append(current_cluster)
+            current_cluster = []
+
+        current_cluster.append(file_path)
+        last_date = file_date
+
+    if current_cluster:
+        clusters.append(current_cluster)
+
+    return clusters
+

vflow/core/fs_ops.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+from typing import Set, Tuple
+
+import shutil
+import typer
+
+
+def copy_and_verify(source: Path, dest: Path) -> bool:
+    """Copies a file and verifies its existence."""
+    try:
+        shutil.copy2(source, dest)
+        if not (dest / source.name).exists():
+            typer.echo(f"  [ERROR] Verification failed for {source.name} at {dest}", err=True)
+            return False
+    except Exception as e:
+        typer.echo(f"  [ERROR] Could not copy {source.name} to {dest}: {e}", err=True)
+        return False
+    return True
+
+
+def _is_duplicate(file_path: Path, dest_dir: Path) -> bool:
+    """
+    Check if a file is a duplicate at the destination (by name and size).
+    """
+    dest_file = dest_dir / file_path.name
+    if not dest_file.exists():
+        return False
+
+    try:
+        source_size = file_path.stat().st_size
+        dest_size = dest_file.stat().st_size
+        return source_size == dest_size
+    except Exception:
+        return False
+
+
+def _build_destination_index(root: Path) -> Set[Tuple[str, int]]:
+    """
+    Build a set of (filename, size) for all video files under root.
+    Used to skip files already ingested anywhere in laptop or archive (cross-shoot).
+    """
+    video_extensions = {".mp4", ".mov", ".mxf", ".mts", ".avi", ".m4v", ".braw", ".r3d", ".crm"}
+    index: Set[Tuple[str, int]] = set()
+    if not root.exists():
+        return index
+    for f in root.rglob("*"):
+        if f.is_file() and f.suffix.lower() in video_extensions:
+            try:
+                index.add((f.name, f.stat().st_size))
+            except (OSError, FileNotFoundError):
+                pass
+    return index
+
+
+def _format_bytes(num: int) -> str:
+    """
+    Simple human-readable byte formatter.
+    """
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if num < 1024.0:
+            return f"{num:.1f} {unit}"
+        num /= 1024.0
+    return f"{num:.1f} PB"
+

vflow/core/media_ops.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import typer
+
+
+def tag_media_file(source_file: Path, tags_str: str) -> Path:
+    """
+    Embed metadata tags into a media file via ffmpeg and apply macOS Finder tags.
+    Returns the path to the new tagged copy (caller is responsible for cleanup).
+    """
+    tags_list = [tag.strip() for tag in tags_str.split(",")]
+
+    tagged_file_path = source_file.with_name(
+        f"{source_file.stem}_tagged{source_file.suffix}"
+    )
+
+    typer.echo("Embedding universal metadata with ffmpeg...")
+    try:
+        ffmpeg_cmd = [
+            "ffmpeg",
+            "-i",
+            str(source_file),
+            "-metadata",
+            f"comment={tags_str}",
+            "-metadata",
+            f"keywords={tags_str}",
+            "-codec",
+            "copy",
+            str(tagged_file_path),
+        ]
+        subprocess.run(ffmpeg_cmd, check=True, capture_output=True, text=True)
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        typer.echo(f"Error with ffmpeg: {e}", err=True)
+        typer.echo(
+            "Please ensure ffmpeg is installed and in your PATH.", err=True
+        )
+        raise typer.Exit(code=1)
+
+    typer.echo("Applying macOS Finder tags...")
+    try:
+        tag_plist = "".join(f"<string>{tag}</string>" for tag in tags_list)
+        bplist_cmd = (
+            "xattr -w com.apple.metadata:_kMDItemUserTags "
+            '\'<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" '
+            '"http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0">'
+            f"<array>{tag_plist}</array></plist>' "
+            f'"{str(tagged_file_path)}"'
+        )
+        subprocess.run(
+            bplist_cmd, shell=True, check=True, capture_output=True
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        typer.echo(f"Could not apply macOS tags: {e}", err=True)
+
+    return tagged_file_path
+
+
+def copy_metadata_between_files(source_file: Path, target_file: Path) -> bool:
+    """
+    Copy metadata from a source file to a target file using ffmpeg.
+    Preserves video/audio streams from target, adds metadata from source.
+    Returns True if successful, False otherwise.
+    """
+    if not source_file.exists() or not target_file.exists():
+        return False
+
+    temp_output = target_file.with_name(
+        f"{target_file.stem}_temp_meta{target_file.suffix}"
+    )
+
+    try:
+        ffmpeg_cmd = [
+            "ffmpeg",
+            "-i",
+            str(target_file),
+            "-i",
+            str(source_file),
+            "-map",
+            "0:v",
+            "-map",
+            "0:a",
+            "-map_metadata",
+            "1",
+            "-c:v",
+            "copy",
+            "-c:a",
+            "copy",
+            "-y",
+            str(temp_output),
+        ]
+        subprocess.run(ffmpeg_cmd, check=True, capture_output=True, text=True)
+
+        shutil.move(str(temp_output), str(target_file))
+        return True
+
+    except FileNotFoundError:
+        typer.echo(
+            "\nError: ffmpeg not found. Please install it and ensure it's in your PATH.",
+            err=True,
+        )
+        return False
+    except subprocess.CalledProcessError as e:
+        typer.echo(f"\nWarning: Could not copy metadata: {e.stderr}", err=True)
+        if temp_output.exists():
+            temp_output.unlink()
+        return False

vflow/core/patterns.py

@@ -0,0 +1,98 @@
+import re
+from typing import Optional
+from pathlib import Path
+
+
+def _extract_number_from_filename(filename: str) -> Optional[int]:
+    """
+    Extract the first numeric sequence from a filename.
+    Returns the number as an integer, or None if no number found.
+    Handles zero-padding by extracting the numeric value.
+    """
+    match = re.search(r"(\d+)", filename)
+    if match:
+        return int(match.group(1))
+    return None
+
+
+def _parse_range_pattern(pattern: str) -> tuple[Optional[str], Optional[int], Optional[int]]:
+    """
+    Parse a range pattern like "C3317-C3351" or "3317-3351" or "C3317-3351".
+    Returns (prefix, start_num, end_num) or (None, None, None) if not a range.
+    """
+    # Pattern to match ranges like "C3317-C3351" or "3317-3351" or "C3317-3351"
+    # The pattern can have a prefix before the first number, and optionally before the second
+    pattern_upper = pattern.upper()
+
+    # Try pattern with prefix on both sides: "C3317-C3351"
+    range_match = re.match(r"^([A-Za-z]*?)(\d+)-([A-Za-z]*?)(\d+)$", pattern_upper)
+    if range_match:
+        prefix1 = range_match.group(1) if range_match.group(1) else None
+        prefix2 = range_match.group(3) if range_match.group(3) else None
+
+        # Use the prefix from the first number, but require both to match (or both be None)
+        if (prefix1 is None and prefix2 is None) or (prefix1 and prefix2 and prefix1 == prefix2):
+            prefix = prefix1
+            start_num = int(range_match.group(2))
+            end_num = int(range_match.group(4))
+
+            if start_num <= end_num:
+                return (prefix, start_num, end_num)
+
+    # Try pattern with no prefix: "3317-3351" or with prefix only on first: "C3317-3351"
+    # This regex allows digits after the dash, and will capture prefix from first number only
+    range_match = re.match(r"^([A-Za-z]*?)(\d+)-(\d+)$", pattern_upper)
+    if range_match:
+        prefix = range_match.group(1) if range_match.group(1) else None
+        start_num = int(range_match.group(2))
+        end_num = int(range_match.group(3))
+
+        if start_num <= end_num:
+            return (prefix, start_num, end_num)
+
+    return (None, None, None)  # Not a range
+
+
+def _matches_pattern(pattern: str, filename: str) -> bool:
+    """
+    Check if a filename matches a pattern, handling both regular patterns and ranges.
+    Uses numeric comparison to handle zero-padding.
+    """
+    filename_lower = filename.lower()
+    pattern_lower = pattern.lower()
+
+    # First, check if pattern is a range
+    prefix, start_num, end_num = _parse_range_pattern(pattern)
+    if start_num is not None and end_num is not None:
+        # It's a range - extract number from filename and check if in range
+        file_num = _extract_number_from_filename(filename)
+        if file_num is None:
+            return False
+
+        # If prefix specified, check that filename contains the prefix
+        if prefix:
+            if prefix.lower() not in filename_lower:
+                return False
+
+        # Check if number is in range
+        return start_num <= file_num <= end_num
+
+    # Not a range - try numeric matching first (for better zero-padding handling)
+    pattern_num = _extract_number_from_filename(pattern)
+    file_num = _extract_number_from_filename(filename)
+
+    if pattern_num is not None and file_num is not None:
+        # Both have numbers - compare numerically and check prefix
+        if pattern_num == file_num:
+            # Numbers match - check if prefixes match (if pattern has a prefix)
+            pattern_letters = re.sub(r"\d+", "", pattern_lower)
+            if pattern_letters:
+                # Pattern has letters - check if filename contains them
+                return pattern_letters in filename_lower
+            else:
+                # Just a number pattern - match if filename contains this number
+                return True
+
+    # Fallback to substring matching for non-numeric patterns
+    return pattern_lower in filename_lower
+