Spaces:
Sleeping
Sleeping
Download runner_client.py from Jplayz/peerpixel-runner: direct link, hf CLI and curl.
- Browser
- Download file 4.32 kB
-
https://huggingface.co/spaces/Jplayz/peerpixel-runner/resolve/main/runner_client.py
- Command line
-
hf download hf://spaces/Jplayz/peerpixel-runner/runner_client.py
-
curl -L -o runner_client.py https://huggingface.co/spaces/Jplayz/peerpixel-runner/resolve/main/runner_client.py
4.32 kB
| from __future__ import annotations | |
| import base64 | |
| import re | |
| from dataclasses import dataclass, field | |
| from typing import Any | |
| import httpx | |
| class RunnerClient: | |
| origin: str | |
| transport: httpx.BaseTransport | None = None | |
| state: str = "disconnected" | |
| device_id: str | None = None | |
| owner_discord_id: str | None = None | |
| task: dict[str, Any] | None = None | |
| _worker_key: str | None = field(default=None, repr=False) | |
| _session_token: str | None = field(default=None, repr=False) | |
| def __repr__(self) -> str: | |
| return f"RunnerClient(origin={self.origin!r}, state={self.state!r}, device_id={self.device_id!r})" | |
| def _client(self) -> httpx.Client: | |
| return httpx.Client(base_url=self.origin, transport=self.transport, timeout=15, headers={"user-agent": "peerpixel-zerogpu/1"}) | |
| def _post(self, path: str, *, session: bool = True, json: dict | None = None) -> httpx.Response: | |
| token = self._session_token if session else self._worker_key | |
| with self._client() as client: | |
| response = client.post(path, json=json, headers={"authorization": f"Bearer {token}"}) | |
| response.raise_for_status() | |
| return response | |
| def connect(self, worker_key: str) -> None: | |
| match = re.search(r"ppw_[A-Za-z0-9_-]{20,80}", str(worker_key or "")) | |
| self._worker_key = match.group(0) if match else None | |
| if not self._worker_key: | |
| raise ValueError("worker key is required") | |
| response = self._post("/api/runner/session", session=False) | |
| data = response.json() | |
| self._session_token = data["sessionToken"] | |
| self.device_id = data["deviceId"] | |
| self.owner_discord_id = data["ownerDiscordId"] | |
| self.state = "waiting" | |
| def claim(self) -> dict | None: | |
| if self.state != "waiting": return None | |
| response = self._post("/api/runner/claim") | |
| if response.status_code == 204: return None | |
| self.task = response.json()["task"] | |
| self.state = "reserved" | |
| return self.task | |
| def renew(self) -> None: | |
| if not self.task: return | |
| self._post("/api/runner/lease", json=self._lease()) | |
| def complete_enhancement(self, prompt: str) -> None: | |
| self._post("/api/runner/enhancement", json={**self._lease(), "prompt": prompt}) | |
| self.task = None | |
| self.state = "waiting" | |
| def release(self, reason: str) -> None: | |
| if not self.task: return | |
| self._post("/api/runner/release", json={**self._lease(), "reason": reason[:120]}) | |
| self.task = None | |
| self.state = "waiting" | |
| def source(self) -> bytes | None: | |
| if not self.task or not self.task.get("sourceUrl"): return None | |
| with self._client() as client: | |
| response = client.get(self.task["sourceUrl"], headers={ | |
| "authorization": f"Bearer {self._worker_key}", | |
| "x-peerpixel-device": self.device_id or "", | |
| "x-peerpixel-assignment": self.task["assignmentToken"], | |
| }, timeout=120) | |
| response.raise_for_status() | |
| return response.content | |
| def upload(self, result: dict) -> None: | |
| self.state = "uploading" | |
| def encoded(item): | |
| return {"imageBase64": base64.b64encode(item["bytes"]).decode(), | |
| "contentType": "image/jpeg", "localSafety": item["localSafety"]} | |
| payload = {"jobId": self.task["id"], "deviceId": self.device_id, | |
| "assignmentToken": self.task["assignmentToken"], | |
| "images": [encoded(item) for item in result["images"]]} | |
| if result.get("grid"): payload["grid"] = encoded(result["grid"]) | |
| with self._client() as client: | |
| response = client.post("/api/worker/result", json=payload, headers={ | |
| "authorization": f"Bearer {self._worker_key}"}, timeout=600) | |
| response.raise_for_status() | |
| self.task = None | |
| self.state = "waiting" | |
| def disconnect(self) -> None: | |
| if self._session_token: | |
| self._post("/api/runner/disconnect", json={}) | |
| self.task = None | |
| self._worker_key = None | |
| self._session_token = None | |
| self.state = "disconnected" | |
| def _lease(self) -> dict: | |
| return {"jobId": self.task["id"], "assignmentToken": self.task["assignmentToken"]} | |