modelport-cli 0.1.0__py3-none-any.whl

modelport/manifest/models.py

@@ -0,0 +1,241 @@
+"""The top-level `modelport.json` manifest."""
+
+from __future__ import annotations
+
+import json
+from collections import Counter
+from enum import StrEnum
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import Field, model_validator
+
+from .base import StrictModel
+from .files import FileRef
+from .postprocess import ClassificationPostprocess, DetectionPostprocess
+from .tensors import InputSpec, OutputSpec
+
+SCHEMA_VERSION = "modelport/0.1"
+MANIFEST_FILENAME = "modelport.json"
+
+_ID_PATTERN = r"^[a-z0-9][a-z0-9._-]*$"
+_SEMVER_PATTERN = (
+    r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)"
+    r"(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$"
+)
+
+
+class Task(StrEnum):
+    """What the model does. Decides which Dart task API can load it."""
+
+    IMAGE_CLASSIFICATION = "image-classification"
+    OBJECT_DETECTION = "object-detection"
+    TEXT_GENERATION = "text-generation"
+
+
+TENSOR_TASKS = frozenset({Task.IMAGE_CLASSIFICATION, Task.OBJECT_DETECTION})
+
+
+class Runtime(StrEnum):
+    """Inference engine that runs a variant."""
+
+    ONNX = "onnx"
+    EXECUTORCH = "executorch"
+    LLAMACPP = "llamacpp"
+
+
+class Tolerance(StrictModel):
+    """How close two outputs must be: |a - b| <= atol + rtol * |b|."""
+
+    atol: float = Field(default=1e-3, ge=0)
+    rtol: float = Field(default=1e-3, ge=0)
+
+
+class Variant(StrictModel):
+    """One concrete form of the model, such as ONNX fp32 or GGUF Q4_K_M."""
+
+    id: str = Field(pattern=_ID_PATTERN, examples=["onnx-fp32", "gguf-q4_k_m"])
+    runtime: Runtime
+    backend: str | None = Field(
+        default=None, description="Engine backend, such as 'xnnpack' or 'coreml'."
+    )
+    precision: str = Field(pattern=r"^[a-z0-9_]+$", examples=["fp32", "fp16", "int8", "q4_k_m"])
+    file: FileRef = Field(description="The main model file.")
+    extra_files: list[FileRef] = Field(
+        default_factory=list,
+        description="Files the main file needs, such as ONNX external weights.",
+    )
+    min_ram_mb: int | None = Field(
+        default=None, gt=0, description="Skip this variant on devices with less RAM."
+    )
+    tolerance: Tolerance | None = Field(
+        default=None, description="Overrides the golden tolerance, for example for int8."
+    )
+
+
+class GenerationDefaults(StrictModel):
+    """Default sampling settings. Apps can override each one per request."""
+
+    temperature: float = Field(default=0.7, ge=0, le=2)
+    top_p: float = Field(default=0.9, gt=0, le=1)
+    top_k: int | None = Field(default=None, gt=0)
+    max_tokens: int = Field(default=512, gt=0)
+    repeat_penalty: float | None = Field(default=None, gt=0)
+
+
+class LlmConfig(StrictModel):
+    """Settings for text-generation models."""
+
+    context_length: int = Field(
+        gt=0,
+        description=(
+            "Context window to allocate on device. Keep it at or below the trained context; "
+            "smaller windows use less RAM."
+        ),
+    )
+    chat_template: Literal["from_gguf"] = Field(
+        default="from_gguf",
+        description="Where the chat template comes from. Templates are never stored as code here.",
+    )
+    defaults: GenerationDefaults = Field(default_factory=GenerationDefaults)
+
+
+class Golden(StrictModel):
+    """Saved inputs and expected outputs, used to prove a device matches Python.
+
+    Each file holds raw little-endian tensor data in the dtype and shape of the tensor
+    with the same name.
+    """
+
+    inputs: dict[str, FileRef] = Field(min_length=1)
+    outputs: dict[str, FileRef] = Field(min_length=1)
+    tolerance: Tolerance = Field(default_factory=Tolerance)
+
+
+def _require_schema_key(schema: dict[str, Any]) -> None:
+    """Files must always state their spec version, even though Python fills a default."""
+    required = schema.setdefault("required", [])
+    if "schema" not in required:
+        required.insert(0, "schema")
+
+
+class Manifest(StrictModel):
+    """Everything an app needs to download, run, and interpret a model."""
+
+    model_config = StrictModel.model_config | {"json_schema_extra": _require_schema_key}
+
+    schema_version: Literal["modelport/0.1"] = Field(default=SCHEMA_VERSION, alias="schema")
+    id: str = Field(pattern=_ID_PATTERN, examples=["mobilenet_v3_small"])
+    version: str = Field(pattern=_SEMVER_PATTERN, examples=["1.0.0"])
+    task: Task
+    license: str = Field(min_length=1, description="SPDX license identifier of the weights.")
+    name: str | None = Field(default=None, description="Human-friendly name.")
+    description: str | None = None
+    source: str | None = Field(default=None, examples=["torchvision:mobilenet_v3_small"])
+    variants: list[Variant] = Field(min_length=1)
+    inputs: list[InputSpec] = Field(default_factory=list)
+    outputs: list[OutputSpec] = Field(default_factory=list)
+    llm: LlmConfig | None = None
+    golden: Golden | None = None
+
+    @model_validator(mode="after")
+    def _check_consistency(self) -> Manifest:
+        _require_unique("variant id", [v.id for v in self.variants])
+        _require_unique("input name", [i.name for i in self.inputs])
+        _require_unique("output name", [o.name for o in self.outputs])
+
+        if self.task in TENSOR_TASKS:
+            self._check_tensor_task()
+            self._check_detection()
+        else:
+            self._check_text_generation()
+
+        if self.golden is not None:
+            self._check_golden(self.golden)
+        return self
+
+    def _check_tensor_task(self) -> None:
+        if not self.inputs or not self.outputs:
+            raise ValueError(f"task '{self.task}' needs at least one input and one output")
+        if self.llm is not None:
+            raise ValueError(f"task '{self.task}' must not have an 'llm' section")
+        if any(v.runtime is Runtime.LLAMACPP for v in self.variants):
+            raise ValueError("runtime 'llamacpp' is only for task 'text-generation'")
+        if not any(i.preprocess is not None for i in self.inputs):
+            raise ValueError(f"task '{self.task}' needs an input with image preprocessing")
+        wanted = (
+            ClassificationPostprocess
+            if self.task is Task.IMAGE_CLASSIFICATION
+            else DetectionPostprocess
+        )
+        if not any(isinstance(o.postprocess, wanted) for o in self.outputs):
+            raise ValueError(
+                f"task '{self.task}' needs an output with '{wanted().type}' postprocess"
+            )
+
+    def _check_text_generation(self) -> None:
+        if self.llm is None:
+            raise ValueError("task 'text-generation' needs an 'llm' section")
+        if any(v.runtime is not Runtime.LLAMACPP for v in self.variants):
+            raise ValueError("task 'text-generation' supports only runtime 'llamacpp' in spec 0.1")
+        if self.golden is not None:
+            raise ValueError("golden tests are only for tensor tasks")
+
+    def _check_detection(self) -> None:
+        names = {o.name for o in self.outputs}
+        for output in self.outputs:
+            post = output.postprocess
+            if not isinstance(post, DetectionPostprocess) or post.boxes_output is None:
+                continue
+            if post.boxes_output not in names or post.boxes_output == output.name:
+                raise ValueError(
+                    f"output '{output.name}' boxes_output '{post.boxes_output}' "
+                    "must name another output"
+                )
+
+    def _check_golden(self, golden: Golden) -> None:
+        input_names = {i.name for i in self.inputs}
+        output_names = {o.name for o in self.outputs}
+        for name in golden.inputs:
+            if name not in input_names:
+                raise ValueError(f"golden input '{name}' is not a model input")
+        for name in golden.outputs:
+            if name not in output_names:
+                raise ValueError(f"golden output '{name}' is not a model output")
+
+    def files(self) -> list[FileRef]:
+        """Every file the manifest points to, in a stable order."""
+        refs: list[FileRef] = []
+        for variant in self.variants:
+            refs.append(variant.file)
+            refs.extend(variant.extra_files)
+        for output in self.outputs:
+            labels = getattr(output.postprocess, "labels", None)
+            if labels is not None:
+                refs.append(labels)
+        if self.golden is not None:
+            refs.extend(self.golden.inputs.values())
+            refs.extend(self.golden.outputs.values())
+        return refs
+
+    def to_json(self) -> str:
+        """Serialize the way the CLI writes `modelport.json`."""
+        return self.model_dump_json(by_alias=True, exclude_none=True, indent=2) + "\n"
+
+    @classmethod
+    def from_file(cls, path: str | Path) -> Manifest:
+        """Load and validate a `modelport.json` file.
+
+        Files must state their spec version, so a missing `schema` key is an error here
+        even though code that builds a manifest in Python gets it filled in.
+        """
+        data = json.loads(Path(path).read_text(encoding="utf-8"))
+        if not isinstance(data, dict) or "schema" not in data:
+            raise ValueError(f"{path}: missing 'schema' key, expected \"{SCHEMA_VERSION}\"")
+        return cls.model_validate(data)
+
+
+def _require_unique(label: str, values: list[str]) -> None:
+    duplicates = sorted(value for value, count in Counter(values).items() if count > 1)
+    if duplicates:
+        raise ValueError(f"duplicate {label}: {', '.join(duplicates)}")

