### Test Security Hardening Setup

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_153548.txt

Sets up the test environment by creating a dummy video file.

```python
class TestSecurityHardening(unittest.TestCase):
    VIDEO_PATH = "test_security.mp4"
    SIDECAR_PATH = "test_security.mp4.vtr.json"

    def setUp(self):
        # Create dummy video
        with open(self.VIDEO_PATH, "wb") as f:
            f.write(b"Security Test Content")
```

--------------------------------

### VTR POC CLI Setup

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

This snippet demonstrates the setup for the VTR Proof of Concept (POC) command-line interface (CLI). It imports necessary modules for argument parsing, system operations, JSON handling, and logging.

```python
# Copyright (c) 2025 OntoLogics (Seth & Axion). All rights reserved.
# Licensed under the VTR Public License (VTR-PL), Version 1.0 (the "License").
# A copy of the License is available in the root/vtr_standard/poc/LICENSE file.
# This code is distributed WITHOUT ANY WARRANTY.

import argparse
import sys
import json
import os
import logging
from .vtr_container import VTRContainer
from .validator import VTRValidator
```

--------------------------------

### Install vtr_standard Package

Source: https://github.com/mnemonice/vtr-standard/blob/main/vtr_standard/README.md

Install the vtr_standard package and its dependencies from the root of the repository. Ensure Python 3.8 or higher is installed.

```bash
pip install .
```

--------------------------------

### Setup Wallet Integration Test Environment

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Sets up a dummy video file and environment variables for wallet integration tests. Requires VTRContainer.

```python
import unittest
import os
import json
from vtr_standard.poc.vtr_container import VTRContainer

class TestWalletIntegration(unittest.TestCase):
    def setUp(self):
        # Create a dummy video file
        self.test_video = "test_wallet_video.mp4"
        with open(self.test_video, "wb") as f:
            f.write(b"dummy content")

        # Set environment variables for deterministic MockPRNU
        os.environ["VTR_TEST_LIVENESS"] = "true"
        os.environ["VTR_TEST_GPS"] = "locked"
```

--------------------------------

### Setup for Wallet Integration Tests

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Sets up a dummy video file and configures environment variables for deterministic MockPRNU in wallet integration tests. Cleans up files and environment variables in tearDown.

```python
import unittest
import os
import json
from vtr_standard.poc.vtr_container import VTRContainer

class TestWalletIntegration(unittest.TestCase):
    def setUp(self):
        # Create a dummy video file
        self.test_video = "test_wallet_video.mp4"
        with open(self.test_video, "wb") as f:
            f.write(b"dummy content")

        # Set environment variables for deterministic MockPRNU
        os.environ["VTR_TEST_LIVENESS"] = "true"
        os.environ["VTR_TEST_GPS"] = "locked"

    def tearDown(self):
        # Clean up files
        if os.path.exists(self.test_video):

```

--------------------------------

### VTR CLI Argument Parser Setup

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Sets up the main argument parser for the VTR CLI, defining subcommands for 'sign' and 'verify' with their respective arguments.

```python
import argparse

def main():
    setup_logging()
    parser = argparse.ArgumentParser(description="VTR Proof of Concept CLI")
    subparsers = parser.add_subparsers(dest="command", required=True, help="Available commands")

    # --- SIGN Command ---
    parser_sign = subparsers.add_parser("sign", help="Generate a VTR sidecar for a video file")
    parser_sign.add_argument("video_path", help="Path to the video file")
    parser_sign.add_argument("--sensor-id", help="Simulate a specific Sensor ID", default=None)
    parser_sign.add_argument("--allow-ai", action="store_true", help="Allow AI training on this content")
    parser_sign.add_argument("--link-to", help="Path to a previous VTR sidecar to create a Chain of Custody")
    parser_sign.add_argument("--wallet", help="Cryptocurrency wallet address for payments (max 128 chars)", default=None)
    parser_sign.add_argument("--force", action="store_true", help="Overwrite existing sidecar file")
    parser_sign.set_defaults(func=cmd_sign)

    # --- VERIFY Command ---
    parser_verify = subparsers.add_parser("verify", help="Verify a VTR sidecar against a video file")
    parser_verify.add_argument("video_path", help="Path to the video file")
    parser_verify.add_argument("--sidecar", help="Path to the .vtr.json sidecar (optional)", default=None)
    parser_verify.add_argument("--json", action="store_true", help="Output result as JSON")
    parser_verify.set_defaults(func=cmd_verify)

    args = parser.parse_args()

    print_banner()
```

