fleetml 0.6.0__py3-none-any.whl

fleetml/__init__.py

@@ -0,0 +1,44 @@
+"""FleetML client: push models and run rollouts on a FleetML server from Python.
+
+The library speaks the server's REST API, the same API the ``fleetml`` CLI uses,
+with the same words: projects, models, versions, push, enrollment keys,
+deployments, devices, telemetry, experiments and drift.
+"""
+
+from fleetml.client import TERMINAL_DEPLOYMENT_STATUSES, FleetML
+from fleetml.errors import FleetMLError
+from fleetml.types import (
+    ArmResult,
+    Deployment,
+    Device,
+    DriftResult,
+    EnrollmentKey,
+    Experiment,
+    ExperimentResults,
+    Model,
+    Project,
+    TelemetrySummary,
+    Version,
+)
+
+# The package version: the single place it is set (pyproject.toml reads it),
+# equal to the FleetML release it ships with.
+__version__ = "0.6.0"
+
+__all__ = [
+    "TERMINAL_DEPLOYMENT_STATUSES",
+    "ArmResult",
+    "Deployment",
+    "Device",
+    "DriftResult",
+    "EnrollmentKey",
+    "Experiment",
+    "ExperimentResults",
+    "FleetML",
+    "FleetMLError",
+    "Model",
+    "Project",
+    "TelemetrySummary",
+    "Version",
+    "__version__",
+]

fleetml/client.py

