Manage check templates¶

Goal¶

Treat a curated set of quality checks as reusable templates that can be applied across many containers or datastores. Templates are how teams enforce "every PII column must have these checks" or "every transactional table must have a freshness check" without copy-pasting check definitions everywhere.

Permissions¶

Prerequisites¶

• The CLI is installed and authenticated with a Manager token.
• Optionally, an enrichment datastore if you want to export templates as data records rather than to a local file.

CLI workflow¶

graph LR
    Export[checks export-templates] --> File[templates.yaml]
    File --> Review[Review / edit]
    Review --> Import[checks import-templates]
    Import --> Templates[(Templates in target instance)]

1. Export templates from the source instance¶

# To a local YAML file
qualytics checks export-templates --output ./templates/golden.yaml

# Filter by rule types and tags
qualytics checks export-templates \
    --output ./templates/pii.yaml \
    --rules "isNotNull,matchesPattern" \
    --tags "pii"

2. (Optional) Edit the file¶

The exported YAML is a list of templates with their full definitions. You can hand-edit them before importing. The import reads only description, rule_type, coverage, filter, properties, the names in global_tags, template_locked, additional_metadata, and anomaly_message_field. It also reads id, but only to record the source template in the new template's metadata (see the next step); the new template gets its own id. Keep id when you edit the file. Every other field, such as created, is ignored.

3. Import templates to the target instance¶

qualytics checks import-templates --input ./templates/pii.yaml

Each template in the file becomes a new template. The CLI records the source template's id in its additional_metadata, under from quality check id.

Behind the scenes¶

Python equivalent¶

import os
import yaml
import httpx

BASE_URL = os.environ["QUALYTICS_URL"].rstrip("/")
TOKEN    = os.environ["QUALYTICS_TOKEN"]
HEADERS  = {"Authorization": f"Bearer {TOKEN}"}

PAGE_SIZE = 100
CREATE_FIELDS = (
    "description", "coverage", "filter", "properties",
    "template_locked", "additional_metadata", "anomaly_message_field",
)

with httpx.Client(headers=HEADERS, timeout=30.0) as client:
    # Export: templates are listed as quality checks with template_only=true
    templates, page = [], 1
    while True:
        r = client.get(
            f"{BASE_URL}/api/quality-checks",
            params={"template_only": "true", "size": PAGE_SIZE, "page": page},
        )
        r.raise_for_status()
        body = r.json()
        templates.extend(body["items"])
        if page * PAGE_SIZE >= body["total"]:
            break
        page += 1
    with open("./templates/golden.yaml", "w") as f:
        yaml.safe_dump(templates, f, sort_keys=False)

    # Import (create-only): build a clean create body for each template,
    # leaving out read-only fields such as id and created
    with open("./templates/golden.yaml") as f:
        for tpl in yaml.safe_load(f):
            payload = {k: tpl[k] for k in CREATE_FIELDS if tpl.get(k) is not None}
            payload["rule"] = tpl["rule_type"]
            payload["tags"] = [t["name"] for t in tpl.get("global_tags") or []]
            r = client.post(f"{BASE_URL}/api/quality-check-templates", json=payload)
            r.raise_for_status()
            print(f"created template {r.json()['id']} from {tpl['id']}")

Variations and advanced usage¶

Lock a template¶

In the web app, a template can be locked. Checks created from a locked template stay in sync with it, and their properties can't be changed directly. Useful for compliance-mandated rule sets. Filter the export by locked status:

qualytics checks export-templates --status true   # locked templates only
qualytics checks export-templates --status false  # unlocked only

Export to an enrichment datastore for downstream analytics¶

qualytics checks export-templates --enrichment_datastore_id 10

The templates are written as records into the selected enrichment datastore. This is useful when you want to track template usage and changes as part of your data pipeline. Add --check_templates "1,2,3" to export only those template ids.

To run the same export from your own code, start a global_export operation:

with httpx.Client(headers=HEADERS, timeout=30.0) as client:
    r = client.post(
        f"{BASE_URL}/api/operations/run",
        json={
            "type": "global_export",
            "asset_type": "check_templates",
            "enrichment_datastore_id": 10,
            "template_ids": [1, 2, 3],  # optional; leave out to export every template
        },
    )
    r.raise_for_status()

Apply a template to many containers in one operation¶

This is a web-app-only operation today (apply-template-to-multiple-containers). See Apply Check Template.

Troubleshooting¶

Related¶

• Quality Checks command reference: export-templates and import-templates flags.
• Apply Check Template for Quality Checks: the web-app side of templates.
• Bulk-create quality checks: create regular (non-template) checks from YAML.