--------------------------------

### Clone and Install VTR Standard

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Clone the repository and install the VTR Standard package using pip. This includes installing necessary dependencies like pydantic.

```bash
git clone https://github.com/ontologics/vtr-standard.git
cd vtr-standard
pip install .
```

--------------------------------

### Configure Logging

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Basic configuration setup for logging within the VTR Standard project.

```python
args.func(args)

if __name__ == "__main__":
    main()
```

--------------------------------

### VTR CLI Argument Parser Setup

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Sets up the main argument parser for the VTR CLI tool, defining subcommands for 'sign' and 'verify' with their respective arguments and help messages.

```python
import argparse
import json
import sys

# Assuming setup_logging and print_banner are defined elsewhere
# Assuming cmd_sign and cmd_verify are defined elsewhere

def main():
    setup_logging()
    parser = argparse.ArgumentParser(description="VTR Proof of Concept CLI")
    subparsers = parser.add_subparsers(dest="command", required=True, help="Available commands")

    # --- SIGN Command ---
    parser_sign = subparsers.add_parser("sign", help="Generate a VTR sidecar for a video file")
    parser_sign.add_argument("video_path", help="Path to the video file")
    parser_sign.add_argument("--sensor-id", help="Simulate a specific Sensor ID", default=None)
    parser_sign.add_argument("--allow-ai", action="store_true", help="Allow AI training on this content")
    parser_sign.add_argument("--link-to", help="Path to a previous VTR sidecar to create a Chain of Custody")
    parser_sign.add_argument("--wallet", help="Cryptocurrency wallet address for payments (max 128 chars)", default=None)
    parser_sign.add_argument("--force", action="store_true", help="Overwrite existing sidecar file")
    parser_sign.set_defaults(func=cmd_sign)

    # --- VERIFY Command ---
    parser_verify = subparsers.add_parser("verify", help="Verify a VTR sidecar against a video file")
    parser_verify.add_argument("video_path", help="Path to the video file")
    parser_verify.add_argument("--sidecar", help="Path to the .vtr.json sidecar (optional)", default=None)
    parser_verify.add_argument("--json", action="store_true", help="Output result as JSON")
    parser_verify.set_defaults(func=cmd_verify)

    args = parser.parse_args()

    print_banner()

    # Execute the function associated with the chosen subcommand
    # args.func(args) # This line is missing in the source but implied for execution
```

--------------------------------

### Install VTR Standard Package

Source: https://github.com/mnemonice/vtr-standard/blob/main/README.md

Clone the repository and install the VTR standard package using pip. This command installs the package and its dependencies, including Pydantic.

```bash
git clone https://github.com/mnemonice/vtr-standard.git
cd vtr-standard
pip install .
```

--------------------------------

### Sign Video with Mock Camera Data

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

This Python snippet demonstrates how to sign a video file using a mock camera sensor ID and AI training settings. It creates a VTR container, generates a sidecar JSON file, and allows the user to download it. Ensure the necessary libraries (streamlit, vtr_standard) are installed.

