CVME Format DOCX API

import json
    import time
    from pathlib import Path

    import requests


    API_KEY = "cvme_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    BASE_URL = "https://cvme.ai/"

    CV_PATH = Path("CVME_Test.pdf")


    def submit_cv():
        url = f"{BASE_URL}/app/format_docx_api/"

        headers = {
            "Authorization": f"Api-Key {API_KEY}",
        }

        data = {
            "template_id": "189",
            "target_language": "English (British)",
            "anonymise": "true",
            "anonymise_scope": "all",
            "note_merge_text": (
                "The candidate is immediately available, is open to hybrid working, "
                "and has recently completed additional cloud-focused project work. "
                "Add this information where appropriate without duplicating existing content."
            ),
            "optimise_text": (
                "Optimise this CV for a Senior Project Manager role requiring "
                "stakeholder management, delivery governance, budget control, "
                "vendor management, risk management, and experience delivering "
                "technology transformation projects."
            ),
            "notes_enabled": "false",
            "candidate_mode": "candidate",
            "abridge_cv": "false",
            "merge_options": json.dumps({
                "merge_summary": True,
                "merge_experience": True,
                "merge_skills_qualifications": True,
                "merge_cover_sheet": False,
            }),
        }

        with CV_PATH.open("rb") as file_handle:
            files = {
                "file": (
                    CV_PATH.name,
                    file_handle,
                    "application/pdf",
                ),
            }

            response = requests.post(
                url,
                headers=headers,
                data=data,
                files=files,
                timeout=60,
            )

        response.raise_for_status()

        payload = response.json()

        if not payload.get("success"):
            raise RuntimeError(payload)

        return payload


    job = submit_cv()

    print(json.dumps(job, indent=2))

def get_job_status(status_url):
        headers = {
            "Authorization": f"Api-Key {API_KEY}",
        }

        response = requests.get(
            status_url,
            headers=headers,
            timeout=30,
        )

        response.raise_for_status()

        payload = response.json()

        if not payload.get("success"):
            raise RuntimeError(payload)

        return payload


    def wait_for_job(status_url, poll_seconds=5, max_attempts=120):
        for attempt in range(max_attempts):
            status_payload = get_job_status(status_url)

            status_value = status_payload.get("status")

            if status_value == "complete":
                return status_payload

            if status_value == "failed":
                raise RuntimeError(status_payload.get("error") or status_payload)

            if status_payload.get("expired"):
                raise RuntimeError("The job expired before it was downloaded.")

            time.sleep(poll_seconds)

        raise TimeoutError("Timed out waiting for CVME formatting job.")


    complete_job = wait_for_job(
        job["status_url"],
    )

    print(json.dumps(complete_job, indent=2))

def download_docx(download_url, output_path):
        headers = {
            "Authorization": f"Api-Key {API_KEY}",
        }

        response = requests.get(
            download_url,
            headers=headers,
            timeout=120,
        )

        if response.headers.get("Content-Type", "").startswith("application/json"):
            payload = response.json()
            raise RuntimeError(payload)

        response.raise_for_status()

        Path(output_path).write_bytes(response.content)

        return output_path


    output_file = download_docx(
        complete_job["download_url"],
        "formatted-cv.docx",
    )

    print(f"Downloaded: {output_file}")

<form id="cvmeApiForm">
      <div class="mb-3">
        <label for="apiKey" class="form-label">API key</label>
        <input type="password" class="form-control" id="apiKey" required>
      </div>

      <div class="mb-3">
        <label for="templateId" class="form-label">Template ID</label>
        <input type="number" class="form-control" id="templateId" value="189" required>
      </div>

      <div class="mb-3">
        <label for="cvFile" class="form-label">CV file</label>
        <input type="file" class="form-control" id="cvFile" accept=".pdf,.doc,.docx,.txt" required>
      </div>

      <div class="form-check mb-3">
        <input class="form-check-input" type="checkbox" id="anonymise" checked>
        <label class="form-check-label" for="anonymise">
          Anonymise CV
        </label>
      </div>

      <div class="mb-3">
        <label for="noteMergeText" class="form-label">Note merge text</label>
        <textarea class="form-control" id="noteMergeText" rows="3"></textarea>
      </div>

      <div class="mb-3">
        <label for="optimiseText" class="form-label">Optimise text / job description</label>
        <textarea class="form-control" id="optimiseText" rows="3"></textarea>
      </div>

      <button type="submit" class="btn btn-primary">
        Submit to CVME
      </button>
    </form>

    <pre id="cvmeApiOutput" class="mt-4"></pre>

