vidlabel-spec 0.6.0__tar.gz

vidlabel_spec-0.6.0/.gitignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.eggs/
+
+# Virtual environments
+venv/
+.venv/
+env/
+
+# Test / tooling caches
+.pytest_cache/
+.coverage
+htmlcov/
+.mypy_cache/
+.ruff_cache/
+wiki-out/
+# Editors and OS
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db
+
+# Local datasets and test data (keep real data out of the repo)
+my_ds/
+preview_out/
+sample_ds/
+*.parquet.tmp
+*.json.tmp
+
+# Video files
+*.mp4
+*.mov
+*.mkv
+*.avi
+*.webm
+*.mxf
+# axe-core, installed only to run the accessibility test
+node_modules/
+package-lock.json

vidlabel_spec-0.6.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.5
+Name: vidlabel-spec
+Version: 0.6.0
+Summary: Specification (pydantic models + JSON Schema) for the vidlabel video annotation format
+Project-URL: Homepage, https://github.com/HIManish-G/pyvidlabel
+Project-URL: Documentation, https://github.com/HIManish-G/pyvidlabel/wiki
+Project-URL: Issues, https://github.com/HIManish-G/pyvidlabel/issues
+Project-URL: Changelog, https://github.com/HIManish-G/pyvidlabel/blob/main/docs/changelog.md
+License: MIT
+Keywords: annotation,bounding boxes,computer vision,dataset,labelling,masks,video
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.5
+Description-Content-Type: text/markdown
+
+# vidlabel-spec
+
+The specification of the [vidlabel](https://github.com/HIManish-G/pyvidlabel) video annotation format: Pydantic models and the JSON Schema for the files in a
+dataset. Most people want the `vidlabel` package, which depends on this one.
+
+**Status: alpha (0.6.0).** Versioned together with `vidlabel`; see the [changelog](https://github.com/HIManish-G/pyvidlabel/blob/main/docs/changelog.md).
+
+```
+pip install vidlabel-spec
+```
+
+MIT licensed.

vidlabel_spec-0.6.0/README.md

@@ -0,0 +1,12 @@
+# vidlabel-spec
+
+The specification of the [vidlabel](https://github.com/HIManish-G/pyvidlabel) video annotation format: Pydantic models and the JSON Schema for the files in a
+dataset. Most people want the `vidlabel` package, which depends on this one.
+
+**Status: alpha (0.6.0).** Versioned together with `vidlabel`; see the [changelog](https://github.com/HIManish-G/pyvidlabel/blob/main/docs/changelog.md).
+
+```
+pip install vidlabel-spec
+```
+
+MIT licensed.

vidlabel_spec-0.6.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vidlabel-spec"
+version = "0.6.0"
+description = "Specification (pydantic models + JSON Schema) for the vidlabel video annotation format"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["video", "annotation", "labelling", "bounding boxes", "masks", "dataset", "computer vision"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+]
+dependencies = ["pydantic>=2.5"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/vidlabel_spec"]
+
+[project.urls]
+Homepage = "https://github.com/HIManish-G/pyvidlabel"
+Documentation = "https://github.com/HIManish-G/pyvidlabel/wiki"
+Issues = "https://github.com/HIManish-G/pyvidlabel/issues"
+Changelog = "https://github.com/HIManish-G/pyvidlabel/blob/main/docs/changelog.md"

vidlabel_spec-0.6.0/src/vidlabel_spec/__init__.py

@@ -0,0 +1,11 @@
+from ._columns import (ANNOTATION_COLUMNS, COLUMN_NAMES, REQUIRED_COLUMNS, ColumnSpec, Kind, MaskCodec, Origin,
+                       Status, is_valid_origin)
+from ._models import (SPEC_VERSION, FrameIndex, Label, Manifest, Rational, Region, Release, VideoMetadata, VideoSource, View,
+                      Vocab)
+from ._schema import json_schema, write_json_schema
+
+__all__ = [
+    "ANNOTATION_COLUMNS", "COLUMN_NAMES", "REQUIRED_COLUMNS", "ColumnSpec", "Kind", "MaskCodec", "Origin", "Status",
+    "SPEC_VERSION", "FrameIndex", "Label", "Manifest", "Rational", "Region", "Release", "VideoMetadata", "VideoSource", "View",
+    "Vocab", "json_schema", "write_json_schema", "is_valid_origin",
+]

vidlabel_spec-0.6.0/src/vidlabel_spec/__main__.py

@@ -0,0 +1,11 @@
+"""`python -m vidlabel_spec [out.json]` writes the JSON Schema."""
+import sys
+
+from ._schema import json_schema, write_json_schema
+
+if len(sys.argv) > 1:
+    write_json_schema(sys.argv[1])
+else:
+    import json
+
+    print(json.dumps(json_schema(), indent=2))

vidlabel_spec-0.6.0/src/vidlabel_spec/_columns.py

@@ -0,0 +1,84 @@
+"""The annotation table: one row per annotation, the same columns for every kind of annotation.
+
+Time markers, boxes and masks all live in this single table. Who or what made an
+annotation is a column (`origin`, `tool`, ...), never a separate file or folder.
+"""
+from __future__ import annotations
+
+import re
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Kind(str, Enum):
+    MARKER = "marker"  # a point or span in time, no geometry
+    BOX = "box"        # a bounding box on one frame
+    MASK = "mask"      # a pixel mask on one frame (also carries its bounding box)
+
+
+class Origin(str, Enum):
+    HUMAN = "human"
+    MODEL = "model"
+    IMPORTED = "imported"  # converted from another tool or dataset; name it in `tool`
+    OTHER = "other"
+
+
+_CUSTOM_ORIGIN_RE = re.compile(r"^x-[a-z0-9][a-z0-9._-]{0,62}$")
+
+
+def is_valid_origin(value) -> bool:
+    """True for the built-in origins, or a custom one: 'x-' + lowercase letters, digits, '.', '_' or '-'."""
+    v = value.value if isinstance(value, Enum) else value
+    return isinstance(v, str) and (v in {o.value for o in Origin} or bool(_CUSTOM_ORIGIN_RE.match(v)))
+
+
+class Status(str, Enum):
+    UNREVIEWED = "unreviewed"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+
+
+class MaskCodec(str, Enum):
+    BITPACK_ZSTD = "bitpack_zstd"  # crop to bbox, bit-pack rows, zstd (see docs/SPEC.md)
+
+
+class ColumnSpec(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    name: str
+    dtype: str  # one of: int32, int64, float32, string, dict_string, binary
+    nullable: bool
+    description: str
+
+
+ANNOTATION_COLUMNS: tuple[ColumnSpec, ...] = (
+    ColumnSpec(name="annotation_id", dtype="int64", nullable=False,
+               description="Stable unique id. Random 63-bit integer assigned on creation; never reused."),
+    ColumnSpec(name="video_id", dtype="dict_string", nullable=False, description="Which video (matches videos/<video_id>/)."),
+    ColumnSpec(name="start_frame", dtype="int32", nullable=False,
+               description="First frame, 0-indexed in display order. A point in time has start_frame == end_frame."),
+    ColumnSpec(name="end_frame", dtype="int32", nullable=False, description="Last frame, inclusive."),
+    ColumnSpec(name="kind", dtype="dict_string", nullable=False, description="marker | box | mask"),
+    ColumnSpec(name="label", dtype="dict_string", nullable=False, description="A label name from vocab.json."),
+    ColumnSpec(name="track_id", dtype="int32", nullable=True,
+               description="Ties boxes/masks of one object across frames. One id means one object within a video and view (rows labelled in different views have separate id spaces)."),
+    ColumnSpec(name="x0", dtype="float32", nullable=True, description="Box left edge, pixels, source-video coordinates."),
+    ColumnSpec(name="y0", dtype="float32", nullable=True, description="Box top edge, pixels (origin top-left)."),
+    ColumnSpec(name="x1", dtype="float32", nullable=True, description="Box right edge (exclusive)."),
+    ColumnSpec(name="y1", dtype="float32", nullable=True, description="Box bottom edge (exclusive)."),
+    ColumnSpec(name="mask", dtype="binary", nullable=True, description="Encoded mask bytes, interpreted by mask_codec."),
+    ColumnSpec(name="mask_codec", dtype="dict_string", nullable=True, description="How `mask` is encoded."),
+    ColumnSpec(name="view_id", dtype="dict_string", nullable=True,
+               description="Optional: the view (crop / focused version) this was labelled in. Geometry is always in source-video coordinates."),
+    ColumnSpec(name="origin", dtype="dict_string", nullable=False, description="human | model | imported | other, or a custom value starting with 'x-' (e.g. x-crowd)"),
+    ColumnSpec(name="tool", dtype="dict_string", nullable=True, description="Tool or model name that produced it."),
+    ColumnSpec(name="tool_version", dtype="dict_string", nullable=True, description="Tool or model version."),
+    ColumnSpec(name="author", dtype="dict_string", nullable=True, description="Person responsible, if any."),
+    ColumnSpec(name="confidence", dtype="float32", nullable=True, description="0..1, usually only for model output."),
+    ColumnSpec(name="status", dtype="dict_string", nullable=False, description="unreviewed | approved | rejected"),
+    ColumnSpec(name="extra", dtype="string", nullable=True,
+               description="Optional JSON object (as text) for anything custom. Use your own top-level key, e.g. extra.mytool."),
+)
+
+COLUMN_NAMES: tuple[str, ...] = tuple(c.name for c in ANNOTATION_COLUMNS)
+REQUIRED_COLUMNS: tuple[str, ...] = tuple(c.name for c in ANNOTATION_COLUMNS if not c.nullable)

vidlabel_spec-0.6.0/src/vidlabel_spec/_models.py

@@ -0,0 +1,288 @@
+"""Metadata models. Core fields are strict (unknown fields are rejected); anything custom goes in `extra`."""
+from __future__ import annotations
+
+import re
+from bisect import bisect_left, bisect_right
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+SPEC_VERSION = "0.6.0"
+
+_ID_RE = re.compile(r"^[A-Za-z0-9._-]+$")
+_HASH_RE = re.compile(r"^[a-z0-9]+:[0-9a-f]+$")
+
+
+class _Strict(BaseModel):
+    # Same rule as GEFF: custom data must live inside `extra`, so the core stays checkable.
+    model_config = ConfigDict(extra="forbid")
+
+
+def _check_id(v: str) -> str:
+    if not _ID_RE.fullmatch(v) or v in (".", ".."):
+        raise ValueError("ids may only contain letters, digits, '.', '_' and '-', and cannot be '.' or '..'")
+    return v
+
+
+class Rational(_Strict):
+    num: int
+    den: int = Field(gt=0)
+
+    @property
+    def value(self) -> float:
+        return self.num / self.den
+
+
+class VideoSource(_Strict):
+    """One known location of the video file. Several may be listed; paths move, hashes don't."""
+    uri: str
+    note: str | None = None
+
+
+class FrameIndex(_Strict):
+    """Optional per-frame timing of one video, stored in videos/<video_id>/frame_index.json.
+
+    Read from the file's packet table (no decoding), so it is cheap to make. It lets a reader seek by timestamp, including
+    in variable-frame-rate video, check where a seek really landed, and plan reads so each keyframe interval is decoded once.
+
+    `pts` holds one presentation timestamp per frame, in `timebase` ticks, in display order (so `pts[i]` belongs to frame
+    `i`) and strictly increasing. `keyframes` lists the frame numbers where decoding can start without earlier frames.
+    """
+    content_hash: str | None = Field(default=None, description="Hash of the file this was read from; a different hash means the index is stale.")
+    timebase: Rational
+    pts: list[int] = Field(min_length=1)
+    keyframes: list[int] = Field(default_factory=list)
+
+    @field_validator("content_hash")
+    @classmethod
+    def _v_hash(cls, v: str | None) -> str | None:
+        if v is not None and not _HASH_RE.match(v):
+            raise ValueError("content_hash must look like '<algo>:<lowercase hex>'")
+        return v
+
+    @model_validator(mode="after")
+    def _v_order(self) -> "FrameIndex":
+        p, k = self.pts, self.keyframes
+        if any(b <= a for a, b in zip(p, p[1:])):
+            raise ValueError("pts must be strictly increasing (one timestamp per frame, in display order)")
+        if any(b <= a for a, b in zip(k, k[1:])):
+            raise ValueError("keyframes must be strictly increasing frame numbers")
+        if k and (k[0] < 0 or k[-1] >= len(p)):
+            raise ValueError("keyframes must be frame numbers inside the video")
+        return self
+
+    @property
+    def frame_count(self) -> int:
+        return len(self.pts)
+
+    def seconds(self, frame: int) -> float:
+        """Time of `frame` in seconds from the first frame."""
+        return (self.pts[frame] - self.pts[0]) * self.timebase.num / self.timebase.den
+
+    def frame_at(self, ticks: float, tolerance: float = 0.3) -> int | None:
+        """The frame whose timestamp is within `tolerance` ticks of `ticks` (absolute, like `pts`), or None."""
+        j = bisect_left(self.pts, ticks)
+        best = min((c for c in (j - 1, j) if 0 <= c < len(self.pts)), key=lambda c: abs(self.pts[c] - ticks), default=None)
+        return best if best is not None and abs(self.pts[best] - ticks) <= tolerance else None
+
+    def keyframe_before(self, frame: int) -> int:
+        """The last keyframe at or before `frame` (0 if the list is empty): where decoding for `frame` has to start."""
+        j = bisect_right(self.keyframes, frame)
+        return self.keyframes[j - 1] if j else 0
+
+    def decode_cost(self, frame: int) -> int:
+        """Frames that must be decoded to reach `frame` from a cold start: its distance from the previous keyframe, plus one."""
+        return frame - self.keyframe_before(frame) + 1
+
+    def interval_stats(self) -> dict[str, float]:
+        """Keyframe spacing: `min`, `median`, `max` interval in frames, and `mean_cost`, the average frames decoded to reach a random frame."""
+        k = self.keyframes or [0]
+        gaps = sorted([b - a for a, b in zip(k, k[1:])] + [len(self.pts) - k[-1]])
+        n = len(self.pts)
+        # frames in an interval of length g cost 1..g, so the mean cost is the sum of g*(g+1)/2 over intervals, divided by n
+        total = sum(g * (g + 1) // 2 for g in gaps)
+        return {"min": gaps[0], "median": gaps[len(gaps) // 2], "max": gaps[-1], "mean_cost": total / n}
+
+
+class VideoMetadata(_Strict):
+    """Generic facts about one video. Lives in videos/<video_id>/metadata.json."""
+    video_id: str
+    content_hash: str | None = Field(default=None, description="'<algo>:<hex>', e.g. 'sha256:ab12...'. Lets anyone detect a re-encoded or wrong file.")
+    duration_s: float | None = Field(default=None, ge=0)
+    frame_count: int = Field(ge=0)
+    fps: Rational
+    timebase: Rational | None = None
+    is_vfr: bool = False
+    width: int = Field(gt=0)
+    height: int = Field(gt=0)
+    rotation: int = Field(default=0, description="Clockwise degrees (0, 90, 180, 270) applied to the stored frame to display it upright. 90 and 270 swap width and height.")
+    codec: str | None = None
+    pix_fmt: str | None = None
+    bit_rate: int | None = Field(default=None, ge=0, description="Bits per second as reported by the container/stream.")
+    sources: list[VideoSource] = Field(default_factory=list)
+    ingested_at: datetime | None = None
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+    _v_id = field_validator("video_id")(_check_id)
+
+    @property
+    def display_size(self) -> tuple[int, int]:
+        """(width, height) as displayed, i.e. after rotation. All annotation coordinates use this orientation."""
+        return (self.height, self.width) if self.rotation in (90, 270) else (self.width, self.height)
+
+    @field_validator("content_hash")
+    @classmethod
+    def _v_hash(cls, v: str | None) -> str | None:
+        if v is not None and not _HASH_RE.match(v):
+            raise ValueError("content_hash must look like '<algo>:<lowercase hex>'")
+        return v
+
+    @field_validator("rotation")
+    @classmethod
+    def _v_rot(cls, v: int) -> int:
+        if v not in (0, 90, 180, 270):
+            raise ValueError("rotation must be 0, 90, 180 or 270")
+        return v
+
+
+class Region(_Strict):
+    x: int = Field(ge=0)
+    y: int = Field(ge=0)
+    width: int = Field(gt=0)
+    height: int = Field(gt=0)
+
+
+class View(_Strict):
+    """A named crop and/or time range of a video. No new video is made; annotations stay in source coordinates.
+
+    `region` is in the video's displayed orientation. If the crop is resized before it reaches a pipeline, give
+    `output_size` (width, height) so coordinates can be converted back. `allowed_labels` optionally limits which
+    labels may be used in this view (e.g. a caption strip that only allows caption labels).
+    """
+    view_id: str
+    video_id: str
+    name: str | None = None
+    region: Region | None = None
+    output_size: tuple[int, int] | None = Field(
+        default=None, description="(width, height) the region is resized to when shown to a pipeline. Omit if not resized.")
+    frame_range: tuple[int, int] | None = Field(default=None, description="Inclusive [first, last] frame.")
+    frame_ranges: list[tuple[int, int]] | None = Field(
+        default=None, description="Several inclusive [first, last] frame ranges, in increasing order and not overlapping "
+                                  "(e.g. every December-February). Use this or frame_range, not both.")
+    allowed_labels: list[str] | None = Field(default=None, description="If set, annotations in this view may only use these labels.")
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+    _v_id = field_validator("view_id", "video_id")(_check_id)
+
+    @model_validator(mode="after")
+    def _v_checks(self) -> "View":
+        if self.frame_range is not None:
+            if self.frame_range[0] < 0 or self.frame_range[0] > self.frame_range[1]:
+                raise ValueError("frame_range must be [first, last] with 0 <= first <= last")
+        if self.frame_ranges is not None:
+            if self.frame_range is not None:
+                raise ValueError("give frame_range or frame_ranges, not both")
+            if not self.frame_ranges:
+                raise ValueError("frame_ranges must not be empty (omit it to use every frame)")
+            prev_end = -1
+            for a, b in self.frame_ranges:
+                if a < 0 or a > b:
+                    raise ValueError("each frame_ranges entry must be [first, last] with 0 <= first <= last")
+                if a <= prev_end:
+                    raise ValueError("frame_ranges must be in increasing order and must not overlap")
+                prev_end = b
+        if self.output_size is not None:
+            if self.region is None:
+                raise ValueError("output_size needs a region")
+            if self.output_size[0] <= 0 or self.output_size[1] <= 0:
+                raise ValueError("output_size must be positive")
+        return self
+
+    @property
+    def ranges(self) -> list[tuple[int, int]] | None:
+        """The view's frame ranges as a list (from `frame_range` or `frame_ranges`), or None when every frame is in the view."""
+        if self.frame_ranges is not None:
+            return [tuple(r) for r in self.frame_ranges]
+        return [tuple(self.frame_range)] if self.frame_range is not None else None
+
+    def contains_frames(self, start: int, end: int) -> bool:
+        """Whether frames start..end (inclusive) all lie inside one of the view's ranges (always True without ranges)."""
+        r = self.ranges
+        return True if r is None else any(a <= start and end <= b for a, b in r)
+
+    @property
+    def scale(self) -> tuple[float, float]:
+        """(x, y) factor from source pixels to view pixels (1, 1 if the crop is not resized)."""
+        if self.region is not None and self.output_size is not None:
+            return (self.output_size[0] / self.region.width, self.output_size[1] / self.region.height)
+        return (1.0, 1.0)
+
+    def to_source_box(self, box: tuple[float, float, float, float]) -> tuple[float, float, float, float]:
+        """Box in this view's pixels -> box in full source-video pixels."""
+        x0, y0, x1, y1 = (float(v) for v in box)
+        if self.region is None:
+            return (x0, y0, x1, y1)
+        sx, sy = self.scale
+        r = self.region
+        return (r.x + x0 / sx, r.y + y0 / sy, r.x + x1 / sx, r.y + y1 / sy)
+
+    def to_view_box(self, box: tuple[float, float, float, float]) -> tuple[float, float, float, float]:
+        """Box in full source-video pixels -> box in this view's pixels."""
+        x0, y0, x1, y1 = (float(v) for v in box)
+        if self.region is None:
+            return (x0, y0, x1, y1)
+        sx, sy = self.scale
+        r = self.region
+        return ((x0 - r.x) * sx, (y0 - r.y) * sy, (x1 - r.x) * sx, (y1 - r.y) * sy)
+
+
+class Label(_Strict):
+    name: str
+    parent: str | None = None
+    description: str | None = None
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class Vocab(_Strict):
+    """The one shared list of labels."""
+    version: str = "0"
+    labels: list[Label] = Field(default_factory=list)
+
+    @model_validator(mode="after")
+    def _v_labels(self) -> "Vocab":
+        names = [l.name for l in self.labels]
+        if len(set(names)) != len(names):
+            raise ValueError("label names must be unique")
+        missing = {l.parent for l in self.labels if l.parent is not None} - set(names)
+        if missing:
+            raise ValueError(f"unknown parent label(s): {sorted(missing)}")
+        return self
+
+
+class Manifest(_Strict):
+    """Dataset-level index. Lives in manifest.json."""
+    spec_version: str = SPEC_VERSION
+    videos: list[str] = Field(default_factory=list)
+    views: list[str] = Field(default_factory=list)
+    vocab_version: str | None = None
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+    @field_validator("videos", "views")
+    @classmethod
+    def _ids_are_safe(cls, v: list[str]) -> list[str]:
+        for item in v:
+            _check_id(item)
+        return v
+
+
+class Release(_Strict):
+    """Describes one compiled (training) build. release_id is derived from content, so a training run can pin it."""
+    release_id: str
+    spec_version: str
+    created_at: datetime
+    n_rows: int
+    n_videos: int
+    row_group_size: int
+    files: dict[str, str] = Field(description="file name -> 'sha256:<hex>'")
+    extra: dict[str, Any] = Field(default_factory=dict, description="Build filters etc.")

vidlabel_spec-0.6.0/src/vidlabel_spec/_schema.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from ._columns import ANNOTATION_COLUMNS
+from ._models import SPEC_VERSION, FrameIndex, Manifest, Release, VideoMetadata, View, Vocab
+
+
+def json_schema() -> dict:
+    """JSON Schema for every metadata file plus the annotation columns, for implementers in other languages."""
+    return {
+        "spec_version": SPEC_VERSION,
+        "manifest": Manifest.model_json_schema(),
+        "video_metadata": VideoMetadata.model_json_schema(),
+        "frame_index": FrameIndex.model_json_schema(),
+        "view": View.model_json_schema(),
+        "vocab": Vocab.model_json_schema(),
+        "release": Release.model_json_schema(),
+        "annotation_columns": [c.model_dump() for c in ANNOTATION_COLUMNS],
+    }
+
+
+def write_json_schema(path: str | Path) -> None:
+    Path(path).write_text(json.dumps(json_schema(), indent=2) + "\n", encoding="utf-8")