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"]}