```python
import streamlit as st
import os
import tempfile
import json
from vtr_standard.poc.vtr_container import VTRContainer
from vtr_standard.poc.validator import VTRValidator

# --- CONFIG ---
st.set_page_config(page_title="VTR Truth Terminal", page_icon="🎥", layout="centered")

st.title("🎥 VTR Truth Terminal")
st.markdown("### The Hardware-Attested Media Validator")

# --- SIDEBAR: GENERATOR ---
st.sidebar.header("1. Signer (Mock Camera)")
st.sidebar.markdown("Simulate a camera sensor capturing and signing a video.")

# Use a specific mock sensor ID
sensor_id = st.sidebar.text_input("Sensor ID (PRNU Source)", "SENSOR_ANDROID_PIXEL_99")
allow_ai = st.sidebar.checkbox("Allow AI Training?", value=False)

uploaded_file_sign = st.sidebar.file_uploader("Upload Video to Sign", type=["mp4", "mov", "avi"])

if st.sidebar.button("🔒 Sign Video") and uploaded_file_sign:
    with tempfile.TemporaryDirectory() as tmp_dir:
        tmp_vid_path = os.path.join(tmp_dir, "video.mp4")
        with open(tmp_vid_path, "wb") as f:
            f.write(uploaded_file_sign.getvalue())

        try:
            # Create Container
            container = VTRContainer(tmp_vid_path, sensor_id_mock=sensor_id)
            # We need to handle the sidecar path manually since VTRContainer writes to disk next to file
            container.create_sidecar(allow_ai_training=allow_ai, overwrite=True)

            sidecar_path = f"{tmp_vid_path}.vtr.json"

            with open(sidecar_path, "r") as f:
                sidecar_json = json.load(f)

            st.sidebar.success("Signed Successfully!")
            st.sidebar.json(sidecar_json)

            # Allow user to download the sidecar
            st.sidebar.download_button(
                label="Download .vtr.json",
                data=json.dumps(sidecar_json, indent=4),
                file_name="video.vtr.json",
                mime="application/json"
            )

        except Exception as e:
            st.sidebar.error(f"Error signing: {e}")

```

--------------------------------

### Unittest Main Execution Block

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_173308.txt

Standard Python block to execute unittest test cases when the script is run directly. No specific setup is required beyond defining test methods.

```python
if __name__ == '__main__':
    unittest.main()
```

--------------------------------

### Main CLI Entry Point

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Sets up argument parsing, logging, prints the banner, and dispatches to the appropriate command function.

```python
import argparse

def main():
    setup_logging()
    parser = argparse.ArgumentParser(description="VTR Proof of Concept CLI")
    subparsers = parser.add_subparsers(dest="command", required=True, help="Available commands")

    # --- SIGN Command ---
    parser_sign = subparsers.add_parser("sign", help="Generate a VTR sidecar for a video file")
    parser_sign.add_argument("video_path", help="Path to the video file")
    parser_sign.add_argument("--sensor-id", help="Simulate a specific Sensor ID", default=None)
    parser_sign.add_argument("--allow-ai", action="store_true", help="Allow AI training on this content")
    parser_sign.add_argument("--link-to", help="Path to a previous VTR sidecar to create a Chain of Custody")
    parser_sign.add_argument("--force", action="store_true", help="Overwrite existing sidecar file")
    parser_sign.set_defaults(func=cmd_sign)

    # --- VERIFY Command ---
    parser_verify = subparsers.add_parser("verify", help="Verify a VTR sidecar against a video file")
    parser_verify.add_argument("video_path", help="Path to the video file")
    parser_verify.add_argument("--sidecar", help="Path to the .vtr.json sidecar (optional)", default=None)
    parser_verify.add_argument("--json", action="store_true", help="Output result as JSON")
    parser_verify.set_defaults(func=cmd_verify)

    args = parser.parse_args()

    print_banner()
    args.func(args)

if __name__ == "__main__":
    main()
```

--------------------------------

### Main CLI Entry Point

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Sets up argument parsing for 'sign' and 'verify' commands, initializes logging, prints the banner, and dispatches to the appropriate command function. Uses argparse for command-line argument handling.

