notebooks/actinia_process_chain.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Image](actinia_logo.png)\n",
    "\n",
    "## User defined processing\n",
    "\n",
    "### The actinia process chain\n",
    "\n",
    "Actinia provides the **process chain** approach to specify import,\n",
    "processing and export of geodata using the actinia GRASS GIS processing\n",
    "system. The process chain must be formulated in JSON. The processing is\n",
    "always performed in an ephemeral database. The computational environment\n",
    "is based on locations in the persistent database. If required, the\n",
    "ephemeral database can be moved into the persistent user database, so\n",
    "that the computational results can be used in further processing steps\n",
    "or visualized using the actinia rendering REST calls.\n",
    "\n",
    "The ephemeral database will be removed after computation. However, all\n",
    "raster and vector data that was generated during the processing can be\n",
    "exported using GDAL/OGR specific datatypes and stored in an object\n",
    "storage, outside the actinia environment. Within a process chain we have\n",
    "read only access to all raster maps of the persistent database location\n",
    "that is used as computational environment.\n",
    "\n",
    "<!---\n",
    "no longer generated: https://actinia.mundialis.de/api_docs\n",
    "--->\n",
    "A process chain is a list of [GRASS GIS modules](https://grass.osgeo.org/grass-stable/manuals/index.html) that will be executed in serial, based on the order of the list. GRASS GIS modules are specified as [process definitions](https://redocly.github.io/redoc/?url=https://actinia.mundialis.de/latest/swagger.json#tag/Processing) that include the name of the command, the inputs and outputs, including import and export definitions as well as the module flags.\n",
    "\n",
    "This tutorial demonstrates the actinia REST service access using the Python\n",
    "library **requests**.\n",
    "\n",
    "The following example is a Jupyter Notebook version of the online [actinia tutorial](https://actinia-dev.mundialis.de/tutorial/tutorial_process_chain.html). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### actinia API documentation\n",
    "\n",
    "* [Stable actinia API v3 docs](https://redocly.github.io/redoc/?url=https://actinia.mundialis.de/api/v3/swagger.json)\n",
    "* [Development actinia API v3 docs](https://redocly.github.io/redoc/?url=https://actinia-dev.mundialis.de/api/v3/swagger.json)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Requirements\n",
    "\n",
    "#### Software & Modules\n",
    "\n",
    "This tutorial assumes your are comfortable with the [Python](https://python.org) programming language. Familiarity with basic REST API concepts and usage is also assumed.\n",
    "\n",
    "Python modules used in this tutorial are:\n",
    "* [requests](http://docs.python-requests.org/)\n",
    "* [json](https://docs.python.org/3/library/json.html)\n",
    "\n",
    "\n",
    "#### ACTINIA API user and password\n",
    "\n",
    "This demo requires credentials for authentication set below in **Preparation** as a variable. Another actinia instance might require different credentials."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper Modules and Functions\n",
    "Before interacting with the actinia server using Python, we will import required packages an set up a helper function to print formatted JSON using json.\n",
    "\n",
    "***Note:*** *You may need to install two helpful browser plugins called **RESTman** and **JSON Formatter** that format JSON and makes it easier to read:*\n",
    "\n",
    "* [RESTman extension](https://chrome.google.com/webstore/detail/restman/ihgpcfpkpmdcghlnaofdmjkoemnlijdi)\n",
    "* [JSON Formatter](https://chrome.google.com/webstore/detail/json-formatter/bcjindcccaagfpapjjmafapmmgkkhgoa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first, let's import the required packages.\n",
    "\n",
    "from pprint import pprint\n",
    "import sys\n",
    "import json\n",
    "import time\n",
    "\n",
    "import requests\n",
    "from requests.auth import HTTPBasicAuth\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "To simplify our life in terms of server communication we store the credentials and REST server URL in  variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# variables to set the actinia host, version, and user\n",
    "\n",
    "actinia_baseurl = \"https://actinia.mundialis.de\"\n",
    "actinia_version = \"v3\"\n",
    "actinia_url = actinia_baseurl + \"/api/\" + actinia_version\n",
    "actinia_auth = HTTPBasicAuth('demouser', 'gu3st!pa55w0rd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# helper function to print formatted JSON using the json module\n",
    "\n",
    "def print_as_json(data):\n",
    "    print(json.dumps(data, indent=2))\n",
    "\n",
    "# helper function to verify a request\n",
    "def verify_request(request, success_code=200):\n",
    "    if request.status_code != success_code:\n",
    "        print(\"ERROR: actinia processing failed with status code %d!\" % request.status_code)\n",
    "        print(\"See errors below:\")\n",
    "        print_as_json(request.json())\n",
    "        request_url = request.json()[\"urls\"][\"status\"]\n",
    "        requests.delete(url=request_url, auth=actinia_auth)\n",
    "        raise Exception(\"The resource <%s> has been terminated.\" % request_url)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examples\n",
    "\n",
    "The following example defines a single process\n",
    "that runs the GRASS GIS module [*r.slope.aspect*](https://grass.osgeo.org/grass-stable/manuals/r.slope.aspect.html) to compute the\n",
    "*slope* for the raster map layer *elev_ned_30m* that is located in the\n",
    "[mapset](https://grass.osgeo.org/grass-stable/manuals/grass_database.html) *PERMANENT*. The output of the module is named\n",
    "*elev_ned_30m_slope* and should be exported as a GeoTiff file.\n",
    "\n",
    "The corresponding process chain item as JSON:\n",
    "\n",
    "```json\n",
    " {\n",
    "   \"module\": \"r.slope.aspect\",\n",
    "   \"id\": \"r_slope_aspect_1\",\n",
    "   \"inputs\": [\n",
    "     {\n",
    "       \"param\": \"elevation\",\n",
    "       \"value\": \"elev_ned_30m@PERMANENT\"\n",
    "     }\n",
    "   ],\n",
    "   \"outputs\": [\n",
    "     {\n",
    "       \"export\": {\n",
    "         \"format\": \"GTiff\",\n",
    "         \"type\": \"raster\"\n",
    "       },\n",
    "       \"param\": \"slope\",\n",
    "       \"value\": \"elev_ned_30m_slope\"\n",
    "     }\n",
    "   ],\n",
    "   \"flags\": \"a\"\n",
    " }\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Import and export**\n",
    "\n",
    "The actinia process chain supports the specification of URL\\'s to raster\n",
    "layers in the input definition. The following process chain imports a\n",
    "raster map layer that is located in an object storage with the name\n",
    "*elev_ned_30m_new* and sets the computational region for the\n",
    "following processing step with the GRASS GIS module [*g.region*](https://grass.osgeo.org/grass-stable/manuals/g.region.html). Then\n",
    "slope and aspect are computed with *r.slope.aspect* and specified for\n",
    "export as GeoTiff files.\n",
    "\n",
    "The corresponding process chain as JSON:\n",
    "\n",
    "\n",
    "```json\n",
    " {\n",
    "   \"list\": [\n",
    "     {\n",
    "       \"module\": \"g.region\",\n",
    "       \"id\": \"g_region_1\",\n",
    "       \"inputs\": [\n",
    "         {\n",
    "           \"import_descr\": {\n",
    "             \"source\": \"https://storage.googleapis.com/graas-geodata/elev_ned_30m.tif\",\n",
    "             \"type\": \"raster\"\n",
    "           },\n",
    "           \"param\": \"raster\",\n",
    "           \"value\": \"elev_ned_30m_new\"\n",
    "         }\n",
    "       ],\n",
    "       \"flags\": \"p\"\n",
    "     },\n",
    "     {\n",
    "       \"module\": \"r.slope.aspect\",\n",
    "       \"id\": \"r_slope_aspect_1\",\n",
    "       \"inputs\": [\n",
    "         {\n",
    "           \"param\": \"elevation\",\n",
    "           \"value\": \"elev_ned_30m_new\"\n",
    "         }\n",
    "       ],\n",
    "       \"outputs\": [\n",
    "         {\n",
    "           \"export\": {\n",
    "             \"format\": \"GTiff\",\n",
    "             \"type\": \"raster\"\n",
    "           },\n",
    "           \"param\": \"slope\",\n",
    "           \"value\": \"elev_ned_30m_new_slope\"\n",
    "         }\n",
    "       ],\n",
    "       \"flags\": \"a\"\n",
    "     }\n",
    "   ],\n",
    "   \"version\": \"1\"\n",
    " }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Output parsing**\n",
    "\n",
    "Many GRASS GIS modules produce textual output in form of lists, tables\n",
    "and key/value pairs. Actinia supports the analysis of this data and the\n",
    "parsing and transformation in JSON accessible data. For each GRASS GIS\n",
    "module the property \\\"stdout\\\" can be specified to transform the output\n",
    "of the module into a list of values, a key/value list or a table.\n",
    "\n",
    "The following options are available as format:\n",
    "\n",
    " -   \\\"kv\\\" parses the module output and creates key/value pairs\n",
    " -   \\\"list\\\" parses the module output and creates a list of values\n",
    " -   \\\"table\\\" parses the module output and creates a list of lists\n",
    "     with values aka 2D array aka table\n",
    "\n",
    "Additionally the unique id that will be used in the response process\n",
    "result dictionary and the delimiter must be defined.\n",
    "\n",
    "The following process chain demonstrates all available approaches, to\n",
    "parse the stdout output of a module:\n",
    "\n",
    "```json\n",
    " {\n",
    "     \"version\": 1,\n",
    "     \"list\": [\n",
    "         {\n",
    "             \"id\": \"1\",\n",
    "             \"module\": \"g.region\",\n",
    "             \"inputs\": [\n",
    "                 {\"param\": \"raster\",\n",
    "                  \"value\": \"elevation@PERMANENT\"},\n",
    "                 {\"param\": \"res\",\n",
    "                  \"value\": \"5000\"}\n",
    "             ],\n",
    "             \"stdout\": {\"id\": \"region\", \"format\": \"kv\", \"delimiter\": \"=\"},\n",
    "             \"flags\": \"g\"\n",
    "         },\n",
    "         {\n",
    "             \"id\": \"2\",\n",
    "             \"module\": \"r.out.ascii\",\n",
    "             \"inputs\": [{\"param\": \"input\",\n",
    "                         \"value\": \"elevation@PERMANENT\"},\n",
    "                        {\"param\": \"precision\", \"value\": \"0\"}],\n",
    "             \"stdout\": {\"id\": \"elevation\", \"format\": \"table\", \"delimiter\": \" \"},\n",
    "             \"flags\": \"h\"\n",
    "         },\n",
    "         {\n",
    "             \"id\": \"3\",\n",
    "             \"module\": \"g.list\",\n",
    "             \"inputs\": [{\"param\": \"type\",\n",
    "                         \"value\": \"raster\"}],\n",
    "             \"stdout\": {\"id\": \"map_list\", \"format\": \"list\", \"delimiter\": \"\\n\"}\n",
    "         },\n",
    "         {\n",
    "             \"id\": \"4\",\n",
    "             \"module\": \"r.univar\",\n",
    "             \"inputs\": [{\"param\": \"map\",\n",
    "                         \"value\": \"elevation@PERMANENT\"}],\n",
    "             \"stdout\": {\"id\": \"stats\", \"format\": \"kv\", \"delimiter\": \"=\"},\n",
    "             \"flags\": \"g\"\n",
    "         },\n",
    "         {\n",
    "             \"id\": \"5\",\n",
    "             \"module\": \"r.univar\",\n",
    "             \"inputs\": [{\"param\": \"map\",\n",
    "                         \"value\": \"elevation@PERMANENT\"},\n",
    "                        {\"param\": \"zones\",\n",
    "                         \"value\": \"basin_50K@PERMANENT\"},\n",
    "                        {\"param\": \"separator\",\n",
    "                         \"value\": \"pipe\"}],\n",
    "             \"stdout\": {\"id\": \"stats_zonal\", \"format\": \"table\", \"delimiter\": \"|\"},\n",
    "             \"flags\": \"t\"\n",
    "         }\n",
    "     ]\n",
    " }\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's send this process chain to actinia: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a POST request to the actinia data API\n",
    "request_url = actinia_url + \"/locations/nc_spm_08/processing_async\"\n",
    "print(\"actinia POST request:\")\n",
    "print(request_url)\n",
    "print(\"---\")\n",
    "\n",
    "process_chain = {\n",
    "     \"version\": 1,\n",
    "     \"list\": [\n",
    "         {\n",
    "             \"id\": \"1\",\n",
    "             \"module\": \"g.region\",\n",
    "             \"inputs\": [\n",
    "                 {\"param\": \"raster\",\n",
    "                  \"value\": \"elevation@PERMANENT\"},\n",
    "                 {\"param\": \"res\",\n",
    "                  \"value\": \"5000\"}\n",
    "             ],\n",
    "             \"stdout\": {\"id\": \"region\", \"format\": \"kv\", \"delimiter\": \"=\"},\n",
    "             \"flags\": \"g\"\n",
    "         },\n",
    "         {\n",
    "             \"id\": \"2\",\n",
    "             \"module\": \"r.out.ascii\",\n",
    "             \"inputs\": [{\"param\": \"input\",\n",
    "                         \"value\": \"elevation@PERMANENT\"},\n",
    "                        {\"param\": \"precision\", \"value\": \"0\"}],\n",
    "             \"stdout\": {\"id\": \"elevation\", \"format\": \"table\", \"delimiter\": \" \"},\n",
    "             \"flags\": \"h\"\n",
    "         },\n",
    "         {\n",
    "             \"id\": \"3\",\n",
    "             \"module\": \"g.list\",\n",
    "             \"inputs\": [{\"param\": \"type\",\n",
    "                         \"value\": \"raster\"}],\n",
    "             \"stdout\": {\"id\": \"map_list\", \"format\": \"list\", \"delimiter\": \"\\n\"}\n",
    "         },\n",
    "         {\n",
    "             \"id\": \"4\",\n",
    "             \"module\": \"r.univar\",\n",
    "             \"inputs\": [{\"param\": \"map\",\n",
    "                         \"value\": \"elevation@PERMANENT\"}],\n",
    "             \"stdout\": {\"id\": \"stats\", \"format\": \"kv\", \"delimiter\": \"=\"},\n",
    "             \"flags\": \"g\"\n",
    "         },\n",
    "         {\n",
    "             \"id\": \"5\",\n",
    "             \"module\": \"r.univar\",\n",
    "             \"inputs\": [{\"param\": \"map\",\n",
    "                         \"value\": \"elevation@PERMANENT\"},\n",
    "                        {\"param\": \"zones\",\n",
    "                         \"value\": \"basin_50K@PERMANENT\"},\n",
    "                        {\"param\": \"separator\",\n",
    "                         \"value\": \"pipe\"}],\n",
    "             \"stdout\": {\"id\": \"stats_zonal\", \"format\": \"table\", \"delimiter\": \"|\"},\n",
    "             \"flags\": \"t\"\n",
    "         }\n",
    "     ]\n",
    " }\n",
    "\n",
    "request = requests.post(url=request_url, auth=actinia_auth, json=process_chain)\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The response provides the status URL that must be polled to receive the\n",
    "finished response:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get a json-encoded content of the response\n",
    "jsonResponse = request.json()\n",
    "\n",
    "print(\"Response with status code %d:\" % request.status_code)\n",
    "\n",
    "# print formatted JSON\n",
    "print_as_json(jsonResponse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poll the status of the asynchronous API call by polling the status URL.\n",
    "Be aware that you have to use the current status url as the resource id will change for different API\n",
    "calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a GET request to the actinia data API\n",
    "request_url = jsonResponse[\"urls\"][\"status\"]\n",
    "print(\"actinia GET request:\")\n",
    "print(request_url)\n",
    "print(\"---\")\n",
    "\n",
    "request = requests.get(url=request_url, auth=actinia_auth)\n",
    "\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)\n",
    "\n",
    "# get a json-encoded content of the response\n",
    "jsonResponse = request.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poll until there is a message **\"Processing successfully finished\"**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# continue polling until finished\n",
    "while request.status_code == 200 and \\\n",
    "        jsonResponse[\"message\"] != \"Processing successfully finished\":\n",
    "    request = requests.get(url=request_url, auth=actinia_auth)\n",
    "    jsonResponse = request.json()\n",
    "\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result of the process chain evaluation is the following JSON\n",
    "response.\n",
    "\n",
    "The result of the stdout output parsing for each module is located in\n",
    "the \"process_results\" section of the json response."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print formatted JSON\n",
    "print_as_json(jsonResponse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a process chain step-by-step\n",
    "\n",
    "First, create an empty process chain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a POST request to the Actinia Data API\n",
    "request_url = actinia_url + \"/locations/nc_spm_08/processing_async\"\n",
    "\n",
    "process_chain = {\"version\": 1, \"list\": []}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set up a helper function to create list items "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to create a process chain item\n",
    "\n",
    "def create_actinia_pc_item(id, module,\n",
    "                           inputs=None, outputs=None, flags=None, stdin=None, stdout=None,\n",
    "                           overwrite=False, superquiet=False, verbose=False, interface_description=False):\n",
    "    \"\"\"\n",
    "    Creates a list item for an actinia process chain\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    id: str\n",
    "        unique id for this item\n",
    "    module: str\n",
    "        some valid GRASS or actinia module\n",
    "    inputs: list or dict\n",
    "        list of input parameters with values in the form\n",
    "        [{\"param\": key1, \"value\": value1}, {\"param\": key2, \"value\": value2}, ...]\n",
    "        shorter alternative as dict\n",
    "        {\"key1\": value1, \"key2\": value2, ...}\n",
    "    outputs: list or dict\n",
    "        list of output parameters with values in the form\n",
    "        [{\"param\": key1, \"value\": value1}, {\"param\": key2, \"value\": value2}, ...]\n",
    "        shorter alternative as dict\n",
    "        {\"key1\": value1, \"key2\": value2, ...}\n",
    "    flags: str\n",
    "        optional flags for the module\n",
    "    stdin: dict\n",
    "        options to read stdin\n",
    "    stdout: dict\n",
    "        options to write to stdout\n",
    "        must be of the form\n",
    "        {\"id\": value1, \"format\": value2, \"delimiter\": value3}\n",
    "    overwrite: bool\n",
    "        optional, set to True to allow overwriting existing data\n",
    "    superquiet: bool\n",
    "        optional, set to True to suppress all messages but errors\n",
    "    verbose: bool\n",
    "        optional, set to True to allow verbose messages\n",
    "    interface_description: bool\n",
    "        optional, set to True to create an interface_description\n",
    "    \"\"\"\n",
    "    pc_item = {\"id\": str(id), \"module\": module}\n",
    "    if inputs:\n",
    "        if isinstance(inputs, list):\n",
    "            pc_item[\"inputs\"] = inputs\n",
    "        elif isinstance(inputs, dict):\n",
    "            tmplist = []\n",
    "            for k, v in inputs.items():\n",
    "                tmplist.append({\"param\": k, \"value\": v})\n",
    "            pc_item[\"inputs\"] = tmplist\n",
    "    if outputs:\n",
    "        if isinstance(outputs, list):\n",
    "            pc_item[\"outputs\"] = outputs\n",
    "        elif isinstance(outputs, dict):\n",
    "            tmplist = []\n",
    "            for k, v in outputs.items():\n",
    "                tmplist.append({\"param\": k, \"value\": v})\n",
    "            pc_item[\"outputs\"] = tmplist\n",
    "    if flags:\n",
    "        pc_item[\"flags\"] = flags\n",
    "    if stdin:\n",
    "        pc_item[\"stdin\"] = stdin\n",
    "    if stdout:\n",
    "        pc_item[\"stdout\"] = stdout\n",
    "    if overwrite is True:\n",
    "        pc_item[\"overwrite\"] = True\n",
    "    if superquiet is True:\n",
    "        pc_item[\"superquiet\"] = True\n",
    "    if verbose is True:\n",
    "        pc_item[\"verbose\"] = True\n",
    "    if interface_description is True:\n",
    "        pc_item[\"interface_description\"] = True\n",
    "\n",
    "    return pc_item\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add items to the process chain list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list item for g.region\n",
    "list_id = 1\n",
    "# long form, as in a process chain\n",
    "#inputs = [{\"param\": \"raster\",\n",
    "#           \"value\": \"elevation@PERMANENT\"},\n",
    "#          {\"param\": \"res\",\n",
    "#           \"value\": \"5000\"}\n",
    "#         ]\n",
    "\n",
    "# short form, accepted by create_actinia_pc_item\n",
    "inputs = {\"raster\": \"elevation@PERMANENT\",\n",
    "          \"res\": \"5000\"}\n",
    "\n",
    "stdout = {\"id\": \"region\", \"format\": \"kv\", \"delimiter\": \"=\"}\n",
    "flags = \"g\"\n",
    "pc_item = create_actinia_pc_item(id=list_id,\n",
    "                                 module=\"g.region\",\n",
    "                                 inputs=inputs,\n",
    "                                 flags=flags)\n",
    "process_chain[\"list\"].append(pc_item)\n",
    "\n",
    "print_as_json(process_chain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list item for r.out.ascii\n",
    "list_id += 1\n",
    "# long form\n",
    "inputs = [{\"param\": \"input\",\n",
    "           \"value\": \"elevation@PERMANENT\"},\n",
    "          {\"param\": \"precision\", \"value\": \"0\"}]\n",
    "\n",
    "# short form\n",
    "inputs = {\"input\": \"elevation@PERMANENT\",\n",
    "          \"precision\": \"0\"}\n",
    "\n",
    "stdout = {\"id\": \"elevation\", \"format\": \"table\", \"delimiter\": \" \"}\n",
    "flags = \"h\"\n",
    "pc_item = create_actinia_pc_item(id=list_id,\n",
    "                                 module=\"r.out.ascii\",\n",
    "                                 inputs=inputs,\n",
    "                                 stdout=stdout,\n",
    "                                 flags=flags)\n",
    "process_chain[\"list\"].append(pc_item)\n",
    "\n",
    "print_as_json(process_chain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list item for g.list\n",
    "list_id += 1\n",
    "# long form\n",
    "inputs = [{\"param\": \"type\",\n",
    "           \"value\": \"raster\"}]\n",
    "# short form\n",
    "inputs = {\"type\": \"raster\"}\n",
    "\n",
    "stdout = {\"id\": \"map_list\", \"format\": \"list\", \"delimiter\": \"\\n\"}\n",
    "pc_item = create_actinia_pc_item(id=list_id,\n",
    "                                 module=\"g.list\",\n",
    "                                 inputs=inputs,\n",
    "                                 stdout=stdout)\n",
    "process_chain[\"list\"].append(pc_item)\n",
    "\n",
    "print_as_json(process_chain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list item for r.univar (key-value output)\n",
    "list_id += 1\n",
    "# long form\n",
    "inputs = [{\"param\": \"map\",\n",
    "           \"value\": \"elevation@PERMANENT\"}]\n",
    "# short form\n",
    "inputs = {\"map\": \"elevation@PERMANENT\"}\n",
    "\n",
    "stdout = {\"id\": \"stats\", \"format\": \"kv\", \"delimiter\": \"=\"}\n",
    "flags = \"g\"\n",
    "pc_item = create_actinia_pc_item(id=list_id,\n",
    "                                 module=\"r.univar\",\n",
    "                                 inputs=inputs,\n",
    "                                 stdout=stdout,\n",
    "                                 flags=flags)\n",
    "process_chain[\"list\"].append(pc_item)\n",
    "\n",
    "print_as_json(process_chain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list item for r.univar (table output)\n",
    "list_id += 1\n",
    "# long form\n",
    "inputs = [{\"param\": \"map\",\n",
    "           \"value\": \"elevation@PERMANENT\"},\n",
    "          {\"param\": \"zones\",\n",
    "                    \"value\": \"basin_50K@PERMANENT\"},\n",
    "          {\"param\": \"separator\",\n",
    "           \"value\": \"pipe\"}]\n",
    "# short form\n",
    "inputs = {\"map\": \"elevation@PERMANENT\",\n",
    "          \"zones\": \"basin_50K@PERMANENT\",\n",
    "          \"separator\": \"pipe\"}\n",
    "\n",
    "stdout = {\"id\": \"stats_zonal\", \"format\": \"table\", \"delimiter\": \"|\"}\n",
    "flags = \"t\"\n",
    "pc_item = create_actinia_pc_item(id=list_id,\n",
    "                                 module=\"r.univar\",\n",
    "                                 inputs=inputs,\n",
    "                                 stdout=stdout,\n",
    "                                 flags=flags)\n",
    "process_chain[\"list\"].append(pc_item)\n",
    "\n",
    "print_as_json(process_chain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# submit the job\n",
    "request = requests.post(url=request_url, auth=actinia_auth, json=process_chain)\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get a json-encoded content of the response\n",
    "jsonResponse = request.json()\n",
    "\n",
    "print(\"Response with status code %d:\" % request.status_code)\n",
    "\n",
    "# print formatted JSON\n",
    "print_as_json(jsonResponse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a GET request to the Actinia Data API\n",
    "request_url = jsonResponse[\"urls\"][\"status\"]\n",
    "print(\"actinia GET request:\")\n",
    "print(request_url)\n",
    "print(\"---\")\n",
    "\n",
    "request = requests.get(url=request_url, auth=actinia_auth)\n",
    "\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)\n",
    "\n",
    "# get a json-encoded content of the response\n",
    "jsonResponse = request.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# continue polling until finished\n",
    "while request.status_code == 200 and \\\n",
    "        jsonResponse[\"message\"] != \"Processing successfully finished\":\n",
    "    request = requests.get(url=request_url, auth=actinia_auth)\n",
    "    jsonResponse = request.json()\n",
    "\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentinel-2A NDVI process chain\n",
    "\n",
    "We create a process chain that computes the NDVI from a Sentinel-2A\n",
    "scene based on the bands 8 and 4 with the GRASS GIS module *r.mapcalc*. We\n",
    "use the North Carolina sample location **nc\\_spm\\_08** as processing\n",
    "environment and the computational region of sentinel band B04 for the\n",
    "NDVI processing. Then we calculate univariate statistics for the\n",
    "Sentinel-2A scene. The computed NDVI raster layer will be exported as\n",
    "geotiff file that can be accessed via an URL.\n",
    "\n",
    "The following JSON code has 5 process definitions:\n",
    "\n",
    " 1.  Import of two bands (B04 and B08) of the Sentinel-2A scene\n",
    "     *S2A\\_MSIL2A\\_20220420T154941\\_N0400\\_R054\\_T18SUE\\_20220421T000632*\n",
    " 2.  Set the computational region to imported raster layer B04\n",
    " 3.  Use *r.mapcalc* to compute the NDVI\n",
    " 4.  Use *r.univar* to compute univariate statistics of the computed NDVI\n",
    "     raster layer\n",
    " 5.  Export the computed NDVI as GeoTiff\n",
    "\n",
    "Run the process chain asynchronously:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a POST request to the actinia data API\n",
    "request_url = actinia_url + \"/locations/nc_spm_08/processing_async_export\"\n",
    "print(\"actinia POST request:\")\n",
    "print(request_url)\n",
    "print(\"---\")\n",
    "\n",
    "process_chain = {\n",
    " \"list\": [{\"id\": \"importer_1\",\n",
    "           \"module\": \"importer\",\n",
    "           \"inputs\": [{\"import_descr\": {\"source\": \"S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632\",\n",
    "                                        \"type\": \"sentinel2\",\n",
    "                                        \"sentinel_band\": \"B04\"},\n",
    "                       \"param\": \"map\",\n",
    "                       \"value\": \"B04\"},\n",
    "                      {\"import_descr\": {\"source\": \"S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632\",\n",
    "                                        \"type\": \"sentinel2\",\n",
    "                                        \"sentinel_band\": \"B08\"},\n",
    "                       \"param\": \"map\",\n",
    "                       \"value\": \"B08\"}]},\n",
    "          {\"id\": \"g_region_1\",\n",
    "           \"module\": \"g.region\",\n",
    "           \"inputs\": [{\"param\": \"raster\",\n",
    "                       \"value\": \"B04\"}],\n",
    "           \"flags\": \"g\"},\n",
    "          {\"id\": \"rmapcalc_1\",\n",
    "           \"module\": \"r.mapcalc\",\n",
    "           \"inputs\": [{\"param\": \"expression\",\n",
    "                       \"value\": \"NDVI = float(B08 - B04)/(B08 + B04)\"}]},\n",
    "          {\"id\": \"r_univar_sentinel2\",\n",
    "           \"module\": \"r.univar\",\n",
    "           \"inputs\": [{\"param\": \"map\",\n",
    "                       \"value\": \"NDVI\"}],\n",
    "           \"flags\": \"g\"},\n",
    "          {\"id\": \"exporter_1\",\n",
    "           \"module\": \"exporter\",\n",
    "           \"outputs\": [{\"export\": {\"type\": \"raster\", \"format\": \"GTiff\"},\n",
    "                        \"param\": \"map\",\n",
    "                        \"value\": \"NDVI\"}]}\n",
    "          ],\n",
    " \"version\": \"1\"}\n",
    "\n",
    "request = requests.post(url=request_url, auth=actinia_auth, json=process_chain)\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)\n",
    "\n",
    "# get a json-encoded content of the response\n",
    "jsonResponse = request.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The response requires the polling of the status URL, since the API call\n",
    "works asynchronously:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a GET request to the actinia data API\n",
    "request_url = jsonResponse[\"urls\"][\"status\"]\n",
    "print(\"actinia GET request:\")\n",
    "print(request_url)\n",
    "print(\"---\")\n",
    "\n",
    "request = requests.get(url=request_url, auth=actinia_auth)\n",
    "\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)\n",
    "\n",
    "# get a json-encoded content of the response\n",
    "jsonResponse = request.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poll until there is a message **\"Processing successfully finished\"**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# continue polling until finished\n",
    "while request.status_code == 200 and \\\n",
    "        jsonResponse[\"message\"] != \"Processing successfully finished\":\n",
    "    request = requests.get(url=request_url, auth=actinia_auth)\n",
    "    jsonResponse = request.json()\n",
    "\n",
    "# check if anything went wrong\n",
    "verify_request(request, 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The finished response should look similar to this:\n",
    "```json\n",
    " {\n",
    "   \"accept_datetime\": \"2018-05-02 21:05:34.873031\",\n",
    "   \"accept_timestamp\": 1525287934.8730297,\n",
    "   \"api_info\": {\n",
    "     \"endpoint\": \"asyncephemeralexportresource\",\n",
    "     \"method\": \"POST\",\n",
    "     \"path\": \"/locations/nc_spm_08/processing_async_export\",\n",
    "     \"request_url\": \"http://actinia.mundialis.de/api/v3/locations/nc_spm_08/processing_async_export\"\n",
    "   },\n",
    "   \"datetime\": \"2018-05-02 21:09:39.823857\",\n",
    "   \"http_code\": 200,\n",
    "   \"message\": \"Processing successfully finished\",\n",
    "   \"process_chain_list\": [\n",
    "     {\n",
    "       \"list\": [\n",
    "         {\n",
    "           \"id\": \"importer_1\",\n",
    "           \"inputs\": [\n",
    "             {\n",
    "               \"import_descr\": {\n",
    "                 \"sentinel_band\": \"B04\",\n",
    "                 \"source\": \"S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632\",\n",
    "                 \"type\": \"sentinel2\"\n",
    "               },\n",
    "               \"param\": \"map\",\n",
    "               \"value\": \"B04\"\n",
    "             },\n",
    "             {\n",
    "               \"import_descr\": {\n",
    "                 \"sentinel_band\": \"B08\",\n",
    "                 \"source\": \"S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632\",\n",
    "                 \"type\": \"sentinel2\"\n",
    "               },\n",
    "               \"param\": \"map\",\n",
    "               \"value\": \"B08\"\n",
    "             }\n",
    "           ],\n",
    "           \"module\": \"importer\"\n",
    "         },\n",
    "         {\n",
    "           \"flags\": \"g\",\n",
    "           \"id\": \"g_region_1\",\n",
    "           \"inputs\": [\n",
    "             {\n",
    "               \"param\": \"raster\",\n",
    "               \"value\": \"B04\"\n",
    "             }\n",
    "           ],\n",
    "           \"module\": \"g.region\"\n",
    "         },\n",
    "         {\n",
    "           \"id\": \"rmapcalc_1\",\n",
    "           \"inputs\": [\n",
    "             {\n",
    "               \"param\": \"expression\",\n",
    "               \"value\": \"NDVI = float(B08 - B04)/(B08 + B04)\"\n",
    "             }\n",
    "           ],\n",
    "           \"module\": \"r.mapcalc\"\n",
    "         },\n",
    "         {\n",
    "           \"flags\": \"g\",\n",
    "           \"id\": \"r_univar_sentinel2\",\n",
    "           \"inputs\": [\n",
    "             {\n",
    "               \"param\": \"map\",\n",
    "               \"value\": \"NDVI\"\n",
    "             }\n",
    "           ],\n",
    "           \"module\": \"r.univar\"\n",
    "         },\n",
    "         {\n",
    "           \"id\": \"exporter_1\",\n",
    "           \"module\": \"exporter\",\n",
    "           \"outputs\": [\n",
    "             {\n",
    "               \"export\": {\n",
    "                 \"format\": \"GTiff\",\n",
    "                 \"type\": \"raster\"\n",
    "               },\n",
    "               \"param\": \"map\",\n",
    "               \"value\": \"NDVI\"\n",
    "             }\n",
    "           ]\n",
    "         }\n",
    "       ],\n",
    "       \"version\": \"1\"\n",
    "     }\n",
    "   ],\n",
    "   \"process_log\": [\n",
    "     {\n",
    "      \"executable\": \"i.sentinel.download\",\n",
    "      \"id\": \"i_sentinel_download_S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632\",\n",
    "      \"mapset_size\": 421,\n",
    "      \"parameter\": [\n",
    "        \"datasource=GCS\",\n",
    "        \"query=identifier=S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632\",\n",
    "        \"output=/actinia_core/workspace/temp_db/gisdbase_dbbd7bc372e942d0953fa0f7d019cacb/.tmp/temp_file_1\"\n",
    "      ],\n",
    "       \"return_code\": 0,\n",
    "       \"run_time\": 36.222164154052734,\n",
    "       \"stderr\": [\n",
    "         \"Downloading data into </actinia_core/workspace/temp_db/gisdbase_dbbd7bc372e942d0953fa0f7d019cacb/.tmp/temp_file_1>...\",\n",
    "        \"Downloading S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632...\",\n",
    "        \"...\",\n",
    "        \"Downloaded to /actinia_core/workspace/temp_db/gisdbase_dbbd7bc372e942d0953fa0f7d019cacb/.tmp/temp_file_1/S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632.SAFE\",\n",
    "        \"\"\n",
    "       ],\n",
    "       \"stdout\": \"\"\n",
    "     },\n",
    "     {\n",
    "      \"executable\": \"i.sentinel.import\",\n",
    "      \"id\": \"i_sentinel_import_S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632\",\n",
    "      \"mapset_size\": 376982877,\n",
    "      \"parameter\": [\n",
    "        \"input=/actinia_core/workspace/temp_db/gisdbase_dbbd7bc372e942d0953fa0f7d019cacb/.tmp/temp_file_1\",\n",
    "        \"pattern=(B04_10m|B08_10m)\",\n",
    "        \"-r\"\n",
    "      ],\n",
    "      \"return_code\": 0,\n",
    "      \"run_time\": 344.0564560890198,\n",
    "      \"stderr\": [\n",
    "        \"Processing <T18SUE_20220420T154941_B08_10m>...\",\n",
    "        \"Importing raster map <T18SUE_20220420T154941_B08_10m>...\",\n",
    "        \"0..3..6..9..12..15..18..21..24..27..30..33..36..39..42..45..48..51..54..57..60..63..66..69..72..75..78..81..84..87..90..93..96..99..100\",\n",
    "        \"Estimated target resolution for input band <T18SUE_20220420T154941_B08_10m>: 9.618686330457596\",\n",
    "        \"Using given resolution for input band <T18SUE_20220420T154941_B08_10m>: 10.0\",\n",
    "        \"Reprojecting <T18SUE_20220420T154941_B08_10m>...\",\n",
    "        \"Rounding to integer after reprojection\",\n",
    "        \"Processing <T18SUE_20220420T154941_B04_10m>...\",\n",
    "        \"Importing raster map <T18SUE_20220420T154941_B04_10m>...\",\n",
    "        \"0..3..6..9..12..15..18..21..24..27..30..33..36..39..42..45..48..51..54..57..60..63..66..69..72..75..78..81..84..87..90..93..96..99..100\",\n",
    "        \"Estimated target resolution for input band <T18SUE_20220420T154941_B04_10m>: 9.618686330457596\",\n",
    "        \"Using given resolution for input band <T18SUE_20220420T154941_B04_10m>: 10.0\",\n",
    "        \"Reprojecting <T18SUE_20220420T154941_B04_10m>...\",\n",
    "        \"Rounding to integer after reprojection\",\n",
    "        \"Writing metadata to maps...\",\n",
    "        \"/usr/local/grass/scripts/i.sentinel.import:830: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\",\n",
    "        \"Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\",\n",
    "        \"  dtype=np.float,\",\n",
    "        \"/usr/local/grass/scripts/i.sentinel.import:834: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\",\n",
    "        \"Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\",\n",
    "        \"  dtype=np.float,\",\n",
    "        \"/usr/local/grass/scripts/i.sentinel.import:846: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\",\n",
    "        \"Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\",\n",
    "        \"  dtype=np.float,\",\n",
    "        \"/usr/local/grass/scripts/i.sentinel.import:850: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\",\n",
    "        \"Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\",\n",
    "        \"  dtype=np.float,\",\n",
    "        \"\"\n",
    "      ],\n",
    "       \"stdout\": \"\"\n",
    "     },\n",
    "     {\n",
    "      \"executable\": \"g.rename\",\n",
    "      \"id\": \"rename_S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632_B04\",\n",
    "      \"mapset_size\": 376982877,\n",
    "      \"parameter\": [\n",
    "        \"raster=T18SUE_20220420T154941_B04_10m,B04\"\n",
    "      ],\n",
    "      \"return_code\": 0,\n",
    "      \"run_time\": 0.15042471885681152,\n",
    "      \"stderr\": [\n",
    "        \"Rename raster <T18SUE_20220420T154941_B04_10m> to <B04>\",\n",
    "        \"\"\n",
    "      ],\n",
    "       \"stdout\": \"\"\n",
    "     },\n",
    "     {\n",
    "      \"executable\": \"g.rename\",\n",
    "      \"id\": \"rename_S2A_MSIL2A_20220420T154941_N0400_R054_T18SUE_20220421T000632_B08\",\n",
    "      \"mapset_size\": 376982877,\n",
    "      \"parameter\": [\n",
    "        \"raster=T18SUE_20220420T154941_B08_10m,B08\"\n",
    "      ],\n",
    "      \"return_code\": 0,\n",
    "      \"run_time\": 0.15053868293762207,\n",
    "      \"stderr\": [\n",
    "        \"Rename raster <T18SUE_20220420T154941_B08_10m> to <B08>\",\n",
    "        \"\"\n",
    "      ],\n",
    "      \"stdout\": \"\"\n",
    "     },\n",
    "     {\n",
    "      \"executable\": \"g.region\",\n",
    "      \"id\": \"g_region_1\",\n",
    "      \"mapset_size\": 376982871,\n",
    "      \"parameter\": [\n",
    "        \"raster=B04\",\n",
    "        \"-g\"\n",
    "      ],\n",
    "      \"return_code\": 0,\n",
    "      \"run_time\": 0.10027408599853516,\n",
    "      \"stderr\": [\n",
    "        \"\"\n",
    "      ],\n",
    "      \"stdout\": \"projection=99\\nzone=0\\nn=269280\\ns=155130\\nw=769610\\ne=883770\\nnsres=10\\newres=10\\nrows=11415\\ncols=11416\\ncells=130313640\\n\"\n",
    "     },\n",
    "     {\n",
    "      \"executable\": \"r.mapcalc\",\n",
    "      \"id\": \"rmapcalc_1\",\n",
    "      \"mapset_size\": 808176157,\n",
    "      \"parameter\": [\n",
    "        \"expression=NDVI = float(B08 - B04)/(B08 + B04)\"\n",
    "      ],\n",
    "      \"return_code\": 0,\n",
    "      \"run_time\": 25.457623958587646,\n",
    "      \"stderr\": [\n",
    "        \"\"\n",
    "      ],\n",
    "      \"stdout\": \"\"\n",
    "     },\n",
    "     {\n",
    "      \"executable\": \"r.univar\",\n",
    "      \"id\": \"r_univar_sentinel2\",\n",
    "      \"mapset_size\": 808176157,\n",
    "      \"parameter\": [\n",
    "        \"map=NDVI\",\n",
    "        \"-g\"\n",
    "      ],\n",
    "      \"return_code\": 0,\n",
    "      \"run_time\": 5.166007995605469,\n",
    "      \"stderr\": [\n",
    "        \"\"\n",
    "      ],\n",
    "      \"stdout\": \"n=120547065\\nnull_cells=9766575\\ncells=130313640\\nmin=-0.468370884656906\\nmax=0.720661163330078\\nrange=1.18903204798698\\nmean=0.25310113195823\\nmean_of_abs=0.283006503246459\\nstddev=0.219731453415328\\nvariance=0.0482819116200123\\ncoeff_var=86.8156739226241\\nsum=30510598.6057423\\n\"\n",
    "     },\n",
    "     {\n",
    "      \"executable\": \"r.out.gdal\",\n",
    "      \"id\": \"exporter_raster_NDVI\",\n",
    "      \"mapset_size\": 808176157,\n",
    "      \"parameter\": [\n",
    "        \"-fmt\",\n",
    "        \"input=NDVI\",\n",
    "        \"format=GTiff\",\n",
    "        \"output=/actinia_core/workspace/temp_db/gisdbase_dbbd7bc372e942d0953fa0f7d019cacb/.tmp/NDVI.tif\",\n",
    "        \"overviews=5\",\n",
    "        \"createopt=BIGTIFF=YES,COMPRESS=LZW,TILED=YES\"\n",
    "      ],\n",
    "      \"return_code\": 0,\n",
    "      \"run_time\": 20.729568481445312,\n",
    "      \"stderr\": [\n",
    "        \"Checking GDAL data type and nodata value...\",\n",
    "        \"2..5..8..11..14..17..20..23..26..29..32..35..38..41..44..47..50..53..56..59..62..65..68..71..74..77..80..83..86..89..92..95..98..100\",\n",
    "        \"Using GDAL data type <Float32>\",\n",
    "        \"Input raster map contains cells with NULL-value (no-data). The value -nan will be used to represent no-data values in the input map. You can specify a nodata value with the nodata option.\",\n",
    "        \"Exporting raster data to GTiff format...\",\n",
    "        \"ERROR 6: /actinia_core/workspace/temp_db/gisdbase_dbbd7bc372e942d0953fa0f7d019cacb/.tmp/NDVI.tif, band 1: SetColorTable() only supported for Byte or UInt16 bands in TIFF format.\",\n",
    "        \"2..5..8..11..14..17..20..23..26..29..32..35..38..41..44..47..50..53..56..59..62..65..68..71..74..77..80..83..86..89..92..95..98..100\",\n",
    "        \"Building overviews ...\",\n",
    "        \"r.out.gdal complete. File </actinia_core/workspace/temp_db/gisdbase_dbbd7bc372e942d0953fa0f7d019cacb/.tmp/NDVI.tif> created.\",\n",
    "        \"\"\n",
    "      ],\n",
    "      \"stdout\": \"\"\n",
    "     }\n",
    "   ],\n",
    "   \"process_results\": {},\n",
    "   \"progress\": {\n",
    "     \"num_of_steps\": 8,\n",
    "     \"step\": 8\n",
    "   },\n",
    "   \"resource_id\": \"resource_id-60f3f012-4220-46ec-9110-694df49006c4\",\n",
    "   \"status\": \"finished\",\n",
    "   \"time_delta\": 440.42616844177246,\n",
    "   \"timestamp\": 1659017682.0043712,\n",
    "   \"urls\": {\n",
    "     \"resources\": [\n",
    "       \"http://actinia.mundialis.de/api/v3/resource/demouser/resource_id-60f3f012-4220-46ec-9110-694df49006c4/NDVI.tiff\"\n",
    "     ],\n",
    "     \"status\": \"http://actinia.mundialis.de/api/v3/resources/demouser/resource_id-60f3f012-4220-46ec-9110-694df49006c4\"\n",
    "   },\n",
    "   \"user_id\": \"demouser\"\n",
    " }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print formatted JSON\n",
    "print_as_json(jsonResponse)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}