Build a lesson plan with the API

import time

import requests

BASE_URL = "https://api.crazygoldfish.com"
HEADERS = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}


def wait_for(path):
    """Check the job every 5 seconds until it's Completed."""
    for _ in range(120):  # Give up after 10 minutes
        response = requests.get(BASE_URL + path, headers=HEADERS)
        body = response.json()
        if response.status_code == 200:
            data = body["data"]
            if data["status"] == "Completed":
                return data
            if data["status"] == "Failed":
                raise RuntimeError(f"{path} failed")
        elif response.status_code in (400, 404):
            first = body["detail"][0]
            if first.get("status") == "Failed":
                raise RuntimeError(first["msg"])
        else:
            response.raise_for_status()
        time.sleep(5)
    raise TimeoutError(f"{path} took longer than 10 minutes")

const BASE_URL = "https://api.crazygoldfish.com";
const HEADERS = { Authorization: "Bearer YOUR_ACCESS_TOKEN" };

// Check the job every 5 seconds until it's Completed
async function waitFor(path) {
  for (let i = 0; i < 120; i++) { // Give up after 10 minutes
    const response = await fetch(BASE_URL + path, { headers: HEADERS });
    const body = await response.json();
    if (response.status === 200) {
      const data = body.data;
      if (data.status === "Completed") return data;
      if (data.status === "Failed") throw new Error(`${path} failed`);
    } else if ([400, 404].includes(response.status)) {
      const first = body.detail[0];
      if (first.status === "Failed") throw new Error(first.msg);
    } else {
      throw new Error(JSON.stringify(body));
    }
    await new Promise((resolve) => setTimeout(resolve, 5000));
  }
  throw new Error(`${path} took longer than 10 minutes`);
}

response = requests.post(
    BASE_URL + "/lesson-plan/v1/metadata",
    headers=HEADERS,
    data={
        "board": BOARD_ID,
        "grade": GRADE_ID,
        "subject": SUBJECT_ID,
        "section": "A",
        "duration_minutes": 45,
        "topic": "Magnetic Effects of Electric Current",
    },
)
response.raise_for_status()
lesson_plan_id = response.json()["detail"][0]["id"]

metadata = wait_for(f"/lesson-plan/v1/metadata/{lesson_plan_id}")

const form = new FormData();
form.append("board", BOARD_ID);
form.append("grade", GRADE_ID);
form.append("subject", SUBJECT_ID);
form.append("section", "A");
form.append("duration_minutes", "45");
form.append("topic", "Magnetic Effects of Electric Current");

const response = await fetch(BASE_URL + "/lesson-plan/v1/metadata", {
  method: "POST",
  headers: HEADERS,
  body: form,
});
if (!response.ok) throw new Error(await response.text());
const lessonPlanId = (await response.json()).detail[0].id;

const metadata = await waitFor(
  `/lesson-plan/v1/metadata/${lessonPlanId}`,
);

response = requests.post(
    BASE_URL + f"/lesson-plan/v1/finalize-metadata/{lesson_plan_id}",
    headers=HEADERS,
    json={
        "subject_matter": metadata["subject_matter"],
        "learning_standards": metadata["learning_standards"],
    },
)
response.raise_for_status()

aligned = wait_for(
    f"/lesson-plan/v1/finalize-metadata/{lesson_plan_id}"
)
alignment = aligned["alignment"]

const finalizeResponse = await fetch(
  `${BASE_URL}/lesson-plan/v1/finalize-metadata/${lessonPlanId}`,
  {
    method: "POST",
    headers: { ...HEADERS, "Content-Type": "application/json" },
    body: JSON.stringify({
      subject_matter: metadata.subject_matter,
      learning_standards: metadata.learning_standards,
    }),
  },
);
if (!finalizeResponse.ok) {
  throw new Error(await finalizeResponse.text());
}

const aligned = await waitFor(
  `/lesson-plan/v1/finalize-metadata/${lessonPlanId}`,
);
const alignment = aligned.alignment;

response = requests.post(
    BASE_URL
    + f"/lesson-plan/v1/instructional-framework-builder/{lesson_plan_id}",
    headers=HEADERS,
    json={"alignment": alignment},
)
response.raise_for_status()

content = wait_for(
    f"/lesson-plan/v1/instructional-framework-builder/{lesson_plan_id}"
)
blocks = content["content_generation"]

const path =
  `/lesson-plan/v1/instructional-framework-builder/${lessonPlanId}`;
const buildResponse = await fetch(BASE_URL + path, {
  method: "POST",
  headers: { ...HEADERS, "Content-Type": "application/json" },
  body: JSON.stringify({ alignment }),
});
if (!buildResponse.ok) throw new Error(await buildResponse.text());

const content = await waitFor(path);
const blocks = content.content_generation;

response = requests.post(
    BASE_URL
    + f"/lesson-plan/v1/additional-enrichment-block/{lesson_plan_id}",
    headers=HEADERS,
    json={
        "additional_blocks": [
            "differentiation",
            "real_life_connections",
        ],
        "duration_minutes": 45,
    },
)
response.raise_for_status()

enriched = wait_for(
    f"/lesson-plan/v1/additional-enrichment-block/{lesson_plan_id}"
)

const blockPath =
  `/lesson-plan/v1/additional-enrichment-block/${lessonPlanId}`;
const enrichResponse = await fetch(BASE_URL + blockPath, {
  method: "POST",
  headers: { ...HEADERS, "Content-Type": "application/json" },
  body: JSON.stringify({
    additional_blocks: ["differentiation", "real_life_connections"],
    duration_minutes: 45,
  }),
});
if (!enrichResponse.ok) throw new Error(await enrichResponse.text());

const enriched = await waitFor(blockPath);