```python
import argparse
import logging
import sys
import json

# Mock logger and VTRContainer/VTRValidator for standalone execution
logger = logging.getLogger("vtr")
logger.setLevel(logging.INFO)
if not logger.handlers:
    handler = logging.StreamHandler(sys.stdout)
    formatter = logging.Formatter('%(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)

class VTRContainer:
    def __init__(self, video_path, sensor_id_mock):
        self.video_path = video_path
        self.sensor_id_mock = sensor_id_mock
        if "existing" in video_path:
            raise FileExistsError(f"Sidecar for {video_path} already exists.")

    def create_sidecar(self, allow_ai_training, previous_sidecar_path, overwrite):
        pass

class VTRValidator:
    def validate_container(self, video_path, sidecar):
        if "fail" in video_path:
            return type('obj', (object,), {"is_valid": False, "error_code": 1001, "message": "Verification failed", "details": {"reason": "Hash mismatch"}})() 
        else:
            return type('obj', (object,), {"is_valid": True, "error_code": 0, "message": "Verification successful", "details": {"hash": "mock_hash_123", "timestamp": "2023-01-01T12:00:00Z"}})() 

def setup_logging():
    """Configures the logging format and level."""
    handler = logging.StreamHandler(sys.stdout)
    formatter = logging.Formatter('%(message)s')  # Simple format for CLI user friendliness
    handler.setFormatter(formatter)

    logger.addHandler(handler)
    logger.setLevel(logging.INFO)

def print_banner():
    """Logs the VTR warning banner."""
    banner = (
        "\n" + "="*60 + "\n" +
        "🎥  ONTOLOGICS VIDEO TRUTH RECORD (VTR) - POC TOOL  🎥\n" +
        "="*60 + "\n" +
        "⚠️  WARNING: RUNNING IN MOCK SENSOR MODE\n" +
        "    This tool uses simulated hardware roots of trust.\n" +
        "    DO NOT USE FOR ACTUAL EVIDENTIARY PURPOSES.\n" +
        "="*60 + "\n"
    )
    logger.warning(banner)

def cmd_sign(args):
    """Handles the 'sign' command."""
    logger.info(f"🔄  Processing video: {args.video_path}")
    if args.sensor_id:
        logger.info(f"🆔  Using Custom Sensor ID: {args.sensor_id}")
    else:
        logger.info("🆔  Using Default Mock Sensor ID")

    sensor_id = args.sensor_id if args.sensor_id else "MOCK_SENSOR_DEFAULT_001"

    try:
        container = VTRContainer(args.video_path, sensor_id_mock=sensor_id)
        prev_sidecar = args.link_to if args.link_to else None
        container.create_sidecar(
            allow_ai_training=args.allow_ai,
            previous_sidecar_path=prev_sidecar,
            overwrite=args.force
        )
    except FileExistsError as e:
        logger.error(f"❌  Error: {e}")
        logger.error("    Use --force to overwrite the existing sidecar.")
        sys.exit(1)
    except FileNotFoundError:
        logger.error(f"❌  Error: Video file '{args.video_path}' not found.")
        sys.exit(1)
    except Exception as e:
        logger.error(f"❌  An unexpected error occurred: {e}")
        sys.exit(1)

def cmd_verify(args):
    """Handles the 'verify' command."""
    if not args.json:
        logger.info(f"🔍  Verifying: {args.video_path}")

    validator = VTRValidator()
    result = validator.validate_container(args.video_path, args.sidecar)

    if args.json:
        output = {
            "is_valid": result.is_valid,
            "error_code": result.error_code,
            "message": result.message,
            "details": result.details
        }
        print(json.dumps(output, indent=4))
        if not result.is_valid:
            sys.exit(1)
        return

    if result.is_valid:
        logger.info("\n✅  VERIFICATION SUCCESSFUL")
        logger.info("    The video content matches the hardware signature.")
        logger.info("-" * 40)
        for key, value in result.details.items():
            logger.info(f"    {key}: {value}")
        logger.info("-" * 40)
    else:
        logger.error("\n❌  VERIFICATION FAILED")
        logger.error(f"    Error Code: {result.error_code}")
        logger.error(f"    Message:    {result.message}")
        if result.details:
            logger.error(f"    Details:    {json.dumps(result.details, indent=4)}")
        sys.exit(1)

def main():
    setup_logging()
    parser = argparse.ArgumentParser(description="VTR Proof of Concept CLI")
    subparsers = parser.add_subparsers(dest="command", required=True, help="Available commands")

    # --- SIGN Command ---
    parser_sign = subparsers.add_parser("sign", help="Generate a VTR sidecar for a video file")
    parser_sign.add_argument("video_path", help="Path to the video file")
    parser_sign.add_argument("--sensor-id", help="Simulate a specific Sensor ID", default=None)
    parser_sign.add_argument("--allow-ai", action="store_true", help="Allow AI training on this content")
    parser_sign.add_argument("--link-to", help="Path to a previous VTR sidecar to create a Chain of Custody")
    parser_sign.add_argument("--force", action="store_true", help="Overwrite existing sidecar file")
    parser_sign.set_defaults(func=cmd_sign)

    # --- VERIFY Command ---
    parser_verify = subparsers.add_parser("verify", help="Verify a VTR sidecar against a video file")
    parser_verify.add_argument("video_path", help="Path to the video file")
    parser_verify.add_argument("--sidecar", help="Path to the .vtr.json sidecar (optional)", default=None)
    parser_verify.add_argument("--json", action="store_true", help="Output result as JSON")
    parser_verify.set_defaults(func=cmd_verify)

    args = parser.parse_args()

    print_banner()
    args.func(args)

if __name__ == "__main__":
    main()
```

