The workflow, step by step

API=https://www.recuromedia.com/api/1.0
AUTH="YOUR_API_KEY:YOUR_API_SECRET"
FILE=A001_C003.mov
unset UPLOAD_KEY JOB_KEY

curl -sS -u "$AUTH" "$API/me"

SIZE=$(wc -c < "$FILE" | tr -d ' ')
UPLOAD_KEY=${UPLOAD_KEY:-$(openssl rand -hex 16)}
curl -sS -u "$AUTH" "$API/uploads" -H "Content-Type: application/json" -H "Idempotency-Key: $UPLOAD_KEY" \
     -d "{\"file_name\": \"$FILE\", \"size\": $SIZE}"

UPLOAD=upl_5f0c2a9e41b7d3c8e6a1f094
split -a 4 -b 8388608 "$FILE" chunk_
INDEX=0
for PART in chunk_*; do
  DIGEST=$(openssl dgst -sha256 -binary "$PART" | base64)
  curl -sS -u "$AUTH" -X PUT "$API/uploads/$UPLOAD/chunks/$INDEX" -H "Content-Type: application/octet-stream" \
       -H "Repr-Digest: sha-256=:$DIGEST:" --data-binary "@$PART"
  echo
  INDEX=$((INDEX + 1))
done
rm chunk_*

curl -sS -u "$AUTH" --data '' "$API/uploads/$UPLOAD/complete"; echo

MEDIA=med_4821
until curl -sS -u "$AUTH" "$API/media/$MEDIA" | grep -Eq '"status":"(ready|failed)"'; do sleep 5; done
curl -sS -u "$AUTH" "$API/media/$MEDIA"

SETTINGS='{"filters": ["noise", "medium_dust_and_scratches"]}'
curl -sS -u "$AUTH" "$API/quotes" -H "Content-Type: application/json" -d "{\"media_id\": \"$MEDIA\", \"settings\": $SETTINGS}"; echo

JOB_KEY=${JOB_KEY:-$(openssl rand -hex 16)}
curl -sS -u "$AUTH" "$API/jobs" -H "Content-Type: application/json" -H "Idempotency-Key: $JOB_KEY" \
     -d "{\"media_id\": \"$MEDIA\", \"settings\": $SETTINGS}"; echo

JOB=job_3150
until curl -sS -u "$AUTH" "$API/jobs/$JOB" | grep -Eq '"status":"(completed|failed|cancelled|needs_action)"'; do sleep 5; done
curl -sS -u "$AUTH" "$API/jobs/$JOB"

curl -sS -u "$AUTH" "$API/jobs/$JOB/keyframes"; echo

curl -sS -u "$AUTH" --data '' "$API/jobs/$JOB/keyframes/approve"; echo

curl -sS --fail -u "$AUTH" -C - -o restored.mov "$API/jobs/$JOB/result" || { [ $? -eq 22 ] && rm -f restored.mov; }
sha256sum restored.mov

curl -sS -u "$AUTH" -X DELETE "$API/jobs/$JOB"
curl -sS -u "$AUTH" -X DELETE "$API/media/$MEDIA"

"""Recuro Media API v1: upload a file, restore it, download the result.

Usage:   python3 restore.py [--retry] [--clean-up] <file>        (Windows: py restore.py ...)
           --retry     after a failed or cancelled job: delete that job and start a new one of the same media
           --clean-up  after the download: delete the job and the media on our side (step 9)
Needs:   Python 3.8 or later, nothing else (standard library only).
Stopped (Ctrl+C, a crash, a closed laptop)? Run it again with the same file: it carries on where it was."""
import base64, hashlib, json, os, sys, time, urllib.error, urllib.request, uuid
from concurrent.futures import ThreadPoolExecutor

API = "https://www.recuromedia.com/api/1.0"
# Your API key and secret (Administrator Tools on the website), joined by a colon. Keep the b in front of the quotes.
AUTH = "Basic " + base64.b64encode(b"YOUR_API_KEY:YOUR_API_SECRET").decode()
SETTINGS = {"filters": ["noise", "medium_dust_and_scratches"]}   # what the job does: filter keys or {"preset_id": "pre_90"}
PARALLEL = 4                                    # chunks sent at the same time (at most max_parallel of the upload)
CLIENT = "restore-py/1.3"
STOP = []                                       # set by Ctrl+C: the chunks not sent yet are skipped


