dirigent-examples 0.15.0__py3-none-any.whl

dirigent_examples/shelves/open-data/hdx-dataset-watch.yaml

@@ -0,0 +1,211 @@
+# Watching one HDX dataset for a new version, with a file in storage standing in for state.
+#
+# The Humanitarian Data Exchange runs CKAN, whose API is keyless for public datasets:
+# /api/3/action/package_show?id=<slug> answers {"success": true, "result": {...}}, and the
+# result carries `metadata_modified` -- an ISO timestamp that moves whenever anything about the
+# dataset changes -- plus a `resources` list, one entry per downloadable file with its own
+# `download_url` and `last_modified`.
+#
+# THE PATTERN THIS TEACHES IS THE MARKER. There is no state block: nothing in dirigent
+# remembers, between runs, what a previous run saw. What there is, is storage, and a marker is
+# just a small object written at a stable path holding what the last run observed. A sensor
+# looks for it, storage.read brings it back into the run, the comparison decides, and
+# storage.write puts the new one down. The whole state machine is a handful of steps and one
+# file, and it works the same against s3:// as against a local artifact root.
+#
+# Two consequences worth reading before copying this:
+#
+#   - The marker below is written under ${run.scratch}, which is deleted with the run, so every
+#     `--local` run is a first sighting: the sensor skips, the comparison skips with it, and the
+#     run ends succeeded having only written a marker. That is the honest first-run behaviour,
+#     and it is what the graph shows. On an instance, write the marker at a stable location --
+#     s3://your-bucket/markers/... -- and the second run is the one that compares.
+#   - The marker path is written out in the two steps that name it, the sensor and the last
+#     write, rather than kept in a parameter, because a parameter default is literal text:
+#     ${run.scratch} in a default is those characters and not a reference to anything.
+#
+# What happens, hop by hop:
+#
+#   dataset   one GET of the package. CKAN answers success/result even for an error, so the
+#             step's own 2xx check is not the whole story; the transform below reads .result
+#             and would fail loudly on anything else.
+#   current   what this run saw: the id, the stamp, and the resource list, reduced to what a
+#             consumer actually needs.
+#   seen      is there a marker? Five seconds is not a wait for the world, it is a lookup with
+#             a deadline; an absent marker skips this step and everything reading it.
+#   recalled  storage.read of that object, which is the only way the previous stamp comes back
+#             into the run.
+#   previous  the stamp taken out of it.
+#   moved     the comparison. Equal stamps produce an empty list, a moved stamp produces the
+#             resource urls: the decision is data, not a status.
+#   decided   storage.write, the decision put down as json, since the converter below reads a
+#             URI rather than a value.
+#   written   that list as ndjson, so an empty decision is an empty file.
+#   changed   the gate. One byte separates "the dataset moved" from "nothing happened", and
+#             a skip here skips the copy behind it while the run stays green.
+#   publish   storage.copy, promoting the url list to a path a downstream pipeline watches.
+#             Copying rather than rewriting keeps the published object byte-identical to what
+#             the decision produced.
+#   current_marker  what the next run should compare against, computed under rule: all_done so
+#             it is produced whether the dataset moved, did not move, or was seen for the
+#             first time.
+#   remember  that marker written over the old one. Writing it last is what makes a failed run
+#             repeatable: the marker only advances on a run that got all the way here.
+#
+# To make it yours: change dataset_id to any HDX slug, and give the marker a stable home.
+# The same shape watches any CKAN instance -- data.gov, the EU portal, a national one -- since
+# package_show and metadata_modified are CKAN's, not HDX's.
+#
+#   dg run --local examples/open-data/hdx-dataset-watch.yaml
+#   dg run --local examples/open-data/hdx-dataset-watch.yaml -p dataset_id=malawi-healthsites
+
+format: dirigent/v1
+kind: pipeline
+code: hdx-dataset-watch
+name: HDX dataset watch
+description: |
+  Poll one **HDX** (CKAN) dataset for a new `metadata_modified`, comparing against a marker
+  object in storage, and publish the resource url list when it moves.
+
+  There is no state block: the marker file *is* the state, and a sensor looking for it is how
+  a run asks whether there was a previous one.
+
+tags: [open-data, http, sensor, storage, transform, starter]
+
+requires:
+  blocks:
+    - http.request
+    - transform.jq
+    - convert.std
+    - storage.exists
+    - storage.read
+    - storage.write
+    - storage.copy
+
+params:
+  type: object
+  additionalProperties: false
+  properties:
+    dataset_id:
+      type: string
+      default: malawi-healthsites
+      description: An HDX dataset slug, as it appears in its page URL.
+
+steps:
+  dataset:
+    block: http.request
+    config:
+      url: https://data.humdata.org/api/3/action/package_show
+      query:
+        id: ${params.dataset_id}
+      # A package with many resources and a long description is still small, but not tiny.
+      max_response: 8mb
+
+  current:
+    block: transform.jq
+    depends_on: [dataset]
+    config:
+      input: ${steps.dataset.output.body}
+      # download_url rather than url: CKAN carries both, and for an uploaded file the plain
+      # url can be the landing page rather than the bytes.
+      program: |
+        .result
+        | {
+            id: .name,
+            title: .title,
+            metadata_modified: .metadata_modified,
+            resources: [.resources[]
+              | {name, format, last_modified, url: (.download_url // .url)}]
+          }
+
+  seen:
+    block: storage.exists
+    depends_on: [current]
+    poll: 1s
+    deadline: 5s
+    # No marker means no previous run to compare against. That is not a failure and not a
+    # reason to publish everything; it is a first sighting, and the branch below skips.
+    on_timeout: skip
+    config:
+      uri: ${run.scratch}/markers/${params.dataset_id}.json
+
+  recalled:
+    block: storage.read
+    depends_on: [seen]
+    config:
+      source: ${steps.seen.output.uri}
+
+  previous:
+    block: transform.jq
+    depends_on: [recalled]
+    config:
+      input: ${steps.recalled.output.value}
+      program: |
+        {metadata_modified}
+
+  moved:
+    block: transform.jq
+    depends_on: [current, previous]
+    config:
+      input:
+        current: ${steps.current.output.value}
+        previous: ${steps.previous.output.value}
+      # An empty list is a decision, not an absence: it says the stamps matched.
+      program: |
+        if .current.metadata_modified == .previous.metadata_modified
+        then []
+        else [.current.resources[].url]
+        end
+
+  decided:
+    block: storage.write
+    depends_on: [moved]
+    config:
+      target: ${run.scratch}/moved/${params.dataset_id}.json
+      value: ${steps.moved.output.value}
+
+  written:
+    block: convert.std
+    depends_on: [decided]
+    config:
+      source: ${steps.decided.output.uri}
+      target: ${run.scratch}/moved/${params.dataset_id}.ndjson
+      from: json
+      to: ndjson
+
+  changed:
+    block: storage.exists
+    depends_on: [written]
+    poll: 1s
+    deadline: 3s
+    on_timeout: skip
+    config:
+      uri: ${steps.written.output.target}
+      min_size: 1b
+
+  publish:
+    block: storage.copy
+    depends_on: [written, changed]
+    config:
+      source: ${steps.written.output.target}
+      target: ${run.scratch}/published/${params.dataset_id}-resources.ndjson
+
+  current_marker:
+    block: transform.jq
+    depends_on: [current, changed]
+    # all_done, because the marker has to advance on every outcome above it: a first sighting
+    # that skipped the comparison, a run where nothing moved, and a run that published.
+    rule: all_done
+    config:
+      input: ${steps.current.output.value}
+      program: |
+        {id, metadata_modified, resources: (.resources | length)}
+
+  remember:
+    block: storage.write
+    depends_on: [current_marker]
+    config:
+      # The same path the sensor at the top looks for, which is what makes this run's
+      # observation the next run's "previous".
+      target: ${run.scratch}/markers/${params.dataset_id}.json
+      value: ${steps.current_marker.output.value}

dirigent_examples/shelves/open-data/kobo-submissions-to-csv.yaml

@@ -0,0 +1,149 @@
+# Form submissions out of KoboToolbox and into a csv, with the one credential on this shelf.
+#
+# NEEDS A TOKEN. Everything else here is public and keyless; Kobo is not, and it should not be:
+# the submissions are somebody's household survey. The API token is per-account, printed at
+# <server>/token/?format=json once you are logged in, and it is sent as `Authorization: Token
+# <token>`. There is no anonymous mode to fall back to, so this document is the one example on
+# the shelf that cannot run against a stranger's server.
+#
+# Where the token belongs. It is a parameter here so the document reads as one piece, and a
+# parameter is *not* a secret store: it is recorded with the run and visible to anyone who can
+# read it. On an instance, create an http connection holding the token and give the step
+# `connection:` instead of `url:` and `headers:` --
+#
+#   dg connection create http kobo \
+#     --set base_url=https://kf.kobotoolbox.org \
+#     --set 'headers.Authorization=Token <your token>'
+#
+# -- and the credential is encrypted at rest, redacted in every API response, and rotated in
+# one place instead of in every run's parameters.
+#
+# The API: GET /api/v2/assets/{uid}/data/?format=json answers {"count": N, "next": ..., "results":
+# [...]}, one object per submission. Kobo's own fields are underscore-prefixed -- `_id`,
+# `_uuid`, `_submission_time`, `_geolocation` -- and everything else is a question, named by its
+# XLSForm column name, with a group's questions namespaced as `group/question`.
+#
+# What happens, hop by hop:
+#
+#   submissions  one GET. `limit` is Kobo's page size; a form with more submissions than that
+#             answers a `next` url, and reading past the first page means following it -- which
+#             this document deliberately does not do, because a paging loop is not a step.
+#   rows      the flattening. The Kobo metadata worth keeping becomes stable columns, and the
+#             questions named in `columns` become the rest. Naming the columns is what keeps a
+#             csv rectangular: submissions collected before a question was added simply do not
+#             have that key, and a codec cannot invent a header from a row that lacks it.
+#   staged    storage.write, the rows as json. A converter reads one URI and writes another, so
+#             the rows are put down before they can be re-encoded.
+#   report    json to csv in storage, named after the asset so several forms can share a
+#             prefix.
+#
+# To make it yours: set server if you self-host, asset_uid to the form's uid (it is in the URL
+# of the form's page), and columns to the questions you actually report on.
+#
+#   dg run --local examples/open-data/kobo-submissions-to-csv.yaml \
+#     -p asset_uid=aBcDeFgHiJkLmNoPqRsTuV -p token=<your token> \
+#     -p columns='["respondent_age","district"]'
+
+format: dirigent/v1
+kind: pipeline
+code: kobo-submissions-to-csv
+name: Kobo submissions to csv
+description: |
+  Submissions for one **KoboToolbox** form, flattened to named columns and written as csv.
+
+  The only document on this shelf that needs a credential: Kobo has no anonymous read, and the
+  token belongs in a connection on any instance you keep this on.
+
+tags: [open-data, http, storage, transform, credential, csv]
+
+requires:
+  blocks:
+    - http.request
+    - transform.jq
+    - storage.write
+    - convert.std
+
+params:
+  type: object
+  required: [asset_uid, token]
+  additionalProperties: false
+  properties:
+    server:
+      type: string
+      default: https://kf.kobotoolbox.org
+      description: The Kobo server; kf.kobotoolbox.org is the global one, and self-hosting is common.
+    asset_uid:
+      type: string
+      description: The form's uid, from its page URL.
+    token:
+      type: string
+      description: |
+        A Kobo API token, required: there is no public read. Given as a parameter only so this
+        document stands alone; on an instance it belongs in a connection.
+    columns:
+      type: array
+      default: []
+      items:
+        type: string
+      description: Question names to include as columns; empty means the keys of the first submission.
+    limit:
+      type: integer
+      default: 200
+      description: Kobo's page size; this document reads one page and does not follow `next`.
+
+steps:
+  submissions:
+    block: http.request
+    config:
+      url: ${params.server}/api/v2/assets/${params.asset_uid}/data/
+      headers:
+        # Kobo's scheme is the literal word Token, not Bearer.
+        Authorization: Token ${params.token}
+      query:
+        format: json
+        limit: ${params.limit}
+      # A survey with photos and long text answers is not small.
+      max_response: 64mb
+
+  rows:
+    block: transform.jq
+    depends_on: [submissions]
+    config:
+      input:
+        payload: ${steps.submissions.output.body}
+        columns: ${params.columns}
+      # The underscore-prefixed keys are Kobo's own and are renamed here; the questions are
+      # taken by name so every row has the same shape, which is what a csv requires. A
+      # submission missing one of them gets a null rather than a shorter row.
+      program: |
+        . as {$payload, $columns}
+        | ($payload.results // []) as $rows
+        | (if ($columns | length) > 0
+           then $columns
+           else ($rows[0] // {} | keys | map(select(startswith("_") | not)))
+           end) as $questions
+        | [$rows[]
+           | . as $row
+           | {
+               submission_id: ._id,
+               uuid: ._uuid,
+               submitted_at: ._submission_time,
+               submitted_by: (._submitted_by // null)
+             }
+             + (reduce $questions[] as $q ({}; .[$q] = ($row[$q] // null)))]
+
+  staged:
+    block: storage.write
+    depends_on: [rows]
+    config:
+      target: ${run.scratch}/kobo/${params.asset_uid}.json
+      value: ${steps.rows.output.value}
+
+  report:
+    block: convert.std
+    depends_on: [staged]
+    config:
+      source: ${steps.staged.output.uri}
+      target: ${run.scratch}/kobo/${params.asset_uid}.csv
+      from: json
+      to: csv

dirigent_examples/shelves/open-data/nominatim-geocode-facilities.yaml

@@ -0,0 +1,169 @@
+# A short list of facility names turned into coordinates, one request per second, as asked.
+#
+# Nominatim is OpenStreetMap's geocoder, public and keyless: GET /search?q=...&format=jsonv2
+# answers a list of candidates, best first, each with `lat` and `lon` as strings, a
+# `display_name`, a `category`/`type` pair saying what kind of thing it matched, and an
+# `importance` score. An empty list is the honest answer for a name it cannot place.
+#
+# The usage policy is the design constraint here, not the API. The public instance allows one
+# request per second from one client and asks for a User-Agent that identifies the application.
+# A fan-out would send every name at once, which is the polite way to get blocked, so the
+# lookups are written out as a chain with a `time.sleep` between them: the rate limit is in the
+# shape of the graph, where it is visible, rather than in a comment nobody enforces. Three names
+# is what a chain is good for; a list of three hundred belongs on your own Nominatim, and then
+# it is a fan-out.
+#
+# What happens, hop by hop:
+#
+#   facilities  the input, written into the document with value.const. It is a list of objects
+#             rather than strings, so a name a person recognises and the query string sent to
+#             the geocoder can differ -- which they always end up doing.
+#   lookup_*  one search each, indexed out of that list. A geocoder cannot promise a match, so
+#             each of these tolerates failure: continue_on_failure means a name that cannot be
+#             resolved leaves a row with no coordinates instead of ending the run.
+#   pause_*   one second, which is the whole point of the chain.
+#   table     the join. The three answers arrive as one list in this step's input, the first
+#             candidate of each is taken, and the strings Nominatim returns for lat and lon are
+#             turned into numbers -- a coordinate that has to be parsed before it can be
+#             compared is not a coordinate.
+#
+# To make it yours: replace the value.const list, and set user_agent to something that says who
+# you are. Any name that resolves ambiguously is worth sending with more context in `query`:
+# Nominatim reads "Central Hospital, Lilongwe, Malawi" far better than "Central Hospital".
+#
+#   dg run --local examples/open-data/nominatim-geocode-facilities.yaml
+
+format: dirigent/v1
+kind: pipeline
+code: nominatim-geocode-facilities
+name: Geocode facilities with Nominatim
+description: |
+  A handful of facility names geocoded through **Nominatim**, one request per second, joined
+  into one table of coordinates.
+
+  The rate limit is expressed as the shape of the graph: a chain with a `time.sleep` between
+  the lookups, not a fan-out.
+
+tags: [open-data, http, sensor, transform, geocode]
+
+requires:
+  blocks:
+    - value.const
+    - http.request
+    - time.sleep
+    - transform.jq
+
+params:
+  type: object
+  additionalProperties: false
+  properties:
+    user_agent:
+      type: string
+      default: dirigent-example/1.0 (https://github.com/winterop-com/dirigent)
+      description: Required by the usage policy; identify the application and how to reach you.
+    country_codes:
+      type: string
+      default: mw
+      description: ISO 3166-1 alpha-2 codes, comma-separated, that the search is confined to.
+
+steps:
+  facilities:
+    block: value.const
+    config:
+      # The list the run works from. `name` is what the output is keyed by and `query` is what
+      # is asked, because the name a register holds is rarely the string a geocoder wants.
+      value:
+        - name: Kamuzu Central Hospital
+          query: Kamuzu Central Hospital, Lilongwe, Malawi
+        - name: Queen Elizabeth Central Hospital
+          query: Queen Elizabeth Central Hospital, Blantyre, Malawi
+        - name: Mzuzu Central Hospital
+          query: Mzuzu Central Hospital, Mzuzu, Malawi
+
+  lookup_1:
+    block: http.request
+    depends_on: [facilities]
+    # A name the geocoder cannot place is a fact about the name, not a broken pipeline; the
+    # chain carries on and the table below records the gap.
+    continue_on_failure: true
+    config:
+      url: https://nominatim.openstreetmap.org/search
+      headers:
+        User-Agent: ${params.user_agent}
+      query:
+        q: ${steps.facilities.output.value.0.query}
+        # jsonv2 rather than json: it is the current shape, and it names the match's category
+        # and type, which is how you tell a hospital from a bus stop called after one.
+        format: jsonv2
+        limit: 1
+        countrycodes: ${params.country_codes}
+
+  pause_1:
+    block: time.sleep
+    depends_on: [lookup_1]
+    # The policy is one request per second from one client, so the wait sits between the
+    # requests and not beside them.
+    config:
+      for: 1s
+
+  lookup_2:
+    block: http.request
+    depends_on: [facilities, pause_1]
+    continue_on_failure: true
+    config:
+      url: https://nominatim.openstreetmap.org/search
+      headers:
+        User-Agent: ${params.user_agent}
+      query:
+        q: ${steps.facilities.output.value.1.query}
+        format: jsonv2
+        limit: 1
+        countrycodes: ${params.country_codes}
+
+  pause_2:
+    block: time.sleep
+    depends_on: [lookup_2]
+    config:
+      for: 1s
+
+  lookup_3:
+    block: http.request
+    depends_on: [facilities, pause_2]
+    continue_on_failure: true
+    config:
+      url: https://nominatim.openstreetmap.org/search
+      headers:
+        User-Agent: ${params.user_agent}
+      query:
+        q: ${steps.facilities.output.value.2.query}
+        format: jsonv2
+        limit: 1
+        countrycodes: ${params.country_codes}
+
+  table:
+    block: transform.jq
+    depends_on: [facilities, lookup_1, lookup_2, lookup_3]
+    config:
+      input:
+        facilities: ${steps.facilities.output.value}
+        answers:
+          - ${steps.lookup_1.output.body}
+          - ${steps.lookup_2.output.body}
+          - ${steps.lookup_3.output.body}
+      # lat and lon arrive as strings; tonumber here is what stops every later consumer from
+      # guessing. A name with no candidate keeps its row, with nulls where the coordinate
+      # would be, so the gap is countable.
+      program: |
+        [range(.facilities | length) as $i
+         | .facilities[$i] as $facility
+         | (.answers[$i][0] // null) as $hit
+         | {
+             name: $facility.name,
+             query: $facility.query,
+             matched: ($hit != null),
+             display_name: ($hit.display_name // null),
+             category: ($hit.category // null),
+             kind: ($hit.type // null),
+             latitude: (if $hit then ($hit.lat | tonumber) else null end),
+             longitude: (if $hit then ($hit.lon | tonumber) else null end)
+           }]

dirigent_examples/shelves/open-data/odk-central-submissions.yaml

@@ -0,0 +1,146 @@
+# The same survey story against ODK Central, where the credential lives in a connection.
+#
+# NEEDS AN ODK CENTRAL SERVER AND AN ACCOUNT. Central serves nothing anonymously, so this
+# document names a connection the instance holds rather than carrying anything itself:
+#
+#   dg connection create http odk-central \
+#     --set base_url=https://central.example.org \
+#     --set basic_username=you@example.org \
+#     --set basic_password='<your password>'
+#
+# Central accepts HTTP Basic on the /v1 API, which is what makes a plain http connection enough
+# and why this document has no session step: the alternative is POST /v1/sessions to trade the
+# password for a bearer token, which is a second request and a token to keep alive for no gain
+# in a pipeline that runs once an hour.
+#
+# The API: every form exposes an OData feed at
+# /v1/projects/{id}/forms/{xmlFormId}.svc/Submissions, answering {"@odata.context": ...,
+# "value": [...]} -- one object per submission, questions at the top level, groups nested as
+# objects, and Central's own metadata under `__id` and `__system` (`submissionDate`,
+# `submitterId`, `reviewState`). Central will also hand you the whole form as csv at
+# /v1/projects/{id}/forms/{xmlFormId}/submissions.csv, and that is the better answer when a csv
+# is all you want; the feed is what you read when the pipeline has to filter, reshape, or check
+# the data before anything downstream sees it.
+#
+# What happens, hop by hop:
+#
+#   submissions  one GET through the connection. $top is OData's page size and $skip its
+#             offset; Central also honours $filter over __system/submissionDate, which is the
+#             natural place to put a run window on a scheduled load.
+#   rows      the flattening: Central's metadata renamed into stable columns, the named
+#             questions read with a path so a grouped question is reachable as "group/field",
+#             and every row given the same keys.
+#   staged    storage.write, the rows as json, because a converter reads a URI rather than a
+#             value the run is holding.
+#   report    csv in storage, named for the form.
+#
+# To make it yours: set project and form_id, list the questions you report on, and add a
+# $filter to the query once the form has more submissions than one page.
+#
+#   dg apply examples/open-data/odk-central-submissions.yaml
+#   dg run odk-central-submissions -p project=1 -p form_id=household-survey --watch
+
+format: dirigent/v1
+kind: pipeline
+code: odk-central-submissions
+name: ODK Central submissions
+description: |
+  Submissions for one **ODK Central** form, read from its OData feed through a connection that
+  holds the credential, flattened to named columns and written as csv.
+
+  Central serves nothing anonymously, so the credential is a connection the instance holds --
+  the same shape as the Kobo document, with the secret in the right place.
+
+tags: [open-data, http, storage, transform, credential, csv]
+
+requires:
+  blocks:
+    - http.request
+    - transform.jq
+    - storage.write
+    - convert.std
+  connections:
+    - odk-central
+
+params:
+  type: object
+  required: [project, form_id]
+  additionalProperties: false
+  properties:
+    project:
+      type: integer
+      description: The numeric project id, as it appears in Central's own URLs.
+    form_id:
+      type: string
+      description: The form's xmlFormId, which is the id inside the XLSForm and not its title.
+    columns:
+      type: array
+      default: []
+      items:
+        type: string
+      description: |
+        Question paths to include, slash-separated for a grouped question ("group/field");
+        empty means the top-level keys of the first submission.
+    top:
+      type: integer
+      default: 250
+      description: OData's page size; this document reads one page.
+
+steps:
+  submissions:
+    block: http.request
+    config:
+      # The base URL is the connection's, so moving from a staging Central to a production one
+      # edits the connection and no pipeline.
+      connection: odk-central
+      path: /v1/projects/${params.project}/forms/${params.form_id}.svc/Submissions
+      query:
+        # OData's own parameter names, dollar signs included.
+        $top: ${params.top}
+        # Without this the feed answers only the current version's fields, which silently
+        # drops answers collected under an earlier form version.
+        $expand: "*"
+      max_response: 64mb
+
+  rows:
+    block: transform.jq
+    depends_on: [submissions]
+    config:
+      input:
+        payload: ${steps.submissions.output.body}
+        columns: ${params.columns}
+      # getpath is what makes a grouped question reachable: "hh/members" is a path into a
+      # nested object, and splitting on "/" turns the column name into that path.
+      program: |
+        . as {$payload, $columns}
+        | ($payload.value // []) as $rows
+        | (if ($columns | length) > 0
+           then $columns
+           else ($rows[0] // {} | keys | map(select(startswith("__") | not)))
+           end) as $questions
+        | [$rows[]
+           | . as $row
+           | {
+               submission_id: .__id,
+               submitted_at: .__system.submissionDate,
+               submitter_id: .__system.submitterId,
+               review_state: .__system.reviewState
+             }
+             + (reduce $questions[] as $q
+                  ({}; .[$q] = ($row | getpath($q | split("/")) // null)))]
+
+  staged:
+    block: storage.write
+    depends_on: [rows]
+    config:
+      target: ${run.scratch}/odk/${params.form_id}.json
+      value: ${steps.rows.output.value}
+
+  report:
+    block: convert.std
+    depends_on: [staged]
+    config:
+      source: ${steps.staged.output.uri}
+      target: ${run.scratch}/odk/${params.form_id}.csv
+      from: json
+      to: csv