genblaze-cli 0.2.0__py3-none-any.whl

genblaze_cli/__init__.py

@@ -0,0 +1 @@
+"""genblaze CLI."""

genblaze_cli/commands/extract.py

@@ -0,0 +1,40 @@
+"""Extract command — print embedded manifest from a media file."""
+
+from pathlib import Path
+
+import click
+from genblaze_core.exceptions import EmbeddingError
+from genblaze_core.media import get_handler, guess_mime
+from genblaze_core.media.sidecar import SidecarHandler
+
+
+def _extract_manifest(file: Path):
+    """Try format-specific handler first, then sidecar fallback."""
+    mime = guess_mime(file)
+    handler = get_handler(mime)
+    if handler is not None:
+        try:
+            return handler.extract(file)
+        except EmbeddingError:
+            pass  # Expected: no manifest in this format, try sidecar
+    # Try sidecar fallback
+    sidecar = SidecarHandler()
+    return sidecar.extract(file)
+
+
+@click.command()
+@click.argument("file", type=click.Path(exists=True, path_type=Path))
+@click.option("--format", "fmt", type=click.Choice(["json", "summary"]), default="json")
+def extract(file: Path, fmt: str) -> None:
+    """Extract and display the genblaze manifest from a media file."""
+    try:
+        manifest = _extract_manifest(file)
+        if fmt == "json":
+            click.echo(manifest.to_canonical_json())
+        else:
+            click.echo(f"Run ID:    {manifest.run.run_id}")
+            click.echo(f"Steps:     {len(manifest.run.steps)}")
+            click.echo(f"Hash:      {manifest.canonical_hash}")
+            click.echo(f"Verified:  {manifest.verify()}")
+    except Exception as exc:
+        raise click.ClickException(f"{type(exc).__name__}: {exc}") from exc

genblaze_cli/commands/index.py

@@ -0,0 +1,34 @@
+"""Index command — write manifest data to a Parquet sink."""
+
+import json
+from pathlib import Path
+
+import click
+
+
+@click.command()
+@click.argument("manifest_file", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(path_type=Path),
+    default="./genblaze_index",
+    help="Base directory for Parquet output.",
+)
+def index(manifest_file: Path, output: Path) -> None:
+    """Write manifest data to a Parquet sink for querying."""
+    from genblaze_core.models.manifest import Manifest
+    from genblaze_core.sinks.parquet import ParquetSink
+
+    try:
+        data = json.loads(manifest_file.read_text(encoding="utf-8"))
+        manifest = Manifest.model_validate(data)
+    except Exception as exc:
+        raise click.ClickException(f"Failed to load manifest: {exc}") from exc
+
+    try:
+        sink = ParquetSink(output)
+        sink.write_run(manifest.run, manifest)
+        click.echo(f"Indexed run {manifest.run.run_id} to {output}")
+    except Exception as exc:
+        raise click.ClickException(f"Failed to write Parquet: {exc}") from exc

genblaze_cli/commands/replay.py