modelport/manifest/postprocess.py

@@ -0,0 +1,79 @@
+"""Rules for turning raw output tensors into results people can use."""
+
+from __future__ import annotations
+
+from typing import Annotated, Literal
+
+from pydantic import Field, model_validator
+
+from .base import StrictModel
+from .files import FileRef
+
+
+class ClassificationPostprocess(StrictModel):
+    """Scores over a fixed set of classes, for example ImageNet logits of shape [1, 1000]."""
+
+    type: Literal["classification"] = "classification"
+    activation: Literal["softmax", "sigmoid", "none"] = Field(
+        default="softmax", description="Applied to raw scores before ranking."
+    )
+    labels: FileRef | None = Field(
+        default=None, description="UTF-8 text file with one class name per line."
+    )
+    top_k: int = Field(default=5, gt=0, description="How many results to return by default.")
+
+
+class DetectionPostprocess(StrictModel):
+    """Boxes with class scores. Two layouts are supported.
+
+    * `rows` (YOLO style): this output is [1, N, 4 + objectness + classes].
+    * `detr` (DETR, YOLOS, RT-DETR style): this output holds class scores
+      [1, N, classes], and `boxes_output` names the [1, N, 4] boxes output.
+    """
+
+    type: Literal["detection"] = "detection"
+    format: Literal["rows", "detr"] = "rows"
+    boxes_output: str | None = Field(
+        default=None, description="For format 'detr': the output with the [1, N, 4] boxes."
+    )
+    activation: Literal["softmax", "sigmoid", "none"] = Field(
+        default="none", description="Applied to class scores before thresholding."
+    )
+    background_class: bool = Field(
+        default=False,
+        description="Whether the last class means 'no object' and is ignored, as in DETR.",
+    )
+    box_format: Literal["xyxy", "cxcywh"] = Field(
+        default="cxcywh", description="How the four box values describe a box."
+    )
+    normalized: bool = Field(
+        default=False,
+        description="true: box values are 0-1 fractions of the input size; false: input pixels.",
+    )
+    has_objectness: bool = Field(
+        default=False, description="For format 'rows': an objectness score follows the box."
+    )
+    score_threshold: float = Field(default=0.25, ge=0, le=1)
+    iou_threshold: float = Field(
+        default=0.45,
+        ge=0,
+        le=1,
+        description="Non-max suppression overlap threshold. 1 turns suppression off.",
+    )
+    max_detections: int = Field(default=100, gt=0)
+    labels: FileRef | None = None
+
+    @model_validator(mode="after")
+    def _check_format(self) -> DetectionPostprocess:
+        if self.format == "detr" and not self.boxes_output:
+            raise ValueError("format 'detr' needs 'boxes_output'")
+        if self.format == "rows" and self.boxes_output:
+            raise ValueError("'boxes_output' is only for format 'detr'")
+        if self.format == "detr" and self.has_objectness:
+            raise ValueError("'has_objectness' is only for format 'rows'")
+        return self
+
+
+Postprocess = Annotated[
+    ClassificationPostprocess | DetectionPostprocess, Field(discriminator="type")
+]

