tinyedge 0.1.0__tar.gz

tinyedge-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lienert De Maeyer / TinyEdge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tinyedge-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: tinyedge
+Version: 0.1.0
+Summary: Benchmark your models (latency + accuracy) on real edge devices — SDK + tinydevice CLI
+Author: Lienert De Maeyer
+License: MIT License
+        
+        Copyright (c) 2026 Lienert De Maeyer / TinyEdge
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://tinyedge.ai
+Project-URL: Documentation, https://tinyedge.ai
+Keywords: edge,benchmark,onnx,inference,embedded,latency,accuracy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Dynamic: license-file
+
+# tinyedge — the Python SDK
+
+Benchmark your models on **real edge devices** from inside any Python pipeline, notebook
+or CI job. PyTorch (or any framework) stays on your machine — the SDK converts what you
+give it into the platform's wire formats (ONNX + labeled image archive) and real hardware
+does the measuring.
+
+```bash
+pip install git+https://github.com/lienertdemaeyer/tinyedge-agent#subdirectory=sdk
+export TINYEDGE_API_KEY=tinyedge_sk_…        # TinyEdge console → New benchmark
+```
+
+## In a PyTorch pipeline
+
+```python
+import tinyedge
+
+client = tinyedge.TinyEdge()
+
+result = client.benchmark(
+    model,                       # a live nn.Module (auto-exported to ONNX) or "model.onnx"
+    devices=["oppo-a74"],        # or ["jetson-orin-nano:tensorrt", "raspberry-pi-5"]
+    dataset=raw_test_set,        # torch Dataset of (image, label) — UNtransformed,
+                                 # or a folder ("./testset"), or an archive (".zip/.tar.gz")
+    precision="fp32",
+)
+
+print(result)                    # <BenchmarkResult oppo-a74 completed p50=56.6ms top1=83.3%>
+print(result.latency_ms_p50, result.accuracy_top1)
+```
+
+Notes that make this work well:
+
+- **Pass the dataset without transforms.** Preprocessing (resize/crop/normalize) is part of
+  the standardized job spec and runs on-device — that's what makes accuracy comparable
+  across devices instead of depending on whatever transform happened to run on your laptop.
+- **Labels are class indices.** Folder names / integer labels map directly to your model's
+  output indices (`207/` = output neuron 207).
+- A custom `example_input` controls the ONNX export shape:
+  `client.benchmark(model, ..., example_input=torch.randn(1, 3, 320, 320))`.
+
+## As a CI gate (pytest)
+
+Fail the build when the model regresses **on the hardware you ship on**:
+
+```python
+# test_edge_performance.py
+import tinyedge
+
+def test_detector_meets_edge_budget():
+    client = tinyedge.TinyEdge()
+    result = client.benchmark("artifacts/model.onnx",
+                              devices=["jetson-orin-nano"],
+                              dataset="testdata/eval_set.tar.gz")
+    result.assert_latency(max_ms=50)
+    result.assert_accuracy(min_top1=0.80)
+```
+
+`assert_*` raise `AssertionError` with a readable message, so any test runner (pytest,
+unittest, GitHub Actions) reports it natively.
+
+## Async style
+
+```python
+jobs = client.benchmark(model, devices=["oppo-a74", "raspberry-pi-5"], wait=False)
+# … do other work …
+for j in jobs:
+    print(client.get(j.id))
+```
+
+## What runs where
+
+| Your machine (SDK) | TinyEdge platform | The device (agent) |
+| --- | --- | --- |
+| torch → ONNX export | stores artifacts, queues job | downloads ONNX + images |
+| dataset → image archive | tracks pending/running | runs inference, computes accuracy |
+| poll / asserts | stores the report | uploads metrics only |

tinyedge-0.1.0/README.md

