vflow-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{vflow_cli-0.1.2 → vflow_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vflow-cli
-Version: 0.1.2
+Version: 0.1.4
 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.2 → vflow_cli-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vflow-cli"
-version = "0.1.2"
+version = "0.1.4"
 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.2 → vflow_cli-0.1.4}/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.2 → vflow_cli-0.1.4}/src/vflow/main.py

@@ -394,6 +394,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():
     """
@@ -418,153 +468,7 @@ def make_config():
         yaml.dump(sample_config, f, default_flow_style=False, sort_keys=False)
         
     typer.echo(f"Sample configuration file created at: {config.CONFIG_PATH}")
-    typer.echo("Please edit this file with your actual folder paths, or run 'v-flow setup' for a guided wizard.")
-
-
-@app.command("setup")
-def setup_config() -> None:
-    """
-    Interactive wizard to create or update your v-flow configuration.
-    """
-    typer.echo(f"\nThis wizard will create or update your v-flow config at:\n  {config.CONFIG_PATH}\n")
-    existing: dict = {}
-    if config.CONFIG_PATH.exists():
-        typer.echo("Existing configuration found. Loading it so you can review/edit values...")
-        try:
-            with config.CONFIG_PATH.open("r") as f:
-                existing = yaml.safe_load(f) or {}
-        except Exception as e:
-            typer.echo(f"[WARNING] Could not read existing config: {e}", err=True)
-            existing = {}
-
-    locations = dict(existing.get("locations", {}))
-    settings = dict(existing.get("settings", {}))
-
-    # Optionally show mounted volumes (macOS style) to help users pick paths.
-    volumes_root = Path("/Volumes")
-    if volumes_root.exists() and volumes_root.is_dir():
-        volumes = [p for p in volumes_root.iterdir() if p.is_dir()]
-        if volumes:
-            typer.echo("\nDetected external volumes (for reference):")
-            for v in volumes:
-                typer.echo(f"  - {v}")
-
-    def ask_location(key: str, label: str, description: str, default_suggestion: Path) -> str:
-        current = locations.get(key)
-        default_value = current or str(default_suggestion)
-        prompt = f"{label} ({description})"
-        value = typer.prompt(prompt, default=default_value)
-        return value
-
-    home = Path.home()
-    laptop_path = ask_location(
-        "laptop",
-        "Laptop ingest folder",
-        "where you first copy footage onto your laptop",
-        home / "Desktop" / "Ingest",
-    )
-    work_ssd_path = ask_location(
-        "work_ssd",
-        "Workspace SSD projects folder",
-        "fast drive where your editing projects live",
-        home / "Movies" / "Projects",
-    )
-    archive_hdd_path = ask_location(
-        "archive_hdd",
-        "Archive drive root",
-        "long-term storage drive for finished and backed-up media",
-        Path("/Volumes/Archive"),
-    )
-
-    new_locations = {
-        "laptop": str(Path(laptop_path).expanduser()),
-        "work_ssd": str(Path(work_ssd_path).expanduser()),
-        "archive_hdd": str(Path(archive_hdd_path).expanduser()),
-    }
-
-    # Optional settings
-    def ask_int_setting(key: str, label: str, default_val: int) -> int:
-        current_val = settings.get(key, default_val)
-        while True:
-            raw = typer.prompt(label, default=str(current_val))
-            try:
-                return int(raw)
-            except ValueError:
-                typer.echo("Please enter a number (e.g. 0, 4, 12).", err=True)
-
-    typer.echo("\nOptional settings (press Enter to accept the suggested default).")
-    default_split_gap = ask_int_setting(
-        "default_split_gap",
-        "Default split gap (in hours) for ingest when --split-by-gap is not provided (0 = disable auto-splitting)",
-        settings.get("default_split_gap", 0),
-    )
-
-    default_backup_source = typer.prompt(
-        "Default folder to back up when you say 'back up my stuff' (optional, can be empty)",
-        default=settings.get("default_backup_source", ""),
-    ).strip()
-
-    new_settings: dict = {}
-    new_settings["default_split_gap"] = default_split_gap
-    if default_backup_source:
-        new_settings["default_backup_source"] = default_backup_source
-
-    new_config: dict = {"locations": new_locations}
-    if new_settings:
-        new_config["settings"] = new_settings
-
-    config.CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
-    with config.CONFIG_PATH.open("w") as f:
-        yaml.dump(new_config, f, default_flow_style=False, sort_keys=False)
-
-    typer.echo(f"\nConfiguration written to: {config.CONFIG_PATH}\n")
-
-    # Basic validation of paths
-    typer.echo("Validating configured locations:")
-    missing = 0
-    for name, path_str in new_locations.items():
-        p = Path(path_str).expanduser()
-        if not p.exists() or not p.is_dir():
-            typer.echo(f"  [WARNING] '{name}' points to a directory that does not exist yet: {p}", err=True)
-            missing += 1
-        else:
-            typer.echo(f"  [OK] {name}: {p}")
-
-    if missing:
-        typer.echo(
-            "\nSome locations do not exist yet. You can create those folders and re-run 'v-flow setup', "
-            "or edit the config file manually if needed.",
-            err=True,
-        )
-    else:
-        typer.echo("\nAll configured locations exist and look good.")
-
-
-@app.command("config-validate")
-def config_validate() -> None:
-    """
-    Validate your v-flow configuration file and report any issues.
-    """
-    typer.echo(f"Validating configuration at: {config.CONFIG_PATH}")
-    cfg = config.load_config()
-    locations = cfg.get("locations", {})
-    if not locations:
-        typer.echo("No locations defined in configuration.", err=True)
-        raise typer.Exit(code=1)
-
-    ok = True
-    for name, path_str in locations.items():
-        p = Path(path_str).expanduser()
-        if not p.exists() or not p.is_dir():
-            typer.echo(f"[ERROR] Location '{name}' points to missing or invalid directory: {p}", err=True)
-            ok = False
-        else:
-            typer.echo(f"[OK] {name}: {p}")
-
-    if not ok:
-        raise typer.Exit(code=1)
-
-    typer.echo("Configuration looks good.")
+    typer.echo("Please edit this file with your actual folder paths.")
 
 
 if __name__ == "__main__":

vflow_cli-0.1.4/src/vflow/utils_date.py

@@ -0,0 +1,104 @@
+"""
+Date parsing and shoot range helper functions.
+"""
+from datetime import datetime, date
+import re
+from typing import Optional, Tuple
+
+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_{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[any, datetime]], gap_hours: int) -> list[list[any]]:
+    """
+    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 = []
+    current_cluster = []
+    
+    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_cli-0.1.2 → vflow_cli-0.1.4}/src/vflow_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vflow-cli
-Version: 0.1.2
+Version: 0.1.4
 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.2 → vflow_cli-0.1.4}/src/vflow_cli.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/vflow/config.py
 src/vflow/delivery_service.py
 src/vflow/ingest_service.py
 src/vflow/main.py
+src/vflow/utils_date.py
 src/vflow/core/__init__.py
 src/vflow/core/date_utils.py
 src/vflow/core/fs_ops.py