Send cases to the Inbox

python -m pip install requests
RELU_API_KEY=... \
EXTERNAL_CASE_ID=CASE-1042 \
PATIENT_NAME="Jane Doe" \
python inbox_intake.py upper.stl lower.stl

import os
import sys
from pathlib import Path

import requests


API_BASE = os.getenv("RELU_API_BASE", "https://api.automate.relu.ai").rstrip("/")
API_KEY = os.environ["RELU_API_KEY"]
EXTERNAL_CASE_ID = os.environ["EXTERNAL_CASE_ID"]
PATIENT_NAME = os.getenv("PATIENT_NAME")
CASE_SOURCE = os.getenv("CASE_SOURCE")

api = requests.Session()
api.headers.update({"X-API-Key": API_KEY})

# Keep storage requests separate so the API key is never sent to a signed URL.
storage = requests.Session()


def upload_case_file(path_string: str, semantic_type: str) -> str:
    path = Path(path_string)
    content_type = "application/octet-stream"

    registration = api.post(
        f"{API_BASE}/inbox-cases/files",
        json={
            "original_file_name": path.name,
            "name": path.stem,
            "display_name": path.name,
            "extension": path.suffix.lower(),
            "mime_type": content_type,
            "size_bytes": path.stat().st_size,
            "semantic_type": semantic_type,
        },
        timeout=(10, 30),
    )
    registration.raise_for_status()
    upload = registration.json()

    with path.open("rb") as file:
        stored = storage.put(
            upload["upload_url"],
            data=file,
            headers={"Content-Type": upload["upload_content_type"]},
            timeout=(10, 300),
        )
    stored.raise_for_status()

    committed = api.post(
        f"{API_BASE}/inbox-cases/files/{upload['file_id']}/commit",
        timeout=(10, 30),
    )
    committed.raise_for_status()
    return upload["file_id"]


if len(sys.argv) != 3:
    raise SystemExit("Usage: python inbox_intake.py UPPER_SCAN LOWER_SCAN")

upper_file_id = upload_case_file(sys.argv[1], "upper_ios")
lower_file_id = upload_case_file(sys.argv[2], "lower_ios")

case_body = {
    "external_case_id": EXTERNAL_CASE_ID,
    "files": [
        {"file_id": upper_file_id},
        {"file_id": lower_file_id},
    ],
}
if PATIENT_NAME:
    case_body["metadata"] = {"patient_name": PATIENT_NAME}
if CASE_SOURCE:
    case_body["source"] = CASE_SOURCE

created = api.post(
    f"{API_BASE}/inbox-cases",
    json=case_body,
    timeout=(10, 30),
)
created.raise_for_status()
print(created.json()["id"])

RELU_API_KEY=... \
EXTERNAL_CASE_ID=CASE-1042 \
npx tsx inbox-intake.ts upper.stl lower.stl

import { readFile, stat } from 'node:fs/promises';
import { basename, extname } from 'node:path';

const apiBase = (
  process.env.RELU_API_BASE ?? 'https://api.automate.relu.ai'
).replace(/\/$/, '');
const apiKey = process.env.RELU_API_KEY;
const externalCaseId = process.env.EXTERNAL_CASE_ID;
const patientName = process.env.PATIENT_NAME;
const caseSource = process.env.CASE_SOURCE;

if (!apiKey || !externalCaseId) {
  throw new Error('Set RELU_API_KEY and EXTERNAL_CASE_ID before running.');
}

async function relu(path: string, init: RequestInit = {}): Promise<Response> {
  const response = await fetch(`${apiBase}${path}`, {
    ...init,
    headers: {
      'X-API-Key': apiKey,
      ...(init.body ? { 'Content-Type': 'application/json' } : {}),
      ...init.headers,
    },
    signal: AbortSignal.timeout(30_000),
  });
  if (!response.ok) {
    throw new Error(
      `Relu API returned ${response.status}: ${await response.text()}`,
    );
  }
  return response;
}

async function uploadCaseFile(
  path: string,
  semanticType: 'upper_ios' | 'lower_ios',
): Promise<string> {
  const fileName = basename(path);
  const extension = extname(fileName).toLowerCase();
  const fileSize = (await stat(path)).size;
  const contentType = 'application/octet-stream';

  const registration = await relu('/inbox-cases/files', {
    method: 'POST',
    body: JSON.stringify({
      original_file_name: fileName,
      name: fileName.slice(0, -extension.length),
      display_name: fileName,
      extension,
      mime_type: contentType,
      size_bytes: fileSize,
      semantic_type: semanticType,
    }),
  });
  const upload = (await registration.json()) as {
    file_id: string;
    upload_url: string;
    upload_content_type: string;
  };

  const bytes = await readFile(path);
  const stored = await fetch(upload.upload_url, {
    method: 'PUT',
    headers: { 'Content-Type': upload.upload_content_type },
    body: new Uint8Array(bytes),
    signal: AbortSignal.timeout(300_000),
  });
  if (!stored.ok) {
    throw new Error(`Storage upload returned HTTP ${stored.status}`);
  }

  await relu(`/inbox-cases/files/${upload.file_id}/commit`, { method: 'POST' });
  return upload.file_id;
}

async function main(): Promise<void> {
  const [upperPath, lowerPath] = process.argv.slice(2);
  if (!upperPath || !lowerPath) {
    throw new Error('Usage: npx tsx inbox-intake.ts UPPER_SCAN LOWER_SCAN');
  }

  const upperFileId = await uploadCaseFile(upperPath, 'upper_ios');
  const lowerFileId = await uploadCaseFile(lowerPath, 'lower_ios');
  const body = {
    external_case_id: externalCaseId,
    ...(caseSource ? { source: caseSource } : {}),
    ...(patientName ? { metadata: { patient_name: patientName } } : {}),
    files: [{ file_id: upperFileId }, { file_id: lowerFileId }],
  };

  const created = await relu('/inbox-cases', {
    method: 'POST',
    body: JSON.stringify(body),
  });
  const inboxCase = (await created.json()) as { id: string };
  console.log(inboxCase.id);
}

void main();