@@ -0,0 +1,211 @@
+"""Replay command — re-execute a pipeline from a manifest file."""
+
+import json
+from pathlib import Path
+
+import click
+from genblaze_core.models.enums import PromptVisibility
+
+
+def _load_provider(provider_name: str, allowed: tuple[str, ...] | None):
+    """Load a provider by name using entry point discovery.
+
+    If allowed is set, reject providers not in the allowlist.
+    """
+    if allowed and provider_name not in allowed:
+        raise click.ClickException(
+            f"Provider '{provider_name}' not in allowlist: {', '.join(allowed)}"
+        )
+    from genblaze_core.providers.registry import discover_providers
+
+    registry = discover_providers()
+    cls = registry.get(provider_name)
+    if cls is None:
+        available = ", ".join(sorted(registry.keys())) or "(none installed)"
+        raise click.ClickException(
+            f"Unknown provider '{provider_name}'. Installed providers: {available}"
+        )
+    click.echo(f"  Loading provider: {provider_name}", err=True)
+    return cls()
+
+
+def _detect_chain_mode(run) -> bool:
+    """Detect if the original pipeline used chain mode by checking step inputs.
+
+    If any step has _input_from metadata, this is a fan-in pipeline (not chain).
+    Otherwise, if every non-first step has inputs, it was likely chain mode.
+    """
+    has_input_from = any(step.metadata.get("_input_from") is not None for step in run.steps)
+    if has_input_from:
+        return False
+    non_first = run.steps[1:]
+    return bool(non_first) and all(len(step.inputs) > 0 for step in non_first)
+
+
+def _print_summary(run, *, show_prompts: bool) -> None:
+    """Print manifest run summary.
+
+    Prompts are only shown when ``show_prompts`` is True AND the step's
+    prompt_visibility is PUBLIC. Non-public prompts are redacted to avoid
+    leaking private content to terminals/CI logs when replaying manifests
+    pulled from shared storage.
+    """
+    click.echo(f"Run:    {run.run_id}")
+    click.echo(f"Name:   {run.name or '(unnamed)'}")
+    click.echo(f"Steps:  {len(run.steps)}")
+    click.echo()
+
+    for i, step in enumerate(run.steps, 1):
+        click.echo(f"  Step {i}: {step.provider}/{step.model}")
+        click.echo(f"    Type:     {step.step_type}")
+        if show_prompts and step.prompt_visibility == PromptVisibility.PUBLIC:
+            click.echo(f"    Prompt:   {step.prompt or '(none)'}")
+        else:
+            click.echo(
+                f"    Prompt:   [redacted — visibility={step.prompt_visibility};"
+                " pass --show-prompts to reveal public prompts]"
+            )
+        click.echo(f"    Modality: {step.modality}")
+        if step.params:
+            click.echo(f"    Params:   {step.params}")
+
+
+# Fields that cannot be faithfully replayed (logged as warnings)
+_UNREPLAYABLE_FIELDS = [
+    ("prompt_visibility", lambda s: s.prompt_visibility != "public"),
+]
+
+
+@click.command()
+@click.argument("manifest_file", type=click.Path(exists=True, path_type=Path))
+@click.option("--dry-run/--no-dry-run", default=True, help="Preview without executing.")
+@click.option(
+    "--allow-provider",
+    multiple=True,
+    help="Only allow these providers (can be specified multiple times).",
+)
+@click.option(
+    "--show-prompts",
+    is_flag=True,
+    help="Show public-visibility prompts in the summary. Non-public prompts are always redacted.",
+)
+@click.option("--force", is_flag=True, help="Skip manifest hash verification.")
+def replay(
+    manifest_file: Path,
+    dry_run: bool,
+    allow_provider: tuple[str, ...],
+    show_prompts: bool,
+    force: bool,
+) -> None:
+    """Re-execute a pipeline from a manifest JSON file."""
+    from genblaze_core.models.manifest import parse_manifest
+    from genblaze_core.pipeline import Pipeline
+
+    try:
+        data = json.loads(manifest_file.read_text(encoding="utf-8"))
+        manifest = parse_manifest(data)
+    except Exception as exc:
+        raise click.ClickException(f"Failed to load manifest: {exc}") from exc
+
+    # Verify manifest hash integrity
+    if not force and not manifest.verify():
+        click.echo(
+            "WARNING: Manifest hash does not match content. The file may have been modified.",
+            err=True,
+        )
+        if not click.confirm("Continue anyway?"):
+            raise click.Abort()
+
+    run = manifest.run
+    _print_summary(run, show_prompts=show_prompts)
+
+    if dry_run:
+        click.echo()
+        click.echo("Dry run — no steps executed. Use --no-dry-run to execute.")
+        return
+
+    # Build and execute pipeline from manifest steps
+    click.echo()
+    click.echo("Replaying pipeline...")
+
+    allowed: tuple[str, ...] | None = allow_provider if allow_provider else None
+
+    # Safety: when no allowlist is provided, confirm each unique provider.
+    # A hostile manifest could reference any installed provider and execute
+    # paid API calls on the user's credentials without consent.
+    if allowed is None:
+        unique_providers = sorted({step.provider for step in run.steps})
+        click.echo(
+            "No --allow-provider allowlist set. Confirm each provider before execution:",
+            err=True,
+        )
+        confirmed: list[str] = []
+        for name in unique_providers:
+            if click.confirm(f"  Execute with provider '{name}'?", default=False):
+                confirmed.append(name)
+            else:
+                raise click.Abort()
+        allowed = tuple(confirmed)
+
+    # Detect chain mode from step inputs in the manifest
+    chain = _detect_chain_mode(run)
+    if chain:
+        click.echo("  Detected chain mode from manifest step inputs.", err=True)
+
+    # Cache providers by name to avoid re-instantiating
+    providers: dict[str, object] = {}
+    pipe = Pipeline(
+        run.name,
+        tenant_id=run.tenant_id,
+        project_id=run.project_id,
+        chain=chain,
+    )
+
+    # Reserved kwargs that Pipeline.step() accepts explicitly
+    _reserved = {"model", "prompt", "modality", "step_type", "seed", "negative_prompt"}
+
+    for step_idx, step in enumerate(run.steps):
+        if step.provider not in providers:
+            providers[step.provider] = _load_provider(step.provider, allowed)
+
+        # Warn about fields that can't be faithfully replayed
+        for field_name, has_value in _UNREPLAYABLE_FIELDS:
+            if has_value(step):
+                click.echo(
+                    f"  WARNING: Step {step_idx + 1} has {field_name}={getattr(step, field_name)}"
+                    f" which may not replay identically.",
+                    err=True,
+                )
+
+        # Strip reserved keys from params to avoid TypeError on collision
+        extra_params = {k: v for k, v in step.params.items() if k not in _reserved}
+
+        # Restore seed and negative_prompt if present
+        if step.seed is not None:
+            extra_params["seed"] = step.seed
+        if step.negative_prompt is not None:
+            extra_params["negative_prompt"] = step.negative_prompt
+
+        # Restore fallback_models and input_from from step metadata
+        fallback_models = step.metadata.get("_fallback_models")
+        input_from = step.metadata.get("_input_from")
+
+        pipe.step(
+            providers[step.provider],
+            model=step.model,
+            prompt=step.prompt,
+            modality=step.modality,
+            step_type=step.step_type,
+            fallback_models=fallback_models,
+            input_from=input_from,
+            **extra_params,
+        )
+
+    try:
+        result = pipe.run()
+        click.echo()
+        click.echo(f"Replay complete. New run ID: {result.run.run_id}")
+        click.echo(f"Hash: {result.manifest.canonical_hash}")
+        click.echo(f"Status: {result.run.status}")
+    except Exception as exc:
+        raise click.ClickException(f"Replay failed: {exc}") from exc