def call(method, path, body=None, data=None, headers=None):
    """One request. Returns (status, headers, JSON answer or None). An error answer raises RuntimeError with its code."""
    h = {"Authorization": AUTH, "Recuro-Client": CLIENT}
    if body is not None:                        # a JSON body
        data, h["Content-Type"] = json.dumps(body).encode(), "application/json"
    elif data is not None:                      # raw bytes (a chunk)
        h["Content-Type"] = "application/octet-stream"
    h.update(headers or {})
    request = urllib.request.Request(API + path, data=data, method=method, headers=h)
    try:
        with urllib.request.urlopen(request, timeout=300) as r:
            status, answer_headers, raw = r.status, r.headers, r.read()
    except urllib.error.HTTPError as e:         # 3xx/4xx/5xx arrive here; 304 too
        status, answer_headers, raw = e.code, e.headers, e.read()
    if status >= 400:                           # an error: {"code": ..., "detail": ..., "request_id": ...}
        try:
            problem = json.loads(raw)
        except ValueError:                      # not our JSON: the error page of a proxy or web server on the way
            raise RuntimeError("HTTP %d for %s %s: %s" % (status, method, path, raw[:200].decode("utf-8", "replace").strip()))
        raise RuntimeError("%s: %s (%s)" % (problem.get("code"), problem.get("detail"), problem.get("request_id")))
    return status, answer_headers, (json.loads(raw) if raw else None)


def wait(path, finished):
    """Polls a media or job until finished(item) is true. A 304 (nothing changed) is free; Retry-After says when to ask again."""
    etag = None
    while True:
        status, headers, item = call("GET", path, headers={"If-None-Match": etag} if etag else {})
        if status == 200:
            etag = headers.get("ETag")
            print(path, item["status"], item.get("stage") or "")
            if finished(item):
                return item
        time.sleep(max(1, int(headers.get("Retry-After", "5"))))   # never faster than once a second


class State:
    """What a run has reached, next to the file (<file>.recuro.json): the upload, the media, the job. Belongs to this file only."""
    def __init__(self, path):
        self.file, info = path + ".recuro.json", os.stat(path)
        self.stamp = [info.st_size, int(info.st_mtime)]
        try:
            self.data = json.load(open(self.file))
        except (OSError, ValueError):
            self.data = {}
        if self.data.get("stamp") != self.stamp:  # another file of the same name: start afresh
            self.data = {"stamp": self.stamp}

    def __getitem__(self, key):
        return self.data.get(key)

    def __setitem__(self, key, value):
        self.data[key] = value
        with open(self.file, "w") as f:
            json.dump(self.data, f)

    def forget(self, *keys):
        for key in keys:
            self.data.pop(key, None)
        self["stamp"] = self.stamp                # (saved)


def send_chunk(path, session, index):
    """Chunk <index>: chunk_size bytes from index * chunk_size (the last one: the rest), with its SHA-256 (Repr-Digest)."""
    if STOP:
        return
    with open(path, "rb") as f:
        f.seek(index * session["chunk_size"])
        chunk = f.read(session["chunk_size"])
    digest = base64.b64encode(hashlib.sha256(chunk).digest()).decode()
    call("PUT", "/uploads/%s/chunks/%d" % (session["id"], index), data=chunk, headers={"Repr-Digest": "sha-256=:%s:" % digest})
    print("chunk", index, "sent")


def upload(path, state):
    """Steps 2 to 4: open (or resume) the upload, send the missing chunks, complete. Returns the media id."""
    if state["media_id"]:
        return state["media_id"]                  # uploaded on an earlier run
    session = None
    if state["upload_id"]:
        try:
            _, _, session = call("GET", "/uploads/" + state["upload_id"])      # the earlier run's upload: what is still missing?
            print("resuming", session["id"] + ":", session["received_count"], "of", session["chunk_count"], "chunks are there")
        except RuntimeError as e:                 # NotFound / UploadExpired (7 days without a chunk): start again
            print("the earlier upload is gone (%s) - starting again" % e)
    if session is None:
        sha256 = hashlib.sha256()                 # the whole file's SHA-256: we check it after the last chunk
        with open(path, "rb") as f:
            for block in iter(lambda: f.read(1 << 20), b""):
                sha256.update(block)
        if not state["upload_key"]:
            state["upload_key"] = str(uuid.uuid4())   # the same key after a lost answer: the same upload, never a second one
        _, _, session = call("POST", "/uploads", {"file_name": os.path.basename(path), "size": os.path.getsize(path), "sha256": sha256.hexdigest()},
                             headers={"Idempotency-Key": state["upload_key"]})
        state["upload_id"] = session["id"]
    while session["missing"]:                   # (the list holds up to 1,000 chunks: asked again until nothing is missing)
        pool = ThreadPoolExecutor(max_workers=min(PARALLEL, session["max_parallel"]))
        try:
            list(pool.map(lambda index: send_chunk(path, session, index), session["missing"]))
        except KeyboardInterrupt:
            STOP.append(True)                     # the chunks on their way finish; the others are skipped
            raise
        finally:
            pool.shutdown()
        _, _, session = call("GET", "/uploads/" + session["id"])
    _, _, done = call("POST", "/uploads/%s/complete" % session["id"], data=b"")
    state["media_id"] = done["media_id"]
    return done["media_id"]


