UNICEF_SDMX_API.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "cdc373ab-8fda-4346-a730-54b269726540",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "# **UNICEF Indicator Data Warehouse** - SDMX REST API Web Service"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {},
     "inputWidgets": {},
     "nuid": "5180c232-9de8-4270-857b-9a2b039f50e7",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "149bb048-0c76-4efb-b8ba-4d192c08f4da",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# import necessary libraries \n",
    "import requests\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from pprint import pprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "cb6050ac-d1e6-4ee8-a80d-5289e0e2871d",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Connecting to the UNICEF's data warehouse using the **Statistical Data and Metadata eXchange** (SDMX) standard."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "ccc10078-a3db-4d49-b5af-6bce4ebd1830",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "endpoint = \"https://sdmx.data.unicef.org/ws/public/sdmxapi/rest\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "9e28b6e6-7aec-4add-9319-07b4f7d6b27d",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "## **1. STEP: select a Data Flow**\n",
    "\n",
    "Data Flows contain a set of data with a common structure and usually group similar topics. So I first use the API to get a list of all those Data Flows. \n",
    "\n",
    "This requires adding the following to the endpoint and providing the parameters for ```format```, ```detail``` and ```reference```. I chose to get the data in the **JSON format**, with **full detail** and **no references**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "ef50142c-1362-4682-aeda-32fcd5aaceb8",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "dataflow_endpoint = \"/dataflow/all/all/latest\"\n",
    "dataflow_params = {\n",
    "    \"format\": \"sdmx-json\",\n",
    "    \"detail\": \"full\",\n",
    "    \"reference\": \"none\",\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "09ca4c0f-1a62-4fde-aecc-7ac81d5c1854",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# get the response and checking the status code \n",
    "dataflow_response = requests.get(url=endpoint+dataflow_endpoint, params=dataflow_params)\n",
    "print(dataflow_response.status_code)\n",
    "\n",
    "# converting the response into JSON format, printing the response  \n",
    "dataflows = dataflow_response.json()['data']['dataflows']\n",
    "# uncomment the next line to see the complete response \n",
    "# pprint(dataflows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "ac6380f9-a123-44c7-ad4d-55aa08de9e05",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# this prints out all the Data Flows and their necessary keys\n",
    "for dflow in dataflows:\n",
    "    # those values will be necessary for the next API call\n",
    "    print(f\"name: {dflow['name']} - id: {dflow['id']} - agency-id: {dflow['agencyID']} - dataflow-version: {dflow['version']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "8e39e797-e628-407c-b193-cd1656227751",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "I chose  ```name: Demography - id: DM - agency-id: UNICEF - dataflow-version: 1.0```  for further exploration.\n",
    "\n",
    "To get hold of the actual data later, it's necessary to remember the **id**, the **id of the agency** and the **version** of the chosen Data Flow. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "db9d74d9-4f0b-42ed-87f6-b1a86afadfb5",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "SELECTED_DFLOW = 'DEMOGRAPHY'\n",
    "SELECTED_DFLOW_ID = 'DM'\n",
    "SELECTED_AGENCY_ID = 'UNICEF'\n",
    "SELECTED_DFLOW_VER = \"1.0\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "597bf8f3-1e3b-470d-842f-561c81665e30",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "## **2. STEP: explore the structure of the selected Data Flow**\n",
    "\n",
    "This structure uses the **Data Structure Definition** (DSD) to achieve reusability between different Data Flows. It comprises concepts that can have the usage roles of a dimension, an attribute or a measure. \n",
    "\n",
    "A new addition to the endpoint, including the agency ID of the selected Data Flow, must be made to get hold of the structure. The parameters that are sent with the API call stay the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "52e56932-ec34-460c-94d0-74b19ef8b0fe",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "structure_endpoint = f\"/datastructure/{SELECTED_AGENCY_ID}/{SELECTED_DFLOW}/latest\"\n",
    "structure_params = {\n",
    "    \"format\": \"sdmx-json\",\n",
    "    \"detail\": \"full\",\n",
    "    \"reference\": \"none\",\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "aea18f33-4b09-480c-8b6c-a660f0d29a47",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# get the response and checking the status code \n",
    "structure_response = requests.get(url=endpoint+structure_endpoint, params=structure_params)\n",
    "print(dataflow_response.status_code)\n",
    "\n",
    "# get hold of the dataStructures \n",
    "selected_structure = structure_response.json()['data']['dataStructures'][0]\n",
    "\n",
    "# display the structure in JSON format \n",
    "pprint(selected_structure)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "485484ff-6abc-4e54-9425-83c40c6a6d2c",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Let's explore the concepts that were contained in the API response at little bit more. The key to access those lists is the ```dataStructureComponents``` key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "db26fb6e-d692-41d1-8b06-9218efc8bae9",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "datastructure_comp = selected_structure['dataStructureComponents']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "24e614d3-1f88-4f1c-b3a0-4de82f0d90c8",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "### Dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "76c4024c-8b0a-4c6a-a765-55f6cc6330a7",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# get the dimensions\n",
    "dimensions_json = datastructure_comp['dimensionList']\n",
    "\n",
    "dimensions = [(dim['id'], dim['position']) for dim in dimensions_json['dimensions']]\n",
    "print(f'dimensions: {dimensions}')\n",
    "\n",
    "time_dimensions = [(tdim['id'],tdim['position']) for tdim in dimensions_json['timeDimensions']]\n",
    "print(f'time dimensions: {time_dimensions}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "9d88aafe-ae00-4b1d-9714-500a24e4e1fc",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "The ```dataStructureComponents``` for the Demography-Data Flow includes **6 dimensions total**, with the ```TIME_PERIOD``` in its own list of ```timeDimensions```. The positions at the second position in the tuple are required when making queries for specific data slices later. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "c24935b6-d976-4913-904a-dda2f1beea8d",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "### Attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "5f042bf2-75af-4517-aee0-af84c5481f99",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# get the attributes\n",
    "attributes_json = datastructure_comp['attributeList']\n",
    "attributes = attributes_json['attributes']\n",
    "\n",
    "for att in attributes:\n",
    "    print(f\"{att['id']} - relation: {att['attributeRelationship']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "6296a597-afba-4a64-b9ef-6d5d1e98facf",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "There are **11 different attributes** that can be attached to different levels in the Demography-Data Flow.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "a684c27a-d6d7-4f6f-8801-fe8fdc54e856",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "## **3. STEP: query the desired slice of data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "624f879b-ce42-4d0c-8d41-9736120fae2c",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "complete_data_endpoint = f\"/data/{SELECTED_AGENCY_ID},{SELECTED_DFLOW_ID},{SELECTED_DFLOW_VER}/all\"\n",
    "complete_data_params = {\n",
    "    \"format\": \"sdmx-json\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "9fddda4a-756f-401f-9717-559ba1f543ae",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "This would get hold of the complete dataset within this chosen Data Flow and version, but it's also possible to get just a piece of this dataset.\n",
    "\n",
    "Getting just a slice of the data is possible by specifying specific values for the dimensions. Let's say we want to select the following:\n",
    "\n",
    "- for the ```REF_AREA``` **Western Europe**\n",
    "- for the ```INDICATOR``` **everything**\n",
    "- for the ```RESIDENCE``` **just the total**\n",
    "- for the ```SEX``` **just the total**\n",
    "- for the ```AGE``` **everything**\n",
    "\n",
    "The possible values for those dimensions can be found in the **Codelist** for this Data Flow. To get hold of this Codelist, another API call is necessary. The string that has to be added to the endpoint is the same as for getting the complete data, but with the parameters, the ```detail``` is limited to ```structureOnly```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "a8cfaa85-851f-4037-9f95-cf60336a3b74",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "codelist_endpoint = f\"/data/{SELECTED_AGENCY_ID},{SELECTED_DFLOW_ID},{SELECTED_DFLOW_VER}/all\"\n",
    "codelist_params = {\n",
    "    \"format\": \"sdmx-json\",\n",
    "    \"detail\": \"structureOnly\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "f4a09fce-895e-432e-b852-56dcbc120566",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# get the response and checking the status code \n",
    "codelist_response = requests.get(url=endpoint+codelist_endpoint, params=codelist_params)\n",
    "print(codelist_response.status_code)\n",
    "\n",
    "codelist = codelist_response.json()['structure']['dimensions']['observation']\n",
    "# uncomment next line to print codelist\n",
    "# pprint(codelist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "858a1c02-d0a0-42ab-a66a-57d9f679ff33",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "The following picture is a screenshot from the Codelist returned from the API call. The Codelist provides a list of all the dimensions and all possible ```values``` for them. Because I wanted to limited the ```REF_AREA```, ```RESIDENCE``` and ```SEX``` let's look at the possible values for those: \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "473e3276-68ff-4619-ab40-dd977f5c526e",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "![codelist_detail.png](attachment:screenshots/codelist_detail.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "653cd2f9-3dc7-4efc-b2d3-47efb33aa58e",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Looking for the ```REF_AREA``` to select only Western Europe. The order of dimensions will be the same as before; therefore, I know that the ```REF_AREA``` will be the first dimension in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "1737052a-7bc9-4e1e-b67b-f4a068ae65b4",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "ref_area_values = [(v['name'], v['id']) for v in codelist[0]['values']]   \n",
    "# this prints a list of tuples containing the name of the country or region and the id \n",
    "print(ref_area_values)\n",
    "\n",
    "# search for the id of Western Europe\n",
    "west_eu_id = [i for (n, i) in ref_area_values if n == \"Western Europe\"]\n",
    "print(f\"ID of Western Europe: {west_eu_id[0]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "c4e2ee01-d3df-4ef5-ac93-b00a96fb6d1a",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Next let's get the value for ```RESIDENCE``` which should be third in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "bd8de7ef-6dea-4bed-a19d-a2f6ae9cd47d",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "residence_values = [(v['name'], v['id']) for v in codelist[2]['values']]\n",
    "print(residence_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "61f31335-a381-45ae-81d6-68d2eb75b609",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "And at last the value for ```SEX``` which should be fourth: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "dbb176bc-cac5-497e-bb3a-bf9628d9b575",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "sex_values = [(v['name'], v['id']) for v in codelist[3]['values']]\n",
    "print(sex_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "e5a32132-646e-4da4-a6f9-e675ca2fc06d",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Now those dimension values can be used in the query string:\n",
    "\n",
    "- select **Western Europe** as reference area: ```UNICEF_WE```\n",
    "- select **all residencies**: ```_T```\n",
    "- select **all genders**: ```_T```\n",
    "\n",
    "Those parameters have to be added to the endpoint string **separated by dots**. Multiple values for a dimension should be separated by a \"+\". \n",
    "\n",
    "**Important**: The query string has to contain every dimension. If nothing should be specified, it has to be treated like being left out by just typing the next separating dot. The order is the same as in the dimensions list shown above or as specified under their ```position``` attribute. \n",
    "\n",
    "**REF_AREA.~~INDICATOR~~.RESIDENCE.SEX.~~AGE~~** -> final string: **UNICEF_WE.._T._T.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "0908d759-7c6b-4350-a818-d52e387e6dff",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "QUERY_STR = \"UNICEF_WE.._T._T.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "794cc9b4-be24-41ea-904f-fdd5c6735a5f",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "data_endpoint = f\"/data/{SELECTED_AGENCY_ID},{SELECTED_DFLOW_ID},{SELECTED_DFLOW_VER}/{QUERY_STR}\"\n",
    "data_params = {\n",
    "    \"format\": \"sdmx-json\",\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "f9244eed-6686-40b0-9398-61afe0d41a7e",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# get the response\n",
    "data_response = requests.get(url=endpoint+data_endpoint, params=data_params).json()['data']\n",
    "\n",
    "for list in data_response:\n",
    "    print(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "f93ac9dc-6b55-4c56-a1c2-3641dc8c23e6",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "After retrieving the response in the JSON format, it's necessary to **connect the data points with their corresponding structure**. Those are separated in ```structure``` and ```dataSets```.\n",
    "\n",
    "Let's first look into the ```structure```:\n",
    "\n",
    "Using the ```dimensions``` key, we find two further keys: ```series``` which contains the **dimensions 1 to 5** and ```observation``` which contains **dimension number 6**, the ```TIME_PERIOD```. Those separated list indicate the different levels of attachment. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "5b8ef59c-2e1c-4cae-a520-d42de3992e6e",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# dimensions attached at series level\n",
    "ser_dim_response = data_response['structure']['dimensions']['series']\n",
    "pprint(ser_dim_response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "90f4e072-cb6e-4e05-b00b-6a3d854028ed",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# dimensions attached at observation level\n",
    "obs_dim_response = data_response['structure']['dimensions']['observation']\n",
    "pprint(obs_dim_response)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "6af82ba2-dbaa-4799-b9e4-504258c70dde",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Looking at those dimensions from the response, we can see the ```TIME_PERIOD``` which goes from 1950 to 2023, the ```REF_AREA``` which I limited to only return values for ```UNICEF_WE``` ('Western Europe'), all those different values for the ```INDICATOR```, and the ```RESIDENCE```, ```SEX``` and ```AGE``` all limited to 'Total'.\n",
    "\n",
    "Next, let's get an overview of the attributes, which are also split into their different attachment levels: ```series``` and ```observation```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "3602dec3-151f-44b6-bb57-ca8e060b6fdc",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# attributes attached at series level\n",
    "ser_attr_response = data_response['structure']['attributes']['series']\n",
    "pprint(ser_attr_response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "c04bf4e6-4298-4ff6-a7d0-c97f7d58ad87",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# attributes attached at observation level\n",
    "obs_attr_response = data_response['structure']['attributes']['observation']\n",
    "pprint(obs_attr_response)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "67b23744-5a3e-4f52-a2da-3d54af53953d",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Now it's time to retrieve the actual data points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "edf74342-5a74-4703-a91a-1eed9a56f697",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "dpoints_response = data_response['dataSets']\n",
    "# to view uncomment the next line\n",
    "# pprint(dpoints_response)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "3e05a726-4eaa-446d-913c-e39391fbf415",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "![data_points_detail.png](attachment:data_points_detail.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "a1242283-c090-4180-9807-88692a84b711",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Each data series is uniquely identified by its **Key**, comprised of the dimensions attached at series level (in this instance: ```'0:0:0:0:0'```). In this case, only the second number changes because that is the number corresponding with the ```INDICATOR```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "899dd53f-7576-4fa0-9edb-f08ee41bf5c4",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# get the different keys of the data points and their corresponding dimensions  \n",
    "for point in dpoints_response[0]['series']:\n",
    "    print(f\"{point} - \"\n",
    "          f\"{ser_dim_response[0]['values'][int(point.split(':')[0])]['name']} : \"\n",
    "          f\"{ser_dim_response[1]['values'][int(point.split(':')[1])]['name']} : \"\n",
    "          f\"{ser_dim_response[2]['values'][int(point.split(':')[2])]['name']} : \"\n",
    "          f\"{ser_dim_response[3]['values'][int(point.split(':')[3])]['name']} : \"\n",
    "          f\"{ser_dim_response[4]['values'][int(point.split(':')[4])]['name']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "e226ab3c-b0dc-4ad5-88e9-e3efe5e7a375",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Next are the attributes attached at series level. In this instance: ```[0, 0, 0, 0]```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "93cc6685-d4a1-4508-ad99-f23a549511f2",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "example = dpoints_response[0]['series']['0:0:0:0:0']\n",
    "print(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "667fedc3-636e-44bf-b3e3-2f58b8380f9a",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "for i, v in enumerate(example['attributes']):\n",
    "    print(f\"{ser_attr_response[i]['id']}: {v} -> {ser_attr_response[i]['values'][v]['name']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "4681915a-d2c0-458d-9f9c-ce3a97b4d650",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Finally, the concepts at the observation level: \n",
    "\n",
    "```'observations': {'0': ['360046.821', None, None, 0, None, None, None, None],}```\n",
    "\n",
    "First, the dimensions attached at the observation level, so in this case, the ```TIME_PERIOD```.\n",
    "\n",
    "The following list starts with the ```OBS_VALUE```, listed under ```primaryMeasure```. The other values correspond with the attributes at the observation-level."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "32ca1dc2-7971-4a86-aec6-07d96a8ff5f9",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "print(f\"'0' -> TIME_PERIOD: {obs_dim_response[0]['values'][0]['name']}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "8ae339da-8373-4abe-a3f9-6f9675cdbcd3",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "obs_attr_response[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "02138e01-95fc-4e16-b915-f30da408b66c",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "for i, v in enumerate(example['observations']['0']):\n",
    "    if i == 0: \n",
    "        print(f\"OBS_VALUE: {v}\\n\")\n",
    "    else:\n",
    "        print(f\"{obs_attr_response[i-1]['name']}: {v}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "a5713b5b-33a6-4c15-ba84-994b4267eb71",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "## **4. STEP: put the data into a Pandas DataFrame**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "cd9fc760-8930-4990-b31b-53ea2b9ba34f",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Let's explore how the number of births in Western Europe changed over the years. To do this I'll first create a DataFrame with all the useful values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "80561e96-b498-42bd-87e5-73452f0334bc",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# create a dictionary which will be converted into a pandas DataFrame later\n",
    "data = {}\n",
    "\n",
    "# going over all those dimension keys \n",
    "for k, v in dpoints_response[0]['series'].items():\n",
    "    # because only the 'INDICATOR' changes I will only keep that \n",
    "    indicator_index = int(k.split(':')[1])\n",
    "\n",
    "    # this will get the 'id' of the corresponding value in the 'INDICATOR' dimension \n",
    "    # this id will be used as column later and therefore used as a key in the new dict \n",
    "    indicator_key = ser_dim_response[1]['values'][indicator_index]['id']\n",
    "\n",
    "    # to get the values I'll loop over the different keys for the observation dimension corresponding with the 'TIME_PERIOD'\n",
    "    # I'll only use the observation values and put them into a consecutive list \n",
    "    # later the years will be used a indices \n",
    "    indicator_values = []\n",
    "    for i, j in enumerate(obs_dim_response[0]['values']):\n",
    "        try: \n",
    "            indicator_values.append(dpoints_response[0]['series'][k]['observations'][str(i)][0])\n",
    "        except KeyError:\n",
    "            indicator_values.append(None)\n",
    "    \n",
    "    # append the attributes to preserve additional information \n",
    "    for g, h in enumerate(v['attributes']):\n",
    "        try:\n",
    "            indicator_values.append(ser_attr_response[g]['values'][h]['name'])\n",
    "        except TypeError:\n",
    "            indicator_values.append(None)\n",
    "    \n",
    "    # put everything together \n",
    "    data[indicator_key] = indicator_values\n",
    "\n",
    "print(data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "67f733f1-7eac-4c85-a408-69e718e79367",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# create indices list for the DataFrame with years from 'TIME_PERIOD' dimension \n",
    "indices = [int(obs_dim_response[0]['values'][i]['id']) for i, v in enumerate(obs_dim_response[0]['values'])]\n",
    "\n",
    "# create indices for the attributes that were added to the end \n",
    "attr_indices = [n['name'] for n in ser_attr_response]\n",
    "\n",
    "# create the DataFrame\n",
    "df = pd.DataFrame(data, index=indices+attr_indices)\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "ae67e38f-6825-4bbb-8dd4-411c507e0ae0",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "21ed94dc-154f-4b2b-abd7-68c6092cf4be",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Because all those values were treated as if they were strings the Dtypes are objects. This has to be changed in order to work with them as numerical values. I will also drop the ```DM_POP_GRT``` and ```DM_POP_U_GRT``` because they only contain 2 NaN values which is not very useful for time comparison. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "c6176639-9adf-4385-b234-4f8a5591e7a7",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "new_df = df.copy()\n",
    "\n",
    "# drop columns with only 2 NaN values \n",
    "new_df.drop(columns=['DM_POP_GRT', 'DM_POP_U_GRT'], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "f1a10568-5ab6-4dd2-93d9-dcd1d97ffd6b",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "While the last four rows are helpful to get more information, like the unit measure and unit multiplier, it has to be dropped to do analysis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "3e10aa2c-334d-4401-8a9f-7a0fef88b17b",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "new_df.drop(index=attr_indices, axis=0, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "c182c50c-f4f4-49b4-a7fd-85604ad7419f",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# change Dtypes \n",
    "for col in new_df.columns:\n",
    "    new_df[col] = pd.to_numeric(new_df[col])\n",
    "\n",
    "new_df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "ab8b37e5-3011-4c4a-b3b8-e99019d6a758",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Now I it's possible to explore how the number of births in Western Europe changed over the years. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "dbc2f84a-2719-4551-b545-8ffb44d91d74",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(17,4))\n",
    "plt.bar(\n",
    "    x=new_df.index,\n",
    "    height=new_df['DM_BRTS'],\n",
    "    color='orange',\n",
    ")\n",
    "\n",
    "ax.grid(True, color=\"lightgrey\")\n",
    "plt.title('Number of Births from 1950 to 2023')\n",
    "plt.ylabel('Number of Births in k')\n",
    "plt.xlabel('Year')\n",
    "plt.xlim(1950, 2023)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "d7d78d78-0914-475e-b475-460586395d94",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "## **5. STEP: export desired data**\n",
    "\n",
    "The DataFrame that was just created can easily be exported to CSV or Excel format for further data visualization with other tools. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "a86e8fb0-7820-4509-b8cc-ab9b5deabef9",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# export to csv\n",
    "df.to_csv(\"my_sdmx_data.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "5b52b556-10ec-4c23-98ac-b31e0ca7970b",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "%pip install openpyxl\n",
    "# export as Excel file \n",
    "df.to_excel(\"my_sdmx_data.xlsx\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "6626303e-ddb7-48a4-967f-5d6a3dac3616",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "### **Read the article for further explanation:** https://medium.com/@schwebel.felix/sdmx-rest-web-service-eafe4107117c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "47f2975a-ad04-4cd9-be96-c89795149896",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "**Useful Links and Sources:**\n",
    "- https://sdmx.data.unicef.org/overview.html\n",
    "- https://sdmx.org/\n",
    "- https://ec.europa.eu/eurostat/web/sdmx-infospace/trainings-tutorials\n",
    "- https://data.unicef.org/sdmx-api-documentation/"
   ]
  }
 ],
 "metadata": {
  "application/vnd.databricks.v1+notebook": {
   "dashboards": [],
   "environmentMetadata": {
    "base_environment": "",
    "client": "1"
   },
   "language": "python",
   "notebookMetadata": {
    "pythonIndentUnit": 2
   },
   "notebookName": "UNICEF_SDMX_API",
   "widgets": {}
  },
  "kernelspec": {
   "display_name": "venv",
   "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.11.1"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 0
}