genblaze_cli/commands/verify.py

@@ -0,0 +1,41 @@
+"""Verify command — check manifest hash integrity."""
+
+from pathlib import Path
+
+import click
+from genblaze_core.exceptions import EmbeddingError
+from genblaze_core.media import get_handler, guess_mime
+from genblaze_core.media.sidecar import SidecarHandler
+
+
+def _verify_manifest(file: Path) -> bool:
+    """Extract and verify manifest, trying format-specific handler then sidecar."""
+    mime = guess_mime(file)
+    handler = get_handler(mime)
+    if handler is not None:
+        try:
+            return handler.verify(file)
+        except EmbeddingError:
+            pass  # Expected: no manifest in this format, try sidecar
+    # Try sidecar fallback
+    sidecar = SidecarHandler()
+    return sidecar.verify(file)
+
+
+@click.command()
+@click.argument("file", type=click.Path(exists=True, path_type=Path))
+def verify(file: Path) -> None:
+    """Verify the integrity of a genblaze manifest in a media file."""
+    try:
+        valid = _verify_manifest(file)
+        if valid:
+            click.echo("OK — manifest hash verified.")
+        else:
+            click.echo("FAIL — manifest hash mismatch.", err=True)
+            raise click.exceptions.Exit(1)
+    except click.exceptions.Exit:
+        raise
+    except Exception as exc:
+        # Prefix with exception type so "PermissionError: ..." and
+        # "EmbeddingError: ..." are distinguishable at a glance.
+        raise click.ClickException(f"{type(exc).__name__}: {exc}") from exc

genblaze_cli/main.py

@@ -0,0 +1,20 @@
+"""CLI entry point."""
+
+import click
+
+from genblaze_cli.commands.extract import extract
+from genblaze_cli.commands.index import index
+from genblaze_cli.commands.replay import replay
+from genblaze_cli.commands.verify import verify
+
+
+@click.group()
+@click.version_option(package_name="genblaze-cli")
+def cli() -> None:
+    """genblaze — media generation manifest toolkit."""
+
+
+cli.add_command(extract)
+cli.add_command(index)
+cli.add_command(replay)
+cli.add_command(verify)