modelport/manifest/schema.py

@@ -0,0 +1,49 @@
+"""Generate the JSON Schema for `modelport.json` from the Pydantic models."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
+from pydantic_core import core_schema
+
+from .models import Manifest
+
+SCHEMA_URL = (
+    "https://raw.githubusercontent.com/ayanparvaiz/modelport/main/spec/manifest.schema.json"
+)
+
+
+class _ManifestSchemaGenerator(GenerateJsonSchema):
+    """Optional fields are written by leaving them out, never as null."""
+
+    def nullable_schema(self, schema: core_schema.NullableSchema) -> JsonSchemaValue:
+        return self.generate_inner(schema["schema"])
+
+    def default_schema(self, schema: core_schema.WithDefaultSchema) -> JsonSchemaValue:
+        json_schema = super().default_schema(schema)
+        if "default" in json_schema and json_schema["default"] is None:
+            del json_schema["default"]
+        return json_schema
+
+
+def manifest_json_schema() -> dict[str, Any]:
+    """The JSON Schema (draft 2020-12) that every `modelport.json` must satisfy."""
+    schema = Manifest.model_json_schema(
+        by_alias=True, mode="validation", schema_generator=_ManifestSchemaGenerator
+    )
+    return {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "$id": SCHEMA_URL,
+        **schema,
+    }
+
+
+def render_schema() -> str:
+    return json.dumps(manifest_json_schema(), indent=2, ensure_ascii=False) + "\n"
+
+
+def write_schema(path: str | Path) -> None:
+    Path(path).write_text(render_schema(), encoding="utf-8")

modelport/manifest/tensors.py

@@ -0,0 +1,158 @@
+"""Tensor descriptions and the rules for turning raw data into model inputs."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Literal
+
+from pydantic import Field, field_validator, model_validator
+
+from .base import StrictModel
+from .postprocess import Postprocess
+
+TensorLayout = Literal["NCHW", "NHWC"]
+
+
+class DType(StrEnum):
+    """Element type of a tensor."""
+
+    FLOAT32 = "float32"
+    FLOAT16 = "float16"
+    INT64 = "int64"
+    INT32 = "int32"
+    INT8 = "int8"
+    UINT8 = "uint8"
+    BOOL = "bool"
+
+
+class TensorSpec(StrictModel):
+    """Name, element type, and shape of one model input or output."""
+
+    name: str = Field(min_length=1, description="Tensor name as the engine knows it.")
+    dtype: DType
+    shape: list[int] = Field(
+        description="Dimensions. Use -1 for a dimension that is only known at run time.",
+        examples=[[1, 3, 224, 224]],
+    )
+
+    @field_validator("shape")
+    @classmethod
+    def _check_dims(cls, value: list[int]) -> list[int]:
+        if any(dim == 0 or dim < -1 for dim in value):
+            raise ValueError("every dimension must be a positive integer or -1")
+        return value
+
+
+class ResizeSpec(StrictModel):
+    """How to resize an image. Set exactly one of `shorter_side` or `size`."""
+
+    model_config = StrictModel.model_config | {
+        "json_schema_extra": {"oneOf": [{"required": ["shorter_side"]}, {"required": ["size"]}]}
+    }
+
+    shorter_side: int | None = Field(
+        default=None,
+        gt=0,
+        description="Scale so the shorter side has this length, keeping the aspect ratio.",
+    )
+    size: tuple[int, int] | None = Field(
+        default=None, description="Exact output size as [height, width]. Ignores aspect ratio."
+    )
+    method: Literal["bilinear", "nearest", "bicubic"] = "bilinear"
+    antialias: bool = Field(
+        default=False,
+        description=(
+            "true: PIL-compatible resampling that filters when shrinking (bilinear or bicubic). "
+            "false: plain half-pixel bilinear in floating point, or nearest."
+        ),
+    )
+
+    @field_validator("size")
+    @classmethod
+    def _check_size(cls, value: tuple[int, int] | None) -> tuple[int, int] | None:
+        if value is not None and min(value) <= 0:
+            raise ValueError("size must be positive")
+        return value
+
+    @model_validator(mode="after")
+    def _check_exactly_one(self) -> ResizeSpec:
+        if (self.shorter_side is None) == (self.size is None):
+            raise ValueError("set exactly one of 'shorter_side' or 'size'")
+        if self.method == "bicubic" and not self.antialias:
+            raise ValueError("bicubic resize needs antialias: true in spec 0.1")
+        if self.method == "nearest" and self.antialias:
+            raise ValueError("nearest resize cannot use antialias")
+        return self
+
+
+class ImagePreprocess(StrictModel):
+    """Turn a decoded image into a tensor.
+
+    Steps run in this order: resize, center crop, channel order, multiply by `scale`,
+    subtract `mean`, divide by `std`, then arrange in the input's layout.
+    """
+
+    type: Literal["image"] = "image"
+    resize: ResizeSpec
+    center_crop: tuple[int, int] | None = Field(
+        default=None, description="Crop [height, width] from the center after resizing."
+    )
+    color: Literal["RGB", "BGR"] = "RGB"
+    scale: float = Field(default=1 / 255, gt=0, description="Multiplier applied to 0-255 pixels.")
+    mean: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    std: tuple[float, float, float] = (1.0, 1.0, 1.0)
+
+    @field_validator("std")
+    @classmethod
+    def _check_std(cls, value: tuple[float, float, float]) -> tuple[float, float, float]:
+        if min(value) <= 0:
+            raise ValueError("std values must be positive")
+        return value
+
+    @property
+    def output_size(self) -> tuple[int, int] | None:
+        """Final [height, width] if it is fixed, otherwise None."""
+        if self.center_crop is not None:
+            return self.center_crop
+        return self.resize.size
+
+
+class InputSpec(TensorSpec):
+    """A model input, with optional preprocessing rules."""
+
+    layout: TensorLayout | None = Field(
+        default=None, description="Dimension order for image tensors."
+    )
+    preprocess: ImagePreprocess | None = None
+
+    @model_validator(mode="after")
+    def _check_image_input(self) -> InputSpec:
+        if self.preprocess is None:
+            return self
+        if self.layout is None:
+            raise ValueError(f"input '{self.name}' has image preprocessing but no layout")
+        if len(self.shape) != 4:
+            raise ValueError(f"image input '{self.name}' must have 4 dimensions")
+        if self.dtype not in (DType.FLOAT32, DType.FLOAT16, DType.UINT8):
+            raise ValueError(f"image input '{self.name}' must be float32, float16, or uint8")
+        if self.layout == "NCHW":
+            channels, height, width = self.shape[1], self.shape[2], self.shape[3]
+        else:
+            height, width, channels = self.shape[1], self.shape[2], self.shape[3]
+        if channels not in (-1, 3):
+            raise ValueError(f"image input '{self.name}' must have 3 channels")
+        size = self.preprocess.output_size
+        if size is not None:
+            for expected, actual, label in ((size[0], height, "height"), (size[1], width, "width")):
+                if actual != -1 and actual != expected:
+                    raise ValueError(
+                        f"input '{self.name}' {label} is {actual}, "
+                        f"but preprocessing produces {expected}"
+                    )
+        return self
+
+
+class OutputSpec(TensorSpec):
+    """A model output, with optional rules for turning it into results."""
+
+    postprocess: Postprocess | None = None

