modelport-cli 0.1.0__py3-none-any.whl

modelport/sources/hf.py

@@ -0,0 +1,265 @@
+"""Hugging Face transformers image classifiers, from the Hub or a local folder."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any, Literal
+
+from ..errors import MissingDependencyError
+from ..manifest import DetectionPostprocess, DType, ImagePreprocess, InputSpec, ResizeSpec, Task
+from . import SourceError, SourceModel, model_id
+
+# PIL resampling codes used by transformers image processors.
+_RESAMPLE: dict[int, Literal["nearest", "bilinear", "bicubic"]] = {
+    0: "nearest",
+    2: "bilinear",
+    3: "bicubic",
+}
+
+
+def load_hf(repo: str, *, license: str | None = None, image_size: int | None = None) -> SourceModel:
+    """Load an image classifier or object detector with its image processor's preprocessing."""
+    try:
+        import torch
+        from transformers import AutoConfig, AutoImageProcessor, AutoModelForImageClassification
+    except ImportError as error:
+        raise MissingDependencyError("hf: sources", "hf") from error
+
+    try:
+        architectures = AutoConfig.from_pretrained(repo).architectures or []
+    except (OSError, ValueError) as error:
+        raise SourceError(f"could not load '{repo}': {error}") from error
+    if any(name.endswith("ForObjectDetection") for name in architectures):
+        return _load_detector(repo, license=license, image_size=image_size)
+
+    try:
+        processor = AutoImageProcessor.from_pretrained(repo)
+        model = AutoModelForImageClassification.from_pretrained(repo).eval()
+    except (OSError, ValueError) as error:
+        raise SourceError(f"could not load '{repo}' as an image classifier: {error}") from error
+
+    preprocess, (height, width) = preprocess_from_processor(processor)
+    config = model.config
+    labels = [str(config.id2label[i]) for i in range(config.num_labels)]
+
+    if license is None and not Path(repo).is_dir():
+        license = _hub_license(repo)
+    if license is None:
+        raise SourceError(f"no license found for '{repo}'. Pass it with --license, e.g. MIT")
+
+    return SourceModel(
+        module=_logits_only(model),
+        example_inputs=(torch.zeros(1, 3, height, width),),
+        id=model_id(repo),
+        task=Task.IMAGE_CLASSIFICATION,
+        license=license,
+        inputs=[
+            InputSpec(
+                name="pixel_values",
+                dtype=DType.FLOAT32,
+                shape=[1, 3, height, width],
+                layout="NCHW",
+                preprocess=preprocess,
+            )
+        ],
+        output_names=["logits"],
+        labels=labels,
+        name=repo.rstrip("/").split("/")[-1],
+        description=f"Hugging Face {type(model).__name__} from {repo}.",
+        source=f"hf:{repo}",
+    )
+
+
+def _size_value(size: Any, key: str) -> int | None:
+    value = size.get(key) if isinstance(size, dict) else getattr(size, key, None)
+    return int(value) if value else None
+
+
+def preprocess_from_processor(processor: Any) -> tuple[ImagePreprocess, tuple[int, int]]:
+    """Translate a transformers image processor into a manifest preprocessing rule.
+
+    Returns the rule and the final (height, width) of the input tensor.
+    """
+    resample = getattr(processor, "resample", 2)
+    code = int(getattr(resample, "value", resample))
+    method = _RESAMPLE.get(code)
+    if method is None:
+        raise SourceError(f"unsupported resample mode {resample!r}")
+    antialias = method != "nearest"  # transformers resizes with PIL or antialiased torchvision
+
+    size = processor.size
+    height, width = _size_value(size, "height"), _size_value(size, "width")
+    shortest = _size_value(size, "shortest_edge")
+    crop_pct = getattr(processor, "crop_pct", None)
+    crop: tuple[int, int] | None = None
+
+    if height and width:
+        resize = ResizeSpec(size=(height, width), method=method, antialias=antialias)
+        final = (height, width)
+    elif shortest and crop_pct:
+        # ConvNext style: below 384, resize to shortest / crop_pct and crop back.
+        if shortest < 384:
+            resize = ResizeSpec(
+                shorter_side=int(shortest / crop_pct), method=method, antialias=antialias
+            )
+            crop = (shortest, shortest)
+        else:
+            resize = ResizeSpec(size=(shortest, shortest), method=method, antialias=antialias)
+        final = (shortest, shortest)
+    elif shortest:
+        resize = ResizeSpec(shorter_side=shortest, method=method, antialias=antialias)
+        crop_size = getattr(processor, "crop_size", None)
+        if not (getattr(processor, "do_center_crop", False) and crop_size):
+            raise SourceError("this processor gives a variable input size; a center crop is needed")
+        crop = (_size_value(crop_size, "height") or 0, _size_value(crop_size, "width") or 0)
+        final = crop
+    else:
+        raise SourceError(f"unsupported image processor size {size!r}")
+
+    if crop is None and getattr(processor, "do_center_crop", False):
+        crop_size = getattr(processor, "crop_size", None)
+        if crop_size:
+            crop = (_size_value(crop_size, "height") or 0, _size_value(crop_size, "width") or 0)
+            final = crop
+
+    do_rescale = getattr(processor, "do_rescale", True)
+    do_normalize = getattr(processor, "do_normalize", True)
+    preprocess = ImagePreprocess(
+        resize=resize,
+        center_crop=crop,
+        scale=float(processor.rescale_factor) if do_rescale else 1.0,
+        mean=_triple(processor.image_mean, "image_mean") if do_normalize else (0.0, 0.0, 0.0),
+        std=_triple(processor.image_std, "image_std") if do_normalize else (1.0, 1.0, 1.0),
+    )
+    return preprocess, final
+
+
+def _triple(values: Any, name: str) -> tuple[float, float, float]:
+    numbers = [float(v) for v in values]
+    if len(numbers) != 3:
+        raise SourceError(f"{name} must have 3 values, got {len(numbers)}")
+    return numbers[0], numbers[1], numbers[2]
+
+
+def _hub_license(repo: str) -> str | None:
+    try:
+        from huggingface_hub import model_info
+
+        card = model_info(repo).card_data
+    except Exception:
+        return None
+    license = getattr(card, "license", None) if card is not None else None
+    if isinstance(license, list):
+        license = license[0] if license else None
+    return str(license) if license else None
+
+
+def _logits_only(model: Any) -> Any:
+    """Wrap a transformers model so forward(pixel_values) returns only the logits tensor."""
+    import torch
+
+    class LogitsOnly(torch.nn.Module):
+        def __init__(self, inner: Any) -> None:
+            super().__init__()
+            self.inner = inner
+
+        def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
+            return self.inner(pixel_values=pixel_values).logits
+
+    return LogitsOnly(model).eval()
+
+
+def _load_detector(repo: str, *, license: str | None, image_size: int | None) -> SourceModel:
+    """DETR-family detectors (DETR, YOLOS, RT-DETR, D-FINE) exported at a fixed square size."""
+    import torch
+    from transformers import AutoImageProcessor, AutoModelForObjectDetection
+
+    try:
+        processor = AutoImageProcessor.from_pretrained(repo)
+        model = AutoModelForObjectDetection.from_pretrained(repo).eval()
+    except (OSError, ValueError) as error:
+        raise SourceError(f"could not load '{repo}' as an object detector: {error}") from error
+
+    try:
+        preprocess, (height, width) = preprocess_from_processor(processor)
+    except SourceError:
+        # Detectors usually accept any size; export at a fixed square instead.
+        size = image_size or _size_value(processor.size, "shortest_edge") or 512
+        fixed = SimpleNamespace(
+            resample=getattr(processor, "resample", 2),
+            do_rescale=getattr(processor, "do_rescale", True) is not False,
+            rescale_factor=getattr(processor, "rescale_factor", 1 / 255),
+            do_normalize=getattr(processor, "do_normalize", True) is not False,
+            image_mean=processor.image_mean,
+            image_std=processor.image_std,
+            size={"height": size, "width": size},
+            do_center_crop=False,
+        )
+        preprocess, (height, width) = preprocess_from_processor(fixed)
+    if image_size and (height, width) != (image_size, image_size):
+        raise SourceError(f"{repo} has a fixed input size of {height}x{width}")
+
+    wrapped = _detector_outputs(model)
+    example = torch.zeros(1, 3, height, width)
+    with torch.no_grad():
+        logits, _ = wrapped(example)
+    config = model.config
+    classes = int(logits.shape[-1])
+    background = classes == config.num_labels + 1
+    labels = [str(config.id2label[i]) for i in range(config.num_labels)]
+
+    if license is None and not Path(repo).is_dir():
+        license = _hub_license(repo)
+    if license is None:
+        raise SourceError(f"no license found for '{repo}'. Pass it with --license, e.g. MIT")
+
+    return SourceModel(
+        module=wrapped,
+        example_inputs=(example,),
+        id=model_id(repo),
+        task=Task.OBJECT_DETECTION,
+        license=license,
+        inputs=[
+            InputSpec(
+                name="pixel_values",
+                dtype=DType.FLOAT32,
+                shape=[1, 3, height, width],
+                layout="NCHW",
+                preprocess=preprocess,
+            )
+        ],
+        output_names=["logits", "pred_boxes"],
+        labels=labels,
+        name=repo.rstrip("/").split("/")[-1],
+        description=f"Hugging Face {type(model).__name__} from {repo}, at {width}x{height}.",
+        source=f"hf:{repo}",
+        detection=DetectionPostprocess(
+            format="detr",
+            boxes_output="pred_boxes",
+            activation="softmax" if background else "sigmoid",
+            background_class=background,
+            box_format="cxcywh",
+            normalized=True,
+            score_threshold=0.5,
+            # DETR-style models predict each object once, so no suppression is needed.
+            iou_threshold=1.0,
+            max_detections=int(logits.shape[1]),
+        ),
+    )
+
+
+def _detector_outputs(model: Any) -> Any:
+    """Wrap a detector so forward(pixel_values) returns (logits, pred_boxes)."""
+    import torch
+
+    class DetectorOutputs(torch.nn.Module):
+        def __init__(self, inner: Any) -> None:
+            super().__init__()
+            self.inner = inner
+
+        def forward(self, pixel_values: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+            out = self.inner(pixel_values=pixel_values)
+            return out.logits, out.pred_boxes
+
+    return DetectorOutputs(model).eval()

modelport/sources/torchvision.py

@@ -0,0 +1,78 @@
+"""torchvision classification models with their ImageNet preprocessing."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from ..errors import MissingDependencyError
+from ..manifest import DType, ImagePreprocess, InputSpec, ResizeSpec, Task
+from . import SourceError, SourceModel
+
+_METHODS: dict[str, Literal["bilinear", "bicubic", "nearest"]] = {
+    "bilinear": "bilinear",
+    "bicubic": "bicubic",
+    "nearest": "nearest",
+}
+
+
+def load_torchvision(name: str, *, pretrained: bool = True) -> SourceModel:
+    """Load a torchvision classifier.
+
+    `pretrained=False` keeps the weights' metadata but skips the download. Tests use it.
+    """
+    try:
+        import torch
+        import torchvision.models as models
+    except ImportError as error:
+        raise MissingDependencyError("torchvision: sources", "torchvision") from error
+
+    try:
+        weights = models.get_model_weights(name)["DEFAULT"]
+    except ValueError as error:
+        raise SourceError(f"torchvision has no model named '{name}'") from error
+
+    transform = weights.transforms()
+    if type(transform).__name__ != "ImageClassification":
+        raise SourceError(
+            f"torchvision:{name} is a {type(transform).__name__} model. "
+            "Only image classification is supported for now."
+        )
+
+    method = _METHODS.get(transform.interpolation.value)
+    if method is None:
+        raise SourceError(f"unsupported interpolation {transform.interpolation}")
+    crop = int(transform.crop_size[0])
+    preprocess = ImagePreprocess(
+        # torchvision resizes PIL images with PIL, which always antialiases.
+        resize=ResizeSpec(
+            shorter_side=int(transform.resize_size[0]),
+            method=method,
+            antialias=method != "nearest",
+        ),
+        center_crop=(crop, crop),
+        mean=tuple(transform.mean),
+        std=tuple(transform.std),
+    )
+    module = models.get_model(name, weights=weights if pretrained else None).eval()
+    return SourceModel(
+        module=module,
+        example_inputs=(torch.zeros(1, 3, crop, crop),),
+        id=name.lower(),
+        task=Task.IMAGE_CLASSIFICATION,
+        # torchvision code and its pretrained weights are released under BSD-3-Clause.
+        license="BSD-3-Clause",
+        inputs=[
+            InputSpec(
+                name="pixel_values",
+                dtype=DType.FLOAT32,
+                shape=[1, 3, crop, crop],
+                layout="NCHW",
+                preprocess=preprocess,
+            )
+        ],
+        output_names=["logits"],
+        labels=list(weights.meta["categories"]),
+        name=name,
+        description=f"torchvision {name} with {weights.name} weights.",
+        source=f"torchvision:{name}",
+    )

modelport/verify.py

@@ -0,0 +1,92 @@
+"""Check every variant of a bundle against its golden data."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import numpy as np
+
+from .bundle import Bundle
+from .errors import MissingDependencyError, ModelPortError
+from .golden import golden_arrays
+from .manifest import ClassificationPostprocess, Tolerance
+from .runtimes import RuntimeNotSupported, run_variant
+
+
+class VerifyError(ModelPortError):
+    """The bundle cannot be verified at all."""
+
+
+@dataclass(frozen=True)
+class OutputCheck:
+    name: str
+    max_abs_diff: float
+    cosine: float
+    within_tolerance: bool
+    top1_match: bool | None = None
+
+
+@dataclass(frozen=True)
+class VariantResult:
+    variant_id: str
+    runtime: str
+    tolerance: Tolerance
+    outputs: list[OutputCheck] = field(default_factory=list)
+    skipped: str | None = None
+
+    @property
+    def passed(self) -> bool:
+        return self.skipped is None and all(
+            o.within_tolerance and o.top1_match is not False for o in self.outputs
+        )
+
+
+def compare(
+    name: str, got: np.ndarray, expected: np.ndarray, tolerance: Tolerance, classify: bool
+) -> OutputCheck:
+    if got.shape != expected.shape:
+        raise VerifyError(f"output '{name}' has shape {got.shape}, golden has {expected.shape}")
+    a = got.astype(np.float64).ravel()
+    b = expected.astype(np.float64).ravel()
+    diff = np.abs(a - b)
+    within = bool(np.all(diff <= tolerance.atol + tolerance.rtol * np.abs(b)))
+    norms = np.linalg.norm(a) * np.linalg.norm(b)
+    cosine = float(np.dot(a, b) / norms) if norms > 0 else float(np.array_equal(a, b))
+    top1 = None
+    if classify:
+        top1 = bool(np.array_equal(got.argmax(axis=-1), expected.argmax(axis=-1)))
+    return OutputCheck(name, float(diff.max(initial=0.0)), cosine, within, top1)
+
+
+def verify_bundle(path: str | Path) -> list[VariantResult]:
+    bundle = Bundle(path)
+    if not bundle.manifest_path.is_file():
+        raise VerifyError(f"{bundle.manifest_path} not found")
+    manifest = bundle.read_manifest()
+    problems = bundle.problems(manifest)
+    if problems:
+        raise VerifyError("bundle files do not match the manifest:\n  " + "\n  ".join(problems))
+    if manifest.golden is None:
+        raise VerifyError(f"{manifest.id} has no golden data to verify against")
+
+    inputs, expected = golden_arrays(bundle, manifest)
+    classify = {
+        o.name for o in manifest.outputs if isinstance(o.postprocess, ClassificationPostprocess)
+    }
+    results = []
+    for variant in manifest.variants:
+        tolerance = variant.tolerance or manifest.golden.tolerance
+        try:
+            got = run_variant(bundle, manifest, variant, inputs)
+        except (MissingDependencyError, RuntimeNotSupported) as error:
+            results.append(
+                VariantResult(variant.id, variant.runtime, tolerance, skipped=str(error))
+            )
+            continue
+        checks = [
+            compare(name, got[name], want, tolerance, name in classify)
+            for name, want in expected.items()
+        ]
+        results.append(VariantResult(variant.id, variant.runtime, tolerance, checks))
+    return results

modelport_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.5
+Name: modelport-cli
+Version: 0.1.0
+Summary: Prepare PyTorch, Hugging Face, and GGUF models for Flutter apps: export, verify, pack, publish.
+Project-URL: Homepage, https://github.com/ayanparvaiz/modelport
+Project-URL: Documentation, https://ayanparvaiz.github.io/modelport/
+Project-URL: Issues, https://github.com/ayanparvaiz/modelport/issues
+Project-URL: Changelog, https://github.com/ayanparvaiz/modelport/blob/main/python/CHANGELOG.md
+Author: Ayan Parvaiz
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: ai,dart,executorch,flutter,gguf,mobile,on-device,onnx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: pillow>=10
+Requires-Dist: pydantic>=2.7
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Provides-Extra: executorch
+Requires-Dist: executorch>=1.0; extra == 'executorch'
+Requires-Dist: torch>=2.9; extra == 'executorch'
+Provides-Extra: gguf
+Requires-Dist: gguf>=0.17; extra == 'gguf'
+Provides-Extra: hf
+Requires-Dist: huggingface-hub>=0.30; extra == 'hf'
+Requires-Dist: torch>=2.9; extra == 'hf'
+Requires-Dist: transformers>=4.50; extra == 'hf'
+Provides-Extra: onnx
+Requires-Dist: onnx>=1.17; extra == 'onnx'
+Requires-Dist: onnxruntime>=1.20; extra == 'onnx'
+Requires-Dist: onnxscript>=0.5; extra == 'onnx'
+Requires-Dist: torch>=2.9; extra == 'onnx'
+Provides-Extra: torchvision
+Requires-Dist: torch>=2.9; extra == 'torchvision'
+Requires-Dist: torchvision>=0.24; extra == 'torchvision'
+Description-Content-Type: text/markdown
+
+# modelport-cli
+
+Prepare models for Flutter apps. Part of [ModelPort](https://github.com/ayanparvaiz/modelport).
+
+Install `modelport-cli`; the command and the Python package are both called `modelport`.
+
+> **Status: 0.1.0, alpha.** Works end to end and is tested on a real Android phone. The spec may still change before 1.0.
+
+The CLI converts PyTorch, Hugging Face, and torchvision models into mobile formats, checks that the converted model gives the same output as the original, and writes a `modelport.json` manifest that the ModelPort Dart packages read.
+
+## Install
+
+```bash
+pip install "modelport-cli[onnx,torchvision]"
+```
+
+| Extra | Adds | Needed for |
+|---|---|---|
+| `onnx` | onnx, onnxruntime, onnxscript, torch | ONNX export, quantize, verify |
+| `executorch` | executorch, torch | ExecuTorch export and verify |
+| `torchvision` | torchvision, torch | `torchvision:` sources |
+| `hf` | transformers, huggingface_hub, torch | `hf:` sources and `publish` |
+| `gguf` | gguf | Inspecting GGUF files |
+
+Run `modelport doctor` to see what is installed.
+
+## Quick start
+
+```bash
+modelport export torchvision:mobilenet_v3_small --target onnx,executorch
+modelport quantize dist/mobilenet_v3_small --fp16 --int8
+modelport verify dist/mobilenet_v3_small
+modelport publish dist/mobilenet_v3_small --hf your-name/mobilenet_v3_small
+```
+
+`verify` runs every variant on the saved golden input and compares it with PyTorch's output:
+
+```
+ variant                 ┃ output ┃ max diff ┃ cosine   ┃ top-1 ┃ result
+━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━╇━━━━━━━━
+ onnx-fp32               │ logits │ 3.34e-05 │ 1.000000 │ same  │ pass
+ executorch-xnnpack-fp32 │ logits │ 3.34e-05 │ 1.000000 │ same  │ pass
+ onnx-fp16               │ logits │ 1.05e-01 │ 0.999952 │ same  │ pass
+ onnx-int8               │ logits │ 1.27e-01 │ 0.999933 │ same  │ pass
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `export SOURCE` | Convert a model and write a bundle with `modelport.json`, labels, and golden data. |
+| `quantize BUNDLE` | Add `--fp16` and `--int8` ONNX variants and record how far each drifts. |
+| `verify BUNDLE` | Run every variant on the golden input and compare with the expected output. |
+| `pack BUNDLE` | Refresh sizes and hashes after manual edits and list unlisted files. |
+| `publish BUNDLE --hf org/name` | Upload to the Hugging Face Hub. Log in first with `hf auth login`. |
+| `inspect FILE` | Show inputs, outputs, and metadata of an `.onnx`, `.pte`, or `.gguf` file. |
+| `validate MANIFEST...` | Check manifests against the spec. |
+| `schema` | Print the manifest JSON Schema. |
+| `doctor` | Check Python, optional packages, and disk space. |
+
+## Sources
+
+| Source | Example |
+|---|---|
+| torchvision classifier | `torchvision:efficientnet_b0` |
+| Hugging Face image classifier | `hf:facebook/deit-tiny-patch16-224` |
+| Your own model | `file:my_model.py:build` |
+
+For `file:`, write a function that returns a `SourceModel`:
+
+```python
+import torch
+from modelport.manifest import DType, ImagePreprocess, InputSpec, ResizeSpec, Task
+from modelport.sources import SourceModel
+
+
+def build() -> SourceModel:
+    net = MyNet()
+    net.load_state_dict(torch.load("weights.pt", weights_only=True))
+    return SourceModel(
+        module=net.eval(),
+        example_inputs=(torch.zeros(1, 3, 224, 224),),
+        id="my_net",
+        task=Task.IMAGE_CLASSIFICATION,
+        license="MIT",
+        inputs=[
+            InputSpec(
+                name="pixel_values",
+                dtype=DType.FLOAT32,
+                shape=[1, 3, 224, 224],
+                layout="NCHW",
+                preprocess=ImagePreprocess(resize=ResizeSpec(size=(224, 224))),
+            )
+        ],
+        output_names=["logits"],
+        labels=["cat", "dog"],
+    )
+```
+
+`file:` runs the code in that file, so only use files you trust.
+
+## Notes on quantization
+
+- `--fp16` halves the size and keeps inputs and outputs in float32.
+- `--int8` quantizes only MatMul and Gemm weights. Dynamic int8 on convolutions changed MobileNetV3's top-1 class in testing, so convolution-heavy models shrink less. Transformers shrink to about a third.
+- Each new variant gets a tolerance of twice its measured error, so devices are checked against a realistic bar.

modelport_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+modelport/__init__.py,sha256=6pDHHCifeMBbty1n-8CVWnv7hpqG75oK_H4gsqGMsmA,73
+modelport/bundle.py,sha256=VjkKeBwDQfyNGLzsUk-NlkoN3iXlhlXBAG5AG9aCaN4,3278
+modelport/cli.py,sha256=jfhfcqzl3RdVkimipNKnQy6mdeKrdiWmKW4ZEJrq_do,19994
+modelport/doctor.py,sha256=Xqt6tz9QdxIvMmrtntBTMmK2o0iKil1PmvzuZ9h7QCk,2633
+modelport/errors.py,sha256=8M2nQDETQT2P_zghN-3zeLCBpSA60asB0xJIrHzD8pY,562
+modelport/gguf_import.py,sha256=bF3R8zvzBZoFqyBrXEpjEMOzCVwXPtREcVxFOk31KZM,6807
+modelport/golden.py,sha256=zFPcD-MYSMmJcJAa9Sh6lwN8P1D8oXrerY4D5cCRXNo,4161
+modelport/hashing.py,sha256=fIIZ_XNK1neFFjbxRKheZ6hwTY-pFuYpC0FG_1t3-Go,411
+modelport/pack.py,sha256=yRYfslaBLEBoBynzvFeFVUUShblx5EGj_LqIiA0vdiA,1682
+modelport/pipeline.py,sha256=HdzUS3xdleY-Zxe3mkNPTaib5E_Oo72RbVoFVKW6cqs,3787
+modelport/preprocess.py,sha256=NzZOD-4cgdx8uBFEBnMPNCTz4zS5BzO-Li3vlwxszHY,5114
+modelport/publish.py,sha256=7YzEbt3uZHU119-5M4IMY-99pMPSTi2JffDwCJ0aaCE,6853
+modelport/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modelport/quantize.py,sha256=E1mBOlIBaE64uNF-kcCWzN_lJbC-5LGreT6kBZ-cZkE,4779
+modelport/runtimes.py,sha256=wAd_-I1e_8XyyWow4KPJi1I2wWUcnMpSdjGAEFrbEJA,2211
+modelport/verify.py,sha256=GMvXQr0RwSSEgjcZOOOX7cjrb_gkqXJk-I401OJGEZ8,3184
+modelport/codegen/__init__.py,sha256=DjDmljKF8DEeHiIJyuW72xARY2ipZ57u_JpHZ1SvTpc,38
+modelport/codegen/dart.py,sha256=DsGA4jXZxkxBKnBnOt1rk3gCdZnNfsgCY_BnbRMBe00,7036
+modelport/exporters/__init__.py,sha256=l7eLwe-YGqYbkQGFusVGWAdEXFkz1CLQNJNalM-ipMU,1488
+modelport/exporters/executorch.py,sha256=Oeyw6zE4Me9X5jYEquhptoeZBNpgZ8OesS130-ZWeyQ,1744
+modelport/exporters/onnx.py,sha256=c9QeMZhloWVIJITkX5G3lG5pHJREheXYgpfDal9TLf8,2429
+modelport/inspection/__init__.py,sha256=AgOK7o-dub3uX18fmCbNtL6B4eLTUhwNCh048erxhAU,2263
+modelport/inspection/executorch.py,sha256=uGytgcUAq2hmV-MHXWPkgrfIoTynoYgnoPg31sW96Ho,1385
+modelport/inspection/gguf.py,sha256=wWHj-Wcf3_ty_xzcNYXMMDYJMBdYcE6_0y9L5dgz1Ww,1362
+modelport/inspection/onnx.py,sha256=sM9KDxNOLtoW6v_YfiUUydjWqGY2vAVB0uzAm0VAXRs,1791
+modelport/manifest/__init__.py,sha256=9AHphUN9Xn_VOZivTYqQs1N7ZF7op6i2sHdr6R_EXOQ,841
+modelport/manifest/base.py,sha256=f7iLoqm-ZRN1Y9HciAnAXREHaaiC3QmD_wzg-uAWpUA,586
+modelport/manifest/files.py,sha256=RQ7cD3ox1s2loYqrFZlalCjy-lwrfJMYQZDAtmK8tII,2150
+modelport/manifest/models.py,sha256=-ibROqatIlHeGusZ7cNSsuQAeiMY9YXq4qd4UxN-JDs,9394
+modelport/manifest/postprocess.py,sha256=9Pm0QtycS3XP-fFqLl-m4wZ0DAfeq3lm4HXRQYJJzNs,3046
+modelport/manifest/schema.py,sha256=Tw_Few0kpkWCdnNJwafPSHp5B-xvGWXEten6D-WhxZg,1586
+modelport/manifest/tensors.py,sha256=aT6Rq80Q9h7zT1oKSWSFMVo-tjg5XTLle2ysh8XT5zc,5776
+modelport/sources/__init__.py,sha256=rPRFaB1XhxCG79Nc11_XW_D86sfmH-zFEidbqCPkPc0,2700
+modelport/sources/file.py,sha256=kxaYd5aC2QzskrOLX6fsffOT-4_oX_5qs8xJrcUD7wU,1672
+modelport/sources/hf.py,sha256=kPhIY9KbAdgv_tNc2dDBfgJxQ2ieBKFf3z12osEzQiI,10536
+modelport/sources/torchvision.py,sha256=wFxfoRY2POeyoY7YSy1TCEnQa1Q_T00Lo16IW_kfQ_Y,2735
+modelport_cli-0.1.0.dist-info/METADATA,sha256=rDUkuPZxeU5yb0kKNtaQcs-TirKElIMe6Yte76EJVw0,6406
+modelport_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+modelport_cli-0.1.0.dist-info/entry_points.txt,sha256=63cpIl0-7KbhdI3Q24NDPfW9jW68A_wIhV1cLPy_p9E,48
+modelport_cli-0.1.0.dist-info/licenses/LICENSE,sha256=yVuuHRzgI17MzTVgt3LsHvuX80innw--CmNPDCzO_iw,11358
+modelport_cli-0.1.0.dist-info/RECORD,,

modelport_cli-0.1.0.dist-info/WHEEL

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

modelport_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+modelport = modelport.cli:app