Ruby

A Ruby script that uses the API with net/http and json from the standard library: no gems to install. 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.rb.

# box.rb: list a template's inputs, measure it and export it as a PDF with the PiQ SaaS API.
# Ruby 3.0 or later; net/http and json from the standard library.
require "json"
require "net/http"

KEY = ENV["PIQ_API_KEY"]
BASE = (ENV["PIQ_URL"] || "https://saas.parametriq.co.uk").chomp("/")
storage = ENV["PIQ_STORAGE"] # optional: a registered storage's name
abort "Set PIQ_API_KEY to your API key." if KEY.to_s.empty?

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 = storage ? { source: { storage: storage, key: "templates/box.piq" } } : { template: TEMPLATE }
values = { L: 500, W: 250 }

def post(path, body)
  uri = URI(BASE + path)
  response = Net::HTTP.post(uri, JSON.generate(body), "X-API-KEY" => KEY, "Content-Type" => "application/json")
  return response if response.is_a?(Net::HTTPSuccess)

  warn "Error #{response.code} #{response.message}"
  unless response.body.to_s.empty? # a 401 has no body
    problem = JSON.parse(response.body) rescue { "detail" => response.body }
    warn problem["title"] if problem["title"]
    warn problem["detail"] if problem["detail"]
    (problem["errors"] || {}).each { |field, messages| warn "  #{field}: #{messages.join(" ")}" }
  end
  exit 1
end

# 1. The template's labelled variables
JSON.parse(post("/inputs", template).body)["inputs"].each do |i|
  puts "#{i["name"]}: #{i["label"]} (#{i["kind"]}, #{i["value"]})"
end

# 2. The drawing measured, with the values given
m = JSON.parse(post("/measure", template.merge(values: values)).body)
cut = m["layers"].find { |layer| layer["layer"] == "Cut" }&.fetch("length") || 0
puts "Size: #{m["width"]} x #{m["height"]}, cut length: #{cut}"

# 3. The drawing as a PDF
pdf = post("/export/pdf", template.merge(values: values))
File.binwrite("box.pdf", pdf.body)
puts "Saved box.pdf (#{pdf["X-PiQ-Warnings"]} warnings)"

# 4. Optional: the PDF saved to your storage instead of downloaded
if storage
  destination = { storage: storage, key: "drawings/box.pdf" }
  saved = JSON.parse(post("/save/pdf", template.merge(values: values, destination: destination, overwrite: true)).body)
  puts "Saved #{saved["key"]} to #{saved["storage"]} (#{saved["size"]} bytes)"
end

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. Each request adds to it with merge.
post sends a body to an operation as JSON, with the key in the X-API-KEY header (Net::HTTP.post uses HTTPS for an https address). A success is handed back to be read.
Errors. Any other response has its status printed, then its 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 there is nothing more to print; 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: its body is written to box.pdf with File.binwrite. 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.rb, then:

export PIQ_API_KEY=XXXX-XXXX-XXXX-XXXXX
ruby box.rb

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.