API Documentation

{
  "error": "Bad Request",
  "message": "Parameter 'bias' must be between 0.0 and 1.0",
  "status": 400,
  "request_id": "req_abc123"
}

import requests
from dataclasses import dataclass
from typing import List, Dict

@dataclass
class ZPLResult:
    p_output: float
    bias: float
    N: int
    samples: int
    elapsed_ms: int

class ZPLClient:
    """Official ZPL Python client."""
    BASE_URL = "https://web-production-5ece2.up.railway.app"

    def __init__(self, api_key: str):
        self.session = requests.Session()
        self.session.headers.update({
            "X-API-Key": api_key,
            "Content-Type": "application/json"
        })

    def compute(self, bias: float, N: int = 7, samples: int = 10000) -> ZPLResult:
        r = self.session.post(f"{self.BASE_URL}/samples",
            json={"bias": bias, "N": N, "samples": samples})
        r.raise_for_status()
        data = r.json()
        return ZPLResult(**{k: data[k] for k in ZPLResult.__dataclass_fields__})

    def sweep(self, N: int = 7, steps: int = 20) -> List[Dict]:
        r = self.session.get(f"{self.BASE_URL}/sweep",
            params={"N": N, "steps": steps})
        r.raise_for_status()
        return r.json()["results"]

    def health(self) -> Dict:
        return self.session.get(f"{self.BASE_URL}/health").json()

# Usage
zpl = ZPLClient("zpl_your_key")
res = zpl.compute(bias=0.9, N=9, samples=50000)
print(f"p_output = {res.p_output:.4f}")  # ≈ 0.5000

class ZPLClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = "https://web-production-5ece2.up.railway.app";
  }

  async compute(bias, N = 7, samples = 10000) {
    const res = await fetch(`${this.baseUrl}/samples`, {
      method: "POST",
      headers: { "Content-Type": "application/json", "X-API-Key": this.apiKey },
      body: JSON.stringify({ bias, N, samples })
    });
    if (!res.ok) throw new Error(`ZPL Error ${res.status}`);
    return res.json();
  }

  async sweep(N = 7, steps = 20) {
    const res = await fetch(`${this.baseUrl}/sweep?N=${N}&steps=${steps}`, {
      headers: { "X-API-Key": this.apiKey }
    });
    return res.json();
  }

  async health() {
    return (await fetch(`${this.baseUrl}/health`)).json();
  }
}

// Usage
const zpl = new ZPLClient("zpl_your_key");
zpl.compute(0.8, 7, 10000).then(r => console.log(`p_output: ${r.p_output}`));

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class ZPLClient : MonoBehaviour
{
    private const string API_KEY = "zpl_your_key";
    private const string BASE_URL = "https://web-production-5ece2.up.railway.app";

    [System.Serializable]
    public class ZPLRequest {
        public float bias;
        public int N;
        public int samples;
    }

    [System.Serializable]
    public class ZPLResponse {
        public float p_output;
        public float bias;
        public int N;
        public int elapsed_ms;
    }

    public IEnumerator ComputeZPL(float bias, int N, System.Action<ZPLResponse> callback)
    {
        var req = new ZPLRequest { bias = bias, N = N, samples = 10000 };
        string json = JsonUtility.ToJson(req);
        using var www = new UnityWebRequest(BASE_URL + "/samples", "POST");
        www.uploadHandler = new UploadHandlerRaw(System.Text.Encoding.UTF8.GetBytes(json));
        www.downloadHandler = new DownloadHandlerBuffer();
        www.SetRequestHeader("Content-Type", "application/json");
        www.SetRequestHeader("X-API-Key", API_KEY);
        yield return www.SendWebRequest();
        if (www.result == UnityWebRequest.Result.Success) {
            var resp = JsonUtility.FromJson<ZPLResponse>(www.downloadHandler.text);
            callback?.Invoke(resp);
        }
    }
}