cli

Modules

fastvideo.entrypoints.cli.bench

Runs benchmark against a running FastVideo OpenAI-compatible server.

Example usage

fastvideo bench --dataset vbench --num-prompts 20 --port 8000

Classes

fastvideo.entrypoints.cli.bench.BenchSubcommand

BenchSubcommand()

Bases: CLISubcommand

The bench subcommand — runs serving benchmarks.

Source code in fastvideo/entrypoints/cli/bench.py

def __init__(self) -> None:
    self.name = "bench"
    super().__init__()

Functions:

fastvideo.entrypoints.cli.bench_serving

Benchmark online serving for diffusion models (Image/Video Generation).

Example usage

launch a server and benchmark on it

T2V or T2I or any other multimodal generation model

fastvideo serve --config serve.yaml

benchmark it and make sure the port is the same as the server's port

fastvideo bench --dataset vbench --num-prompts 20 --port 8000

Classes

fastvideo.entrypoints.cli.bench_serving.VBenchDataset

VBenchDataset(args, api_url: str, model: str)

Bases: BaseDataset

Dataset loader for VBench prompts. Supports t2v, i2v.

Source code in fastvideo/entrypoints/cli/bench_serving.py

def __init__(self, args, api_url: str, model: str):
    super().__init__(args, api_url, model)
    self.cache_dir = os.path.join(os.path.expanduser("~"), ".cache", "fastvideo")
    self.items = self._load_data()

Functions:

fastvideo.entrypoints.cli.cli_types

Classes

fastvideo.entrypoints.cli.cli_types.CLISubcommand

Base class for CLI subcommands

Methods:

fastvideo.entrypoints.cli.cli_types.CLISubcommand.cmd

cmd(args: Namespace) -> None

Execute the command with the given arguments

Source code in fastvideo/entrypoints/cli/cli_types.py

def cmd(self, args: argparse.Namespace) -> None:
    """Execute the command with the given arguments"""
    raise NotImplementedError

fastvideo.entrypoints.cli.cli_types.CLISubcommand.subparser_init

subparser_init(subparsers: _SubParsersAction) -> FlexibleArgumentParser

Initialize the subparser for this command

Source code in fastvideo/entrypoints/cli/cli_types.py

def subparser_init(self, subparsers: argparse._SubParsersAction) -> FlexibleArgumentParser:
    """Initialize the subparser for this command"""
    raise NotImplementedError

fastvideo.entrypoints.cli.cli_types.CLISubcommand.validate

validate(args: Namespace) -> None

Validate the arguments for this command

Source code in fastvideo/entrypoints/cli/cli_types.py

def validate(self, args: argparse.Namespace) -> None:
    """Validate the arguments for this command"""
    pass

fastvideo.entrypoints.cli.eval

fastvideo eval CLI: list registered eval metrics and run them against a set of videos.

This is a thin wrapper around :mod:fastvideo.eval. Heavy lifting (metric loading, GPU handling, batching) lives in :func:fastvideo.eval.create_evaluator.

Examples::

