1770 lines
56 KiB
Python
1770 lines
56 KiB
Python
"""Command-line interface for Video Library Manager.
|
|
|
|
This module provides the main CLI entry point using Click framework.
|
|
It implements global options (--config, --log-level) and error handling.
|
|
"""
|
|
|
|
import json
|
|
import sys
|
|
import traceback
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
import click
|
|
import yaml
|
|
from click.core import ParameterSource
|
|
|
|
from vlm.config import Config, load_config, create_default_config, validate_config
|
|
from vlm.context import CLIContext, pass_context
|
|
from vlm.logging_config import setup_logging, get_logger
|
|
from vlm.plan_render import fallback_plan_summary, preferred_plan_summary, render_review_preview
|
|
from vlm.utils import format_size
|
|
|
|
|
|
def default_config_path() -> Path:
|
|
"""Return the default config path resolved at runtime."""
|
|
return Path.home() / ".vlm" / "config.yaml"
|
|
|
|
|
|
def _workspace_dir_from_context() -> Path:
|
|
"""Resolve workspace directory from CLI context at runtime."""
|
|
click_ctx = click.get_current_context(silent=True)
|
|
if click_ctx and isinstance(click_ctx.obj, CLIContext):
|
|
return click_ctx.obj.config.workspace_dir
|
|
return Path("artifacts")
|
|
|
|
|
|
def default_artifact_path(filename: str) -> Path:
|
|
"""Build default artifact path for a filename at runtime."""
|
|
return _workspace_dir_from_context() / filename
|
|
|
|
|
|
def _is_default_parameter(parameter_name: str) -> bool:
|
|
"""Check whether a parameter value came from Click default."""
|
|
click_ctx = click.get_current_context(silent=True)
|
|
if click_ctx is None:
|
|
return False
|
|
return click_ctx.get_parameter_source(parameter_name) == ParameterSource.DEFAULT
|
|
|
|
|
|
def resolve_legacy_default_input_path(
|
|
current_path: Path,
|
|
parameter_name: str,
|
|
legacy_filename: str,
|
|
option_name: str,
|
|
) -> Path:
|
|
"""Fallback to legacy root path when default workspace file is missing.
|
|
|
|
This keeps stage-A compatibility for users who still have legacy artifacts
|
|
in repository root while printing a migration warning.
|
|
"""
|
|
if not _is_default_parameter(parameter_name):
|
|
return current_path
|
|
|
|
workspace_default = default_artifact_path(legacy_filename)
|
|
legacy_default = Path(legacy_filename)
|
|
if current_path != workspace_default:
|
|
return current_path
|
|
if current_path.exists() or not legacy_default.exists():
|
|
return current_path
|
|
|
|
click.echo(
|
|
"Warning: detected legacy default input at "
|
|
f"{legacy_default.resolve()}. Please migrate to "
|
|
f"{workspace_default.resolve()} (example: {option_name} {workspace_default.resolve()}).",
|
|
err=True,
|
|
)
|
|
return legacy_default
|
|
|
|
|
|
def _command_error(ctx: CLIContext, user_message: str, logger_message: str, *, exc_info: bool = False) -> None:
|
|
"""Print a command error message, log it, and exit consistently."""
|
|
click.echo(user_message, err=True)
|
|
ctx.logger.error(logger_message, exc_info=exc_info)
|
|
raise SystemExit(1)
|
|
|
|
|
|
def _load_or_create_config(config: Path) -> Config:
|
|
"""Load configuration from disk or create a default config file."""
|
|
if config.exists():
|
|
try:
|
|
cfg = load_config(config)
|
|
except yaml.YAMLError as e:
|
|
click.echo(f"Error: Invalid YAML syntax in configuration file: {e}", err=True)
|
|
click.echo("Using default configuration values.", err=True)
|
|
cfg = create_default_config(config)
|
|
except ValueError as e:
|
|
click.echo(f"Error: {e}", err=True)
|
|
click.echo("Using default configuration values.", err=True)
|
|
cfg = create_default_config(config)
|
|
else:
|
|
click.echo(f"Configuration file not found at {config}", err=True)
|
|
click.echo("Creating default configuration...", err=True)
|
|
cfg = create_default_config(config)
|
|
click.echo(f"Default configuration created at {config}", err=True)
|
|
|
|
validation_errors = validate_config(cfg)
|
|
if validation_errors:
|
|
click.echo("Configuration validation errors:", err=True)
|
|
for error in validation_errors:
|
|
click.echo(f" - {error}", err=True)
|
|
click.echo("Please fix the configuration file and try again.", err=True)
|
|
raise ValueError("invalid configuration")
|
|
|
|
return cfg
|
|
|
|
|
|
def _initialize_cli_context(config: Path, log_level: Optional[str]) -> CLIContext:
|
|
"""Load config, apply CLI overrides, and build the CLI context."""
|
|
cfg = _load_or_create_config(config)
|
|
if log_level:
|
|
cfg.log_level = log_level.upper()
|
|
|
|
logger = setup_logging(log_level=cfg.log_level)
|
|
return CLIContext(config=cfg, logger=logger)
|
|
|
|
|
|
@click.group()
|
|
@click.option(
|
|
'--config',
|
|
type=click.Path(path_type=Path),
|
|
default=default_config_path,
|
|
help='Path to configuration file (default: ~/.vlm/config.yaml)'
|
|
)
|
|
@click.option(
|
|
'--log-level',
|
|
type=click.Choice(['DEBUG', 'INFO', 'WARNING', 'ERROR'], case_sensitive=False),
|
|
default=None,
|
|
help='Set logging level (overrides config file)'
|
|
)
|
|
@click.pass_context
|
|
def main(ctx, config: Path, log_level: Optional[str]):
|
|
"""Video Library Manager - A tool for managing personal video collections.
|
|
|
|
VLM helps you organize, analyze, and maintain your video library with a
|
|
safety-first approach. All operations are reversible and require explicit
|
|
confirmation before making changes.
|
|
|
|
Common workflow:
|
|
|
|
1. vlm scan - Discover all video files
|
|
2. vlm parse - Extract titles, years, seasons, episodes
|
|
3. vlm enrich - Enrich parsed identities with external metadata
|
|
4. vlm analyze - Detect gaps and duplicates
|
|
5. vlm plan - Generate execution plan
|
|
6. vlm execute - Execute plan (dry-run by default)
|
|
7. vlm execute --confirm - Actually execute operations
|
|
|
|
Use 'vlm COMMAND --help' for more information on a specific command.
|
|
"""
|
|
# Ensure context object exists
|
|
ctx.ensure_object(dict)
|
|
|
|
try:
|
|
ctx.obj = _initialize_cli_context(config, log_level)
|
|
except Exception as e:
|
|
traceback.print_exc(file=sys.stderr)
|
|
click.echo(f"Error initializing VLM: {e}", err=True)
|
|
sys.exit(1)
|
|
|
|
|
|
@main.command()
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('inventory.csv'),
|
|
help='Output file for inventory (default: artifacts/inventory.csv)'
|
|
)
|
|
@click.option(
|
|
'--metadata/--no-metadata',
|
|
default=True,
|
|
help='Extract video metadata via ffprobe (default: enabled)'
|
|
)
|
|
@click.option(
|
|
'--reuse-from',
|
|
type=click.Path(exists=True, path_type=Path),
|
|
default=None,
|
|
help='Reuse metadata cache from an existing inventory CSV (default: output file if it exists)'
|
|
)
|
|
@click.option(
|
|
'--force-refresh-metadata',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Ignore metadata cache and re-run ffprobe for all files'
|
|
)
|
|
@pass_context
|
|
def scan(
|
|
ctx: CLIContext,
|
|
output: Path,
|
|
metadata: bool,
|
|
reuse_from: Optional[Path],
|
|
force_refresh_metadata: bool
|
|
):
|
|
"""Scan library and generate inventory.
|
|
|
|
Discovers all video files in the library and records their metadata.
|
|
This is a read-only operation that does not modify any files.
|
|
|
|
Example:
|
|
|
|
vlm scan # Save to inventory.csv
|
|
vlm scan --output my_library.csv # Save to custom file
|
|
vlm scan --no-metadata # Faster scan without ffprobe
|
|
vlm scan --reuse-from old.csv # Reuse prior metadata cache
|
|
vlm scan --force-refresh-metadata # Re-run ffprobe for all files
|
|
"""
|
|
try:
|
|
from vlm.commands.scan import scan_cmd
|
|
scan_cmd(ctx, output, metadata, reuse_from, force_refresh_metadata)
|
|
except Exception as e:
|
|
click.echo(f"Error during scan: {e}", err=True)
|
|
ctx.logger.error(f"Scan failed: {e}", exc_info=True)
|
|
sys.exit(1)
|
|
|
|
|
|
@main.command()
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('inventory.csv'),
|
|
help='Input inventory CSV file (default: artifacts/inventory.csv)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('identities.json'),
|
|
help='Output file for parsed identities (default: artifacts/identities.json)'
|
|
)
|
|
@click.option(
|
|
'--inventory',
|
|
type=click.Path(exists=True, path_type=Path),
|
|
default=None,
|
|
help='Inventory CSV to embed video metadata (enables v2 schema with quality data)'
|
|
)
|
|
@pass_context
|
|
def parse(ctx: CLIContext, input: Path, output: Path, inventory: Optional[Path]):
|
|
"""Parse identities from filenames.
|
|
|
|
Extracts movie titles, years, series titles, seasons, and episodes
|
|
from video filenames in the inventory.
|
|
|
|
Use --inventory to embed video metadata (size, resolution, codec) in the output,
|
|
which enables accurate duplicate resolution by quality in the analyze stage.
|
|
|
|
Example:
|
|
|
|
vlm parse # Use default files (v1 schema)
|
|
vlm parse --inventory inventory.csv # Embed metadata (v2 schema)
|
|
vlm parse --input my_inventory.csv # Custom input
|
|
vlm parse --output parsed_identities.json # Custom output
|
|
"""
|
|
try:
|
|
input = resolve_legacy_default_input_path(input, "input", "inventory.csv", "--input")
|
|
from vlm.commands.parse import parse_cmd
|
|
parse_cmd(ctx, input, output, inventory)
|
|
except FileNotFoundError:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Input file not found: {input}",
|
|
f"Input file not found: {input}",
|
|
)
|
|
except ValueError as e:
|
|
_command_error(ctx, f"Error: {e}", f"Parse failed: {e}")
|
|
except OSError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error reading/writing files: {e}",
|
|
f"Parse file I/O failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.command()
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('identities.json'),
|
|
help='Path to identities JSON file (default: artifacts/identities.json)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Output path (default: overwrite input file)'
|
|
)
|
|
@click.option(
|
|
'--refresh-changed-only',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Refresh only records whose identity fingerprint changed (incremental behavior)'
|
|
)
|
|
@click.option(
|
|
'--refresh-all',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Bypass cache and re-enrich all records'
|
|
)
|
|
@click.option(
|
|
'--timeout',
|
|
type=int,
|
|
default=6,
|
|
show_default=True,
|
|
help='Per-request timeout in seconds'
|
|
)
|
|
@click.option(
|
|
'--retries',
|
|
type=int,
|
|
default=2,
|
|
show_default=True,
|
|
help='Retry attempts for provider/API requests'
|
|
)
|
|
@pass_context
|
|
def enrich(
|
|
ctx: CLIContext,
|
|
input: Path,
|
|
output: Optional[Path],
|
|
refresh_changed_only: bool,
|
|
refresh_all: bool,
|
|
timeout: int,
|
|
retries: int,
|
|
):
|
|
"""Enrich identities with translation and reputation metadata.
|
|
|
|
Applies incremental cache-backed enrichment to parsed identities and writes
|
|
results back into identities JSON.
|
|
"""
|
|
try:
|
|
input = resolve_legacy_default_input_path(input, "input", "identities.json", "--input")
|
|
from vlm.commands.enrich import enrich_cmd
|
|
enrich_cmd(
|
|
ctx,
|
|
input,
|
|
output,
|
|
refresh_changed_only,
|
|
refresh_all,
|
|
timeout,
|
|
retries,
|
|
)
|
|
except FileNotFoundError:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Input file not found: {input}",
|
|
f"Input file not found: {input}",
|
|
)
|
|
except json.JSONDecodeError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Failed to parse JSON file: {e}",
|
|
f"JSON parsing failed during enrich: {e}",
|
|
exc_info=True,
|
|
)
|
|
except ValueError as e:
|
|
_command_error(ctx, f"Error: {e}", f"Enrich validation failed: {e}")
|
|
except OSError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error reading/writing files: {e}",
|
|
f"Enrich file I/O failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.command()
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('identities.json'),
|
|
help='Path to parsed identities JSON file (default: artifacts/identities.json)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('analysis.json'),
|
|
help='Path to save analysis results (default: artifacts/analysis.json)'
|
|
)
|
|
@click.option(
|
|
'--inventory',
|
|
type=click.Path(exists=True, path_type=Path),
|
|
default=None,
|
|
help='Optional inventory CSV to merge size/resolution/codec for duplicate quality comparison'
|
|
)
|
|
@pass_context
|
|
def analyze(ctx: CLIContext, input: Path, output: Path, inventory: Optional[Path]):
|
|
"""Analyze completeness and duplicates.
|
|
|
|
Detects episode gaps in series and identifies potential duplicate files.
|
|
Provides quality comparison data for duplicates.
|
|
|
|
Example:
|
|
|
|
vlm analyze # Use default files
|
|
vlm analyze --input my_identities.json # Custom input
|
|
vlm analyze --inventory inventory.csv # Merge metadata for quality comparison
|
|
vlm analyze --output my_analysis.json # Custom output
|
|
"""
|
|
try:
|
|
input = resolve_legacy_default_input_path(input, "input", "identities.json", "--input")
|
|
from vlm.commands.analyze import analyze_cmd
|
|
analyze_cmd(ctx, input, output, inventory)
|
|
except FileNotFoundError:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Input file not found: {input}",
|
|
f"Input file not found: {input}",
|
|
)
|
|
except json.JSONDecodeError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Failed to parse JSON file: {e}",
|
|
f"JSON parsing failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error during analysis: {e}",
|
|
f"Analysis failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.command()
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('identities.json'),
|
|
help='Path to parsed identities JSON file (default: artifacts/identities.json)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('plan.json'),
|
|
help='Path to save execution plan (default: artifacts/plan.json)'
|
|
)
|
|
@click.option(
|
|
'--analysis',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Path to analysis JSON (optional); when provided, duplicate groups are applied to the plan'
|
|
)
|
|
@pass_context
|
|
def plan(ctx: CLIContext, input: Path, output: Path, analysis: Path | None):
|
|
"""Generate execution plan.
|
|
|
|
Creates a structured, reviewable plan of all file operations to be performed.
|
|
The plan can be edited before execution.
|
|
|
|
Example:
|
|
|
|
vlm plan # Use default files
|
|
vlm plan --input my_identities.json # Custom input
|
|
vlm plan --analysis analysis.json # Use analysis for duplicate handling
|
|
vlm plan --output my_plan.json # Custom output
|
|
"""
|
|
try:
|
|
input = resolve_legacy_default_input_path(input, "input", "identities.json", "--input")
|
|
from vlm.commands.plan import plan_cmd
|
|
plan_cmd(ctx, input, output, analysis)
|
|
except FileNotFoundError:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Input file not found: {input}",
|
|
f"Input file not found: {input}",
|
|
)
|
|
except json.JSONDecodeError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Failed to parse JSON file: {e}",
|
|
f"JSON parsing failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error during plan generation: {e}",
|
|
f"Plan generation failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.command(name="review-plan")
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(exists=True, path_type=Path),
|
|
default=lambda: default_artifact_path('plan.json'),
|
|
help='Path to execution plan JSON file (default: artifacts/plan.json)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('plan_manual_review.csv'),
|
|
help='Path to save manual review CSV (default: artifacts/plan_manual_review.csv)'
|
|
)
|
|
@click.option(
|
|
'--season-threshold',
|
|
type=int,
|
|
default=20,
|
|
show_default=True,
|
|
help='Flag operations with season >= this value as high risk'
|
|
)
|
|
@click.option(
|
|
'--episode-threshold',
|
|
type=int,
|
|
default=40,
|
|
show_default=True,
|
|
help='Flag operations with episode >= this value as high risk'
|
|
)
|
|
@click.option(
|
|
'--preview-limit',
|
|
type=int,
|
|
default=10,
|
|
show_default=True,
|
|
help='Number of high-risk operations to preview in console output'
|
|
)
|
|
@click.option(
|
|
'--show-all',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Show all high-risk operations in console preview'
|
|
)
|
|
@pass_context
|
|
def review_plan_cmd(
|
|
ctx: CLIContext,
|
|
input: Path,
|
|
output: Path,
|
|
season_threshold: int,
|
|
episode_threshold: int,
|
|
preview_limit: int,
|
|
show_all: bool,
|
|
):
|
|
"""Review a plan and export high-risk operations for manual confirmation."""
|
|
from vlm.planner import load_plan
|
|
from vlm.plan_review import review_plan, save_review_csv
|
|
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
input = resolve_legacy_default_input_path(input, "input", "plan.json", "--input")
|
|
if season_threshold < 1 or episode_threshold < 1:
|
|
click.echo("Error: thresholds must be >= 1", err=True)
|
|
sys.exit(1)
|
|
if preview_limit < 1:
|
|
click.echo("Error: --preview-limit must be >= 1", err=True)
|
|
sys.exit(1)
|
|
|
|
click.echo(f"Loading plan: {input}")
|
|
execution_plan = load_plan(input)
|
|
rows, counters = review_plan(
|
|
execution_plan,
|
|
season_threshold=season_threshold,
|
|
episode_threshold=episode_threshold,
|
|
)
|
|
|
|
save_review_csv(rows, output)
|
|
|
|
click.echo()
|
|
click.echo("Plan overview:")
|
|
click.echo(preferred_plan_summary(execution_plan))
|
|
|
|
click.echo()
|
|
click.echo("Plan review summary:")
|
|
click.echo(f" Total operations: {counters['total_operations']}")
|
|
click.echo(f" High-risk operations: {counters['high_risk_operations']}")
|
|
click.echo(f" manual_review: {counters['manual_review']}")
|
|
click.echo(f" sample_source: {counters['sample_source']}")
|
|
click.echo(f" high_season: {counters['high_season']}")
|
|
click.echo(f" high_episode: {counters['high_episode']}")
|
|
click.echo(f" conflicts: {counters['conflicts']}")
|
|
|
|
click.echo()
|
|
click.echo("High-risk operations preview:")
|
|
if rows:
|
|
preview_lines, hidden_count = render_review_preview(
|
|
rows,
|
|
preview_limit=preview_limit,
|
|
show_all=show_all,
|
|
)
|
|
for line in preview_lines:
|
|
click.echo(line)
|
|
if hidden_count > 0:
|
|
click.echo(
|
|
f" ... and {hidden_count} more high-risk operations "
|
|
"(use --show-all to display all)"
|
|
)
|
|
else:
|
|
click.echo(" (none)")
|
|
|
|
click.echo()
|
|
click.echo(f"Saved manual review CSV to: {output}")
|
|
|
|
logger.info(
|
|
"Plan review completed: total=%s high_risk=%s output=%s",
|
|
counters["total_operations"],
|
|
counters["high_risk_operations"],
|
|
output,
|
|
)
|
|
except FileNotFoundError:
|
|
_command_error(ctx, f"Error: Plan file not found: {input}", f"Plan file not found: {input}")
|
|
except json.JSONDecodeError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Failed to parse plan JSON: {e}",
|
|
f"Plan review JSON parsing failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error during plan review: {e}",
|
|
f"Plan review failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.command(name="apply-review")
|
|
@click.option(
|
|
'--plan',
|
|
type=click.Path(exists=True, path_type=Path),
|
|
default=Path('plan.json'),
|
|
help='Path to execution plan JSON file (default: plan.json)'
|
|
)
|
|
@click.option(
|
|
'--csv',
|
|
type=click.Path(exists=True, path_type=Path),
|
|
default=Path('plan_manual_review.csv'),
|
|
help='Path to the modified manual review CSV (default: plan_manual_review.csv)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Path to save updated plan (default: overwrite input plan)'
|
|
)
|
|
@pass_context
|
|
def apply_review_cmd(
|
|
ctx: CLIContext,
|
|
plan: Path,
|
|
csv: Path,
|
|
output: Optional[Path],
|
|
):
|
|
"""Apply modifications from a manual review CSV back to the plan JSON.
|
|
|
|
This command reads the 'operation_type' column from the CSV and updates
|
|
the corresponding operations in the plan. This is the primary way to
|
|
manually approve or reject high-risk operations.
|
|
"""
|
|
from vlm.planner import load_plan, save_plan, apply_review_to_plan
|
|
|
|
logger = ctx.logger
|
|
output_path = output or plan
|
|
|
|
try:
|
|
click.echo(f"Loading plan: {plan}")
|
|
execution_plan = load_plan(plan)
|
|
|
|
click.echo(f"Applying review from: {csv}")
|
|
updated_plan = apply_review_to_plan(execution_plan, csv)
|
|
|
|
save_plan(updated_plan, output_path)
|
|
click.echo(f"Successfully updated plan saved to: {output_path}")
|
|
|
|
# Calculate changes for user feedback
|
|
modified = 0
|
|
for i, op in enumerate(updated_plan.operations):
|
|
if op.operation_type != execution_plan.operations[i].operation_type:
|
|
modified += 1
|
|
|
|
click.echo(f"Total operations modified: {modified}")
|
|
logger.info("Applied review from %s to %s, modified %s ops", csv, output_path, modified)
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error applying review: {e}",
|
|
f"Apply review failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.command()
|
|
@click.option(
|
|
'--plan',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('plan.json'),
|
|
help='Path to execution plan JSON file (default: artifacts/plan.json)'
|
|
)
|
|
@click.option(
|
|
'--confirm',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Actually execute operations (default is dry-run)'
|
|
)
|
|
@click.option(
|
|
'--yes',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Skip confirmation prompt (auto-approve)'
|
|
)
|
|
@click.option(
|
|
'--verbose-ops',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Print per-operation dry-run logs at INFO level'
|
|
)
|
|
@click.option(
|
|
'--preserve-directories',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Preserve empty source directories instead of allowing them to be destroyed'
|
|
)
|
|
@click.option(
|
|
'--safe-mode',
|
|
is_flag=True,
|
|
default=False,
|
|
help='Enable safe mode: prevent any operations that would destroy directories'
|
|
)
|
|
@pass_context
|
|
def execute(ctx: CLIContext, plan: Path, confirm: bool, yes: bool, verbose_ops: bool, preserve_directories: bool, safe_mode: bool):
|
|
"""Execute plan (defaults to dry-run, requires --confirm).
|
|
|
|
Executes file operations from a plan. Defaults to dry-run mode which
|
|
simulates operations without making changes. Use --confirm to actually
|
|
execute operations.
|
|
|
|
Example:
|
|
|
|
vlm execute # Dry-run with plan.json
|
|
vlm execute --plan my_plan.json # Dry-run with custom plan
|
|
vlm execute --confirm # Actually execute operations (with prompt)
|
|
vlm execute --confirm --yes # Execute without confirmation prompt
|
|
"""
|
|
try:
|
|
plan = resolve_legacy_default_input_path(plan, "plan", "plan.json", "--plan")
|
|
from vlm.commands.execute import execute_cmd
|
|
execute_cmd(ctx, plan, confirm, yes, verbose_ops, preserve_directories, safe_mode)
|
|
except FileNotFoundError:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: File not found: {plan}",
|
|
f"Execution file not found: {plan}",
|
|
)
|
|
except ValueError as e:
|
|
_command_error(ctx, f"Error: {e}", f"Execution validation failed: {e}")
|
|
except OSError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error during execution: {e}",
|
|
f"Execution I/O failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.group()
|
|
@pass_context
|
|
def quarantine(ctx: CLIContext):
|
|
"""Manage quarantined files.
|
|
|
|
Quarantine operations allow you to safely isolate unwanted files
|
|
for review before deletion. Only movie and series files can be
|
|
quarantined in v1.
|
|
"""
|
|
pass
|
|
|
|
|
|
@quarantine.command('list')
|
|
@click.option(
|
|
'--category',
|
|
type=click.Choice(['movie', 'series'], case_sensitive=False),
|
|
default=None,
|
|
help='Filter by category (movie or series)'
|
|
)
|
|
@pass_context
|
|
def quarantine_list(ctx: CLIContext, category: Optional[str]):
|
|
"""List quarantined files.
|
|
|
|
Shows all files currently in quarantine with their original locations,
|
|
quarantine timestamps, and reasons.
|
|
|
|
Example:
|
|
|
|
vlm quarantine list # List all quarantined files
|
|
vlm quarantine list --category movie # List only movie files
|
|
"""
|
|
from vlm.quarantine import QuarantineManager
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
# Create quarantine manager
|
|
manager = QuarantineManager(config, logger)
|
|
|
|
# List quarantined files
|
|
entries = manager.list_quarantined(category=category)
|
|
|
|
if not entries:
|
|
if category:
|
|
click.echo(f"No quarantined files found in category '{category}'.")
|
|
else:
|
|
click.echo("No quarantined files found.")
|
|
return
|
|
|
|
# Display quarantined files
|
|
click.echo()
|
|
if category:
|
|
click.echo(f"Quarantined files in category '{category}':")
|
|
else:
|
|
click.echo("Quarantined files:")
|
|
click.echo("=" * 80)
|
|
|
|
for i, entry in enumerate(entries, 1):
|
|
click.echo(f"\n[{i}] {entry.quarantine_path.name}")
|
|
click.echo(f" Category: {entry.category}")
|
|
click.echo(f" Original: {entry.original_path}")
|
|
click.echo(f" Quarantine: {entry.quarantine_path}")
|
|
click.echo(f" Size: {format_size(entry.size_bytes)}")
|
|
click.echo(f" Quarantined: {entry.quarantined_at.strftime('%Y-%m-%d %H:%M:%S')}")
|
|
if entry.reason:
|
|
click.echo(f" Reason: {entry.reason}")
|
|
|
|
click.echo()
|
|
click.echo("=" * 80)
|
|
click.echo(f"Total: {len(entries)} quarantined file(s)")
|
|
click.echo()
|
|
|
|
logger.info(f"Listed {len(entries)} quarantined files" +
|
|
(f" from category '{category}'" if category else ""))
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error listing quarantined files: {e}",
|
|
f"Failed to list quarantined files: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@quarantine.command('add')
|
|
@click.argument('file', type=click.Path(exists=True, path_type=Path))
|
|
@click.option(
|
|
'--reason',
|
|
type=str,
|
|
default=None,
|
|
help='Reason for quarantining the file'
|
|
)
|
|
@pass_context
|
|
def quarantine_add(ctx: CLIContext, file: Path, reason: Optional[str]):
|
|
"""Add file to quarantine.
|
|
|
|
Moves a file to the category-specific quarantine directory. Only movie
|
|
and series files can be quarantined in v1. Anime and other files will
|
|
be rejected.
|
|
|
|
Example:
|
|
|
|
vlm quarantine add /path/to/movie.mkv
|
|
vlm quarantine add /path/to/series.mkv --reason "duplicate"
|
|
"""
|
|
from vlm.quarantine import QuarantineManager
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
# Create quarantine manager
|
|
manager = QuarantineManager(config, logger)
|
|
|
|
# Display confirmation
|
|
click.echo(f"Quarantining file: {file}")
|
|
if reason:
|
|
click.echo(f"Reason: {reason}")
|
|
click.echo()
|
|
|
|
# Quarantine the file
|
|
result = manager.quarantine_file(file, reason=reason)
|
|
|
|
if result.success:
|
|
click.echo(f"✓ File successfully quarantined!")
|
|
click.echo(f" Original: {result.operation.source_path}")
|
|
click.echo(f" Quarantine: {result.operation.destination_path}")
|
|
click.echo()
|
|
click.echo("To restore this file, run:")
|
|
click.echo(f" vlm quarantine restore {result.operation.destination_path}")
|
|
else:
|
|
_command_error(
|
|
ctx,
|
|
f"✗ Failed to quarantine file: {result.error_message}",
|
|
f"Quarantine failed for {file}: {result.error_message}",
|
|
)
|
|
|
|
logger.info(f"Quarantined file: {file}")
|
|
|
|
except ValueError as e:
|
|
# Category restriction error
|
|
_command_error(ctx, f"Error: {e}", f"Quarantine rejected: {e}")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error quarantining file: {e}",
|
|
f"Failed to quarantine file: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@quarantine.command('restore')
|
|
@click.argument('file', type=click.Path(exists=True, path_type=Path))
|
|
@pass_context
|
|
def quarantine_restore(ctx: CLIContext, file: Path):
|
|
"""Restore file from quarantine.
|
|
|
|
Moves a file from quarantine back to its original location. This is a
|
|
best-effort operation that may fail if the original location is occupied.
|
|
|
|
Example:
|
|
|
|
vlm quarantine restore /path/to/.quarantine/movie.mkv
|
|
"""
|
|
from vlm.quarantine import QuarantineManager
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
# Create quarantine manager
|
|
manager = QuarantineManager(config, logger)
|
|
|
|
# Display confirmation
|
|
click.echo(f"Restoring file from quarantine: {file}")
|
|
click.echo()
|
|
|
|
# Restore the file
|
|
result = manager.restore_from_quarantine(file)
|
|
|
|
if result.success:
|
|
click.echo(f"✓ File successfully restored!")
|
|
click.echo(f" Quarantine: {result.operation.source_path}")
|
|
click.echo(f" Restored to: {result.operation.destination_path}")
|
|
else:
|
|
if result.operation.has_conflict:
|
|
click.echo(f"✗ Cannot restore: {result.operation.conflict_reason}", err=True)
|
|
click.echo(f" Original location: {result.operation.destination_path}", err=True)
|
|
else:
|
|
click.echo(f"✗ Failed to restore file: {result.error_message}", err=True)
|
|
_command_error(
|
|
ctx,
|
|
f"Error restoring file: {result.error_message or result.operation.conflict_reason or 'unknown error'}",
|
|
f"Failed to restore file: {file}",
|
|
)
|
|
|
|
logger.info(f"Restored file from quarantine: {file}")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error restoring file: {e}",
|
|
f"Failed to restore file: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.command()
|
|
@click.option(
|
|
'--log',
|
|
type=click.Path(exists=True, path_type=Path),
|
|
default=None,
|
|
help='Path to rollback log JSON file'
|
|
)
|
|
@pass_context
|
|
def rollback(ctx: CLIContext, log: Optional[Path]):
|
|
"""Rollback previous execution (best-effort).
|
|
|
|
Attempts to reverse file operations from a previous execution by moving
|
|
files from their destination back to their source. This is a best-effort
|
|
operation that may not succeed if files have been modified or moved.
|
|
|
|
Operations are processed in LIFO (Last In, First Out) order for best-effort
|
|
restoration. All rollback attempts are logged with detailed results.
|
|
|
|
Example:
|
|
|
|
vlm rollback # Find latest rollback log
|
|
vlm rollback --log rollback_<uuid>.json # Use specific log
|
|
vlm rollback --log ~/.vlm/rollback/rollback_*.json
|
|
"""
|
|
try:
|
|
from vlm.commands.execute import rollback_cmd
|
|
rollback_cmd(ctx, log)
|
|
except FileNotFoundError as e:
|
|
_command_error(ctx, f"Error: {e}", f"Rollback log not found: {e}")
|
|
except ValueError as e:
|
|
_command_error(ctx, f"Error: {e}", f"Rollback failed: {e}")
|
|
except OSError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error during rollback: {e}",
|
|
f"Rollback failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
def _fallback_plan_summary(execution_plan) -> str:
|
|
"""Build a short plan summary from summary and summary_by_reason when human_summary is empty."""
|
|
return fallback_plan_summary(execution_plan)
|
|
|
|
|
|
@main.group()
|
|
@pass_context
|
|
def report(ctx: CLIContext):
|
|
"""Generate and export reports.
|
|
|
|
Generate various reports about your video library including inventory,
|
|
completeness analysis, duplicate detection, and summary statistics.
|
|
"""
|
|
pass
|
|
|
|
|
|
@report.command('inventory')
|
|
@click.option(
|
|
'--format',
|
|
type=click.Choice(['csv', 'json', 'text'], case_sensitive=False),
|
|
default='text',
|
|
help='Output format (default: text)'
|
|
)
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('inventory.csv'),
|
|
help='Input inventory CSV file (default: artifacts/inventory.csv)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Output file (default: print to console)'
|
|
)
|
|
@pass_context
|
|
def report_inventory(ctx: CLIContext, format: str, input: Path, output: Optional[Path]):
|
|
"""Generate inventory report.
|
|
|
|
Lists all discovered video files with metadata in the specified format.
|
|
|
|
Example:
|
|
|
|
vlm report inventory # Text format to console
|
|
vlm report inventory --format csv # CSV format to console
|
|
vlm report inventory --format json --output inventory_report.json
|
|
"""
|
|
from vlm.reports import generate_inventory_report
|
|
from vlm.io import load_inventory_csv
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
input = resolve_legacy_default_input_path(input, "input", "inventory.csv", "--input")
|
|
# Load inventory from CSV
|
|
click.echo(f"Loading inventory from: {input}")
|
|
|
|
video_files = load_inventory_csv(input)
|
|
|
|
click.echo(f"Loaded {len(video_files)} files")
|
|
click.echo()
|
|
|
|
# Generate report
|
|
click.echo(f"Generating inventory report in {format} format...")
|
|
|
|
# For text format, use CSV format as the text representation
|
|
report_format = 'csv' if format == 'text' else format
|
|
report_content = generate_inventory_report(video_files, report_format, config.library_root)
|
|
|
|
# Output report
|
|
if output:
|
|
# Save to file
|
|
output.parent.mkdir(parents=True, exist_ok=True)
|
|
with open(output, 'w', encoding='utf-8') as f:
|
|
f.write(report_content)
|
|
click.echo(f"Report saved to: {output}")
|
|
else:
|
|
# Print to console
|
|
click.echo()
|
|
click.echo(report_content)
|
|
|
|
logger.info(f"Generated inventory report in {format} format with {len(video_files)} files")
|
|
|
|
except FileNotFoundError:
|
|
_command_error(ctx, f"Error: Input file not found: {input}", f"Input file not found: {input}")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error generating inventory report: {e}",
|
|
f"Inventory report generation failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@report.command('completeness')
|
|
@click.option(
|
|
'--format',
|
|
type=click.Choice(['text', 'json'], case_sensitive=False),
|
|
default='text',
|
|
help='Output format (default: text)'
|
|
)
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('analysis.json'),
|
|
help='Input analysis JSON file (default: artifacts/analysis.json)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Output file (default: print to console)'
|
|
)
|
|
@click.option(
|
|
'--plan',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Optional plan JSON; when provided, report includes plan content summary'
|
|
)
|
|
@pass_context
|
|
def report_completeness(ctx: CLIContext, format: str, input: Path, output: Optional[Path], plan: Optional[Path]):
|
|
"""Generate completeness report.
|
|
|
|
Shows series with episode gaps detected through heuristic analysis.
|
|
|
|
Example:
|
|
|
|
vlm report completeness # Text format to console
|
|
vlm report completeness --format json # JSON format to console
|
|
vlm report completeness --plan plan.json # Include plan content summary
|
|
vlm report completeness --format text --output completeness.txt
|
|
"""
|
|
from vlm.reports import generate_completeness_report
|
|
from vlm.models import SeasonCompleteness
|
|
from vlm.planner import load_plan
|
|
from vlm.io import load_analysis_json
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
input = resolve_legacy_default_input_path(input, "input", "analysis.json", "--input")
|
|
plan_summary = None
|
|
if plan:
|
|
if not plan.exists():
|
|
click.echo(f"Error: Plan file not found: {plan}", err=True)
|
|
sys.exit(1)
|
|
execution_plan = load_plan(plan)
|
|
plan_summary = execution_plan.human_summary or _fallback_plan_summary(execution_plan)
|
|
|
|
try:
|
|
# Load analysis from JSON
|
|
click.echo(f"Loading analysis from: {input}")
|
|
|
|
analysis_data = load_analysis_json(input)
|
|
|
|
# Extract completeness data
|
|
completeness_list = analysis_data.get('completeness', [])
|
|
|
|
# Convert to SeasonCompleteness objects
|
|
season_completeness = []
|
|
for c in completeness_list:
|
|
season_completeness.append(SeasonCompleteness(
|
|
series_title=c['series_title'],
|
|
season=c['season'],
|
|
episodes_found=c['episodes_found'],
|
|
episodes_missing=c['episodes_missing']
|
|
))
|
|
|
|
click.echo(f"Loaded {len(season_completeness)} series with gaps")
|
|
click.echo()
|
|
|
|
# Generate report
|
|
click.echo(f"Generating completeness report in {format} format...")
|
|
report_content = generate_completeness_report(
|
|
season_completeness, format, config.library_root, plan_summary=plan_summary
|
|
)
|
|
|
|
# Output report
|
|
if output:
|
|
# Save to file
|
|
output.parent.mkdir(parents=True, exist_ok=True)
|
|
with open(output, 'w', encoding='utf-8') as f:
|
|
f.write(report_content)
|
|
click.echo(f"Report saved to: {output}")
|
|
else:
|
|
# Print to console
|
|
click.echo()
|
|
click.echo(report_content)
|
|
|
|
logger.info(f"Generated completeness report in {format} format with {len(season_completeness)} series")
|
|
|
|
except FileNotFoundError:
|
|
_command_error(ctx, f"Error: Input file not found: {input}", f"Input file not found: {input}")
|
|
|
|
except json.JSONDecodeError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Failed to parse JSON file: {e}",
|
|
f"JSON parsing failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error generating completeness report: {e}",
|
|
f"Completeness report generation failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@report.command('duplicates')
|
|
@click.option(
|
|
'--format',
|
|
type=click.Choice(['text', 'json'], case_sensitive=False),
|
|
default='text',
|
|
help='Output format (default: text)'
|
|
)
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('analysis.json'),
|
|
help='Input analysis JSON file (default: artifacts/analysis.json)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Output file (default: print to console)'
|
|
)
|
|
@click.option(
|
|
'--plan',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Optional plan JSON; when provided, report includes plan content summary'
|
|
)
|
|
@pass_context
|
|
def report_duplicates(ctx: CLIContext, format: str, input: Path, output: Optional[Path], plan: Optional[Path]):
|
|
"""Generate duplicate report.
|
|
|
|
Shows duplicate files with quality comparison data to help decide which
|
|
files to keep.
|
|
|
|
Example:
|
|
|
|
vlm report duplicates # Text format to console
|
|
vlm report duplicates --format json # JSON format to console
|
|
vlm report duplicates --plan plan.json # Include plan content summary
|
|
vlm report duplicates --format text --output duplicates.txt
|
|
"""
|
|
from vlm.reports import generate_duplicate_report
|
|
from vlm.models import DuplicateGroup, MovieIdentity, SeriesIdentity, VideoFile
|
|
from vlm.planner import load_plan
|
|
from datetime import datetime, timezone
|
|
from vlm.io import load_analysis_json
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
input = resolve_legacy_default_input_path(input, "input", "analysis.json", "--input")
|
|
plan_summary = None
|
|
if plan:
|
|
if not plan.exists():
|
|
click.echo(f"Error: Plan file not found: {plan}", err=True)
|
|
sys.exit(1)
|
|
execution_plan = load_plan(plan)
|
|
plan_summary = execution_plan.human_summary or _fallback_plan_summary(execution_plan)
|
|
|
|
try:
|
|
# Load analysis from JSON
|
|
click.echo(f"Loading analysis from: {input}")
|
|
|
|
analysis_data = load_analysis_json(input)
|
|
|
|
# Extract duplicates data
|
|
duplicates_list = analysis_data.get('duplicates', [])
|
|
|
|
# Convert to DuplicateGroup objects
|
|
duplicate_groups = []
|
|
for d in duplicates_list:
|
|
identity_data = d['identity']
|
|
|
|
# Reconstruct identity
|
|
if identity_data['type'] == 'movie':
|
|
identity = MovieIdentity(
|
|
title=identity_data['title'],
|
|
year=identity_data.get('year'),
|
|
confidence=1.0,
|
|
needs_review=False,
|
|
original_filename=""
|
|
)
|
|
else: # series
|
|
identity = SeriesIdentity(
|
|
title=identity_data['title'],
|
|
season=identity_data.get('season'),
|
|
episodes=identity_data.get('episodes', []),
|
|
confidence=1.0,
|
|
needs_review=False,
|
|
original_filename=""
|
|
)
|
|
|
|
quality_by_path = {
|
|
str(item.get("path", "")): item for item in d.get("quality_comparison", [])
|
|
}
|
|
|
|
# Reconstruct VideoFile objects from file paths and preserve size metadata
|
|
files = []
|
|
for file_path in d['files']:
|
|
quality = quality_by_path.get(str(file_path), {})
|
|
files.append(VideoFile(
|
|
path=Path(file_path),
|
|
filename=Path(file_path).name,
|
|
size_bytes=int(quality.get("size_bytes", 0) or 0),
|
|
modified_timestamp=datetime.now(timezone.utc),
|
|
category="",
|
|
resolution=quality.get("resolution"),
|
|
codec=quality.get("codec"),
|
|
duration_seconds=quality.get("duration_seconds"),
|
|
bitrate_kbps=quality.get("bitrate_kbps"),
|
|
))
|
|
|
|
duplicate_groups.append(DuplicateGroup(
|
|
identity=identity,
|
|
files=files,
|
|
quality_comparison=d['quality_comparison']
|
|
))
|
|
|
|
click.echo(f"Loaded {len(duplicate_groups)} duplicate groups")
|
|
click.echo()
|
|
|
|
# Generate report
|
|
click.echo(f"Generating duplicate report in {format} format...")
|
|
report_content = generate_duplicate_report(
|
|
duplicate_groups, format, config.library_root, plan_summary=plan_summary
|
|
)
|
|
|
|
# Output report
|
|
if output:
|
|
# Save to file
|
|
output.parent.mkdir(parents=True, exist_ok=True)
|
|
with open(output, 'w', encoding='utf-8') as f:
|
|
f.write(report_content)
|
|
click.echo(f"Report saved to: {output}")
|
|
else:
|
|
# Print to console
|
|
click.echo()
|
|
click.echo(report_content)
|
|
|
|
logger.info(f"Generated duplicate report in {format} format with {len(duplicate_groups)} groups")
|
|
|
|
except FileNotFoundError:
|
|
_command_error(ctx, f"Error: Input file not found: {input}", f"Input file not found: {input}")
|
|
|
|
except json.JSONDecodeError as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error: Failed to parse JSON file: {e}",
|
|
f"JSON parsing failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error generating duplicate report: {e}",
|
|
f"Duplicate report generation failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@report.command('summary')
|
|
@click.option(
|
|
'--input',
|
|
type=click.Path(path_type=Path),
|
|
default=lambda: default_artifact_path('inventory.csv'),
|
|
help='Input inventory CSV file (default: artifacts/inventory.csv)'
|
|
)
|
|
@click.option(
|
|
'--output',
|
|
type=click.Path(path_type=Path),
|
|
default=None,
|
|
help='Output file (default: print to console)'
|
|
)
|
|
@pass_context
|
|
def report_summary(ctx: CLIContext, input: Path, output: Optional[Path]):
|
|
"""Generate summary report.
|
|
|
|
Shows library statistics including total file count, size, and category
|
|
breakdown.
|
|
|
|
Example:
|
|
|
|
vlm report summary # Print to console
|
|
vlm report summary --output summary.txt # Save to file
|
|
"""
|
|
from vlm.reports import generate_summary_report
|
|
from vlm.io import load_inventory_csv
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
input = resolve_legacy_default_input_path(input, "input", "inventory.csv", "--input")
|
|
# Load inventory from CSV
|
|
click.echo(f"Loading inventory from: {input}")
|
|
|
|
video_files = load_inventory_csv(input)
|
|
|
|
click.echo(f"Loaded {len(video_files)} files")
|
|
click.echo()
|
|
|
|
# Generate report
|
|
click.echo("Generating summary report...")
|
|
report_content = generate_summary_report(video_files, config.library_root)
|
|
|
|
# Output report
|
|
if output:
|
|
# Save to file
|
|
output.parent.mkdir(parents=True, exist_ok=True)
|
|
with open(output, 'w', encoding='utf-8') as f:
|
|
f.write(report_content)
|
|
click.echo(f"Report saved to: {output}")
|
|
else:
|
|
# Print to console
|
|
click.echo()
|
|
click.echo(report_content)
|
|
|
|
logger.info(f"Generated summary report with {len(video_files)} files")
|
|
|
|
except FileNotFoundError:
|
|
_command_error(ctx, f"Error: Input file not found: {input}", f"Input file not found: {input}")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error generating summary report: {e}",
|
|
f"Summary report generation failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.group()
|
|
@pass_context
|
|
def state(ctx: CLIContext):
|
|
"""Manage file states.
|
|
|
|
Track file statuses and user decisions throughout the workflow.
|
|
"""
|
|
pass
|
|
|
|
|
|
@state.command('show')
|
|
@click.argument('file', type=click.Path(path_type=Path))
|
|
@pass_context
|
|
def state_show(ctx: CLIContext, file: Path):
|
|
"""Show state for a file.
|
|
|
|
Displays the current status, reason, and last update timestamp for a file.
|
|
|
|
Example:
|
|
|
|
vlm state show /path/to/movie.mkv
|
|
"""
|
|
from vlm.state import StateManager
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
# Get state store path
|
|
state_path = Path.home() / ".vlm" / "state.json"
|
|
|
|
# Create state manager
|
|
manager = StateManager(state_path)
|
|
|
|
# Get file state
|
|
file_state = manager.get_file_state(file)
|
|
|
|
if file_state is None:
|
|
click.echo(f"No state found for file: {file}")
|
|
click.echo("This file has not been tracked yet.")
|
|
else:
|
|
click.echo(f"State for file: {file}")
|
|
click.echo()
|
|
click.echo(f" Status: {file_state.status}")
|
|
if file_state.reason:
|
|
click.echo(f" Reason: {file_state.reason}")
|
|
click.echo(f" Updated: {file_state.updated_at.strftime('%Y-%m-%d %H:%M:%S')}")
|
|
|
|
logger.info(f"Showed state for file: {file}")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error showing file state: {e}",
|
|
f"Failed to show file state: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@state.command('set')
|
|
@click.argument('file', type=click.Path(path_type=Path))
|
|
@click.option(
|
|
'--status',
|
|
type=click.Choice(['reviewed', 'ignored', 'planned', 'executed', 'quarantined'], case_sensitive=False),
|
|
required=True,
|
|
help='Status to set for the file'
|
|
)
|
|
@click.option(
|
|
'--reason',
|
|
type=str,
|
|
default=None,
|
|
help='Optional reason for the status'
|
|
)
|
|
@pass_context
|
|
def state_set(ctx: CLIContext, file: Path, status: str, reason: Optional[str]):
|
|
"""Set state for a file.
|
|
|
|
Updates the status and optional reason for a file. This operation is
|
|
idempotent - setting the same status multiple times will update the
|
|
timestamp and reason.
|
|
|
|
Valid statuses: reviewed, ignored, planned, executed, quarantined
|
|
|
|
Example:
|
|
|
|
vlm state set /path/to/movie.mkv --status reviewed
|
|
vlm state set /path/to/movie.mkv --status ignored --reason "duplicate"
|
|
"""
|
|
from vlm.state import StateManager
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
# Get state store path
|
|
state_path = Path.home() / ".vlm" / "state.json"
|
|
|
|
# Create state manager
|
|
manager = StateManager(state_path)
|
|
|
|
# Set file state
|
|
manager.set_file_state(file, status, reason)
|
|
|
|
# Save state
|
|
manager.save()
|
|
|
|
# Display confirmation
|
|
click.echo(f"✓ State updated for file: {file}")
|
|
click.echo(f" Status: {status}")
|
|
if reason:
|
|
click.echo(f" Reason: {reason}")
|
|
|
|
logger.info(f"Set state for file {file}: status={status}, reason={reason}")
|
|
|
|
except ValueError as e:
|
|
_command_error(ctx, f"Error: {e}", f"Invalid status: {e}")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error setting file state: {e}",
|
|
f"Failed to set file state: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@state.command('query')
|
|
@click.option(
|
|
'--status',
|
|
type=click.Choice(['reviewed', 'ignored', 'planned', 'executed', 'quarantined'], case_sensitive=False),
|
|
required=True,
|
|
help='Status to query for'
|
|
)
|
|
@pass_context
|
|
def state_query(ctx: CLIContext, status: str):
|
|
"""Query files by status.
|
|
|
|
Lists all files with the specified status.
|
|
|
|
Example:
|
|
|
|
vlm state query --status ignored
|
|
vlm state query --status reviewed
|
|
"""
|
|
from vlm.state import StateManager
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
# Get state store path
|
|
state_path = Path.home() / ".vlm" / "state.json"
|
|
|
|
# Create state manager
|
|
manager = StateManager(state_path)
|
|
|
|
# Query files by status
|
|
file_states = manager.query_by_status(status)
|
|
|
|
if not file_states:
|
|
click.echo(f"No files found with status '{status}'.")
|
|
return
|
|
|
|
# Display results
|
|
click.echo(f"Files with status '{status}':")
|
|
click.echo("=" * 80)
|
|
click.echo()
|
|
|
|
for i, file_state in enumerate(file_states, 1):
|
|
click.echo(f"[{i}] {file_state.file_path}")
|
|
if file_state.reason:
|
|
click.echo(f" Reason: {file_state.reason}")
|
|
click.echo(f" Updated: {file_state.updated_at.strftime('%Y-%m-%d %H:%M:%S')}")
|
|
click.echo()
|
|
|
|
click.echo("=" * 80)
|
|
click.echo(f"Total: {len(file_states)} file(s)")
|
|
|
|
logger.info(f"Queried files with status '{status}': {len(file_states)} found")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error querying file states: {e}",
|
|
f"Failed to query file states: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@state.command('clear')
|
|
@click.argument('file', type=click.Path(path_type=Path))
|
|
@pass_context
|
|
def state_clear(ctx: CLIContext, file: Path):
|
|
"""Clear state for a file.
|
|
|
|
Removes the state tracking for a file.
|
|
|
|
Example:
|
|
|
|
vlm state clear /path/to/movie.mkv
|
|
"""
|
|
from vlm.state import StateManager
|
|
|
|
config = ctx.config
|
|
logger = ctx.logger
|
|
|
|
try:
|
|
# Get state store path
|
|
state_path = Path.home() / ".vlm" / "state.json"
|
|
|
|
# Create state manager
|
|
manager = StateManager(state_path)
|
|
|
|
# Check if state exists
|
|
file_state = manager.get_file_state(file)
|
|
|
|
if file_state is None:
|
|
click.echo(f"No state found for file: {file}")
|
|
click.echo("Nothing to clear.")
|
|
return
|
|
|
|
# Clear file state
|
|
manager.clear_state(file)
|
|
|
|
# Save state
|
|
manager.save()
|
|
|
|
# Display confirmation
|
|
click.echo(f"✓ State cleared for file: {file}")
|
|
|
|
logger.info(f"Cleared state for file: {file}")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error clearing file state: {e}",
|
|
f"Failed to clear file state: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@main.group(name='config')
|
|
@pass_context
|
|
def config_cmd(ctx: CLIContext):
|
|
"""Manage configuration.
|
|
|
|
Initialize, view, and validate configuration settings.
|
|
"""
|
|
pass
|
|
|
|
|
|
@config_cmd.command('init')
|
|
@click.option(
|
|
'--path',
|
|
type=click.Path(path_type=Path),
|
|
default=default_config_path,
|
|
help='Path where configuration file should be created'
|
|
)
|
|
@pass_context
|
|
def config_init(ctx: CLIContext, path: Path):
|
|
"""Initialize configuration file with defaults."""
|
|
try:
|
|
if path.exists():
|
|
click.echo(f"Configuration file already exists at {path}", err=True)
|
|
if not click.confirm("Overwrite existing configuration?"):
|
|
click.echo("Configuration initialization cancelled.")
|
|
return
|
|
|
|
create_default_config(path)
|
|
click.echo(f"Configuration file created at {path}")
|
|
click.echo("Edit this file to customize your settings.")
|
|
|
|
except Exception as e:
|
|
_command_error(
|
|
ctx,
|
|
f"Error creating configuration: {e}",
|
|
f"Configuration creation failed: {e}",
|
|
exc_info=True,
|
|
)
|
|
|
|
|
|
@config_cmd.command('show')
|
|
@pass_context
|
|
def config_show(ctx: CLIContext):
|
|
"""Show current configuration."""
|
|
cfg = ctx.config
|
|
click.echo("Current configuration:")
|
|
click.echo(f" Library root: {cfg.library_root}")
|
|
click.echo(f" Video extensions: {', '.join(cfg.video_extensions)}")
|
|
click.echo(f" Movie template: {cfg.movie_template}")
|
|
click.echo(f" Series template: {cfg.series_template}")
|
|
click.echo(f" Movie filename template: {cfg.movie_filename_template}")
|
|
click.echo(f" Series filename template: {cfg.series_filename_template}")
|
|
click.echo(f" Quarantine directory: {cfg.quarantine_dir}")
|
|
click.echo(f" Workspace directory: {cfg.workspace_dir}")
|
|
click.echo(f" Log level: {cfg.log_level}")
|
|
|
|
|
|
@config_cmd.command('validate')
|
|
@pass_context
|
|
def config_validate(ctx: CLIContext):
|
|
"""Validate configuration."""
|
|
cfg = ctx.config
|
|
errors = validate_config(cfg)
|
|
|
|
if not errors:
|
|
click.echo("Configuration is valid.")
|
|
else:
|
|
click.echo("Configuration validation errors:", err=True)
|
|
for error in errors:
|
|
click.echo(f" - {error}", err=True)
|
|
_command_error(ctx, "Configuration validation failed.", "Configuration validation failed")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|