const CVME_BASE_URL = "https://cvme.ai";

    async function submitCvToCvme({
      apiKey,
      templateId,
      file,
      anonymise,
      noteMergeText,
      optimiseText
    }) {
      const formData = new FormData();

      formData.append("template_id", String(templateId));
      formData.append("target_language", "English (British)");
      formData.append("anonymise", anonymise ? "true" : "false");
      formData.append("anonymise_scope", "all");
      formData.append("notes_enabled", "false");
      formData.append("candidate_mode", "candidate");
      formData.append("abridge_cv", "false");

      formData.append(
        "merge_options",
        JSON.stringify({
          merge_summary: true,
          merge_experience: true,
          merge_skills_qualifications: true,
          merge_cover_sheet: false
        })
      );

      if (noteMergeText) {
        formData.append("note_merge_text", noteMergeText);
      }

      if (optimiseText) {
        formData.append("optimise_text", optimiseText);
      }

      formData.append("file", file, file.name);

      const response = await fetch(`${CVME_BASE_URL}/app/format_docx_api/`, {
        method: "POST",
        headers: {
          Authorization: `Api-Key ${apiKey}`
        },
        body: formData
      });

      const payload = await response.json();

      if (!response.ok || payload.success === false) {
        throw new Error(
          payload?.error?.message || "CVME API request failed."
        );
      }

      return payload;
    }

async function getCvmeJobStatus(apiKey, statusUrl) {
      const response = await fetch(statusUrl, {
        method: "GET",
        headers: {
          Authorization: `Api-Key ${apiKey}`
        }
      });

      const payload = await response.json();

      if (!response.ok || payload.success === false) {
        throw new Error(
          payload?.error?.message || "Could not fetch CVME job status."
        );
      }

      return payload;
    }

    function sleep(ms) {
      return new Promise((resolve) => setTimeout(resolve, ms));
    }

    async function waitForCvmeJob(apiKey, statusUrl, {
      pollMs = 5000,
      maxAttempts = 120
    } = {}) {
      for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
        const statusPayload = await getCvmeJobStatus(apiKey, statusUrl);

        if (statusPayload.status === "complete") {
          return statusPayload;
        }

        if (statusPayload.status === "failed") {
          throw new Error(
            statusPayload?.error?.message || "CVME formatting job failed."
          );
        }

        if (statusPayload.expired) {
          throw new Error("The CVME job expired before it was downloaded.");
        }

        await sleep(pollMs);
      }

      throw new Error("Timed out waiting for CVME formatting job.");
    }

async function downloadCvmeDocx(apiKey, downloadUrl, filename = "formatted-cv.docx") {
      const response = await fetch(downloadUrl, {
        method: "GET",
        headers: {
          Authorization: `Api-Key ${apiKey}`
        }
      });

      const contentType = response.headers.get("Content-Type") || "";

      if (contentType.includes("application/json")) {
        const payload = await response.json();

        throw new Error(
          payload?.error?.message || "CVME download failed."
        );
      }

      if (!response.ok) {
        throw new Error("CVME download failed.");
      }

      const blob = await response.blob();
      const objectUrl = URL.createObjectURL(blob);

      const link = document.createElement("a");
      link.href = objectUrl;
      link.download = filename;
      document.body.appendChild(link);
      link.click();
      link.remove();

      URL.revokeObjectURL(objectUrl);
    }