@@ -0,0 +1,77 @@
+# tinyedge — the Python SDK
+
+Benchmark your models on **real edge devices** from inside any Python pipeline, notebook
+or CI job. PyTorch (or any framework) stays on your machine — the SDK converts what you
+give it into the platform's wire formats (ONNX + labeled image archive) and real hardware
+does the measuring.
+
+```bash
+pip install git+https://github.com/lienertdemaeyer/tinyedge-agent#subdirectory=sdk
+export TINYEDGE_API_KEY=tinyedge_sk_…        # TinyEdge console → New benchmark
+```
+
+## In a PyTorch pipeline
+
+```python
+import tinyedge
+
+client = tinyedge.TinyEdge()
+
+result = client.benchmark(
+    model,                       # a live nn.Module (auto-exported to ONNX) or "model.onnx"
+    devices=["oppo-a74"],        # or ["jetson-orin-nano:tensorrt", "raspberry-pi-5"]
+    dataset=raw_test_set,        # torch Dataset of (image, label) — UNtransformed,
+                                 # or a folder ("./testset"), or an archive (".zip/.tar.gz")
+    precision="fp32",
+)
+
+print(result)                    # <BenchmarkResult oppo-a74 completed p50=56.6ms top1=83.3%>
+print(result.latency_ms_p50, result.accuracy_top1)
+```
+
+Notes that make this work well:
+
+- **Pass the dataset without transforms.** Preprocessing (resize/crop/normalize) is part of
+  the standardized job spec and runs on-device — that's what makes accuracy comparable
+  across devices instead of depending on whatever transform happened to run on your laptop.
+- **Labels are class indices.** Folder names / integer labels map directly to your model's
+  output indices (`207/` = output neuron 207).
+- A custom `example_input` controls the ONNX export shape:
+  `client.benchmark(model, ..., example_input=torch.randn(1, 3, 320, 320))`.
+
+## As a CI gate (pytest)
+
+Fail the build when the model regresses **on the hardware you ship on**:
+
+```python
+# test_edge_performance.py
+import tinyedge
+
+def test_detector_meets_edge_budget():
+    client = tinyedge.TinyEdge()
+    result = client.benchmark("artifacts/model.onnx",
+                              devices=["jetson-orin-nano"],
+                              dataset="testdata/eval_set.tar.gz")
+    result.assert_latency(max_ms=50)
+    result.assert_accuracy(min_top1=0.80)
+```
+
+`assert_*` raise `AssertionError` with a readable message, so any test runner (pytest,
+unittest, GitHub Actions) reports it natively.
+
+## Async style
+
+```python
+jobs = client.benchmark(model, devices=["oppo-a74", "raspberry-pi-5"], wait=False)
+# … do other work …
+for j in jobs:
+    print(client.get(j.id))
+```
+
+## What runs where
+
+| Your machine (SDK) | TinyEdge platform | The device (agent) |
+| --- | --- | --- |
+| torch → ONNX export | stores artifacts, queues job | downloads ONNX + images |
+| dataset → image archive | tracks pending/running | runs inference, computes accuracy |
+| poll / asserts | stores the report | uploads metrics only |