--------------------------------

### Get Merkle Root

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

A public method to retrieve the computed Merkle Root of the file in hexadecimal format.

```python
    def get_root(self) -> str:
        """Returns the hexadecimal Merkle Root."""
        return self.root
```

--------------------------------

### Test KDF Configuration via Environment Variables

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_153548.txt

Demonstrates how to configure the KDF salt and iterations using environment variables. It shows that changing these variables results in different derived keys and includes cleanup of the environment variables.

```python
import unittest
import hashlib
from vtr_standard.poc.mock_prnu import MockPRNU
import os

class TestKDFStrength(unittest.TestCase):
    def test_kdf_config_via_env_vars(self):
        sensor_id = "config_sensor"

        # Original keys
        prnu_default = MockPRNU(sensor_id)
        pk_default = prnu_default.get_public_key()

        # Keys with custom salt
        os.environ["VTR_KDF_SALT"] = "custom_salt"
        prnu_custom_salt = MockPRNU(sensor_id)
        pk_custom_salt = prnu_custom_salt.get_public_key()
        self.assertNotEqual(pk_default, pk_custom_salt)

        # Keys with custom iterations
        os.environ["VTR_KDF_ITERATIONS"] = "200000"
        prnu_custom_iter = MockPRNU(sensor_id)
        pk_custom_iter = prnu_custom_iter.get_public_key()
        self.assertNotEqual(pk_custom_salt, pk_custom_iter)

        # Cleanup
        del os.environ["VTR_KDF_SALT"]
        del os.environ["VTR_KDF_ITERATIONS"]
```

--------------------------------

### Get Merkle Root Hex String

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Provides a public method to retrieve the computed Merkle Root of the file as a hexadecimal string.

```python
# Assuming MerkleTree class context

    def get_root(self) -> str:
        """Returns the hexadecimal Merkle Root."""
        return self.root
```

--------------------------------

### Initialize VTRContainer

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Initializes the VTRContainer with the path to the raw video file and a sensor ID for the mock hardware root of trust.

```python
logger = logging.getLogger(__name__)

class VTRContainer:
    """Manages the creation of Video Truth Record (VTR) containers.

    This is the canonical V2.1 generator. It handles the association of a raw video
    file with a hardware root of trust (via MockPRNU), generating a sidecar file
    containing cryptographic proofs and legal assertions.
    """

    def __init__(self, raw_video_path, sensor_id_mock):
        """Initializes the VTRContainer."""
        self.video_path = raw_video_path
        self.timestamp = time.time()
        # Initialize the hardware root of trust (the Merged MockPRNU)
        self.prnu = MockPRNU(sensor_id_mock)
```