modelport/pack.py

@@ -0,0 +1,48 @@
+"""Finalize a bundle after manual edits: refresh hashes and find stray files."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .bundle import Bundle
+from .errors import ModelPortError
+from .manifest import MANIFEST_FILENAME, Manifest
+
+# Files that may sit next to the manifest without being listed in it.
+ALLOWED_EXTRA = {MANIFEST_FILENAME, "README.md", ".gitattributes"}
+
+
+@dataclass(frozen=True)
+class PackResult:
+    manifest: Manifest
+    changed: list[str]
+    stray: list[str]
+    total_bytes: int
+
+
+def pack_bundle(path: str | Path) -> PackResult:
+    bundle = Bundle(path)
+    if not bundle.manifest_path.is_file():
+        raise ModelPortError(f"{bundle.manifest_path} not found")
+    before = bundle.read_manifest()
+    missing = [p for p in bundle.problems(before) if p.endswith(": missing")]
+    if missing:
+        raise ModelPortError("files listed in the manifest are missing:\n  " + "\n  ".join(missing))
+
+    after = bundle.refresh(before)
+    old = {ref.path: ref for ref in before.files() if ref.path}
+    changed = sorted(ref.path for ref in after.files() if ref.path and old.get(ref.path) != ref)
+    if after != before:
+        bundle.write_manifest(after)
+
+    listed = {ref.path for ref in after.files() if ref.path}
+    stray = sorted(
+        p.relative_to(bundle.root).as_posix()
+        for p in bundle.root.rglob("*")
+        if p.is_file()
+        and p.relative_to(bundle.root).as_posix() not in listed
+        and p.relative_to(bundle.root).as_posix() not in ALLOWED_EXTRA
+    )
+    total = sum(ref.size for ref in after.files() if ref.path)
+    return PackResult(after, changed, stray, total)

modelport/pipeline.py

@@ -0,0 +1,109 @@
+"""The export pipeline: SourceModel in, verified-ready bundle folder out."""
+
+from __future__ import annotations
+
+import shutil
+from collections.abc import Sequence
+from pathlib import Path
+
+from PIL import Image
+
+from .bundle import Bundle
+from .exporters import ExportError, get_exporter
+from .golden import dtype_of, make_golden, sample_image
+from .manifest import (
+    ClassificationPostprocess,
+    DetectionPostprocess,
+    Manifest,
+    OutputSpec,
+    Task,
+    Variant,
+)
+from .sources import SourceModel
+
+
+def export_bundle(
+    source: SourceModel,
+    out_dir: str | Path,
+    targets: Sequence[str],
+    *,
+    image: Image.Image | None = None,
+    version: str = "1.0.0",
+    overwrite: bool = False,
+) -> tuple[Bundle, Manifest]:
+    """Write `<out_dir>/<id>/` with model files, labels, golden data, and modelport.json."""
+    if not targets:
+        raise ExportError("choose at least one export target")
+    root = Path(out_dir) / source.id
+    if root.exists() and any(root.iterdir()):
+        if not overwrite:
+            raise ExportError(f"{root} already exists. Use --force to replace it.")
+        shutil.rmtree(root)
+    bundle = Bundle(root)
+    # Fail fast on unknown targets before doing any work.
+    exporters = [get_exporter(target) for target in dict.fromkeys(targets)]
+
+    labels = None
+    if source.labels:
+        labels = bundle.write_text("labels.txt", "\n".join(source.labels) + "\n")
+    golden = make_golden(source, bundle, image or sample_image())
+
+    variants = []
+    for exporter in exporters:
+        exported = exporter(source, bundle)
+        variants.append(
+            Variant(
+                id=exported.id,
+                runtime=exported.runtime,
+                backend=exported.backend,
+                precision=exported.precision,
+                file=bundle.add(exported.main_file),
+                extra_files=[bundle.add(path) for path in exported.extra_files],
+            )
+        )
+
+    outputs = []
+    for index, name in enumerate(source.output_names):
+        array = golden.outputs[name]
+        postprocess: ClassificationPostprocess | DetectionPostprocess | None = None
+        if index == 0 and source.task is Task.IMAGE_CLASSIFICATION:
+            classes = int(array.shape[-1])
+            _check_labels(source, classes)
+            postprocess = ClassificationPostprocess(labels=labels, top_k=min(source.top_k, classes))
+        elif index == 0 and source.task is Task.OBJECT_DETECTION:
+            if source.detection is None:
+                raise ExportError("object detection sources must describe their outputs")
+            detection = source.detection
+            classes = int(array.shape[-1])
+            if detection.format == "rows":
+                classes -= 4 + (1 if detection.has_objectness else 0)
+            elif detection.background_class:
+                classes -= 1
+            _check_labels(source, classes)
+            postprocess = detection.model_copy(update={"labels": labels})
+        outputs.append(
+            OutputSpec(
+                name=name, dtype=dtype_of(array), shape=list(array.shape), postprocess=postprocess
+            )
+        )
+
+    manifest = Manifest(
+        id=source.id,
+        version=version,
+        task=source.task,
+        license=source.license,
+        name=source.name,
+        description=source.description,
+        source=source.source,
+        variants=variants,
+        inputs=source.inputs,
+        outputs=outputs,
+        golden=golden.golden,
+    )
+    bundle.write_manifest(manifest)
+    return bundle, manifest
+
+
+def _check_labels(source: SourceModel, classes: int) -> None:
+    if source.labels and len(source.labels) != classes:
+        raise ExportError(f"model has {classes} classes but {len(source.labels)} labels were given")