@@ -0,0 +1,377 @@
+"""The FleetML client."""
+
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import os
+import time
+from typing import Any, Collection, Dict, List, Mapping, Optional, Sequence, Union
+
+import httpx
+
+from fleetml.errors import FleetMLError
+from fleetml.types import (
+    Deployment,
+    Device,
+    DriftResult,
+    EnrollmentKey,
+    Experiment,
+    ExperimentResults,
+    Model,
+    Project,
+    TelemetrySummary,
+    Version,
+    from_list,
+)
+
+DEFAULT_SERVER = "http://localhost:18080"
+
+#: Deployment statuses after which a deployment no longer changes by itself.
+TERMINAL_DEPLOYMENT_STATUSES = frozenset({"COMPLETE", "ROLLED_BACK", "CANCELLED", "FAILED"})
+
+Json = Dict[str, Any]
+PathLike = Union[str, "os.PathLike[str]"]
+
+
+class FleetML:
+    """A client for a FleetML server's REST API.
+
+    ``server`` defaults to ``FLEETML_SERVER``, then ``http://localhost:18080``;
+    ``api_key`` (an admin API key, sent as ``Authorization: Bearer``) defaults
+    to ``FLEETML_API_KEY``. Every call raises :class:`FleetMLError` when the
+    server refuses it or cannot be reached. Use it as a context manager, or
+    call :meth:`close`.
+    """
+
+    def __init__(
+        self,
+        server: Optional[str] = None,
+        api_key: Optional[str] = None,
+        *,
+        timeout: float = 30.0,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        self.server = (server or os.environ.get("FLEETML_SERVER") or DEFAULT_SERVER).rstrip("/")
+        self._api_key = api_key if api_key is not None else os.environ.get("FLEETML_API_KEY", "")
+        self._http = httpx.Client(timeout=timeout, transport=transport)
+        self.projects = Projects(self)
+        self.models = Models(self)
+        self.versions = Versions(self)
+        self.enrollment_keys = EnrollmentKeys(self)
+        self.deployments = Deployments(self)
+        self.devices = Devices(self)
+        self.telemetry = Telemetry(self)
+        self.experiments = Experiments(self)
+        self.drift = Drift(self)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> FleetML:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"FleetML(server={self.server!r})"
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Optional[Mapping[str, Any]] = None,
+        params: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        """Calls ``/api/v1`` + path and returns the response's ``data``."""
+        headers = {"Authorization": f"Bearer {self._api_key}"} if self._api_key else {}
+        try:
+            resp = self._http.request(method, f"{self.server}/api/v1{path}", json=body, params=params, headers=headers)
+        except httpx.HTTPError as e:
+            raise FleetMLError(0, "UNAVAILABLE", f"server unavailable: {e}") from e
+        if resp.status_code == 204:
+            return None
+        try:
+            payload = resp.json()
+        except ValueError:
+            payload = None
+        if not isinstance(payload, dict):
+            if resp.is_error:
+                raise FleetMLError(resp.status_code, "HTTP_ERROR", resp.text[:500] or resp.reason_phrase)
+            raise FleetMLError(resp.status_code, "INVALID_RESPONSE", resp.text[:500])
+        err = payload.get("error")
+        if isinstance(err, dict) or resp.is_error:
+            err = err if isinstance(err, dict) else {}
+            code = str(err.get("code") or "HTTP_ERROR")
+            message = str(err.get("message") or resp.reason_phrase)
+            if resp.status_code == 401:
+                message += " (pass api_key= or set FLEETML_API_KEY to an admin API key)"
+            raise FleetMLError(resp.status_code, code, message)
+        return payload.get("data")
+
+    @staticmethod
+    def _page(limit: Optional[int], offset: Optional[int]) -> Json:
+        return {k: v for k, v in (("limit", limit), ("offset", offset)) if v is not None}
+
+    def push(
+        self,
+        path: PathLike,
+        project: str,
+        model: str,
+        version: str,
+        quantization: str = "INT8",
+        target_runtime: str = "TFLITE",
+        task: str = "CLASSIFICATION",
+        promote: bool = False,
+    ) -> Version:
+        """Uploads a model file as a variant of ``model`` ``version`` in
+        ``project``, like ``fleetml push``: it creates the model (with
+        ``target_runtime`` as its framework and ``task``) and the version if
+        they do not exist, declares the variant with the file's size and
+        sha256, uploads the file to the presigned URL (without the API key),
+        and asks the server to verify it. With ``promote`` the version is then
+        moved to STAGED and ACTIVE. Returns the version.
+        """
+        size = os.path.getsize(path)
+        digest = hashlib.sha256()
+        with open(path, "rb") as f:
+            for chunk in iter(lambda: f.read(1 << 20), b""):
+                digest.update(chunk)
+
+        try:
+            model_obj = self.models.create(project, model, framework=target_runtime, task=task)
+        except FleetMLError as create_err:
+            found = [m for m in self.models.list(project) if m.name == model]
+            if not found:
+                raise create_err
+            model_obj = found[0]
+
+        try:
+            version_obj = self.versions.create(model_obj.id, version)
+        except FleetMLError as create_err:
+            found_v = [v for v in self.versions.list(model_obj.id) if v.version == version]
+            if not found_v:
+                raise create_err
+            version_obj = found_v[0]
+
+        created = self._request(
+            "POST",
+            f"/versions/{version_obj.id}/variants",
+            {
+                "quantization": quantization,
+                "target_runtime": target_runtime,
+                "blob_size_bytes": size,
+                "blob_sha256": digest.hexdigest(),
+            },
+        )
+        upload_url = str(created["upload_url"])
+        variant_id = str(created["variant"]["id"])
+
+        with open(path, "rb") as f:
+            try:
+                resp = self._http.put(upload_url, content=f, headers={"Content-Length": str(size)})
+            except httpx.HTTPError as e:
+                raise FleetMLError(0, "UPLOAD_FAILED", f"upload failed: {e}") from e
+        if resp.status_code >= 300:
+            raise FleetMLError(resp.status_code, "UPLOAD_FAILED", f"upload failed: HTTP {resp.status_code}")
+
+        self._request("POST", f"/variants/{variant_id}/finalize")
+        if promote:
+            # DRAFT -> STAGED -> ACTIVE, as the CLI does (a version that is
+            # already further along keeps its status).
+            for status in ("STAGED", "ACTIVE"):
+                with contextlib.suppress(FleetMLError):
+                    self._request("PATCH", f"/versions/{version_obj.id}/status", {"status": status})
+        return self.versions.get(version_obj.id)
+
+    def wait_for_deployment(
+        self,
+        deployment_id: str,
+        timeout: float = 600.0,
+        interval: float = 2.0,
+        statuses: Collection[str] = TERMINAL_DEPLOYMENT_STATUSES,
+    ) -> Deployment:
+        """Polls a deployment until its status is one of ``statuses`` (by
+        default COMPLETE, ROLLED_BACK, CANCELLED or FAILED) and returns it.
+        Raises :class:`TimeoutError` after ``timeout`` seconds."""
+        deadline = time.monotonic() + timeout
+        while True:
+            d = self.deployments.get(deployment_id)
+            if d.status in statuses:
+                return d
+            if time.monotonic() >= deadline:
+                raise TimeoutError(f"deployment {deployment_id} is still {d.status} after {timeout:g}s")
+            time.sleep(interval)
+
+
+class _API:
+    def __init__(self, client: FleetML) -> None:
+        self._c = client
+
+
+class Projects(_API):
+    """``fleetml project``."""
+
+    def create(self, name: str, description: str = "") -> Project:
+        return Project.from_api(self._c._request("POST", "/projects", {"name": name, "description": description}))
+
+    def list(self, limit: Optional[int] = None, offset: Optional[int] = None) -> List[Project]:
+        return from_list(self._c._request("GET", "/projects", params=self._c._page(limit, offset)), Project.from_api)
+
+    def get(self, project_id: str) -> Project:
+        return Project.from_api(self._c._request("GET", f"/projects/{project_id}"))
+
+
+class Models(_API):
+    """``fleetml model``."""
+
+    def create(self, project: str, name: str, framework: str = "TFLITE", task: str = "CLASSIFICATION") -> Model:
+        body = {"name": name, "framework": framework, "task_type": task}
+        return Model.from_api(self._c._request("POST", f"/projects/{project}/models", body))
+
+    def list(self, project: str, limit: Optional[int] = None, offset: Optional[int] = None) -> List[Model]:
+        data = self._c._request("GET", f"/projects/{project}/models", params=self._c._page(limit, offset))
+        return from_list(data, Model.from_api)
+
+
+class Versions(_API):
+    """``fleetml ver``."""
+
+    def create(self, model: str, version: str, metadata: Optional[Mapping[str, Any]] = None) -> Version:
+        body: Json = {"version": version}
+        if metadata is not None:
+            body["metadata"] = dict(metadata)
+        return Version.from_api(self._c._request("POST", f"/models/{model}/versions", body))
+
+    def list(self, model: str, limit: Optional[int] = None, offset: Optional[int] = None) -> List[Version]:
+        data = self._c._request("GET", f"/models/{model}/versions", params=self._c._page(limit, offset))
+        return from_list(data, Version.from_api)
+
+    def get(self, version_id: str) -> Version:
+        return Version.from_api(self._c._request("GET", f"/versions/{version_id}"))
+
+
+class EnrollmentKeys(_API):
+    """A project's enrollment keys, which devices register with."""
+
+    def create(self, project: str, name: str) -> EnrollmentKey:
+        return EnrollmentKey.from_api(self._c._request("POST", f"/projects/{project}/enrollment-keys", {"name": name}))
+
+
+class Deployments(_API):
+    """``fleetml deploy``."""
+
+    def create(
+        self,
+        project: str,
+        version: str,
+        strategy: str = "ALL_AT_ONCE",
+        target_selector: Optional[Mapping[str, str]] = None,
+        health_gate: Optional[Mapping[str, Any]] = None,
+        canary_stages: Optional[Sequence[Mapping[str, Any]]] = None,
+        rolling_config: Optional[Mapping[str, Any]] = None,
+        urgent: bool = False,
+    ) -> Deployment:
+        """Creates a deployment of model version ``version`` (an ID) in
+        ``project``. ``health_gate``, ``canary_stages`` and ``rolling_config``
+        are passed through as the REST API documents them (docs/ROLLOUTS.md)."""
+        body: Json = {"project_id": project, "model_version_id": version, "strategy": strategy, "urgent": urgent}
+        if target_selector is not None:
+            body["target_selector"] = dict(target_selector)
+        if health_gate is not None:
+            body["health_gate"] = dict(health_gate)
+        if canary_stages is not None:
+            body["canary_stages"] = [dict(s) for s in canary_stages]
+        if rolling_config is not None:
+            body["rolling_config"] = dict(rolling_config)
+        return Deployment.from_api(self._c._request("POST", "/deployments", body))
+
+    def start(self, deployment_id: str) -> Deployment:
+        return Deployment.from_api(self._c._request("POST", f"/deployments/{deployment_id}/start"))
+
+    def get(self, deployment_id: str) -> Deployment:
+        return Deployment.from_api(self._c._request("GET", f"/deployments/{deployment_id}"))
+
+    def list(self, limit: Optional[int] = None, offset: Optional[int] = None) -> List[Deployment]:
+        return from_list(
+            self._c._request("GET", "/deployments", params=self._c._page(limit, offset)), Deployment.from_api
+        )
+
+    def rollback(self, deployment_id: str, reason: str = "manual rollback") -> Deployment:
+        data = self._c._request("POST", f"/deployments/{deployment_id}/rollback", {"reason": reason})
+        return Deployment.from_api(data)
+
+
+class Devices(_API):
+    """``fleetml device``."""
+
+    def list(
+        self,
+        labels: Optional[Mapping[str, str]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> List[Device]:
+        """Lists devices; with ``labels``, only those that have all of them."""
+        params = self._c._page(limit, offset)
+        for k, v in (labels or {}).items():
+            params[f"label.{k}"] = v
+        return from_list(self._c._request("GET", "/devices", params=params), Device.from_api)
+
+
+class Telemetry(_API):
+    """``fleetml telemetry``."""
+
+    def summary(self, version_id: str) -> TelemetrySummary:
+        return TelemetrySummary.from_api(self._c._request("GET", f"/telemetry/summary/{version_id}"))
+
+
+class Experiments(_API):
+    """``fleetml experiment``."""
+
+    def create(
+        self,
+        project: str,
+        name: str,
+        control: str,
+        treatment: str,
+        metric: str = "latency",
+        split: int = 50,
+        auto_conclude: bool = False,
+        target_selector: Optional[Mapping[str, str]] = None,
+        min_sample_size: Optional[int] = None,
+    ) -> Experiment:
+        """Creates an A/B experiment between the model versions ``control``
+        and ``treatment`` (IDs); ``split`` is the treatment's share in percent."""
+        body: Json = {
+            "project_id": project,
+            "name": name,
+            "control_version_id": control,
+            "treatment_version_id": treatment,
+            "primary_metric": metric,
+            "split_ratio": split,
+            "auto_conclude": auto_conclude,
+        }
+        if target_selector is not None:
+            body["target_selector"] = dict(target_selector)
+        if min_sample_size is not None:
+            body["min_sample_size"] = min_sample_size
+        return Experiment.from_api(self._c._request("POST", "/experiments", body))
+
+    def start(self, experiment_id: str) -> Experiment:
+        return Experiment.from_api(self._c._request("POST", f"/experiments/{experiment_id}/start"))
+
+    def results(self, experiment_id: str) -> ExperimentResults:
+        return ExperimentResults.from_api(self._c._request("GET", f"/experiments/{experiment_id}/results"))
+
+
+class Drift(_API):
+    """``fleetml drift``."""
+
+    def check(self, version_id: str) -> List[DriftResult]:
+        """Runs a drift check now: one result per metric."""
+        return from_list(self._c._request("POST", f"/drift/{version_id}/check"), DriftResult.from_api)
+
+    def history(self, version_id: str) -> List[DriftResult]:
+        """The last 50 drift results, newest first."""
+        return from_list(self._c._request("GET", f"/drift/{version_id}/history"), DriftResult.from_api)

fleetml/errors.py

@@ -0,0 +1,19 @@
+"""The error every FleetML call raises."""
+
+from __future__ import annotations
+
+
+class FleetMLError(Exception):
+    """A request the server refused, or one that did not reach it.
+
+    ``status`` is the HTTP status (0 when the server could not be reached),
+    ``code`` the server's error code (such as ``NOT_FOUND``, ``CONFLICT``,
+    ``VALIDATION_ERROR``, ``INTEGRITY_ERROR``, ``UNAUTHORIZED``) and
+    ``message`` the server's message.
+    """
+
+    def __init__(self, status: int, code: str, message: str) -> None:
+        self.status = status
+        self.code = code
+        self.message = message
+        super().__init__(f"{status} {code}: {message}" if status else f"{code}: {message}")

fleetml/types.py

@@ -0,0 +1,336 @@
+"""The responses users read, as dataclasses.
+
+Each keeps the server's full JSON object in ``raw``, so fields that are not
+listed here are still there. Timestamps are the server's RFC 3339 strings.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Mapping, Optional
+
+
+def _str(d: Mapping[str, Any], key: str) -> str:
+    v = d.get(key)
+    return "" if v is None else str(v)
+
+
+def _opt_str(d: Mapping[str, Any], key: str) -> Optional[str]:
+    v = d.get(key)
+    return None if v is None else str(v)
+
+
+def _int(d: Mapping[str, Any], key: str) -> int:
+    v = d.get(key)
+    return int(v) if isinstance(v, (int, float)) else 0
+
+
+def _float(d: Mapping[str, Any], key: str) -> float:
+    v = d.get(key)
+    return float(v) if isinstance(v, (int, float)) else 0.0
+
+
+def _opt_float(d: Mapping[str, Any], key: str) -> Optional[float]:
+    v = d.get(key)
+    return float(v) if isinstance(v, (int, float)) else None
+
+
+def _labels(d: Mapping[str, Any], key: str) -> Dict[str, str]:
+    v = d.get(key)
+    return {str(k): str(x) for k, x in v.items()} if isinstance(v, dict) else {}
+
+
+@dataclass(frozen=True)
+class Project:
+    id: str
+    name: str
+    slug: str
+    description: str
+    created_at: str
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> Project:
+        return cls(
+            _str(d, "id"), _str(d, "name"), _str(d, "slug"), _str(d, "description"), _str(d, "created_at"), dict(d)
+        )
+
+
+@dataclass(frozen=True)
+class Model:
+    id: str
+    project_id: str
+    name: str
+    framework: str
+    task_type: str
+    created_at: str
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> Model:
+        return cls(
+            _str(d, "id"),
+            _str(d, "project_id"),
+            _str(d, "name"),
+            _str(d, "framework"),
+            _str(d, "task_type"),
+            _str(d, "created_at"),
+            dict(d),
+        )
+
+
+@dataclass(frozen=True)
+class Version:
+    """A model version. ``status`` is DRAFT, STAGED, ACTIVE or ARCHIVED."""
+
+    id: str
+    model_id: str
+    version: str
+    status: str
+    metadata: Dict[str, Any]
+    created_at: str
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> Version:
+        meta = d.get("metadata")
+        return cls(
+            _str(d, "id"),
+            _str(d, "model_id"),
+            _str(d, "version"),
+            _str(d, "status"),
+            dict(meta) if isinstance(meta, dict) else {},
+            _str(d, "created_at"),
+            dict(d),
+        )
+
+
+@dataclass(frozen=True)
+class EnrollmentKey:
+    """A project's enrollment key. ``key`` is returned only when it is created."""
+
+    id: str
+    project_id: str
+    name: str
+    key: str
+    created_at: str
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> EnrollmentKey:
+        return cls(
+            _str(d, "id"), _str(d, "project_id"), _str(d, "name"), _str(d, "key"), _str(d, "created_at"), dict(d)
+        )
+
+    def __repr__(self) -> str:
+        return f"EnrollmentKey(id={self.id!r}, project_id={self.project_id!r}, name={self.name!r}, key='…')"
+
+
+@dataclass(frozen=True)
+class Deployment:
+    """A rollout. ``status`` is PENDING, ROLLING_OUT, PAUSED, COMPLETE,
+    ROLLED_BACK or CANCELLED; ``strategy`` is ALL_AT_ONCE, CANARY or ROLLING."""
+
+    id: str
+    project_id: str
+    model_version_id: str
+    strategy: str
+    status: str
+    target_selector: Dict[str, str]
+    current_stage: int
+    urgent: bool
+    rollback_reason: str
+    created_at: str
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> Deployment:
+        return cls(
+            _str(d, "id"),
+            _str(d, "project_id"),
+            _str(d, "model_version_id"),
+            _str(d, "strategy"),
+            _str(d, "status"),
+            _labels(d, "target_selector"),
+            _int(d, "current_stage"),
+            bool(d.get("urgent")),
+            _str(d, "rollback_reason"),
+            _str(d, "created_at"),
+            dict(d),
+        )
+
+
+@dataclass(frozen=True)
+class Device:
+    id: str
+    project_id: Optional[str]
+    os: str
+    os_version: str
+    ram_mb: int
+    chipset: str
+    agent_version: str
+    labels: Dict[str, str]
+    last_seen_at: Optional[str]
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> Device:
+        return cls(
+            _str(d, "id"),
+            _opt_str(d, "project_id"),
+            _str(d, "os"),
+            _str(d, "os_version"),
+            _int(d, "ram_mb"),
+            _str(d, "chipset"),
+            _str(d, "agent_version"),
+            _labels(d, "labels"),
+            _opt_str(d, "last_seen_at"),
+            dict(d),
+        )
+
+
+@dataclass(frozen=True)
+class TelemetrySummary:
+    """Inference telemetry of one model version over the last day."""
+
+    model_version_id: str
+    total_events: int
+    error_count: int
+    avg_latency_ms: float
+    p50_latency_ms: float
+    p95_latency_ms: float
+    p99_latency_ms: float
+    avg_confidence: float
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> TelemetrySummary:
+        return cls(
+            _str(d, "model_version_id"),
+            _int(d, "total_events"),
+            _int(d, "error_count"),
+            _float(d, "avg_latency_ms"),
+            _float(d, "p50_latency_ms"),
+            _float(d, "p95_latency_ms"),
+            _float(d, "p99_latency_ms"),
+            _float(d, "avg_confidence"),
+            dict(d),
+        )
+
+
+@dataclass(frozen=True)
+class Experiment:
+    """An A/B experiment. ``status`` is DRAFT, RUNNING, PAUSED, CONCLUDED or CANCELLED."""
+
+    id: str
+    project_id: str
+    name: str
+    status: str
+    control_version_id: str
+    treatment_version_id: str
+    primary_metric: str
+    split_ratio: int
+    min_sample_size: int
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> Experiment:
+        return cls(
+            _str(d, "id"),
+            _str(d, "project_id"),
+            _str(d, "name"),
+            _str(d, "status"),
+            _str(d, "control_version_id"),
+            _str(d, "treatment_version_id"),
+            _str(d, "primary_metric"),
+            _int(d, "split_ratio"),
+            _int(d, "min_sample_size"),
+            dict(d),
+        )
+
+
+@dataclass(frozen=True)
+class ArmResult:
+    """One arm (control or treatment) of an experiment's results."""
+
+    version_id: str
+    sample_size: int
+    avg_latency_ms: float
+    p95_latency_ms: float
+    error_rate: float
+    avg_confidence: float
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> ArmResult:
+        return cls(
+            _str(d, "version_id"),
+            _int(d, "sample_size"),
+            _float(d, "avg_latency_ms"),
+            _float(d, "p95_latency_ms"),
+            _float(d, "error_rate"),
+            _float(d, "avg_confidence"),
+            dict(d),
+        )
+
+
+@dataclass(frozen=True)
+class ExperimentResults:
+    """``recommendation`` is COLLECTING_DATA until both arms reach
+    ``min_sample_size``, then ADOPT_TREATMENT, KEEP_CONTROL or INCONCLUSIVE;
+    ``final`` is true once the test has run."""
+
+    control: ArmResult
+    treatment: ArmResult
+    p_value: Optional[float]
+    effect_size: Optional[float]
+    is_significant: bool
+    recommendation: str
+    final: bool
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> ExperimentResults:
+        control, treatment = d.get("control"), d.get("treatment")
+        return cls(
+            ArmResult.from_api(control if isinstance(control, dict) else {}),
+            ArmResult.from_api(treatment if isinstance(treatment, dict) else {}),
+            _opt_float(d, "p_value"),
+            _opt_float(d, "effect_size"),
+            bool(d.get("is_significant")),
+            _str(d, "recommendation"),
+            bool(d.get("final")),
+            dict(d),
+        )
+
+
+@dataclass(frozen=True)
+class DriftResult:
+    """One drift check of one metric. ``severity`` is NONE, WARNING or CRITICAL."""
+
+    id: str
+    model_version_id: str
+    metric: str
+    psi_value: float
+    severity: str
+    message: str
+    checked_at: str
+    raw: Dict[str, Any] = field(repr=False, compare=False)
+
+    @classmethod
+    def from_api(cls, d: Mapping[str, Any]) -> DriftResult:
+        return cls(
+            _str(d, "id"),
+            _str(d, "model_version_id"),
+            _str(d, "metric"),
+            _float(d, "psi_value"),
+            _str(d, "severity"),
+            _str(d, "message"),
+            _str(d, "checked_at"),
+            dict(d),
+        )
+
+
+def from_list(items: Any, parse: Any) -> List[Any]:
+    """Parses a JSON array with ``parse``; anything else is an empty list."""
+    return [parse(x) for x in items] if isinstance(items, list) else []

fleetml-0.6.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.5
+Name: fleetml
+Version: 0.6.0
+Summary: Python client for FleetML: push models, run and watch rollouts, A/B experiments and drift checks on a FleetML server.
+Project-URL: Homepage, https://github.com/fleetml/fleetml
+Project-URL: Documentation, https://github.com/fleetml/fleetml/blob/main/docs/PYTHON_CLIENT.md
+Project-URL: Repository, https://github.com/fleetml/fleetml
+Project-URL: Changelog, https://github.com/fleetml/fleetml/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/fleetml/fleetml/issues
+Author-email: FleetML Maintainers <hello@fleetml.dev>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: a/b testing,canary,edge,mlops,model deployment,ota
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+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 :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.24
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# fleetml
+
+The Python client for [FleetML](https://github.com/fleetml/fleetml), the
+self-hosted platform that rolls models out to Android, iOS and Linux devices
+with canaries, automatic rollback, A/B experiments and drift detection.
+
+From a training pipeline, a notebook or CI: push a model, start a rollout,
+wait for it, and read what the fleet reports. It speaks the server's REST API,
+with the same words as the `fleetml` CLI, and depends only on `httpx`.
+
+```bash
+pip install fleetml
+```
+
+`pip install fleetml` works from 0.6.0; until then, `pip install ./python`
+from a clone of the repository.
+
+```python
+from fleetml import FleetML
+
+fm = FleetML("http://localhost:18080", api_key="...")  # or FLEETML_SERVER, FLEETML_API_KEY
+project = fm.projects.create("demo")
+version = fm.push("model.tflite", project=project.id, model="iris", version="1.0.0")
+deployment = fm.deployments.start(fm.deployments.create(project.id, version.id).id)
+print(fm.wait_for_deployment(deployment.id).status)
+```
+
+Documentation: [docs/PYTHON_CLIENT.md](https://github.com/fleetml/fleetml/blob/main/docs/PYTHON_CLIENT.md).
+License: Apache-2.0.

fleetml-0.6.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+fleetml/__init__.py,sha256=6VhLLXhzfAzor8gjSGN5X3BQjz-wZsCzdY2ydiqapyI,1058
+fleetml/client.py,sha256=MyJw8MR-OC36vf2t8yyW1yx7rJWL477EO_EOwiV0g-s,14856
+fleetml/errors.py,sha256=ndy4ftaM6JGPf4lz3_17DsKrzqqOGVXP34QAf6o3zwA,694
+fleetml/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fleetml/types.py,sha256=rYnP4TEw-75alkKi1ufU1reApx_UWtjX4FvYcvHya5A,9295
+fleetml-0.6.0.dist-info/METADATA,sha256=CIw9YA1-sPvGjIiPYY9xMlDsyBr9bo4gHbUCG4P5NjA,2783
+fleetml-0.6.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+fleetml-0.6.0.dist-info/licenses/LICENSE,sha256=wCOt_hFFj7dchnKFFqTmd1ObW6UlZ0tikrYrwuYs2Tk,10771
+fleetml-0.6.0.dist-info/licenses/NOTICE,sha256=14at2VbDYGE0I_eGpxV16yM30RiIZExyDNE8QUydrIU,1456
+fleetml-0.6.0.dist-info/RECORD,,

fleetml-0.6.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

fleetml-0.6.0.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 FleetML Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

fleetml-0.6.0.dist-info/licenses/NOTICE

@@ -0,0 +1,29 @@
+FleetML
+Copyright 2026 FleetML Contributors
+
+This product includes software developed by third parties:
+
+internal/delta (the diff algorithm) is derived from bsdiff:
+
+  Copyright 2003-2005 Colin Percival. All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted providing that the following conditions
+  are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+  IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.