--------------------------------

### Initialize VTRContainer

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_173308.txt

Initializes the VTRContainer with the path to the raw video file and a sensor ID mock. It sets up the hardware root of trust using MockPRNU.

```python
def __init__(self, raw_video_path, sensor_id_mock):
    """Initializes the VTRContainer."""
    self.video_path = raw_video_path
    self.timestamp = time.time()
    # Initialize the hardware root of trust (the Merged MockPRNU)
    self.prnu = MockPRNU(sensor_id_mock)
```

--------------------------------

### Get Mocked Economic Data

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Returns a dictionary containing the mocked economic data, including semantic score and device tier.

```python
economic_data = mock_prnu.get_economic_data()
```

--------------------------------

### Create VTR Sidecar for First Video

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Instantiates a VTRContainer and creates its sidecar file, enabling AI training.

```python
# Simulate a "Potato Phone" capturing a video (First Link in the Chain)
camera_1 = VTRContainer("first_video.mp4", sensor_id_mock="SENSOR_PRNU_XYZ_999")
camera_1.create_sidecar(allow_ai_training=True)
```

--------------------------------

### Generate and Verify ZK Proof for Video

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Demonstrates the generation of a Zero-Knowledge proof for a video file and its subsequent verification using a public key. Requires a dummy video file for testing.

```python
def test_proof_generation_and_verification(self):
        # Create a dummy video file
        with open("test.mp4", "wb") as f:
            f.write(b"video data")

        prnu = MockPRNU("sensor_123")
        ts = 1234567890.0
        lf = True
        lbh = "lbh_hash"
        n = "nonce_123"
        ps = "prev_sig"

        proof = prnu.generate_zk_proof("test.mp4", ts, lf, lbh, n, ps)
        self.assertTrue(proof.startswith("zk_snark_"))

        pk = prnu.get_public_key()
        is_valid = MockPRNU.verify_zk_proof(pk, "test.mp4", ts, proof, lf, lbh, n, ps)
        self.assertTrue(is_valid)

        # Cleanup
        os.remove("test.mp4")
```

--------------------------------

### Get Commit Count

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Retrieves the total number of commits in the current git branch. Exits with an error if the repository is not a git repository or if the output is unexpected.

```python
def get_commit_count():
    """Returns the total number of commits in the current branch."""
    try:
        # git rev-list --count HEAD
        result = subprocess.run(
            ["git", "rev-list", "--count", "HEAD"],
            capture_output=True,
            text=True,
            check=True
        )
        return int(result.stdout.strip())
    except subprocess.CalledProcessError:
        print("Error: Could not determine commit count. Is this a git repository?")
        sys.exit(1)
    except ValueError:
        print("Error: Unexpected output from git.")
        sys.exit(1)
```

--------------------------------

### Ensure Dummy Video File Creation

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Tests the `ensure_dummy_video` function, verifying that it creates a 1MB dummy video file when the specified path does not exist. It also includes cleanup to remove the created file.

```python
def test_ensure_dummy_video_creates_file(tmp_path):
    """Test that ensure_dummy_video creates a 1MB file when it doesn't exist."""
    test_file = tmp_path / "test_video.mp4"
    file_path_str = str(test_file)

    # Ensure file doesn't exist yet
    assert not os.path.exists(file_path_str)

    try:
        # Call the function
        ensure_dummy_video(file_path_str)

        # Verify file exists
        assert os.path.exists(file_path_str)

        # Verify file size is 1MB (1024 * 1024 bytes)
        assert os.path.getsize(file_path_str) == 1024 * 1024
    finally:
        # Cleanup
        if os.path.exists(file_path_str):
            os.remove(file_path_str)
```

--------------------------------

