Creating the first report

import os
import time
import uuid
from urllib.parse import urljoin

import requests

# Keep the key out of source code and load it from the environment.
API_BASE = 'http://uned.tail9cc3dd.ts.net'
API_KEY = os.environ["ARTEXT_API_KEY"]
HEADERS = {"Authorization": f"Bearer {API_KEY}"}
payload = {'language': 'en', 'domain_slug': 'plain-language', 'text_type_slug': 'legal-administrative-text-addressed-to-citizens', 'text': 'The application will be reviewed at the present time.', 'external_id': 'document-123'}

# Create the report once. Idempotency-Key makes a POST retry safe after a network failure.
response = requests.post(
    f"{API_BASE}/v1/reports",
    headers={**HEADERS, "Idempotency-Key": str(uuid.uuid4())},
    json=payload,
    timeout=30,
)
response.raise_for_status()
created = response.json()
# status_url is relative; resolve it against API_BASE.
status_url = urljoin(f"{API_BASE}/", created["status_url"])
retry_after = int(response.headers.get("Retry-After", "2"))

# Poll the same report while honoring Retry-After and an overall deadline.
deadline = time.monotonic() + 180
while True:
    time.sleep(retry_after)
    response = requests.get(status_url, headers=HEADERS, timeout=30)
    retry_after = int(response.headers.get("Retry-After", "2"))
    if response.status_code == 429:
        continue
    response.raise_for_status()
    report = response.json()
    status = report["status"]
    if status == "completed":
        break
    if status == "failed":
        raise RuntimeError((report.get("error") or {}).get("message") or "Analysis failed")
    if status not in {"queued", "running"}:
        raise RuntimeError(f"Unknown report status: {status}")
    if time.monotonic() >= deadline:
        raise TimeoutError("Report polling timed out")

# Process the result only after completed.
result = report["result"]
for measurement in result["measurements"]:
    print(measurement["metric_id"], measurement["value"], measurement["unit"])
for index, suggestion in enumerate(result["suggestions"]):
    print(index, suggestion["metric_id"], len(suggestion["occurrences"]))

// Node.js 18+. Run this code on a server; never expose the key in a browser.
const API_BASE = "http://uned.tail9cc3dd.ts.net";
const API_KEY = process.env.ARTEXT_API_KEY;
if (!API_KEY) throw new Error("ARTEXT_API_KEY is required");

const headers = {
  "Authorization": `Bearer ${API_KEY}`,
  "Content-Type": "application/json"
};
const api = async (path, options = {}) => {
  const response = await fetch(new URL(path, `${API_BASE}/`), {
    ...options,
    headers: { ...headers, ...options.headers },
    signal: AbortSignal.timeout(30_000)
  });
  if (!response.ok && response.status !== 429) {
    throw new Error(`${response.status}: ${await response.text()}`);
  }
  return response;
};
const delay = (milliseconds) =>
  new Promise((resolve) => setTimeout(resolve, milliseconds));

// Create the report once. Idempotency-Key makes a POST retry safe after a network failure.
const createdResponse = await api("v1/reports", {
  method: "POST",
  headers: { "Idempotency-Key": crypto.randomUUID() },
  body: JSON.stringify({"language":"en","domain_slug":"plain-language","text_type_slug":"legal-administrative-text-addressed-to-citizens","text":"The application will be reviewed at the present time.","external_id":"document-123"})
});
const created = await createdResponse.json();
const deadline = Date.now() + 180_000;
let retryAfter = Number(createdResponse.headers.get("Retry-After") || 2);
let report;

// Poll the same report while honoring Retry-After and an overall deadline.
while (Date.now() < deadline) {
  await delay(retryAfter * 1_000);
  const statusResponse = await api(created.status_url);
  retryAfter = Number(statusResponse.headers.get("Retry-After") || 2);
  if (statusResponse.status === 429) continue;
  report = await statusResponse.json();
  if (report.status === "completed") break;
  if (report.status === "failed") {
    throw new Error(report.error?.message || "Analysis failed");
  }
  if (!["queued", "running"].includes(report.status)) {
    throw new Error(`Unknown report status: ${report.status}`);
  }
}
if (report?.status !== "completed") {
  throw new Error("Report polling timed out");
}

// Process the result only after completed.
for (const item of report.result.measurements) {
  console.log(item.metric_id, item.value, item.unit);
}
for (const [index, item] of report.result.suggestions.entries()) {
  console.log(index, item.metric_id, item.occurrences.length);
}