Examples.ipynb

{
 "metadata": {
  "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.8.7-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.7 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "dcbe076a40d8142e585077643c26fc4a9c0eed423ce3f041c8a5b2e5c8137bb1"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Feistel Cipher\n",
    "\n",
    "PyPI package - [Feistel Cipher package](https://pypi.org/project/feistelcipher/)\n",
    "\n",
    "GitHub repo - [Feistel Cipher repo](https://github.com/mayur7garg/FeistelCipher)\n",
    "\n",
    "Created by - Mayur Kr. Garg"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Importing the necessary libraries"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Version:  0.2.0\nAuthor:   Mayur Kr. Garg\n"
     ]
    }
   ],
   "source": [
    "import feistelcipher\n",
    "\n",
    "print(f\"{'Version: ':10}{feistelcipher.__version__}\")\n",
    "print(f\"{'Author: ':10}{feistelcipher.__author__}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import feistelcipher.FeistelCipher as fc\n",
    "import feistelcipher.CryptFunctions as cfs\n",
    "import feistelcipher.StandardCryptFunctions as scf\n",
    "\n",
    "import random as rnd\n",
    "import pandas as pd"
   ]
  },
  {
   "source": [
    "## Implementing Feistel Cipher"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Using the inbuilt `StandardCryptFunctions`"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "#### Numbers to encrypt"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[28642, 36237, -31007, -37915, 31467, 50123, 5334, 64223, -69200, 1016]"
      ]
     },
     "metadata": {},
     "execution_count": 3
    }
   ],
   "source": [
    "numsToEncrypt = [rnd.randint(-99_999, 99_999) for i in range(10)]\n",
    "numsToEncrypt"
   ]
  },
  {
   "source": [
    "#### Creating a cryptographic function list"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "funcList = cfs.CryptFunctions()"
   ]
  },
  {
   "source": [
    "#### Adding functions to the `CryptFunctions` object using the inbuilt `StandardCryptFunctions`\n",
    "\n",
    "The `addFunc` method on a `CryptFunctions` object accepts two arguments:\n",
    "\n",
    "1. A function which accepts its first argument as an integer\n",
    "2. A list\\tuple of keys corresponding to other arguments of that function\n",
    "\n",
    "> Kindly note that:\n",
    "- The second argument is optional and not required when the function has only one parameter.\n",
    "- The same function can be added multiple times with either same or different keys.\n",
    "- Kindly note that currently keyword arguments are not supported in the `CryptFunctions` object.\n",
    "\n",
    "Here, we add all functios from the inbuilt `StandardCryptFunctions` using random keys. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "funcList.addFunc(scf.identity)\n",
    "funcList.addFunc(scf.add, [rnd.randint(-10, 10)])\n",
    "funcList.addFunc(scf.multiply, [rnd.randint(-10, 10)])\n",
    "funcList.addFunc(scf.strLength)\n",
    "funcList.addFunc(scf.power, [rnd.randint(-10, 10)])\n",
    "funcList.addFunc(scf.reverse)\n",
    "funcList.addFunc(scf.truncate, [rnd.randint(-10, 10)])\n",
    "funcList.addFunc(scf.remainder, [rnd.randint(-10, 10)])\n",
    "funcList.addFunc(scf.quotient, [rnd.randint(-10, 10)])\n",
    "funcList.addFunc(scf.scaledDistance, [rnd.randint(-10, 10) for i in range(4)])"
   ]
  },
  {
   "source": [
    "#### Creating a `FeistelCipher` object using the `CryptFunctions` object\n",
    "\n",
    "A Feistel Cipher is uniquely identified by the list of functions (including the order and their associated keys) used to create that cipher. So to be able to decrypt the numbers encoded using this cipher, you may want to save either the `CryptFunctions` object (here the `funcList` variable) or the `FeistelCipher` object (here the `cipher` variable) in a file from wherein it can be retrieved again."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nFunction                        Keys\n\nidentity                        []\nadd                             [-1]\nmultiply                        [-2]\nstrLength                       []\npower                           [-3]\nreverse                         []\ntruncate                        [2]\nremainder                       [-10]\nquotient                        [6]\nscaledDistance                  [-9, -10, -7, -6]\n\n"
     ]
    }
   ],
   "source": [
    "cipher = fc.FeistelCipher(funcList)\n",
    "cipher.printCipherBlock()"
   ]
  },
  {
   "source": [
    "#### Encryption\n",
    "\n",
    "To encrypt a number, just call the `encrypt` method on the `FeiselCipher` object with the number to encrypt as an argument.\n",
    "\n",
    "Every number is encrypted as an `EncryptedObject` which is denoted by 3 integer values:\n",
    "- Left\n",
    "- Right\n",
    "- BlockLength\n",
    "\n",
    "> All of these three variables are used during the decryption process"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[EncryptedObject(346, -1766, 3),\n",
       " EncryptedObject(379, -475, 3),\n",
       " EncryptedObject(34, -27, 3),\n",
       " EncryptedObject(3346, -1316, 3),\n",
       " EncryptedObject(813, 522, 3),\n",
       " EncryptedObject(963, 127, 3),\n",
       " EncryptedObject(126, 86, 2),\n",
       " EncryptedObject(153, 319, 3),\n",
       " EncryptedObject(803, -305, 3),\n",
       " EncryptedObject(53, 11, 2)]"
      ]
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "encryptedNums = list(map(cipher.encrypt, numsToEncrypt))\n",
    "encryptedNums"
   ]
  },
  {
   "source": [
    "#### NOTE\n",
    "\n",
    "The absolute magnitude of the `left` and the `right` variables of the `EncryptedObject` depends on the list of functions being used in the cipher and is usually hard to predict in advance.\n",
    "\n",
    "The general rule of thumb is that if the functions used in the cipher generate an output which is usually bigger than the input in terms of absolute magnitude, then the value of the `left` and the `right` variables will explode (such as the `power` function in the inbuilt `StandardCryptFunctions`). \n",
    "\n",
    "To combat this, it is a better idea to use some or all functions whose output is generally smaller than the input (such as the `strLength`, `truncate` or `remainder` functions in the inbuilt `StandardCryptFunctions`)\n",
    "\n",
    "The value of the `blockLength` variable of the `EncryptedObject` depends on the absolute magnitude of the number being encrypted. Since this variable gives some information about the original number, Feistel Cipher should preferably be used only for numbers much bigger in magnitude to prevent brute force attacks."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "#### Decryption\n",
    "\n",
    "To decrypt a number, just call the `decrypt` method on the `FeiselCipher` object with the corresponding `EncryptedObject` variable as an argument."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[28642, 36237, -31007, -37915, 31467, 50123, 5334, 64223, -69200, 1016]"
      ]
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "source": [
    "decryptedNums = list(map(cipher.decrypt, encryptedNums))\n",
    "decryptedNums"
   ]
  },
  {
   "source": [
    "#### Visualising the entire data"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "   Numbers  Encrypted_Left  Encrypted_Right  Encrypted_BlockLength  \\\n",
       "0    28642             346            -1766                      3   \n",
       "1    36237             379             -475                      3   \n",
       "2   -31007              34              -27                      3   \n",
       "3   -37915            3346            -1316                      3   \n",
       "4    31467             813              522                      3   \n",
       "5    50123             963              127                      3   \n",
       "6     5334             126               86                      2   \n",
       "7    64223             153              319                      3   \n",
       "8   -69200             803             -305                      3   \n",
       "9     1016              53               11                      2   \n",
       "\n",
       "   Decrypted_Numbers  \n",
       "0              28642  \n",
       "1              36237  \n",
       "2             -31007  \n",
       "3             -37915  \n",
       "4              31467  \n",
       "5              50123  \n",
       "6               5334  \n",
       "7              64223  \n",
       "8             -69200  \n",
       "9               1016  "
      ],
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Numbers</th>\n      <th>Encrypted_Left</th>\n      <th>Encrypted_Right</th>\n      <th>Encrypted_BlockLength</th>\n      <th>Decrypted_Numbers</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>28642</td>\n      <td>346</td>\n      <td>-1766</td>\n      <td>3</td>\n      <td>28642</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>36237</td>\n      <td>379</td>\n      <td>-475</td>\n      <td>3</td>\n      <td>36237</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-31007</td>\n      <td>34</td>\n      <td>-27</td>\n      <td>3</td>\n      <td>-31007</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-37915</td>\n      <td>3346</td>\n      <td>-1316</td>\n      <td>3</td>\n      <td>-37915</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>31467</td>\n      <td>813</td>\n      <td>522</td>\n      <td>3</td>\n      <td>31467</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>50123</td>\n      <td>963</td>\n      <td>127</td>\n      <td>3</td>\n      <td>50123</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>5334</td>\n      <td>126</td>\n      <td>86</td>\n      <td>2</td>\n      <td>5334</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>64223</td>\n      <td>153</td>\n      <td>319</td>\n      <td>3</td>\n      <td>64223</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-69200</td>\n      <td>803</td>\n      <td>-305</td>\n      <td>3</td>\n      <td>-69200</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>1016</td>\n      <td>53</td>\n      <td>11</td>\n      <td>2</td>\n      <td>1016</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {},
     "execution_count": 9
    }
   ],
   "source": [
    "encryptedLeft = [enc.left for enc in encryptedNums]\n",
    "encryptedRight = [enc.right for enc in encryptedNums]\n",
    "encryptedBlockLength = [enc.blockLength for enc in encryptedNums]\n",
    "\n",
    "df = pd.DataFrame({\n",
    "    'Numbers': numsToEncrypt,\n",
    "    'Encrypted_Left': encryptedLeft,\n",
    "    'Encrypted_Right': encryptedRight,\n",
    "    'Encrypted_BlockLength': encryptedBlockLength,\n",
    "    'Decrypted_Numbers': decryptedNums\n",
    "})\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "execution_count": 10
    }
   ],
   "source": [
    "(df['Numbers'] == df['Decrypted_Numbers']).all()"
   ]
  },
  {
   "source": [
    "### Using custom functions"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "#### Creating custom functions\n",
    "\n",
    "A valid function which can be used in the function list to build the `CryptFunctions` object for the cipher must have the following properties:\n",
    "- It accepts at least one argument with the first argument being an integer.\n",
    "- It outputs an integer value for all possible inputs.\n",
    "- It should always have the same output for the same set of inputs i.e. it should not be dependent on random number generation or time.\n",
    "\n",
    "> The exact mathematical implementation of the function is irrelevant.\n",
    "\n",
    "Here we define two basic functions which we will use to build the `CryptFunctions` object:\n",
    "- `clamp` function which clamps the input number between the two given numbers.\n",
    "- `sumOfDigits` which sums up the digits in the absolute value of the input number."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clamp(num: int, numFirst: int = -100, numSecond: int = 100):\n",
    "    minNum = min(numFirst, numSecond)\n",
    "    maxNum = max(numFirst, numSecond)\n",
    "    return max(min(minNum, num), maxNum)\n",
    "\n",
    "def sumOfDigits(num: int):\n",
    "    num = str(abs(num))\n",
    "    return sum(list(map(int, num)))"
   ]
  },
  {
   "source": [
    "#### Creating a cryptographic function list"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "funcList = cfs.CryptFunctions()"
   ]
  },
  {
   "source": [
    "#### Adding functions to the `CryptFunctions` object\n",
    "\n",
    "Here, we add the `clamp` and the `sumOfDigits` functions to the object using different keys.\n",
    "\n",
    "> The functions from `StandardCryptFunctions` can also be used alongside custom functions."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "funcList.addFunc(clamp, [-1_000, 1000])\n",
    "funcList.addFunc(sumOfDigits)\n",
    "funcList.addFunc(clamp, [0])\n",
    "funcList.addFunc(sumOfDigits)\n",
    "funcList.addFunc(clamp)"
   ]
  },
  {
   "source": [
    "#### Creating a `FeistelCipher` object using the `CryptFunctions` object"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\nFunction                        Keys\n\nclamp                           [-1000, 1000]\nsumOfDigits                     []\nclamp                           [0]\nsumOfDigits                     []\nclamp                           []\n\n"
     ]
    }
   ],
   "source": [
    "cipher = fc.FeistelCipher(funcList)\n",
    "cipher.printCipherBlock()"
   ]
  },
  {
   "source": [
    "#### Encryption\n",
    "\n",
    "Kindly note that the encrypted values here are different from the ones we got using the first `FeiselCipher`. This is because, as said before, a `FeistelCipher` is uniquely defined by the set and order of its functions and keys."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[EncryptedObject(362, 30, 3),\n",
       " EncryptedObject(773, 38, 3),\n",
       " EncryptedObject(1007, -7, 3),\n",
       " EncryptedObject(123, -39, 3),\n",
       " EncryptedObject(571, 31, 3),\n",
       " EncryptedObject(915, 58, 3),\n",
       " EncryptedObject(970, 42, 2),\n",
       " EncryptedObject(823, 67, 3),\n",
       " EncryptedObject(800, -94, 3),\n",
       " EncryptedObject(1016, 13, 2)]"
      ]
     },
     "metadata": {},
     "execution_count": 15
    }
   ],
   "source": [
    "encryptedNums = list(map(cipher.encrypt, numsToEncrypt))\n",
    "encryptedNums"
   ]
  },
  {
   "source": [
    "#### Decryption"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[28642, 36237, -31007, -37915, 31467, 50123, 5334, 64223, -69200, 1016]"
      ]
     },
     "metadata": {},
     "execution_count": 16
    }
   ],
   "source": [
    "decryptedNums = list(map(cipher.decrypt, encryptedNums))\n",
    "decryptedNums"
   ]
  },
  {
   "source": [
    "#### Visualising the entire data"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "   Numbers  Encrypted_Left  Encrypted_Right  Encrypted_BlockLength  \\\n",
       "0    28642             362               30                      3   \n",
       "1    36237             773               38                      3   \n",
       "2   -31007            1007               -7                      3   \n",
       "3   -37915             123              -39                      3   \n",
       "4    31467             571               31                      3   \n",
       "5    50123             915               58                      3   \n",
       "6     5334             970               42                      2   \n",
       "7    64223             823               67                      3   \n",
       "8   -69200             800              -94                      3   \n",
       "9     1016            1016               13                      2   \n",
       "\n",
       "   Decrypted_Numbers  \n",
       "0              28642  \n",
       "1              36237  \n",
       "2             -31007  \n",
       "3             -37915  \n",
       "4              31467  \n",
       "5              50123  \n",
       "6               5334  \n",
       "7              64223  \n",
       "8             -69200  \n",
       "9               1016  "
      ],
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Numbers</th>\n      <th>Encrypted_Left</th>\n      <th>Encrypted_Right</th>\n      <th>Encrypted_BlockLength</th>\n      <th>Decrypted_Numbers</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>28642</td>\n      <td>362</td>\n      <td>30</td>\n      <td>3</td>\n      <td>28642</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>36237</td>\n      <td>773</td>\n      <td>38</td>\n      <td>3</td>\n      <td>36237</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-31007</td>\n      <td>1007</td>\n      <td>-7</td>\n      <td>3</td>\n      <td>-31007</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-37915</td>\n      <td>123</td>\n      <td>-39</td>\n      <td>3</td>\n      <td>-37915</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>31467</td>\n      <td>571</td>\n      <td>31</td>\n      <td>3</td>\n      <td>31467</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>50123</td>\n      <td>915</td>\n      <td>58</td>\n      <td>3</td>\n      <td>50123</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>5334</td>\n      <td>970</td>\n      <td>42</td>\n      <td>2</td>\n      <td>5334</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>64223</td>\n      <td>823</td>\n      <td>67</td>\n      <td>3</td>\n      <td>64223</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-69200</td>\n      <td>800</td>\n      <td>-94</td>\n      <td>3</td>\n      <td>-69200</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>1016</td>\n      <td>1016</td>\n      <td>13</td>\n      <td>2</td>\n      <td>1016</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {},
     "execution_count": 17
    }
   ],
   "source": [
    "encryptedLeft = [enc.left for enc in encryptedNums]\n",
    "encryptedRight = [enc.right for enc in encryptedNums]\n",
    "encryptedBlockLength = [enc.blockLength for enc in encryptedNums]\n",
    "\n",
    "df = pd.DataFrame({\n",
    "    'Numbers': numsToEncrypt,\n",
    "    'Encrypted_Left': encryptedLeft,\n",
    "    'Encrypted_Right': encryptedRight,\n",
    "    'Encrypted_BlockLength': encryptedBlockLength,\n",
    "    'Decrypted_Numbers': decryptedNums\n",
    "})\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "execution_count": 18
    }
   ],
   "source": [
    "(df['Numbers'] == df['Decrypted_Numbers']).all()"
   ]
  },
  {
   "source": [
    "## Upcoming improvements\n",
    "- Support for Keyword arguments\n",
    "- Encrypting/Decrypting iterables of integers\n",
    "- Support for easily saving the `FeistelCipher` object to a pickled or binary file\n",
    "- Improved Documentation"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Thank You\n",
    "If you liked this package or found it useful, consider starring the associated GitHub repository."
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}