### AsyncFileStream Generator

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

The stream method starts the background thread and yields chunks from the queue. It stops when it receives the None sentinel value, indicating the end of the file.

```python
    def stream(self) -> Generator[bytes, None, None]:
        self.thread.start()
        while True:
            chunk = self.queue.get()
            if chunk is None:
                break
            yield chunk
```

--------------------------------

### Format Python Files with Autopep8

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_153548.txt

This function formats specified Python files using autopep8. It installs autopep8 if not found and then runs the formatter with aggressive options.

```python
import subprocess
import sys

def format_files():
    try:
        import autopep8
    except ImportError:
        subprocess.run([sys.executable, "-m", "pip", "install", "autopep8"], check=True)
        import autopep8

    subprocess.run([sys.executable, "-m", "autopep8", "--in-place", "--aggressive", "--aggressive", "vtr_standard/poc/mock_prnu.py"], check=True)
    subprocess.run([sys.executable, "-m", "autopep8", "--in-place", "--aggressive", "--aggressive", "vtr_standard/poc/tests/test_mock_prnu_logic.py"], check=True)

if __name__ == "__main__":
    format_files()
```

--------------------------------

### Get KDF Parameters from Environment

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Retrieves salt and iteration count for Key Derivation Functions from environment variables. Provides default values if environment variables are not set.

```python
def _get_kdf_params():
    """Centralized helper to retrieve KDF parameters from the environment."""
    env_salt = os.environ.get("VTR_KDF_SALT")
    salt = env_salt.encode() if env_salt else b"vtr_kdf_salt_2025_canonical"
    try:
        iterations = max(100000, int(os.environ.get("VTR_KDF_ITERATIONS", 100000)))
    except ValueError:
        iterations = 100000
    return salt, iterations
```

--------------------------------

### Generate and Verify Mock PRNU ZK Proof (Python)

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Demonstrates generating a Zero-Knowledge Proof for a video file using MockPRNU and then verifying its validity with the public key.

```Python
import unittest
from vtr_standard.poc.mock_prnu import MockPRNU
import os

class TestMockPRNU(unittest.TestCase):
    def test_proof_generation_and_verification(self):
        # Create a dummy video file
        with open("test.mp4", "wb") as f:
            f.write(b"video data")

        prnu = MockPRNU("sensor_123")
        ts = 1234567890.0
        lf = True
        lbh = "lbh_hash"
        n = "nonce_123"
        ps = "prev_sig"

        proof = prnu.generate_zk_proof("test.mp4", ts, lf, lbh, n, ps)
        self.assertTrue(proof.startswith("zk_snark_"))

        pk = prnu.get_public_key()
        is_valid = MockPRNU.verify_zk_proof(pk, "test.mp4", ts, proof, lf, lbh, n, ps)
        self.assertTrue(is_valid)

        # Cleanup
        os.remove("test.mp4")

if __name__ == "__main__":
    unittest.main()
```

--------------------------------

### Configure Logging

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Sets up a stream handler for logging to standard output with a simple formatter and an INFO level.

```python
import logging
import sys

logger = logging.getLogger("vtr")

def setup_logging():
    """Configures the logging format and level."""
    handler = logging.StreamHandler(sys.stdout)
    formatter = logging.Formatter('%(message)s')  # Simple format for CLI user friendliness
    handler.setFormatter(formatter)

    logger.addHandler(handler)
    logger.setLevel(logging.INFO)
```

--------------------------------

### Handle 'sign' Command

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Processes video files to create a VTR sidecar, supporting custom sensor IDs, AI training flags, linking to previous sidecars, wallet addresses, and overwriting existing files.