fastvideo eval list
fastvideo eval list --group vbench
fastvideo eval run --videos path/to/videos/*.mp4 \
    --metrics common.ssim --reference path/to/refs/
fastvideo eval run --videos clip.mp4 --metrics vbench.aesthetic_quality \
    --output scores.json

Classes

fastvideo.entrypoints.cli.eval.EvalSubcommand

EvalSubcommand()

Bases: CLISubcommand

The eval subcommand — entry point for the eval suite.

Source code in fastvideo/entrypoints/cli/eval.py

def __init__(self) -> None:
    self.name = "eval"
    super().__init__()

Functions:

fastvideo.entrypoints.cli.generate

Classes

fastvideo.entrypoints.cli.generate.GenerateSubcommand

GenerateSubcommand()

Bases: CLISubcommand

The generate subcommand for the FastVideo CLI

Source code in fastvideo/entrypoints/cli/generate.py

def __init__(self) -> None:
    self.name = "generate"
    super().__init__()

Methods:

fastvideo.entrypoints.cli.generate.GenerateSubcommand.validate

validate(args: Namespace) -> None

Validate the arguments for this command

Source code in fastvideo/entrypoints/cli/generate.py

def validate(self, args: argparse.Namespace) -> None:
    """Validate the arguments for this command"""
    if not args.config:
        raise ValueError("fastvideo generate requires --config PATH; use a nested "
                         "run config plus optional dotted overrides")
    if not os.path.exists(args.config):
        raise ValueError(f"Config file not found: {args.config}")
    setattr(
        args,
        _VALIDATED_RUN_CONFIG_ATTR,
        build_generate_run_config(
            args,
            overrides=getattr(args, "_unknown", None),
        ),
    )

Functions:

fastvideo.entrypoints.cli.main

Classes

Functions:

fastvideo.entrypoints.cli.main.cmd_init

cmd_init() -> list[CLISubcommand]

Initialize all commands from separate modules

Source code in fastvideo/entrypoints/cli/main.py

def cmd_init() -> list[CLISubcommand]:
    """Initialize all commands from separate modules"""
    commands = []
    commands.extend(generate_cmd_init())
    commands.extend(serve_cmd_init())
    commands.extend(router_serve_cmd_init())
    commands.extend(bench_cmd_init())
    commands.extend(eval_cmd_init())
    return commands

fastvideo.entrypoints.cli.router_serve

fastvideo router-serve CLI subcommand.

Launches the streaming router from a YAML config. Separate from fastvideo serve because the router is an orthogonal process: it fronts one or more running servers rather than hosting a generator itself.

Classes

fastvideo.entrypoints.cli.router_serve.RouterServeSubcommand

RouterServeSubcommand()

Bases: CLISubcommand

Start the multi-replica WebSocket router.

Source code in fastvideo/entrypoints/cli/router_serve.py

def __init__(self) -> None:
    self.name = "router-serve"
    super().__init__()

Functions:

fastvideo.entrypoints.cli.serve

Classes

fastvideo.entrypoints.cli.serve.ServeSubcommand

ServeSubcommand()

Bases: CLISubcommand

Starts an OpenAI-compatible API server.

Source code in fastvideo/entrypoints/cli/serve.py

def __init__(self) -> None:
    self.name = "serve"
    super().__init__()

Functions:

fastvideo.entrypoints.cli.utils

Functions:

fastvideo.entrypoints.cli.utils.launch_distributed

launch_distributed(num_gpus: int, args: list[str], master_port: int | None = None) -> int

Launch a distributed job with the given arguments

Parameters:

Name	Type	Description	Default
num_gpus	int	Number of GPUs to use	required
args	list[str]	Arguments to pass to v1_fastvideo_inference.py (defaults to sys.argv[1:])	required
master_port	int | None	Port for the master process (default: random)	None

Source code in fastvideo/entrypoints/cli/utils.py

def launch_distributed(num_gpus: int, args: list[str], master_port: int | None = None) -> int:
    """
    Launch a distributed job with the given arguments

    Args:
        num_gpus: Number of GPUs to use
        args: Arguments to pass to v1_fastvideo_inference.py (defaults to sys.argv[1:])
        master_port: Port for the master process (default: random)
    """

    current_env = os.environ.copy()
    python_executable = sys.executable
    project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../.."))
    main_script = os.path.join(project_root, "fastvideo/sample/v1_fastvideo_inference.py")

    cmd = [python_executable, "-m", "torch.distributed.run", f"--nproc_per_node={num_gpus}"]

    if master_port is not None:
        cmd.append(f"--master_port={master_port}")

    cmd.append(main_script)
    cmd.extend(args)

    logger.info("Running inference with %d GPU(s)", num_gpus)
    logger.info("Launching command: %s", " ".join(cmd))

    current_env["PYTHONIOENCODING"] = "utf-8"
    process = subprocess.Popen(cmd,
                               env=current_env,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.STDOUT,
                               universal_newlines=True,
                               bufsize=1,
                               encoding='utf-8',
                               errors='replace')

    if process.stdout:
        for line in iter(process.stdout.readline, ''):
            print(line.strip())

    return process.wait()