genblaze_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: genblaze-cli
+Version: 0.2.0
+Summary: CLI for genblaze manifest operations
+Project-URL: Homepage, https://github.com/backblaze-labs/genblaze
+Project-URL: Repository, https://github.com/backblaze-labs/genblaze
+Project-URL: Changelog, https://github.com/backblaze-labs/genblaze/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/backblaze-labs/genblaze/issues
+Author-email: Jeronimo De Leon <jdeleon@backblaze.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: genblaze-core<0.3,>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pillow>=10.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<!-- last_verified: 2026-04-22 -->
+# genblaze-cli
+
+**Command-line toolkit for inspecting, verifying, and indexing genblaze AI-generated-media provenance manifests.**
+
+`genblaze-cli` is the companion CLI for [genblaze](https://github.com/backblaze-labs/genblaze) — the Python SDK for generative AI pipelines across video, image, and audio. It lets anyone (not just Python developers) audit AI-generated media: extract the embedded provenance manifest from an MP4 / PNG / MP3, verify its SHA-256 hash, replay a run, or index manifests into Parquet for downstream analytics.
+
+## Why genblaze-cli
+
+- **Audit AI-generated media in one command** — `genblaze verify video.mp4` confirms a file's manifest hash hasn't been tampered with.
+- **Works on any genblaze output** — PNG, JPEG, WebP, MP4, MP3, WAV with embedded manifests.
+- **Analytics-ready** — `genblaze index` emits partitioned Parquet tables (runs, steps, assets) for BI tools and data warehouses.
+- **Zero provider dependencies** — reads manifests; doesn't call any AI API.
+- **Shell-friendly** — non-zero exit codes on verification failure, pipeable JSON output.
+
+## Install
+
+```bash
+pip install genblaze-cli
+```
+
+Installs the `genblaze` console script.
+
+## Usage
+
+```bash
+genblaze --help
+
+genblaze extract video.mp4                # Extract embedded manifest → stdout (JSON)
+genblaze extract video.mp4 -o m.json      # …or to a file
+
+genblaze verify video.mp4                 # Verify the embedded manifest's SHA-256
+genblaze verify manifest.json             # Or verify a standalone manifest file
+
+genblaze replay manifest.json             # Show what a replay would do (dry run)
+
+genblaze index manifest.json -o data/     # Index into partitioned Parquet tables
+```
+
+Exit codes are non-zero on verification failure — safe to drop into CI pipelines, release checks, or content-moderation workflows.
+
+## Typical flow
+
+```bash
+# 1. Someone ships you an AI-generated video
+genblaze extract delivered-ad.mp4 -o manifest.json
+
+# 2. Confirm it hasn't been tampered with
+genblaze verify delivered-ad.mp4
+
+# 3. Index into your analytics warehouse
+genblaze index manifest.json -o s3://analytics/genblaze/
+```
+
+## Documentation
+
+- **Main repo**: https://github.com/backblaze-labs/genblaze
+- **CLI reference**: https://github.com/backblaze-labs/genblaze/tree/main/cli
+
+## Related packages
+
+- [`genblaze-core`](https://pypi.org/project/genblaze-core/) — the pipeline SDK that produces these manifests
+- [`genblaze-s3`](https://pypi.org/project/genblaze-s3/) — durable storage on [Backblaze B2](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze), AWS S3, Cloudflare R2, MinIO
+
+## License
+
+MIT

genblaze_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+genblaze_cli/__init__.py,sha256=bugOiMl926GX70kdp9IhfgjC4Wa7nJ1Q0ej3OXPp0oQ,20
+genblaze_cli/main.py,sha256=7rqLrPhC5oNAftoyOzGIQM-xyuSZ7Ca34gmPUYIk724,473
+genblaze_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+genblaze_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+genblaze_cli/commands/extract.py,sha256=Wp_LJHMtwXNysB4aWA8_eE5F2K0m6mXjRkvhPxvsaB0,1499
+genblaze_cli/commands/index.py,sha256=wyfSha0oXWkv89TNVzj9rXboCZRU0dS3IQv2zfyE8Tk,1104
+genblaze_cli/commands/replay.py,sha256=E2ujYBfyN7Z2CFBoJlqYZ6v7rCvu5lM5bx7Ycg9eXdg,7779
+genblaze_cli/commands/verify.py,sha256=qLi68LFevBL5Yj5LoeWr60F0TfR2bFpgl1gbc5Mvk5I,1445
+genblaze_cli-0.2.0.dist-info/METADATA,sha256=XAsvE5WqGWLEI-mhB9DcMtjqFomLEWMjbss6gso0J7k,3580
+genblaze_cli-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+genblaze_cli-0.2.0.dist-info/entry_points.txt,sha256=BhMtCFvHqDssP-lleKOdxIBzN3oVqWjDGr45uP9tzzQ,51
+genblaze_cli-0.2.0.dist-info/RECORD,,

genblaze_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

genblaze_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+genblaze = genblaze_cli.main:cli