Insurance claim evidence pack

import os, time, requests
from concurrent.futures import ThreadPoolExecutor

BASE = "https://api.orion.file.ai/prod/v1"
HEADERS = {"x-api-key": os.environ["FILEAI_API_KEY"]}

PACK = [
    "claim-form.pdf", "repair-estimate.pdf", "police-report.pdf",
    "photo_1.jpg", "photo_2.jpg", "photo_3.jpg",
    "photo_4.jpg", "photo_5.jpg", "photo_6.jpg",
]

def upload(path):
    is_photo = path.endswith(".jpg")
    mime = "image/jpeg" if is_photo else "application/pdf"
    body = {"fileName": path, "fileType": mime}
    if is_photo:
        body |= {"enabledProducts": ["FILE_FORENSICS"], "storageOnly": True}
    else:
        body |= {"enabledProducts": ["FILE_SCOUT", "FILE_FORENSICS"]}

    res = requests.post(f"{BASE}/files/upload", headers=HEADERS, json=body)
    res.raise_for_status()
    up = res.json()
    with open(path, "rb") as f:
        requests.put(up["presignedUploadURL"], data=f,
                     headers={"Content-Type": mime}).raise_for_status()

    while True:
        status = requests.get(f"{BASE}/uploads/{up['uploadId']}", headers=HEADERS).json()
        if any(s["step"] == "processing_failed" for s in status.get("statuses", [])):
            raise RuntimeError(f"{path}: processing failed")
        files = status.get("files", [])
        if files and all(f["status"] in ("processed", "action_required") for f in files):
            return path, files[0]["fileId"]
        time.sleep(5)

import { readFile } from "node:fs/promises";

const BASE = "https://api.orion.file.ai/prod/v1";
const headers = { "x-api-key": process.env.FILEAI_API_KEY };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const PACK = [
  "claim-form.pdf", "repair-estimate.pdf", "police-report.pdf",
  "photo_1.jpg", "photo_2.jpg", "photo_3.jpg",
  "photo_4.jpg", "photo_5.jpg", "photo_6.jpg",
];

async function upload(path) {
  const isPhoto = path.endsWith(".jpg");
  const mime = isPhoto ? "image/jpeg" : "application/pdf";
  const body = isPhoto
    ? { fileName: path, fileType: mime, enabledProducts: ["FILE_FORENSICS"], storageOnly: true }
    : { fileName: path, fileType: mime, enabledProducts: ["FILE_SCOUT", "FILE_FORENSICS"] };

  const res = await fetch(`${BASE}/files/upload`, {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(`${path}: upload request failed (${res.status})`);
  const up = await res.json();
  await fetch(up.presignedUploadURL, {
    method: "PUT",
    headers: { "Content-Type": mime },
    body: await readFile(path),
  });

  while (true) {
    const status = await fetch(`${BASE}/uploads/${up.uploadId}`, { headers }).then((r) => r.json());
    if ((status.statuses ?? []).some((s) => s.step === "processing_failed")) {
      throw new Error(`${path}: processing failed`);
    }
    const files = status.files ?? [];
    if (files.length && files.every((f) => ["processed", "action_required"].includes(f.status))) {
      return { path, fileId: files[0].fileId };
    }
    await sleep(5000);
  }
}

def forensics(path, file_id, timeout=600):
    deadline = time.time() + timeout
    while time.time() < deadline:
        res = requests.get(f"{BASE}/forensics/files/{file_id}", headers=HEADERS)
        if res.status_code != 404:            # 404: the run hasn't been created yet
            res.raise_for_status()
            run = res.json()
            if run["status"] in ("complete", "error"):
                return path, run
        time.sleep(10)
    return path, None                          # no finished run in time

async function forensics(path, fileId, timeoutMs = 600_000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const res = await fetch(`${BASE}/forensics/files/${fileId}`, { headers });
    if (res.status !== 404) {                  // 404: the run hasn't been created yet
      if (!res.ok) throw new Error(`${path}: ${res.status}`);
      const run = await res.json();
      if (["complete", "error"].includes(run.status)) return { path, run };
    }
    await sleep(10_000);
  }
  return { path, run: null };                  // no finished run in time
}

with ThreadPoolExecutor(max_workers=len(PACK)) as pool:
    uploaded = list(pool.map(upload, PACK))
    runs = list(pool.map(lambda pf: forensics(*pf), uploaded))

issues, errors = [], []
for path, run in runs:
    if run is None or run["status"] == "error":
        errors.append((path, "run"))
        continue
    for check, result in run["forensics"].items():
        if result["status"] == "issue":
            issues.append((path, check, result.get("value")))
        elif result["status"] == "error":
            errors.append((path, check))

if issues:
    decision = "investigate"        # route to an investigator with `issues`
elif errors:
    decision = "hold"               # retry the failed checks, then decide
else:
    decision = "straight_through"   # every check reported none or skip

const uploaded = await Promise.all(PACK.map(upload));
const runs = await Promise.all(uploaded.map(({ path, fileId }) => forensics(path, fileId)));

const issues = [];
const errors = [];
for (const { path, run } of runs) {
  if (!run || run.status === "error") {
    errors.push({ path, check: "run" });
    continue;
  }
  for (const [check, result] of Object.entries(run.forensics ?? {})) {
    if (result.status === "issue") issues.push({ path, check, value: result.value });
    else if (result.status === "error") errors.push({ path, check });
  }
}

const decision = issues.length
  ? "investigate"        // route to an investigator with `issues`
  : errors.length
    ? "hold"             // retry the failed checks, then decide
    : "straight_through"; // every check reported none or skip