Skip to content

Migrating from Anyformat

extractit import anyformat imports workflows exported from Anyformat (the JSON export of one workflow) and turns each into a versioned draft plus a compatibility report that lists every option that was approximated or is not supported, with a JSON Pointer into the export and a reason.

extractit import anyformat export.json --dry-run -o workflow.json --report report.json
extractit import anyformat export.json              # creates the workflow and its draft
extractit import anyformat export.json --strict     # exit 5 (and create nothing) on any finding

Interoperability note

The importer reads the export format as described below and was built and tested with our own synthetic exports only; it does not download anything from Anyformat and makes no claim about Anyformat's product. Exports may contain options this description does not cover: they are rejected as input violations (exit 2) or reported as unsupported, never dropped silently. Before announcing compatibility publicly, have the wording reviewed by legal counsel.

What happens

  1. The file is validated against a closed JSON Schema of the export (unknown node options are violations). An invalid file exits 2 listing every violation.
  2. The conversion is a pure function (no network, no files, no clock): the same export always gives the same graph, schemas and report. --dry-run imports no network module.
  3. Without --dry-run the node types registered on the target server (GET /v1/node-types) are read first; a node whose type the server does not have yet is left out, its neighbours are re-connected and the report says node_type_unavailable (offline, --node-types FILE takes a saved GET /v1/node-types answer).
  4. The workflow is created and its draft written only when POST :validate reports 0 violations (otherwise nothing is kept and the command exits 2). The draft becomes 1.0.0 when it is published. Re-importing the same file answers no_changes (a fingerprint of the conversion is kept in the graph's annotations); a changed file of the same workflow writes a new revision of the draft, and later publications follow T25's semver.

Export format (version 1)

{
  "export_version": 1,
  "workflow": {
    "name": "Invoices", "description": "…",
    "nodes": [{"id": "n1", "type": "parse", "name": "Read", "config": {"mode": "standard"},
               "position": {"x": 0, "y": 0}}],
    "edges": [{"source": "n1", "target": "n2", "branch": "invoice"}]
  }
}

Node ids become [a-z0-9_]{1,64} (lower case, other characters as _, suffix _2… on a clash); the workflow name becomes a slug (Invoices (all nodes) → invoices-all-nodes).

Nodes

Export type Graph node Notes
parse parse mode: flash and lite → tier fast (approximated), standard, agentic → the tier of the extract nodes below
classify classify threshold 0–100 → 0–1 (heuristic until recalibrated)
splitter split min_confidence 0–100 → 0–1
extract extract fields → an extraction schema; mode overrides the tier; instructions → prompt_addendum
validate validate checks → rules of T09
if_else branch condition → a check; one that cannot be converted never holds (the run takes false)
slack_alert notify (channel: slack) channel → target, message → template
edit fill_form
code transform
report_generator report
knowledge knowledge

Fields

Export Extraction schema (dialect 1.2)
string, integer, boolean same type
float number
date, datetime (+ date_format) string with format: date / date-time; the order of DD, MM, YYYY → x-dx.normalize.date_order
enum (options[{value, description}]) enum + x-dx.enum_descriptions
multi_select array of one enum with uniqueItems: true
object with nested_fields array of objects
source: smart_lookup / lookup_if_missing + lookup{table|file, key, column} x-dx.source of kind lookup, mode always / if_missing (T24's contract, emitted as data); a table referenced by name is reported lookup_table_unbound, a file that is not part of the export lookup_file_missing
persistent_id (UUID) x-dx.field_id = fld_ TypeID whose suffix encodes that UUID; the UUID stays in x-dx.import.persistent_id
no persistent_id field_id from the UUIDv5 of workflow and field path (deterministic)

Names become snake_case keys; siblings that collide after normalizing get _2, _3… and are reported duplicate_name_suffixed.

Checks

required, range, date, arithmetic, comparison, one_of, regex, confidence, expression, validation (→ checksum: iban, luhn, nif_es, vat_eu, isbn, lei), all_of and any_of become T09 checks. References by name or persistent_id are rewritten to field_id.

  • Regexes are compiled with RE2: a pattern RE2 cannot run (look-around, back-references) is imported disabled with regex_not_re2.
  • CEL expressions that name fields are rewritten to data.<field_id>; a name that is not a field imports the rule disabled with expression_unresolved.
  • confidence thresholds go from 0–100 to 0–1 with confidence_heuristic: the imported confidence is heuristic until it is recalibrated on your data.

T09 rules have no enabled flag yet, so a disabled rule is a placeholder: id prefix disabled_, name prefix [disabled], severity info, not blocking, and an applies_when that can never hold. The original is in the report.

The report

{"report_version": "1.0", "summary": {"mapped": 19, "approximated": 1, "unsupported": 0},
 "items": [{"status": "approximated", "code": "confidence_heuristic",
            "pointer": "/workflow/nodes/1/config/threshold",
            "message": "threshold 70 (0-100) became 0.7 (0-1); …",
            "detail": {"original": 70, "threshold": 0.7}}]}

Codes: node_type_unavailable, parse_mode_approximated, confidence_heuristic, regex_not_re2, expression_unresolved, field_unresolved, check_unsupported, persistent_id_missing, persistent_id_invalid, persistent_id_duplicate, duplicate_name_suffixed, lookup_table_unbound, lookup_file_missing, unknown_option. --strict exits 5 when there is any approximated or unsupported item.

Not covered

Downloading workflows from Anyformat's API, a compatibility facade for its endpoints and importing datasets or historical results are not planned. The nodes delivered by other tickets (notify, edit, report, knowledge…) are converted to their graph types; whether a server runs them depends on its registered node types, which the importer checks.