def download(job, target):
    """Step 8: the result, resumed where an earlier run stopped (Range), then checked against result.sha256."""
    result = job["result"]
    if not result["url"]:
        raise RuntimeError("the result has no download address: the file has been deleted")
    have = os.path.getsize(target) if os.path.exists(target) else 0
    if have > result["size"]:                    # not this result: download it again
        os.remove(target)
        have = 0
    headers = {"Authorization": AUTH, "Recuro-Client": CLIENT}
    if have:
        headers["Range"] = "bytes=%d-" % have
    if have != result["size"]:
        request = urllib.request.Request(result["url"], headers=headers)
        with urllib.request.urlopen(request, timeout=300) as r, open(target, "ab" if r.status == 206 else "wb") as out:
            for block in iter(lambda: r.read(1 << 20), b""):
                out.write(block)
    with open(target, "rb") as f:
        if result["sha256"] and hashlib.sha256(f.read()).hexdigest() != result["sha256"]:
            os.remove(target)
            raise RuntimeError("the download does not match the job's SHA-256 - it was deleted; run this again to download it again")


def main(args):
    files = [a for a in args if not a.startswith("--")]
    flags = set(args) - set(files)
    if len(files) != 1 or not flags <= {"--retry", "--clean-up"} or not os.path.isfile(files[0]):
        sys.exit(__doc__.split("\n\n", 1)[1])   # the usage lines
    path = files[0]
    state = State(path)
    media_id = upload(path, state)
    media = wait("/media/" + media_id, lambda m: m["status"] in ("ready", "failed"))
    if media["status"] == "failed":
        sys.exit("the analysis failed (%s): %s\nTo upload the file again, delete %s and run this again." % (media["error"]["code"], media["error"]["message"], state.file))
    if state["job_id"] and "--retry" in flags:
        _, _, old = call("GET", "/jobs/" + state["job_id"])
        if old["status"] in ("failed", "cancelled"):
            call("DELETE", "/jobs/" + old["id"])
            print("deleted", old["id"], "(" + old["status"] + ") - starting a new job")
            state.forget("job_id", "job_key")
    if not state["job_id"]:
        _, _, quote = call("POST", "/quotes", {"media_id": media_id, "settings": SETTINGS})   # step 5: the price first
        print("price", quote["price"]["amount"], quote["price"]["currency"], "- starts:", quote["covers"])
        if not quote["covers"]:
            sys.exit("the job would not start: %(code)s: %(detail)s" % quote["refusal"])
        if not state["job_key"]:
            state["job_key"] = str(uuid.uuid4())     # the same key after a lost answer: the same job, never a second one
        _, _, job = call("POST", "/jobs", {"media_id": media_id, "settings": SETTINGS}, headers={"Idempotency-Key": state["job_key"]})
        state["job_id"] = job["id"]
    job = wait("/jobs/" + state["job_id"], lambda j: j["status"] in ("completed", "failed", "cancelled", "needs_action"))   # step 6
    if job["status"] == "needs_action":
        sys.exit("the job waits for your keyframe review (step 7): approve the keyframes, then run this again")
    if job["status"] != "completed":
        sys.exit("the job %s ended as %s%s - its charge was given back.\nTo start a new job of the same media: python3 restore.py --retry %s"
                 % (job["id"], job["status"], (": " + job["error"]["message"]) if job["error"] else "", path))
    target = "restored - " + job["result"]["file_name"]
    download(job, target)
    print("saved", target)
    if "--clean-up" in flags:                     # step 9
        call("DELETE", "/jobs/" + job["id"])
        call("DELETE", "/media/" + media_id)
        print("deleted", job["id"], "and", media_id, "on our side")
    os.remove(state.file)


if __name__ == "__main__":
    try:
        main(sys.argv[1:])
    except KeyboardInterrupt:
        sys.exit("\nstopped - run the same command again to carry on where it was")
    except (RuntimeError, OSError) as e:          # an error answer, the network, the disk
        sys.exit("stopped: %s\nRun the same command again to carry on; to start this file afresh, delete its .recuro.json file." % e)