Python Language/03–Functional Programming.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "eQLewTbKGq3F",
        "QgFbhWGNdOoc",
        "77KZ0Wp2hBEf",
        "hM7Wvn1hADi8",
        "1lL4zWnUWXON"
      ],
      "authorship_tag": "ABX9TyNVtYneZJGh+ZsZsRm4opAg"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Functional Programming\n",
        "\n",
        "There are a number of programming paradigms: imperative, object-oriented (one we saw in the previous notebook) and functional programming.\n",
        "\n",
        "In functional programming, we primarily deal in functions. It uses a declarative style which means that code (often in a single line) is quite self-contained.\n",
        "\n",
        "Functional Programming is a broad paradigm and hence only a limited features will be covered here."
      ],
      "metadata": {
        "id": "SiaRSh5vLOl9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## $\\lambda$ functions\n",
        "\n",
        "Often there are scenarios where we need a function with just a little (one-liner) functionality. For such a functions, it's upto you, whether you want to :\n",
        "\n",
        "- Define the function properly\n",
        "- Or just use a concise way of defining it anonymously – an anonymous function is defined directly without a name.\n",
        "\n",
        "**$\\lambda$** functions are defined using the keyword **`lambda`** as:\n",
        "\n",
        "**`lambda <input variables>:<output>`**\n",
        "\n",
        "Since output of a lambda function is calculated directly (i.e, an expression), so they may look a bit daunting at first. But with little practice, they become a go-to approach of the programmers for concise code.\n",
        "\n",
        "Let's start with a basic lambda function:"
      ],
      "metadata": {
        "id": "eQLewTbKGq3F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sq = lambda x:x*x\n",
        "print(sq(2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "62D1e_Y-Gp6w",
        "outputId": "0103b806-0fcb-47e3-8d87-ced1c14b722e"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As you can notice, lambda functions don't require a `return` statement as the last part (after `:`) is automatically assumed to be the output.\n",
        "\n",
        "### Example: Equation of Motion\n",
        "\n",
        "3rd equation of motion is:\n",
        "\n",
        "$$2aS = v_f^2 - v_i^2$$\n",
        "\n",
        "$$ \\Rightarrow S = \\frac{v^2 - u^2}{2a}$$\n",
        "\n",
        ">**Note:** We are using the standard notation where usually final velocity is represented as $v$ and initial velocity as $u$.\n",
        "\n",
        "We can directly make a lambda function:"
      ],
      "metadata": {
        "id": "QgFbhWGNdOoc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "S = lambda u,v,a:(v**2-u**2)/2*a\n",
        "\n",
        "S(0,10,4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rb8pAifXe_6F",
        "outputId": "d3bcafd0-8b48-4745-a92e-a16a61f4b9da"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "200.0"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Example: Sigmoid Function\n",
        "\n",
        "A key function in DL is Sigmoid, which is defined as:\n",
        "\n",
        "$$\\sigma(x) = \\frac{e^x+e^{-x}}{e^x-e^{-x}}$$\n",
        "\n",
        "It ranges between $1$ and $-1$ as we will see."
      ],
      "metadata": {
        "id": "77KZ0Wp2hBEf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sig = lambda x:(math.exp(x)+math.exp(0-x))/(math.exp(x)-math.exp(0-x))\n",
        "\n",
        "print(sig(400))\n",
        "\n",
        "print(sig(-30))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KX3FOBdrgqet",
        "outputId": "434a5999-1b1f-4ce5-b123-5708f39476f6"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.0\n",
            "-1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## List Comprehensions\n",
        "\n",
        "We can make a new list (or any collection) from an existing collection by using a loop. For example:\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "hM7Wvn1hADi8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "itvl_9wiJpde"
      },
      "outputs": [],
      "source": [
        "citiesList = [(31.32, 74.2), (21.32, 39.1), (39.1, 21.32), (-7.29, 110.0)]"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using the [previous example](https://github.com/EngineerKhan/Python-ML/blob/main/01_Basics.ipynb), we have made this list. Now, we can make a new list for cities in the Northern Hemisphere."
      ],
      "metadata": {
        "id": "8vKFO9t2BcJd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newList = []\n",
        "for city in citiesList:\n",
        "  if(city[0]>0):\n",
        "    newList.append(city)\n",
        "\n",
        "newList"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jJq-lLzGB7G5",
        "outputId": "483e2844-8c35-448b-e0c2-55d79f5448ea"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(31.32, 74.2), (21.32, 39.1), (39.1, 21.32)]"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "List's **`append()`** method came handy here. List comprehensions allow us to perform all this in a single statement (may or may not involve the loop, but always in a single statement). There are a number of ways to perform it and the most common one is **$\\lambda$ functions**\n",
        "\n",
        "---\n"
      ],
      "metadata": {
        "id": "Dxip-IvtCPMF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Let's try to make a lambda function for fetching the Northern Hemisphere cities."
      ],
      "metadata": {
        "id": "PxcOxYR-SVN9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newList = lambda x:x[0]>0"
      ],
      "metadata": {
        "id": "uqnYuAF6TXcG"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "But it doesn't work. It's just fetching the cities having positive first coordinate. Though we need to have a **new list with those cities too**, and this part is missing yet. On the other hand, what's the point of having the lambda function approach, if we are going to properly define a whole multiline function?\n",
        "\n",
        "As we mentioned above that a lambda function can perform **only a single expression**, so doing it with just a lambda function ain't possible.\n",
        "\n",
        "**Solution: Higher-order Function**\n"
      ],
      "metadata": {
        "id": "PJ8dUzC1Uc6O"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Higher-Order Functions\n",
        "\n",
        "Lets revisit functions quickly: A function takes some inputs and returns output. These input/output are variables which can be integers, lists, sets, etc.\n",
        "\n",
        "Higher-order functions, on the other hand, can take functions even as its input(s) and can even return them as output.\n",
        "\n",
        "Let's take an example:"
      ],
      "metadata": {
        "id": "1lL4zWnUWXON"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum(x,y):\n",
        "  return x+y\n",
        "\n",
        "def subtract(x,y):\n",
        "  return x-y\n",
        "\n",
        "def multiply(x,y):\n",
        "  return x*y"
      ],
      "metadata": {
        "id": "L7euatZLUcFc"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Higher-order functions are defined in pretty much the same way as the normal functions (don't need a separate syntax). It's upto the programmer's discretion that which parameter (or even output, if one would like to) will be a function and which one will be a normal variable. Yes! We can combine both normal variables and functions in the parameters.\n",
        "\n",
        "> Those coming from C++ can find it relevant (but easier) to the function pointers concept; similarly, its similar to delegates in C#."
      ],
      "metadata": {
        "id": "Hg02kL3dTYb7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def ArithmeticOperation(operationFunction, x, y):\n",
        "  return operationFunction(x,y)"
      ],
      "metadata": {
        "id": "QiBKJbyah2LX"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, this is a higher-order function and we can use it to call the respective (arithmetic) function to perform it. Like:"
      ],
      "metadata": {
        "id": "LCcXVmctZzqV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ArithmeticOperation(multiply,12,4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WEi1N15RZ9Hx",
        "outputId": "63c6600b-3675-46ca-b94c-2fe6fb1e9796"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "48"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Having defined this higher-order function, we can use it to call other functions as well, like:"
      ],
      "metadata": {
        "id": "ToHHUk3taGih"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ArithmeticOperation(subtract, 12,3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SIeByu4GaMSX",
        "outputId": "229024fd-302e-44df-f47b-99b57de47670"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are a number of built-in higher order functions too. Let's see some of them.\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "mtOxWeTFabex"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Coming back to our northern hemisphere cities problem. We had defined the lambda function as:"
      ],
      "metadata": {
        "id": "HxbCRs-ibAhH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "northernCities = lambda x:x[0]>0"
      ],
      "metadata": {
        "id": "HVfcLEUybAIW"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "That was the point where we found it hard to keep going before we understand the higher-order functions. Now, having understood ~the assignment~ them, we can continue further.\n",
        "\n",
        "\n",
        "\n",
        "#### **`filter()`**\n",
        "\n",
        "Now our next step is to make the new list using the existing list and the above filter. For it, we have a function named.... unsurprisingly, its **`filter()`**.\n",
        "\n",
        "Its syntax is:\n",
        "\n",
        "**`filter(<desired filter function>,<collection variable>)`**\n",
        "\n",
        ">As you can notice; for the sake of generalization, we have mentioned \"collection\" in lieu of the list above."
      ],
      "metadata": {
        "id": "f0z_vakWlpoy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newList = filter(northernCities,citiesList)\n",
        "\n",
        "newList"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kpQeyDYrmopF",
        "outputId": "64d7cecb-0295-4348-c18d-dc6e9326dd5b"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<filter at 0x7b138374dc30>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The output is a bit surprising, but shouldn't be. The output of `filter()` can be converted back into the list by using the conversion method **`list()`**.\n",
        "\n"
      ],
      "metadata": {
        "id": "r_GkwPfDnF_m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list(newList)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_6rOHsdMnZef",
        "outputId": "871dc8dc-46f2-403c-e7b1-6d27232b5789"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(31.32, 74.2), (21.32, 39.1), (39.1, 21.32)]"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ">**Point to Ponder:** Is `northernCities` a normal variable or a function?\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "LMzuoM5zcE73"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Suppose we have a list as:\n"
      ],
      "metadata": {
        "id": "isk2z_SkRxCv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "listA = [2, 3, 4, 10]"
      ],
      "metadata": {
        "id": "oBjL0-A3cbVb"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And we want to get another list having say square of all these numbers (or any other function). It's extremely easy as we have a (higher order as goes without saying) function for that.\n",
        "\n",
        "#### **`map()`**\n",
        "\n",
        "`map()` takes the desired function with the intended list/set and applies it throughout the list/set to fetch a new one. Its syntax is:\n",
        "\n",
        "**`map(<function>,<list/set>`**\n",
        "\n",
        "So we define the square function and apply it on `listA`."
      ],
      "metadata": {
        "id": "-rwnJGebcr-8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sq = lambda x:x*x\n",
        "listB = list(map(sq,listA))\n",
        "\n",
        "listB"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zgYt4PkZdaFf",
        "outputId": "3830b182-5901-4b0d-8e40-d2a566f61cfd"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[4, 9, 16, 100]"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "As we saw earlier that `filter()` just returns an object and we have to convert it back into the list by `list()` conversion."
      ],
      "metadata": {
        "id": "NSNTVZWicaTx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **`reduce()`**\n",
        "\n",
        "While `map()` applies the function to each member of the list, **`reduce()`** on the other hand (as its name depicts) returns a single/scalar answer after performing an operation on the list iteratively.\n",
        "\n",
        ">**Note:** Those coming with a DB background can find it relevant to the aggregate functions.\n",
        "\n",
        "Some technical caveats about **`map()`**:\n",
        "\n",
        "- **Left to right:** It traverses the list from left (0th index) onwards towards right.\n",
        "\n",
        "- **Binary inputs:** Although it works on the whole list, but it works in a binary way. Let's suppose if we have the `listB` above and want to perform summation, `reduce()` will add `listB[0]` with `listB[1]` (i.e, `4` and `9`) and then will add the result (13) with `16` (29) and so on..."
      ],
      "metadata": {
        "id": "ghYn0Unme6ED"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from functools import reduce\n",
        "\n",
        "sumFunc = lambda x,y:x+y\n",
        "\n",
        "finalSum = reduce(sumFunc,listB)\n",
        "\n",
        "finalSum"
      ],
      "metadata": {
        "id": "_c2TdY7Evl7P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb3eb6af-b324-4680-e83a-ac8cfd06a7e6"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "129"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Set Comprehension\n",
        "\n",
        "Similar to lists, we can perform set comprehensions too.\n",
        "\n",
        ">**Note:** Tuples are immutable, hence we can't make a new tuple using the comprehension, which includes an assignment operator.\n",
        "\n"
      ],
      "metadata": {
        "id": "gxbEoK_Lx3oh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = {1,3,5,9}\n",
        "B = {2,3,4,5}\n",
        "\n",
        "cube = lambda x:x*x*x\n",
        "\n",
        "C = set(map(cube,A))\n",
        "C"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k7SirpIM-4nV",
        "outputId": "5cacd995-560b-4fad-f63c-ec1099cf81d9"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1, 27, 125, 729}"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Actually, we can fetch a set for any of the above examples (for lists) by taking `set()` instead of the `list()`.\n",
        "\n",
        "We can also use list/set comprehensions to populate an empty/new list/set. Here we use inline `for` loop to serve the cause.\n",
        "\n",
        "For example, set of first 50 odd numbers:"
      ],
      "metadata": {
        "id": "B8Jq_L0j_WD7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "D = {x for x in range(1,100,2)}\n",
        "D"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0EPfA_FE_xfj",
        "outputId": "4f1b4001-3da1-48b7-91fe-6fd6d4e815a8"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1,\n",
              " 3,\n",
              " 5,\n",
              " 7,\n",
              " 9,\n",
              " 11,\n",
              " 13,\n",
              " 15,\n",
              " 17,\n",
              " 19,\n",
              " 21,\n",
              " 23,\n",
              " 25,\n",
              " 27,\n",
              " 29,\n",
              " 31,\n",
              " 33,\n",
              " 35,\n",
              " 37,\n",
              " 39,\n",
              " 41,\n",
              " 43,\n",
              " 45,\n",
              " 47,\n",
              " 49,\n",
              " 51,\n",
              " 53,\n",
              " 55,\n",
              " 57,\n",
              " 59,\n",
              " 61,\n",
              " 63,\n",
              " 65,\n",
              " 67,\n",
              " 69,\n",
              " 71,\n",
              " 73,\n",
              " 75,\n",
              " 77,\n",
              " 79,\n",
              " 81,\n",
              " 83,\n",
              " 85,\n",
              " 87,\n",
              " 89,\n",
              " 91,\n",
              " 93,\n",
              " 95,\n",
              " 97,\n",
              " 99}"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "\n",
        "## Dictionary Comprehension\n",
        "\n",
        "Set comprehension is similar to list comprehension, so we will leave it as an excercise here for further exploration (all the things are same). Now we will focus towards Dictionary comprehension.\n",
        "\n",
        "As we remember, we use **`dict.items()`** to iterate over the dictionary items. It will be useful in dictionary comprehension too. Like:"
      ],
      "metadata": {
        "id": "bgwBbCvqH47h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "UTC_Gap = {\"Greenwich\":0, \"Jeddah\":3, \"Istanbul\":3, \"Doha\": 3, \"Dubai\": 4, \"Lahore\": 5, \"San Francisco\": -7, \"Cairo\": 3, \"Sydney\": 10, \"Auckland\": 12}\n",
        "UTC_Gap"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fcr09aqVq6-F",
        "outputId": "9c57818e-bb3b-4da4-a4bd-6a84e266095c"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Greenwich': 0,\n",
              " 'Jeddah': 3,\n",
              " 'Istanbul': 3,\n",
              " 'Doha': 3,\n",
              " 'Dubai': 4,\n",
              " 'Lahore': 5,\n",
              " 'San Francisco': -7,\n",
              " 'Cairo': 3,\n",
              " 'Sydney': 10,\n",
              " 'Auckland': 12}"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We have one city on the left of atlantic. Let's fetch it. Since it includes both looping over the dictionary and filtering, we can use a combination of `filter()` with dictionary creation. But we can do it directly too, as collection comprehension allows us to construct a compound statement as well.\n"
      ],
      "metadata": {
        "id": "U9l8QmcSr7OA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Left_Hemisphere = {x:y for x,y in UTC_Gap.items() if y<0}\n",
        "\n",
        "Left_Hemisphere"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EtpRrrhxsCO2",
        "outputId": "0f5a0305-db6a-417e-873a-634583996d80"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'San Francisco': -7}"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you have to combine `for` and `if`, the syntax is straightforward:\n",
        "\n",
        "**`<new dictionary> = {x:y for x,y in <existing dictionary> if <condition>}`**\n",
        "\n",
        "Inevitably, this is something not reserved to the dictionaries and can be used with the sets or lists comprehension as well."
      ],
      "metadata": {
        "id": "kpgRmKOFtNCI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "Functional programming can have plenty of other things too, but they (some of them) will be covered later if time permitted."
      ],
      "metadata": {
        "id": "5tssv_5mtzad"
      }
    }
  ]
}