```python
import argparse
import json

# Assuming VTRContainer and other necessary imports are available
# from vtr_lib import VTRContainer

def cmd_sign(args):
    """Handles the 'sign' command."""
    logger.info(f"🔄  Processing video: {args.video_path}")
    if args.sensor_id:
        logger.info(f"🆔  Using Custom Sensor ID: {args.sensor_id}")
    else:
        logger.info("🆔  Using Default Mock Sensor ID")

    # Initialize Container
    # Using a default sensor ID if not provided, or the one from args
    sensor_id = args.sensor_id if args.sensor_id else "MOCK_SENSOR_DEFAULT_001"

    # Validate Wallet Address
    if args.wallet and len(args.wallet) > 128:
        logger.error("❌  Error: Wallet address is too long (max 128 characters).")
        sys.exit(1)

    try:
        container = VTRContainer(args.video_path, sensor_id_mock=sensor_id)

        # Determine previous sidecar path for chaining
        prev_sidecar = args.link_to if args.link_to else None

        container.create_sidecar(
            allow_ai_training=args.allow_ai,
            previous_sidecar_path=prev_sidecar,
            wallet_address=args.wallet,
            overwrite=args.force
        )
    except FileExistsError as e:
        logger.error(f"❌  Error: {e}")
        logger.error("    Use --force to overwrite the existing sidecar.")
        sys.exit(1)
    except FileNotFoundError:
        logger.error(f"❌  Error: Video file '{args.video_path}' not found.")
        sys.exit(1)
    except Exception as e:
        logger.error(f"❌  An unexpected error occurred: {e}")
        sys.exit(1)
```

--------------------------------

### Main Execution Block with Logging and Dummy Video Generation

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

This is the main execution block that sets up logging to stdout, generates two dummy video files, and simulates video capture using VTRContainer. It demonstrates creating sidecars with and without linking to previous ones.

```python
if __name__ == "__main__":
    import sys
    logging.basicConfig(level=logging.INFO, stream=sys.stdout, format='%(message)s')
    logger.info("--- OntoLogics VTR Generator v2.0 (Merged POC) ---")

    ensure_dummy_video("first_video.mp4")
    ensure_dummy_video("second_video.mp4")

    # Simulate a "Potato Phone" capturing a video (First Link in the Chain)
    camera_1 = VTRContainer("first_video.mp4", sensor_id_mock="SENSOR_PRNU_XYZ_999")
    camera_1.create_sidecar(allow_ai_training=True)

    # Simulate capturing a subsequent video (Second Link in the Chain)
    camera_2 = VTRContainer("second_video.mp4", sensor_id_mock="SENSOR_PRNU_XYZ_999")
    # Link to the first sidecar to create the Chain of Custody
    camera_2.create_sidecar(allow_ai_training=False, previous_sidecar_path="first_video.mp4.vtr.json")
```

--------------------------------

### Cleanup Test Files and Environment Variables

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

Removes test video files and associated sidecar files, and unsets specific environment variables used for testing. This is typically part of a test setup or teardown process.

```python
        os.remove(self.test_video)

        sidecar_path = f"{self.test_video}.vtr.json"
        if os.path.exists(sidecar_path):
            os.remove(sidecar_path)

        # Unset env vars
        os.environ.pop("VTR_TEST_LIVENESS", None)
        os.environ.pop("VTR_TEST_GPS", None)
```

--------------------------------

### Setup VTR Truth Terminal with Streamlit

Source: https://github.com/mnemonice/vtr-standard/blob/main/ingests/digest_20260515_111918.txt

This snippet sets up a basic Streamlit application for the VTR Truth Terminal, including configuration and title display. It's used to simulate a camera sensor capturing and signing video.

```python
import streamlit as st
import os
import tempfile
import json
from vtr_standard.poc.vtr_container import VTRContainer
from vtr_standard.poc.validator import VTRValidator

# --- CONFIG ---
st.set_page_config(page_title="VTR Truth Terminal", page_icon="🎥", layout="centered")

st.title("🎥 VTR Truth Terminal")
st.markdown("### The Hardware-Attested Media Validator")

# --- SIDEBAR: GENERATOR ---
st.sidebar.header("1. Signer (Mock Camera)")
st.sidebar.markdown("Simulate a camera sensor capturing and signing a video.")
```