Spaces:
Sleeping
Sleeping
File size: 4,322 Bytes
1ba6b4e 0bcabe8 1ba6b4e 0bcabe8 5e8907b 1ba6b4e 886fb78 1ba6b4e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | from __future__ import annotations
import base64
import re
from dataclasses import dataclass, field
from typing import Any
import httpx
@dataclass(repr=False)
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"]}
|