Python

A Python script that uses the API with the requests package. It lists a template's labelled variables, measures the drawing it makes with the values given, and exports it as a PDF.

Download it: box.py.

# box.py: list a template's inputs, measure it and export it as a PDF with the PiQ SaaS API.
# Python 3.8 or later, with requests (pip install requests).
import os
import sys

import requests

key = os.environ.get("PIQ_API_KEY")
base = os.environ.get("PIQ_URL", "https://saas.parametriq.co.uk").rstrip("/")
storage = os.environ.get("PIQ_STORAGE")  # optional: a registered storage's name
if not key:
    sys.exit("Set PIQ_API_KEY to your API key.")

TEMPLATE = 'L=400,"Length"\nW=300,"Width"\nP1=[L,0]\nP2=[L,W]\nP3=[0,W]\nPOLYLINE @1,[P0,P1,P2,P3],TRUE,0'
# the template itself, or (optional) where it is kept in your storage
template = {"source": {"storage": storage, "key": "templates/box.piq"}} if storage else {"template": TEMPLATE}
values = {"L": 500, "W": 250}

session = requests.Session()
session.headers["X-API-KEY"] = key


def post(path, body):
    response = session.post(base + path, json=body, timeout=60)
    if not response.ok:
        fail(response)
    return response


def fail(response):
    print(f"Error {response.status_code} {response.reason}", file=sys.stderr)
    if response.content:  # a 401 has no body
        try:
            problem = response.json()
        except ValueError:
            problem = {"detail": response.text}
        for part in ("title", "detail"):
            if problem.get(part):
                print(problem[part], file=sys.stderr)
        for field, messages in (problem.get("errors") or {}).items():
            print(f"  {field}: {' '.join(messages)}", file=sys.stderr)
    sys.exit(1)


# 1. The template's labelled variables
for i in post("/inputs", template).json()["inputs"]:
    print(f"{i['name']}: {i['label']} ({i['kind']}, {i['value']})")

# 2. The drawing measured, with the values given
m = post("/measure", {**template, "values": values}).json()
cut = next((layer["length"] for layer in m["layers"] if layer["layer"] == "Cut"), 0)
print(f"Size: {m['width']} x {m['height']}, cut length: {cut}")

# 3. The drawing as a PDF
pdf = post("/export/pdf", {**template, "values": values})
with open("box.pdf", "wb") as file:
    file.write(pdf.content)
print(f"Saved box.pdf ({pdf.headers.get('X-PiQ-Warnings')} warnings)")

# 4. Optional: the PDF saved to your storage instead of downloaded
if storage:
    destination = {"storage": storage, "key": "drawings/box.pdf"}
    body = {**template, "values": values, "destination": destination, "overwrite": True}
    saved = post("/save/pdf", body).json()
    print(f"Saved {saved['key']} to {saved['storage']} ({saved['size']} bytes)")

How it works

Settings. The key comes from PIQ_API_KEY, the address from PIQ_URL (the service itself if not set) and, optionally, a storage's name from PIQ_STORAGE. Without a key the script stops at once.
The template. template is the body every request starts from: the template's text as template or, when PIQ_STORAGE is set, where it is kept in your storage as source. values gives L and W by name.
The session carries the key in the X-API-KEY header of every request, and reuses the connection between them.
post sends a body to an operation as JSON (json= sets the Content-Type too). A response that isn't a success goes to fail; any other is handed back to be read.
fail prints the status, then the problem description: its title, its detail, and each entry of errors, the field and what is wrong with it. A 401 has no body, so the body is only parsed when there is one; a body that isn't JSON is printed as it is. The script then exits with 1.
Inputs. POST /inputs needs only the template. Each of its inputs has a name, label, kind and value.
Measure. POST /measure with the values gives the drawing's width and height, and its lines' lengths by layer in layers; the cut length is the length on the Cut layer.
Export. POST /export/pdf answers with the PDF itself, not JSON: response.content is its bytes, written to box.pdf. The X-PiQ-Warnings header says how many things couldn't be exported as they are.
Save (optional). With a storage, POST /save/pdf exports the same drawing and saves it to your storage at destination, "overwrite": True replacing a file already there. It answers with where it saved it and its size.

Running it

Save the script as box.py, then:

pip install requests
export PIQ_API_KEY=XXXX-XXXX-XXXX-XXXXX
python box.py

It prints the template's labelled variables, the drawing's size and cut length, and saves box.pdf:

L: Length (Number, 400)
W: Width (Number, 300)
D: Depth (Number, 300)
Size: 500 x 250, cut length: 1500
Saved box.pdf (0 warnings)

With a value the template can't use ("L": "long", say), it prints the problem and stops:

Error 400 Bad Request
One or more validation errors occurred.
Some of the values given can't be used.
  L: L is a number.

With a key that isn't right it prints only Error 401 Unauthorized: a 401 has no problem description.

To try the storage part, register a storage (see Register a storage), put a template in it as templates/box.piq, and set PIQ_STORAGE to the storage's name. The template is then read from your storage, and the PDF is also saved to it as drawings/box.pdf, replacing any file already there.