tinyedge-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tinyedge"
+version = "0.1.0"
+description = "Benchmark your models (latency + accuracy) on real edge devices — SDK + tinydevice CLI"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Lienert De Maeyer" }]
+requires-python = ">=3.10"
+dependencies = ["requests>=2.31"]
+# PyTorch integration is optional and lazy — `pip install torch` only if you pass
+# nn.Modules / torch Datasets. Plain ONNX paths + image folders need nothing extra.
+keywords = ["edge", "benchmark", "onnx", "inference", "embedded", "latency", "accuracy"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://tinyedge.ai"
+Documentation = "https://tinyedge.ai"
+
+[project.scripts]
+tinydevice = "tinyedge.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["tinyedge*"]

tinyedge-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tinyedge-0.1.0/tinyedge/__init__.py

@@ -0,0 +1,12 @@
+"""TinyEdge SDK — run your models on real edge devices from any Python pipeline.
+
+    import tinyedge
+    client = tinyedge.TinyEdge()          # TINYEDGE_API_KEY from env
+    result = client.benchmark(model, devices=["oppo-a74"], dataset="./testset")
+    result.assert_accuracy(min_top1=0.8)
+"""
+
+from .client import BenchmarkResult, TinyEdge
+
+__version__ = "0.1.0"
+__all__ = ["TinyEdge", "BenchmarkResult"]

tinyedge-0.1.0/tinyedge/cli.py

@@ -0,0 +1,108 @@
+"""tinydevice — the TinyEdge CLI, shipped inside the `tinyedge` package.
+
+  export TINYEDGE_API_KEY=tinyedge_sk_…
+  tinydevice run model.onnx --device oppo-a74 --dataset ./testset.zip --watch
+  tinydevice list
+  tinydevice status <job-id>
+"""
+
+import argparse
+import json
+import sys
+
+from . import __version__
+from .client import BenchmarkResult, TinyEdge
+
+ICON = {"pending": "⏳", "running": "⚙ ", "completed": "✓ ", "failed": "✗ "}
+
+
+def _print(b: BenchmarkResult) -> None:
+    line = f"{ICON.get(b.status, '· ')} {b.id[:8]}  {b.status:<9}  {b.device}"
+    if b.runtime:
+        line += f" · {b.runtime}"
+    if b.status == "completed":
+        line += f"  — p50 {b.latency_ms_p50} ms · {b.throughput_per_s}/s"
+        if b.accuracy_top1 is not None:
+            line += f" · top-1 {b.accuracy_top1 * 100:.1f}%"
+    if b.status == "failed" and b.error:
+        line += f"  — {b.error}"
+    print(line)
+
+
+def _client(args) -> TinyEdge:
+    return TinyEdge(api_key=args.key or None, api_base=args.api or None)
+
+
+def cmd_run(args) -> None:
+    client = _client(args)
+    results = client.benchmark(
+        model=args.model,
+        model_id=args.model_id,
+        devices=args.device,
+        dataset=args.dataset,
+        dataset_id=args.dataset_id,
+        runtime=args.runtime,
+        precision=args.precision,
+        batch_size=args.batch,
+        wait=args.watch,
+    )
+    for b in results if isinstance(results, list) else [results]:
+        _print(b)
+    if not args.watch:
+        print("Track at https://tinyedge.ai/dashboard/benchmarks")
+
+
+def cmd_status(args) -> None:
+    b = _client(args).get(args.job_id)
+    if args.json:
+        json.dump(b.raw, sys.stdout, indent=2)
+        print()
+    else:
+        _print(b)
+
+
+def cmd_list(args) -> None:
+    for b in _client(args).list_benchmarks(limit=args.limit):
+        _print(b)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(prog="tinydevice", description=__doc__)
+    ap.add_argument("--version", action="version", version=__version__)
+    ap.add_argument("--api", default=None, help="API base (default https://tinyedge.ai/api)")
+    ap.add_argument("--key", default=None, help="API key (or env TINYEDGE_API_KEY)")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    run = sub.add_parser("run", help="upload + queue a benchmark on real devices")
+    run.add_argument("model", nargs="?", help="path to model file (or use --model-id)")
+    run.add_argument("--model-id", default=None, help="id of an already-uploaded model")
+    run.add_argument("--device", action="append", required=True,
+                     help="device id, repeatable; ':runtime' suffix ok (oppo-a74:onnxruntime)")
+    run.add_argument("--runtime", default=None)
+    run.add_argument("--precision", default="fp32", choices=["fp32", "fp16", "int8", "int4"])
+    run.add_argument("--batch", type=int, default=1)
+    run.add_argument("--dataset", default=None,
+                     help="labeled test set: folder or .zip/.tar.gz (for on-device accuracy)")
+    run.add_argument("--dataset-id", default=None)
+    run.add_argument("--watch", action="store_true", help="wait and print results")
+    run.set_defaults(fn=cmd_run)
+
+    st = sub.add_parser("status", help="show one job")
+    st.add_argument("job_id")
+    st.add_argument("--json", action="store_true")
+    st.set_defaults(fn=cmd_status)
+
+    ls = sub.add_parser("list", help="list recent jobs")
+    ls.add_argument("--limit", type=int, default=20)
+    ls.set_defaults(fn=cmd_list)
+
+    args = ap.parse_args()
+    try:
+        args.fn(args)
+    except Exception as e:  # noqa: BLE001 — clean CLI errors, no tracebacks
+        print(f"error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tinyedge-0.1.0/tinyedge/client.py

@@ -0,0 +1,322 @@
+"""TinyEdge client: model/dataset intake from Python objects → real-device jobs.
+
+Design rule: PyTorch (or any framework) stays on the developer's machine. The SDK
+converts whatever it's given into the platform's wire formats — ONNX file + labeled
+imagefolder archive — and the device only ever sees those.
+"""
+
+from __future__ import annotations
+
+import os
+import tarfile
+import tempfile
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import requests
+
+DEFAULT_API = "https://tinyedge.ai/api"
+ARCHIVE_EXTS = (".zip", ".tar", ".tar.gz", ".tgz", ".gz")
+
+
+class TinyEdgeError(RuntimeError):
+    pass
+
+
+@dataclass
+class BenchmarkResult:
+    """One device run. Raw platform record in `.raw`."""
+
+    id: str
+    device: str
+    runtime: str | None
+    status: str  # pending | running | completed | failed
+    latency_ms_p50: float | None = None
+    throughput_per_s: float | None = None
+    accuracy_top1: float | None = None
+    error: str | None = None
+    raw: dict = field(default_factory=dict)
+
+    # ---- CI helpers: fail the build when the model regresses on real hardware ----
+    def assert_completed(self) -> "BenchmarkResult":
+        if self.status != "completed":
+            raise AssertionError(f"[tinyedge] job {self.id[:8]} on {self.device} is "
+                                 f"{self.status}: {self.error or 'no result'}")
+        return self
+
+    def assert_latency(self, max_ms: float) -> "BenchmarkResult":
+        self.assert_completed()
+        if self.latency_ms_p50 is None or self.latency_ms_p50 > max_ms:
+            raise AssertionError(
+                f"[tinyedge] {self.device}: p50 latency {self.latency_ms_p50} ms "
+                f"exceeds budget {max_ms} ms"
+            )
+        return self
+
+    def assert_accuracy(self, min_top1: float) -> "BenchmarkResult":
+        self.assert_completed()
+        if self.accuracy_top1 is None:
+            raise AssertionError(
+                f"[tinyedge] {self.device}: no accuracy measured — attach a dataset"
+            )
+        if self.accuracy_top1 < min_top1:
+            raise AssertionError(
+                f"[tinyedge] {self.device}: on-device top-1 {self.accuracy_top1:.3f} "
+                f"below required {min_top1:.3f}"
+            )
+        return self
+
+    def __repr__(self) -> str:  # readable in notebooks/logs
+        bits = [f"{self.device}", self.status]
+        if self.latency_ms_p50 is not None:
+            bits.append(f"p50={self.latency_ms_p50}ms")
+        if self.accuracy_top1 is not None:
+            bits.append(f"top1={self.accuracy_top1:.1%}")
+        if self.error:
+            bits.append(f"error={self.error!r}")
+        return f"<BenchmarkResult {' '.join(bits)}>"
+
+
+def _from_record(b: dict) -> BenchmarkResult:
+    return BenchmarkResult(
+        id=b["id"],
+        device=b["device"],
+        runtime=b.get("runtime"),
+        status=b["status"],
+        latency_ms_p50=b.get("latencyMs") or None,
+        throughput_per_s=b.get("throughput") or None,
+        accuracy_top1=b.get("accuracy"),
+        error=b.get("error"),
+        raw=b,
+    )
+
+
+class TinyEdge:
+    def __init__(self, api_key: str | None = None, api_base: str | None = None):
+        self.api_key = api_key or os.environ.get("TINYEDGE_API_KEY")
+        if not self.api_key:
+            raise TinyEdgeError(
+                "No API key. Pass TinyEdge(api_key=…) or set TINYEDGE_API_KEY "
+                "(find yours in the TinyEdge console → New benchmark)."
+            )
+        self.base = (api_base or os.environ.get("TINYEDGE_API", DEFAULT_API)).rstrip("/")
+        self._s = requests.Session()
+        self._s.headers["Authorization"] = f"Bearer {self.api_key}"
+
+    # ---- HTTP ----------------------------------------------------------------
+    def _check(self, r: requests.Response) -> dict:
+        if r.status_code >= 400:
+            try:
+                msg = r.json().get("error", r.text)
+            except Exception:  # noqa: BLE001
+                msg = r.text
+            raise TinyEdgeError(f"API {r.status_code}: {msg}")
+        return r.json()
+
+    def _upload(self, kind: str, field_name: str, path: Path) -> dict:
+        with open(path, "rb") as f:
+            r = self._s.post(
+                f"{self.base}/{kind}/upload",
+                files={field_name: (path.name, f)},
+                timeout=900,
+            )
+        return self._check(r)[field_name]
+
+    # ---- Model intake ----------------------------------------------------------
+    def upload_model(self, model, example_input=None, name: str = "model.onnx") -> str:
+        """Accepts a path to a model file, or a live torch.nn.Module (exported to
+        ONNX automatically). Returns the platform model id."""
+        if isinstance(model, (str, Path)):
+            p = Path(model).expanduser()
+            if not p.exists():
+                raise TinyEdgeError(f"Model file not found: {p}")
+            return self._upload("models", "model", p)["id"]
+
+        # Live PyTorch module → ONNX (torch stays on YOUR machine, never the device).
+        try:
+            import torch
+        except ImportError:
+            raise TinyEdgeError(
+                f"Can't handle model of type {type(model).__name__}: pass a file path, "
+                "or install torch to pass an nn.Module."
+            ) from None
+        if not isinstance(model, torch.nn.Module):
+            raise TinyEdgeError(f"Unsupported model type: {type(model).__name__}")
+
+        if example_input is None:
+            example_input = torch.randn(1, 3, 224, 224)
+        tmp = Path(tempfile.mkdtemp(prefix="tinyedge-")) / name
+        model = model.eval()
+        torch.onnx.export(
+            model,
+            example_input,
+            str(tmp),
+            input_names=["input"],
+            output_names=["output"],
+            dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}},
+        )
+        return self._upload("models", "model", tmp)["id"]
+
+    # ---- Dataset intake --------------------------------------------------------
+    def upload_dataset(self, dataset, limit: int = 500) -> str:
+        """Accepts an archive path, an imagefolder directory (auto-archived), or an
+        iterable / torch Dataset of (image, label) pairs (materialized; labels become
+        class-index folders). Returns the platform dataset id."""
+        if isinstance(dataset, (str, Path)):
+            p = Path(dataset).expanduser()
+            if p.is_file() and p.name.endswith(ARCHIVE_EXTS):
+                return self._upload("datasets", "dataset", p)["id"]
+            if p.is_dir():
+                return self._upload("datasets", "dataset", self._archive_dir(p))["id"]
+            raise TinyEdgeError(f"Dataset not found (need folder or archive): {p}")
+
+        # Iterable of (image, int label) — e.g. a torch Dataset WITHOUT transforms.
+        return self._upload("datasets", "dataset", self._materialize(dataset, limit))["id"]
+
+    @staticmethod
+    def _archive_dir(folder: Path) -> Path:
+        out = Path(tempfile.mkdtemp(prefix="tinyedge-")) / f"{folder.name}.tar.gz"
+        with tarfile.open(out, "w:gz") as tar:
+            for child in sorted(folder.iterdir()):
+                tar.add(child, arcname=child.name)
+        return out
+
+    @staticmethod
+    def _materialize(items, limit: int) -> Path:
+        """Write (image, label) pairs to <label>/<i>.png folders and archive them.
+        Pass images UN-transformed — on-device preprocessing is standardized by the
+        job spec, which is what makes accuracy comparable across devices."""
+        try:
+            from PIL import Image
+        except ImportError:
+            raise TinyEdgeError("Materializing a dataset requires pillow (pip install pillow).") from None
+
+        root = Path(tempfile.mkdtemp(prefix="tinyedge-")) / "dataset"
+        n = 0
+        for img, label in items:
+            if n >= limit:
+                break
+            pil = _to_pil(img, Image)
+            d = root / str(int(label))
+            d.mkdir(parents=True, exist_ok=True)
+            pil.save(d / f"{n:05d}.png")
+            n += 1
+        if n == 0:
+            raise TinyEdgeError("Dataset yielded no (image, label) samples.")
+        return TinyEdge._archive_dir(root)
+
+    # ---- The one-call API --------------------------------------------------------
+    def benchmark(
+        self,
+        model=None,
+        devices: list[str] | str = (),
+        dataset=None,
+        runtime: str | None = None,
+        precision: str = "fp32",
+        batch_size: int = 1,
+        example_input=None,
+        wait: bool = True,
+        timeout: float = 900,
+        poll_interval: float = 3,
+        dataset_limit: int = 500,
+        model_id: str | None = None,
+        dataset_id: str | None = None,
+    ):
+        """Upload model (+ dataset), queue one job per device, optionally wait.
+
+        devices: ["oppo-a74", "jetson-orin-nano:tensorrt"] — ':runtime' overrides.
+        Pass model_id/dataset_id to reuse already-uploaded artifacts.
+        Returns a BenchmarkResult (single device) or list of them.
+        """
+        single = isinstance(devices, str)
+        device_list = [devices] if single else list(devices)
+        if not device_list:
+            raise TinyEdgeError("Pass at least one device, e.g. devices=['oppo-a74']")
+
+        if model_id is None:
+            if model is None:
+                raise TinyEdgeError("Pass a model (path / nn.Module) or model_id=…")
+            model_id = self.upload_model(model, example_input=example_input)
+        if dataset_id is None and dataset is not None:
+            dataset_id = self.upload_dataset(dataset, limit=dataset_limit)
+
+        jobs = []
+        for spec in device_list:
+            dev, _, rt = spec.partition(":")
+            payload = {
+                "mode": "device",
+                "device": dev,
+                "runtime": rt or runtime,
+                "precision": precision,
+                "batchSize": batch_size,
+                "modelId": model_id,
+                "datasetId": dataset_id,
+            }
+            r = self._check(self._s.post(f"{self.base}/benchmarks", json=payload, timeout=60))
+            jobs.append(_from_record(r["benchmark"]))
+
+        if wait:
+            jobs = self._wait(jobs, timeout=timeout, poll_interval=poll_interval)
+        return jobs[0] if single else jobs
+
+    def get(self, job_id: str) -> BenchmarkResult:
+        r = self._check(self._s.get(f"{self.base}/benchmarks/{job_id}", timeout=30))
+        return _from_record(r["benchmark"])
+
+    def list_benchmarks(self, limit: int = 20) -> list[BenchmarkResult]:
+        r = self._check(self._s.get(f"{self.base}/benchmarks", timeout=30))
+        return [_from_record(b) for b in r["benchmarks"][:limit]]
+
+    def _wait(self, jobs, timeout: float, poll_interval: float):
+        deadline = time.time() + timeout
+        done: dict[str, BenchmarkResult] = {}
+        while len(done) < len(jobs):
+            if time.time() > deadline:
+                raise TinyEdgeError(
+                    f"Timed out after {timeout}s waiting for "
+                    f"{[j.id[:8] for j in jobs if j.id not in done]} — is the device's "
+                    "agent running? (tinyedge-agent daemon --device <id>)"
+                )
+            for j in jobs:
+                if j.id in done:
+                    continue
+                cur = self.get(j.id)
+                if cur.status in ("completed", "failed"):
+                    done[j.id] = cur
+            if len(done) < len(jobs):
+                time.sleep(poll_interval)
+        return [done[j.id] for j in jobs]
+
+
+def _to_pil(img, Image):
+    """Best-effort conversion of common pipeline image types to PIL."""
+    if isinstance(img, Image.Image):
+        return img.convert("RGB")
+    if isinstance(img, (str, Path)):
+        return Image.open(img).convert("RGB")
+    # numpy HWC uint8 / torch CHW float tensor
+    try:
+        import numpy as np
+
+        if hasattr(img, "detach"):  # torch tensor
+            t = img.detach().cpu()
+            arr = t.numpy()
+            if arr.ndim == 3 and arr.shape[0] in (1, 3):  # CHW → HWC
+                arr = arr.transpose(1, 2, 0)
+            if arr.dtype != np.uint8:
+                arr = (arr.clip(0, 1) * 255).astype(np.uint8)
+            if arr.shape[-1] == 1:
+                arr = arr.repeat(3, axis=-1)
+            return Image.fromarray(arr).convert("RGB")
+        if isinstance(img, np.ndarray):
+            arr = img
+            if arr.dtype != np.uint8:
+                arr = (arr.clip(0, 1) * 255).astype(np.uint8)
+            return Image.fromarray(arr).convert("RGB")
+    except ImportError:
+        pass
+    raise TinyEdgeError(
+        f"Can't convert image of type {type(img).__name__} — yield PIL images, "
+        "file paths, numpy arrays or torch tensors."
+    )

