REST_API_Developement_Crash_Notes_FastAPI.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7212409a",
   "metadata": {},
   "source": [
    "# REST API Development  Crash Notes (Python-FastAPI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dd71d32",
   "metadata": {},
   "source": [
    "### =======Syllabus=======\n",
    "__1. Introduction to API__\n",
    "\n",
    "__2. REST API__\n",
    "\n",
    "    2.1 Sample Public APIs (GET)\n",
    "    2.2. Status Codes\n",
    "    2.3 API Requests\n",
    "    \n",
    "__3. POSTMAN__\n",
    "\n",
    "__4. FastAPI__\n",
    "    \n",
    "    4.1 Hello World!\n",
    "    4.2 Endpoints\n",
    "    4.3. Dynamic Endpoints\n",
    "    4.4. HTTP POST Methods\n",
    "\n",
    "**5.  Usage of CRUD Functionalities with FastAPI**\n",
    "\n",
    "    5.1 Setting up FastAPI and Dummy Data\n",
    "    5.2 GET Requests\n",
    "    5.3 POST Request\n",
    "    5.4 PUT Request\n",
    "    5.5 DELETE Request\n",
    "    5.6 Running the Server\n",
    "    \n",
    "**6. Secret Key and WSGI/ASGI Explanation**\n",
    "    \n",
    "    6.1 Securing Endpoints with a Secret Key\n",
    "    6.2 GET Requests with a secret key\n",
    "    6.3 POST Request with a secret key\n",
    "    6.4 PUT Request with a secret key\n",
    "    6.5 DELETE Request with a secret key\n",
    "    6.6. Running the FastAPI Server with a secret key\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64061e93",
   "metadata": {},
   "source": [
    "## 1. Introduction to API"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e4ad8ee",
   "metadata": {},
   "source": [
    "An API, short for <b>Application Programming Interface</b>, is a set of rules and protocols that allows different software applications to communicate and interact with each other. <br><br>\n",
    "\n",
    "<li>It defines the methods and data formats that applications can use to request and exchange information.</li> \n",
    "<li>An API acts as a bridge between different software systems, enabling them to share data and functionality in a standardized and controlled manner.</li>\n",
    "<li>A developer extensively uses APIs in his software to implement various features by using an API call without writing complex codes for the same. </li>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "023ff023",
   "metadata": {},
   "source": [
    "<img src=\"https://github.com/msklc/crash_api_notes/blob/4fa528d979a51cacc7e8d47e043bbf095cff024b/images/What-is-an-API.png?raw=true\">\n",
    "<b>Source:</b>https://www.geeksforgeeks.org/what-is-an-api/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efc915c3",
   "metadata": {},
   "source": [
    "#### Types of APIs<br>\n",
    "<li>RESTful APIs</li>\n",
    "<li>SOAP APIs</li>\n",
    "<li>GraphQL APIs</li>\n",
    "<li>Library APIs</li>\n",
    "<li>Operating system APIs</li>\n",
    "<li>...</li>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fc854dc",
   "metadata": {},
   "source": [
    "## 2. REST API"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bb58425",
   "metadata": {},
   "source": [
    "REST API services let us interact with the database (or different software systems) by simply doing HTTP requests.\n",
    "This is often how the backend of web apps is created. <b>Returning data is in JSON format</b> and requests we are using are PUT, DELETE, POST, and GET."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "670df209",
   "metadata": {},
   "source": [
    "### 2.1 Sample Public APIs (GET)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c17805e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"ip\":\"31.201.88.161\"}'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import requests\n",
    "url='https://api.ipify.org/?format=json'\n",
    "r = requests.get(url)\n",
    "r.text "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fe11aa53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'status': 'success',\n",
       " 'data': [{'id': 1,\n",
       "   'employee_name': 'Tiger Nixon',\n",
       "   'employee_salary': 320800,\n",
       "   'employee_age': 61,\n",
       "   'profile_image': ''},\n",
       "  {'id': 2,\n",
       "   'employee_name': 'Garrett Winters',\n",
       "   'employee_salary': 170750,\n",
       "   'employee_age': 63,\n",
       "   'profile_image': ''},\n",
       "  {'id': 3,\n",
       "   'employee_name': 'Ashton Cox',\n",
       "   'employee_salary': 86000,\n",
       "   'employee_age': 66,\n",
       "   'profile_image': ''},\n",
       "  {'id': 4,\n",
       "   'employee_name': 'Cedric Kelly',\n",
       "   'employee_salary': 433060,\n",
       "   'employee_age': 22,\n",
       "   'profile_image': ''},\n",
       "  {'id': 5,\n",
       "   'employee_name': 'Airi Satou',\n",
       "   'employee_salary': 162700,\n",
       "   'employee_age': 33,\n",
       "   'profile_image': ''},\n",
       "  {'id': 6,\n",
       "   'employee_name': 'Brielle Williamson',\n",
       "   'employee_salary': 372000,\n",
       "   'employee_age': 61,\n",
       "   'profile_image': ''},\n",
       "  {'id': 7,\n",
       "   'employee_name': 'Herrod Chandler',\n",
       "   'employee_salary': 137500,\n",
       "   'employee_age': 59,\n",
       "   'profile_image': ''},\n",
       "  {'id': 8,\n",
       "   'employee_name': 'Rhona Davidson',\n",
       "   'employee_salary': 327900,\n",
       "   'employee_age': 55,\n",
       "   'profile_image': ''},\n",
       "  {'id': 9,\n",
       "   'employee_name': 'Colleen Hurst',\n",
       "   'employee_salary': 205500,\n",
       "   'employee_age': 39,\n",
       "   'profile_image': ''},\n",
       "  {'id': 10,\n",
       "   'employee_name': 'Sonya Frost',\n",
       "   'employee_salary': 103600,\n",
       "   'employee_age': 23,\n",
       "   'profile_image': ''},\n",
       "  {'id': 11,\n",
       "   'employee_name': 'Jena Gaines',\n",
       "   'employee_salary': 90560,\n",
       "   'employee_age': 30,\n",
       "   'profile_image': ''},\n",
       "  {'id': 12,\n",
       "   'employee_name': 'Quinn Flynn',\n",
       "   'employee_salary': 342000,\n",
       "   'employee_age': 22,\n",
       "   'profile_image': ''},\n",
       "  {'id': 13,\n",
       "   'employee_name': 'Charde Marshall',\n",
       "   'employee_salary': 470600,\n",
       "   'employee_age': 36,\n",
       "   'profile_image': ''},\n",
       "  {'id': 14,\n",
       "   'employee_name': 'Haley Kennedy',\n",
       "   'employee_salary': 313500,\n",
       "   'employee_age': 43,\n",
       "   'profile_image': ''},\n",
       "  {'id': 15,\n",
       "   'employee_name': 'Tatyana Fitzpatrick',\n",
       "   'employee_salary': 385750,\n",
       "   'employee_age': 19,\n",
       "   'profile_image': ''},\n",
       "  {'id': 16,\n",
       "   'employee_name': 'Michael Silva',\n",
       "   'employee_salary': 198500,\n",
       "   'employee_age': 66,\n",
       "   'profile_image': ''},\n",
       "  {'id': 17,\n",
       "   'employee_name': 'Paul Byrd',\n",
       "   'employee_salary': 725000,\n",
       "   'employee_age': 64,\n",
       "   'profile_image': ''},\n",
       "  {'id': 18,\n",
       "   'employee_name': 'Gloria Little',\n",
       "   'employee_salary': 237500,\n",
       "   'employee_age': 59,\n",
       "   'profile_image': ''},\n",
       "  {'id': 19,\n",
       "   'employee_name': 'Bradley Greer',\n",
       "   'employee_salary': 132000,\n",
       "   'employee_age': 41,\n",
       "   'profile_image': ''},\n",
       "  {'id': 20,\n",
       "   'employee_name': 'Dai Rios',\n",
       "   'employee_salary': 217500,\n",
       "   'employee_age': 35,\n",
       "   'profile_image': ''},\n",
       "  {'id': 21,\n",
       "   'employee_name': 'Jenette Caldwell',\n",
       "   'employee_salary': 345000,\n",
       "   'employee_age': 30,\n",
       "   'profile_image': ''},\n",
       "  {'id': 22,\n",
       "   'employee_name': 'Yuri Berry',\n",
       "   'employee_salary': 675000,\n",
       "   'employee_age': 40,\n",
       "   'profile_image': ''},\n",
       "  {'id': 23,\n",
       "   'employee_name': 'Caesar Vance',\n",
       "   'employee_salary': 106450,\n",
       "   'employee_age': 21,\n",
       "   'profile_image': ''},\n",
       "  {'id': 24,\n",
       "   'employee_name': 'Doris Wilder',\n",
       "   'employee_salary': 85600,\n",
       "   'employee_age': 23,\n",
       "   'profile_image': ''}],\n",
       " 'message': 'Successfully! All records has been fetched.'}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import requests\n",
    "url = 'https://dummy.restapiexample.com/api/v1/employees'\n",
    "headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; rv:91.0) Gecko/20100101 Firefox/91.0',\n",
    "'Content-type': 'application/json'}\n",
    "\n",
    "r = requests.get(url, headers = headers)\n",
    "r.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a436a095",
   "metadata": {},
   "source": [
    "### 2.2. Status Codes\n",
    "- 200 : OK (Successfuly Connection)\n",
    "- 3xx : Redirection\n",
    "- 400 : Bad Request\n",
    "- 401 : Unauthorized\n",
    "- 403 : Forbidden\n",
    "- 404 : Not Found\n",
    "- 5xx Server Error\n",
    "    - 500 : Internal Server Error\n",
    "    - 501 : Not Implemented\n",
    "    - 502 : Bad Gateway\n",
    "    - 503 : Service Unavailable\n",
    "    - 504 : Gateway Timeout\n",
    "\n",
    "For better visualization check this link https://http.cat/ "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2f485c7",
   "metadata": {},
   "source": [
    "__Example__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3c0d027e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import requests\n",
    "url='http://www.google.com'\n",
    "r=requests.get(url)\n",
    "r.status_code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6992fa20",
   "metadata": {},
   "source": [
    "__More Example__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a7a3b1a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://www.mysoly.nl : 200\n",
      "http://worldagnetwork.com : 200\n",
      "http://www.mysoly.nl/notfound.php : 404\n",
      "https://www.duo.nl/particulier/ : 200\n",
      "https://www.duo.nl/particulier/fistatttempt : 200\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "url_list=['http://www.mysoly.nl', 'http://worldagnetwork.com', 'http://www.mysoly.nl/notfound.php', 'https://www.duo.nl/particulier/', 'https://www.duo.nl/particulier/fistatttempt']\n",
    "for url in url_list:\n",
    "    r=requests.get(url)\n",
    "    print('{} : {}'.format(url,r.status_code))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77bad1e7",
   "metadata": {},
   "source": [
    "### 2.3 API Requests"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14d40e79",
   "metadata": {},
   "source": [
    "An API request is a communication made by a client application to an API in order to retrieve or manipulate data or access a particular functionality provided by the API."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb3b33d1",
   "metadata": {},
   "source": [
    "- <b>Request URL</b> – The URL is the link that the API communicates with.\n",
    "\n",
    "- <b>Request Headers</b> – The headers contain the key-value pairs sent with the request to the application. It describes the format of the object data for the request and response. It also includes an authorization token to identify the requester by getting new access token.\n",
    "\n",
    "- <b>Request Body</b> – The body is the place to customize details in a request."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1068f196",
   "metadata": {},
   "source": [
    "## 3. POSTMAN"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7390e99",
   "metadata": {},
   "source": [
    "Postman is one of the most popular software testing tools which is used for API testing. With the help of this tool, developers can easily create, test, share, and document APIs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "891872de",
   "metadata": {},
   "source": [
    "<img src=\"https://github.com/msklc/crash_api_notes/blob/80755692d0e7382338a3967df27d23575a1f9c8e/images/postman_api_get.png?raw=true\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39d77719",
   "metadata": {},
   "source": [
    "## 4- FastAPI \n",
    "FastAPI is an awesome, modern web framework that makes building APIs with Python not only fast but also fun. It is widely used by developers after it is published since 2018.\n",
    "\n",
    "#### What is the advantages of FastAPI?\n",
    "\n",
    "- __Blazing Fast:__ It's one of the fastest Python frameworks out there, on par with NodeJS and Go. So if you need performance, FastAPI has got you covered.\n",
    "- __Super Easy to Use:__ FastAPI is designed to be user-friendly. It even creates interactive documentation for you automatically, which is great for testing and exploring your API.\n",
    "- __Built-in Data Validation:__ With Python's type hints, FastAPI automatically checks the data you receive. This means fewer bugs and more reliable code.\n",
    "- __Async Support:__ FastAPI handles a lot of requests at once, thanks to its support for asynchronous programming. Perfect for real-time apps!\n",
    "- __Modern Python Features:__ It takes full advantage of Python’s latest features like type annotations, making your code cleaner and easier to maintain.\n",
    "\n",
    "#### Why should developers use it?\n",
    "\n",
    "If a developer looking to build APIs quickly and efficiently without sacrificing performance, FastAPI is the way to go. Whether we’re working on a small project or something that needs to scale, FastAPI helps us get there faster and with less difficulty.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b7f53d9",
   "metadata": {},
   "source": [
    "### 4.1 Hello World!\n",
    "\n",
    "In this part, we'll start with the basics by creating a simple FastAPI application that returns a \"Hello World\" message. FastAPI is a modern, fast (high-performance), web framework for building APIs with Python (its version should be upper than 3.7).\n",
    "\n",
    "We need to install some modules and libraries __FastAPI__, __Uvicorn__, and __nest_asyncio__:\n",
    "\n",
    "To do installation run the code spinnet below in a code cell\n",
    "\n",
    "- pip install fastapi uvicorn nest-asyncio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f339e8dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Started server process [36288]\n",
      "INFO:     Waiting for application startup.\n",
      "INFO:     Application startup complete.\n",
      "INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:     127.0.0.1:50308 - \"GET / HTTP/1.1\" 200 OK\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Shutting down\n",
      "INFO:     Waiting for application shutdown.\n",
      "INFO:     Application shutdown complete.\n",
      "INFO:     Finished server process [36288]\n"
     ]
    }
   ],
   "source": [
    "import nest_asyncio\n",
    "from fastapi import FastAPI\n",
    "import uvicorn\n",
    "\n",
    "nest_asyncio.apply()\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "@app.get(\"/\")\n",
    "async def root():\n",
    "    return {\"message\": \"Hello World\"}\n",
    "\n",
    "uvicorn.run(app, host=\"127.0.0.1\", port=8000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dd32d09",
   "metadata": {},
   "source": [
    "Before we continue, it is better to know why we used uvicorn and nest_asyncio\n",
    "\n",
    "#### uvicorn\n",
    "\n",
    "uvicorn is a lightning-fast ASGI server used to run asynchronous Python web applications, like those built with FastAPI. It acts as ASGI server that can launch and serve FastAPI application by handling HTTP connection, requets, back responses etc.\n",
    "\n",
    "#### nest_asyncio\n",
    "\n",
    "nest_asyncio is a small utility that allows us our asynchronous application to run in environments that don't fully support async features. (for instance Jupyter Notebooks)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb8687b",
   "metadata": {},
   "source": [
    "### 4.2 Endpoints\n",
    "\n",
    "Endpoints in FastAPI define how our application responds to different HTTP methods. In this part, we'll focus on GET endpoints to retrieve data based on specific URLs.\n",
    "\n",
    "Here's multiple examples that work in a Jupyter Notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "31201272",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Started server process [36288]\n",
      "INFO:     Waiting for application startup.\n",
      "INFO:     Application startup complete.\n",
      "INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:     127.0.0.1:50317 - \"GET /items/5 HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:50323 - \"GET /user/5/profile HTTP/1.1\" 200 OK\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Shutting down\n",
      "INFO:     Waiting for application shutdown.\n",
      "INFO:     Application shutdown complete.\n",
      "INFO:     Finished server process [36288]\n"
     ]
    }
   ],
   "source": [
    "import nest_asyncio\n",
    "from fastapi import FastAPI\n",
    "import uvicorn\n",
    "\n",
    "nest_asyncio.apply()\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "@app.get(\"/\")\n",
    "async def root():\n",
    "    return {\"message\": \"Hello World\"}\n",
    "\n",
    "@app.get(\"/items/{item_id}\")\n",
    "async def read_item(item_id: int):\n",
    "    return {\"item_id\": item_id}\n",
    "\n",
    "@app.get(\"/user/{user_id}/profile\")\n",
    "async def user_profile(user_id: int):\n",
    "    return {\"user_id\": user_id, \"profile\": \"This is the profile of User\"}\n",
    "\n",
    "uvicorn.run(app, host=\"127.0.0.1\", port=8000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7018b4c0",
   "metadata": {},
   "source": [
    "### 4.3 Dynamic Endpoints\n",
    "\n",
    "In some situations we may need to send some data via URL and at that point \"Dynamic endpoints\" allow us to capture values from the URL and use them in our functions.\n",
    "Here are the some examples of Dynamic endpoints\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "101e5b78",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Started server process [36288]\n",
      "INFO:     Waiting for application startup.\n",
      "INFO:     Application startup complete.\n",
      "INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:     127.0.0.1:50334 - \"GET /products/cable/2 HTTP/1.1\" 200 OK\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Shutting down\n",
      "INFO:     Waiting for application shutdown.\n",
      "INFO:     Application shutdown complete.\n",
      "INFO:     Finished server process [36288]\n"
     ]
    }
   ],
   "source": [
    "import nest_asyncio\n",
    "from fastapi import FastAPI\n",
    "import uvicorn\n",
    "\n",
    "nest_asyncio.apply()\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "@app.get(\"/\")\n",
    "async def root():\n",
    "    return {\"message\": \"Hello World\"}\n",
    "\n",
    "@app.get(\"/products/{category}/{product_id}\")\n",
    "async def get_product(category: str, product_id: int):\n",
    "    return {\"category\": category, \"product_id\": product_id}\n",
    "\n",
    "@app.get(\"/files/{file_path:path}\")\n",
    "async def read_file(file_path: str):\n",
    "    return {\"file_path\": file_path}\n",
    "\n",
    "uvicorn.run(app, host=\"127.0.0.1\", port=8000)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fbe27c9",
   "metadata": {},
   "source": [
    "### 4.4 HTTP POST Methods\n",
    "\n",
    "In addition to GET requests, FastAPI allows us to define endpoints for other HTTP methods like POST. POST is typically used to send data to the server.\n",
    "\n",
    "Let's create an example where we accept data in a POST request:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f983ed6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Started server process [36288]\n",
      "INFO:     Waiting for application startup.\n",
      "INFO:     Application startup complete.\n",
      "INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:     127.0.0.1:50338 - \"GET /create_item/ HTTP/1.1\" 405 Method Not Allowed\n",
      "INFO:     127.0.0.1:50341 - \"POST /create_item/ HTTP/1.1\" 200 OK\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Shutting down\n",
      "INFO:     Waiting for application shutdown.\n",
      "INFO:     Application shutdown complete.\n",
      "INFO:     Finished server process [36288]\n"
     ]
    }
   ],
   "source": [
    "import nest_asyncio\n",
    "from fastapi import FastAPI, Body\n",
    "import uvicorn\n",
    "\n",
    "nest_asyncio.apply()\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "@app.post(\"/create_item/\")\n",
    "async def create_item(name: str = Body(...), price: float = Body(...)):\n",
    "    return {\"name\": name, \"price\": price}\n",
    "\n",
    "uvicorn.run(app, host=\"127.0.0.1\", port=8000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89a4377d",
   "metadata": {},
   "source": [
    "## 5 Usage of CRUD Functionalities with FastAPI\n",
    "In this part, we'll implement basic CRUD functionalities in FastAPI. These are main operations for managing data in any application. For simplicity, we'll use an in-memory data structure (a Python dictionary) to simulate a database."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e80dbf1",
   "metadata": {},
   "source": [
    "### 5.1 Setup FastAPI and Dummy Data\n",
    "In the first cell, we set up the FastAPI app, initialize the dummy data, and apply nest_asyncio to allow FastAPI to run in the Jupyter environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8feaec13",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nest_asyncio\n",
    "from fastapi import FastAPI, HTTPException\n",
    "from pydantic import BaseModel\n",
    "import uvicorn\n",
    "import threading\n",
    "\n",
    "nest_asyncio.apply()\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "items_db = {\n",
    "    1: {\"name\": \"Laptop\", \"price\": 1000.0},\n",
    "    2: {\"name\": \"Smartphone\", \"price\": 500.0},\n",
    "    3: {\"name\": \"Tablet\", \"price\": 300.0}\n",
    "}\n",
    "\n",
    "class Item(BaseModel):\n",
    "    name: str\n",
    "    price: float"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b8dd59",
   "metadata": {},
   "source": [
    "### 5.2 GET Requests\n",
    "\n",
    "\n",
    "- **GET /items/**: This endpoint retrieves all items in the database.\n",
    "- **GET /items/{item_id}**: This endpoint retrieves a specific item by its `item_id`.\n",
    "\n",
    "GET requests are used to **read** or **fetch** resources from the server. In this case, we're using GET to fetch items from our in-memory `items_db`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7325980e",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.get(\"/items/\", response_model=dict)\n",
    "async def get_all_items():\n",
    "    return items_db\n",
    "\n",
    "@app.get(\"/items/{item_id}\", response_model=Item)\n",
    "async def get_item_by_id(item_id: int):\n",
    "    item = items_db.get(item_id)\n",
    "    if item is None:\n",
    "        raise HTTPException(status_code=404, detail=\"Item not found\")\n",
    "    return item\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb6eee24",
   "metadata": {},
   "source": [
    "### 5.3 POST Request\n",
    "\n",
    "- **POST /items/**: This endpoint allows clients to create a new item by sending its details (name, price) in the request body.\n",
    "\n",
    "POST requests are used to **create** new resources on the server. Here, we use POST to add a new item to our in-memory `items_db`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8891e990",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.post(\"/items/\", response_model=Item)\n",
    "async def create_item(item: Item):\n",
    "    item_id = len(items_db) + 1  \n",
    "    items_db[item_id] = item  \n",
    "    return item\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76e4cf20",
   "metadata": {},
   "source": [
    "### 5.4 PUT Request\n",
    "\n",
    "- **PUT /items/{item_id}**: This endpoint allows clients to update the details of an existing item by providing its `item_id` and updated data.\n",
    "\n",
    "PUT requests are used to **update** existing resources. If an item exists, we update its name and price in the `items_db`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "68bdea2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.put(\"/items/{item_id}\", response_model=Item)\n",
    "async def update_item(item_id: int, updated_item: Item):\n",
    "    if item_id not in items_db:\n",
    "        raise HTTPException(status_code=404, detail=\"Item not found\")\n",
    "    items_db[item_id] = updated_item\n",
    "    return updated_item\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11c8508d",
   "metadata": {},
   "source": [
    "### 5.5 DELETE Request\n",
    "\n",
    "- **DELETE /items/{item_id}**: This endpoint allows clients to delete an item by its `item_id`.\n",
    "\n",
    "DELETE requests are used to **remove** resources from the server. Here, we're using DELETE to remove an item from the `items_db` by its ID.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "87a1d955",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.delete(\"/items/{item_id}\", response_model=dict)\n",
    "async def delete_item(item_id: int):\n",
    "    if item_id not in items_db:\n",
    "        raise HTTPException(status_code=404, detail=\"Item not found\")\n",
    "    del items_db[item_id]\n",
    "    return {\"detail\": \"Item deleted\"}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6be8ff4",
   "metadata": {},
   "source": [
    "### 5.6 Running the Server\n",
    "\n",
    "This will start the FastAPI server in a separate thread so that it can run in the background while you interact with the API.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c78c8f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Started server process [15428]\n",
      "INFO:     Waiting for application startup.\n",
      "INFO:     Application startup complete.\n",
      "INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:     127.0.0.1:50481 - \"GET /items/ HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:50483 - \"GET /items/2 HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:50488 - \"POST /items/ HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:50490 - \"PUT /items/4 HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:50492 - \"DELETE /items/4 HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:50494 - \"GET /items/ HTTP/1.1\" 200 OK\n"
     ]
    }
   ],
   "source": [
    "def run_server():\n",
    "    uvicorn.run(app, host=\"127.0.0.1\", port=8000)\n",
    "\n",
    "thread = threading.Thread(target=run_server, args=(), daemon=True)\n",
    "thread.start()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9ecb647",
   "metadata": {},
   "source": [
    "## 6 Secret Key and WSGI Explanation\n",
    "\n",
    "##### What is a Secret Key?\n",
    "A secret key is a crucial part of web application security. It is used for tasks like encryption, signing data (e.g., tokens), or for authenticating API requests. In this case, we'll use a secret key to authenticate users making requests to our FastAPI endpoints.\n",
    "\n",
    "Common Uses:\n",
    "- Token signing (e.g., JWT).\n",
    "- Session management.\n",
    "- API request authentication.\n",
    "\n",
    "##### What is WSGI?\n",
    "\n",
    "WSGI (Web Server Gateway Interface) is a specification that defines how web servers communicate with Python applications. It acts as a bridge between the web server (like Nginx or Apache) and the Python web application.\n",
    "\n",
    "WSGI vs ASGI:\n",
    "- WSGI is synchronous and was designed to handle simple web applications.\n",
    "- ASGI (Asynchronous Server Gateway Interface) is a newer specification that allows asynchronous processing, making it ideal for modern applications like FastAPI, which may involve real-time features and websockets.\n",
    "\n",
    "FastAPI, by default, uses ASGI but it’s useful to know that WSGI is an older, more traditional way of deploying Python web apps."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bb2a07d",
   "metadata": {},
   "source": [
    "### 6.1 Securing Endpoints with a Secret Key\n",
    "In below code cell there is an CRUD application so that users need to provide a valid secret key to access the endpoints. We will create a list of up to 5 secret keys, and only users with one of these keys can interact with the API.\n",
    "\n",
    "If the user doesn’t provide a valid secret key, they’ll receive an \"Access Denied\" response.\n",
    "\n",
    "We will use the same example that we create before but in this time we add secret key authentication\n",
    "\n",
    "- **FastAPI Initialization**: We use FastAPI to handle our HTTP routes and manage the API endpoints.\n",
    "- **Dummy Data**: We prepopulate `items_db` with three items: a Laptop, a Smartphone, and a Tablet. This gives us a starting point when interacting with the API.\n",
    "- **Secret Keys**: We define a list of allowed secret keys (`SECRET_KEYS`) that are required to access any of the API endpoints.\n",
    "- **Middleware**: The middleware intercepts every request and checks for the presence of a valid `x-secret-key` in the headers. If the secret key is missing or invalid, the user is denied access (`403 Forbidden`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "75ebdc92",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nest_asyncio\n",
    "from fastapi import FastAPI, Request, HTTPException\n",
    "from fastapi.responses import JSONResponse\n",
    "from pydantic import BaseModel\n",
    "import uvicorn\n",
    "import threading\n",
    "\n",
    "nest_asyncio.apply()\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "SECRET_KEYS = [\"key1\", \"key2\", \"key3\", \"key4\", \"key5\"]\n",
    "\n",
    "items_db = {\n",
    "    1: {\"name\": \"Laptop\", \"price\": 1000.0},\n",
    "    2: {\"name\": \"Smartphone\", \"price\": 500.0},\n",
    "    3: {\"name\": \"Tablet\", \"price\": 300.0}\n",
    "}\n",
    "\n",
    "class Item(BaseModel):\n",
    "    name: str\n",
    "    price: float\n",
    "\n",
    "@app.middleware(\"http\")\n",
    "async def check_secret_key(request: Request, call_next):\n",
    "    secret_key = request.headers.get(\"x-secret-key\")\n",
    "    \n",
    "    if secret_key not in SECRET_KEYS:\n",
    "        return JSONResponse(status_code=403, content={\"detail\": \"Access Denied: Invalid Secret Key\"})\n",
    "    \n",
    "    response = await call_next(request)\n",
    "    return response"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c90e3346",
   "metadata": {},
   "source": [
    "### 6.2. GET Requests with a secret key\n",
    "\n",
    "This cell defines the **GET** endpoints for retrieving items from the `items_db`.\n",
    "\n",
    "- **GET /items/**: This endpoint retrieves all items stored in the in-memory database.\n",
    "- **GET /items/{item_id}**: This endpoint retrieves a specific item by its `item_id`. If the item doesn't exist, it returns a `404 Item Not Found` error.\n",
    "\n",
    "These endpoints allow you to read data from the API. Since the secret key is validated through the middleware, you don't need to add it to each endpoint.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b2020b2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.get(\"/items/\", response_model=dict)\n",
    "async def get_all_items():\n",
    "    return items_db\n",
    "\n",
    "@app.get(\"/items/{item_id}\", response_model=Item)\n",
    "async def get_item_by_id(item_id: int):\n",
    "    item = items_db.get(item_id)\n",
    "    if item is None:\n",
    "        raise HTTPException(status_code=404, detail=\"Item not found\")\n",
    "    return item"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b4b526f",
   "metadata": {},
   "source": [
    "### 6.3. POST Request with a secret key\n",
    "\n",
    "This cell defines the **POST** endpoint for creating a new item.\n",
    "\n",
    "- **POST /items/**: This endpoint allows clients to create a new item by sending its `name` and `price` in the request body. The new item is added to the `items_db`, and the response returns the newly created item.\n",
    "\n",
    "This is how new resources are added to the in-memory database. The secret key validation is handled by the middleware, so only authorized users can create new items.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2803b1bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.post(\"/items/\", response_model=Item)\n",
    "async def create_item(item: Item):\n",
    "    item_id = len(items_db) + 1  \n",
    "    items_db[item_id] = item  \n",
    "    return item\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53685746",
   "metadata": {},
   "source": [
    "### 6.4. PUT Request with a secret key\n",
    "\n",
    "This cell defines the **PUT** endpoint for updating an existing item.\n",
    "\n",
    "- **PUT /items/{item_id}**: This endpoint allows clients to update the `name` and `price` of an existing item. If the item doesn't exist, it returns a `404 Item Not Found` error.\n",
    "\n",
    "The PUT method is used to modify existing resources, and as with the other endpoints, secret key validation is automatically handled via the middleware.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c267aecf",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.put(\"/items/{item_id}\", response_model=Item)\n",
    "async def update_item(item_id: int, updated_item: Item):\n",
    "    if item_id not in items_db:\n",
    "        raise HTTPException(status_code=404, detail=\"Item not found\")\n",
    "    items_db[item_id] = updated_item\n",
    "    return updated_item"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e31c6995",
   "metadata": {},
   "source": [
    "### 6.5. DELETE Request with a secret key\n",
    "\n",
    "This cell defines the **DELETE** endpoint for removing an item from the database.\n",
    "\n",
    "- **DELETE /items/{item_id}**: This endpoint allows clients to delete an item by its `item_id`. If the item doesn't exist, it returns a `404 Item Not Found` error.\n",
    "\n",
    "The DELETE method is used to remove resources from the database. The secret key validation ensures that only authorized users can delete items.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9edb4193",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.delete(\"/items/{item_id}\", response_model=dict)\n",
    "async def delete_item(item_id: int):\n",
    "    if item_id not in items_db:\n",
    "        raise HTTPException(status_code=404, detail=\"Item not found\")\n",
    "    del items_db[item_id]\n",
    "    return {\"detail\": \"Item deleted\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41315a2c",
   "metadata": {},
   "source": [
    "### 6.6. Running the FastAPI Server with a secret key\n",
    "\n",
    "In this final cell, we start the FastAPI server using `uvicorn` in a separate thread.\n",
    "\n",
    "- **Threaded Server**: We run the FastAPI server in a separate thread to avoid blocking the Jupyter Notebook kernel. This allows you to continue interacting with the notebook while the server runs in the background.\n",
    "\n",
    "Once the server is running, you can interact with the API via tools like Postman or curl, using the appropriate routes and headers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fb4e48a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:     Started server process [4100]\n",
      "INFO:     Waiting for application startup.\n",
      "INFO:     Application startup complete.\n",
      "INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:     127.0.0.1:51023 - \"GET /items/ HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:51023 - \"GET /items/ HTTP/1.1\" 403 Forbidden\n",
      "INFO:     127.0.0.1:51026 - \"GET /items/2 HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:51029 - \"GET /items/4 HTTP/1.1\" 404 Not Found\n",
      "INFO:     127.0.0.1:51031 - \"POST /items/ HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:51033 - \"PUT /items/4 HTTP/1.1\" 200 OK\n",
      "INFO:     127.0.0.1:51033 - \"PUT /items/4 HTTP/1.1\" 403 Forbidden\n",
      "INFO:     127.0.0.1:51042 - \"DELETE /items/4 HTTP/1.1\" 200 OK\n"
     ]
    }
   ],
   "source": [
    "def run_server():\n",
    "    uvicorn.run(app, host=\"127.0.0.1\", port=8000)\n",
    "\n",
    "thread = threading.Thread(target=run_server, args=(), daemon=True)\n",
    "thread.start()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}