tinyedge-0.1.0/tinyedge.egg-info/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: tinyedge
+Version: 0.1.0
+Summary: Benchmark your models (latency + accuracy) on real edge devices — SDK + tinydevice CLI
+Author: Lienert De Maeyer
+License: MIT License
+        
+        Copyright (c) 2026 Lienert De Maeyer / TinyEdge
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://tinyedge.ai
+Project-URL: Documentation, https://tinyedge.ai
+Keywords: edge,benchmark,onnx,inference,embedded,latency,accuracy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Dynamic: license-file
+
+# tinyedge — the Python SDK
+
+Benchmark your models on **real edge devices** from inside any Python pipeline, notebook
+or CI job. PyTorch (or any framework) stays on your machine — the SDK converts what you
+give it into the platform's wire formats (ONNX + labeled image archive) and real hardware
+does the measuring.
+
+```bash
+pip install git+https://github.com/lienertdemaeyer/tinyedge-agent#subdirectory=sdk
+export TINYEDGE_API_KEY=tinyedge_sk_…        # TinyEdge console → New benchmark
+```
+
+## In a PyTorch pipeline
+
+```python
+import tinyedge
+
+client = tinyedge.TinyEdge()
+
+result = client.benchmark(
+    model,                       # a live nn.Module (auto-exported to ONNX) or "model.onnx"
+    devices=["oppo-a74"],        # or ["jetson-orin-nano:tensorrt", "raspberry-pi-5"]
+    dataset=raw_test_set,        # torch Dataset of (image, label) — UNtransformed,
+                                 # or a folder ("./testset"), or an archive (".zip/.tar.gz")
+    precision="fp32",
+)
+
+print(result)                    # <BenchmarkResult oppo-a74 completed p50=56.6ms top1=83.3%>
+print(result.latency_ms_p50, result.accuracy_top1)
+```
+
+Notes that make this work well:
+
+- **Pass the dataset without transforms.** Preprocessing (resize/crop/normalize) is part of
+  the standardized job spec and runs on-device — that's what makes accuracy comparable
+  across devices instead of depending on whatever transform happened to run on your laptop.
+- **Labels are class indices.** Folder names / integer labels map directly to your model's
+  output indices (`207/` = output neuron 207).
+- A custom `example_input` controls the ONNX export shape:
+  `client.benchmark(model, ..., example_input=torch.randn(1, 3, 320, 320))`.
+
+## As a CI gate (pytest)
+
+Fail the build when the model regresses **on the hardware you ship on**:
+
+```python
+# test_edge_performance.py
+import tinyedge
+
+def test_detector_meets_edge_budget():
+    client = tinyedge.TinyEdge()
+    result = client.benchmark("artifacts/model.onnx",
+                              devices=["jetson-orin-nano"],
+                              dataset="testdata/eval_set.tar.gz")
+    result.assert_latency(max_ms=50)
+    result.assert_accuracy(min_top1=0.80)
+```
+
+`assert_*` raise `AssertionError` with a readable message, so any test runner (pytest,
+unittest, GitHub Actions) reports it natively.
+
+## Async style
+
+```python
+jobs = client.benchmark(model, devices=["oppo-a74", "raspberry-pi-5"], wait=False)
+# … do other work …
+for j in jobs:
+    print(client.get(j.id))
+```
+
+## What runs where
+
+| Your machine (SDK) | TinyEdge platform | The device (agent) |
+| --- | --- | --- |
+| torch → ONNX export | stores artifacts, queues job | downloads ONNX + images |
+| dataset → image archive | tracks pending/running | runs inference, computes accuracy |
+| poll / asserts | stores the report | uploads metrics only |

tinyedge-0.1.0/tinyedge.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+tinyedge/__init__.py
+tinyedge/cli.py
+tinyedge/client.py
+tinyedge.egg-info/PKG-INFO
+tinyedge.egg-info/SOURCES.txt
+tinyedge.egg-info/dependency_links.txt
+tinyedge.egg-info/entry_points.txt
+tinyedge.egg-info/requires.txt
+tinyedge.egg-info/top_level.txt

tinyedge-0.1.0/tinyedge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tinyedge-0.1.0/tinyedge.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tinydevice = tinyedge.cli:main

tinyedge-0.1.0/tinyedge.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.31

tinyedge-0.1.0/tinyedge.egg-info/top_level.txt

@@ -0,0 +1 @@
+tinyedge