04_analysis_tests.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "This code reads the raw data from a scio scan stored in a json file, then tries to decode it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# From ChatGPT\n",
    "# Here is a function that can decrypt a hex-encoded string using a given encryption key:\n",
    "\n",
    "import binascii\n",
    "\n",
    "def decrypt_hex(hex_string: str, key: int) -> str:\n",
    "    # Convert the hex-encoded string to bytes\n",
    "    encrypted_bytes = binascii.unhexlify(hex_string)\n",
    "    \n",
    "    # XOR each byte in the encrypted string with the key\n",
    "    decrypted_bytes = bytearray(byte ^ key for byte in encrypted_bytes)\n",
    "    \n",
    "    # Return the decrypted string\n",
    "    return decrypted_bytes.decode()\n",
    "\n",
    "# Here's how you would use this function:\n",
    "\n",
    "# Decrypt a hex-encoded string with a key of 5\n",
    "#decrypt_hex(\"63727970746f7b596f755f77696c6c5f62655f776f726b696e675f776974685f6865785f737472696e67735f615f6c6f747d\", 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To read settings file\n",
    "import json\n",
    "# Parst the command line arguments\n",
    "import argparse\n",
    "\n",
    "# Logging/output format setup\n",
    "import logging\n",
    "log = logging.getLogger('root')\n",
    "log.setLevel(logging.DEBUG)\n",
    "#logging.basicConfig(format='[%(asctime)s] %(levelname)8s %(module)15s: %(message)s')\n",
    "logging.basicConfig(format='[%(asctime)s] %(levelname)8s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')\n",
    "\n",
    "# The SCIO library\n",
    "#import sciolib.sciolib as scio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "project_path = './'\n",
    "project_path_scans = project_path + '01_rawdata/scan_json/calibrations/'\n",
    "project_path_output = project_path + '02_processed_data/'\n",
    "# input file (TODO: replace with reading all files in folder)\n",
    "input_file = 'scio_scan_20211025_194204.json'\n",
    "output_file = 'scio_scan_20211025_194204_out.json'\n",
    "\n",
    "# Some general parameters\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Supporting functions\n",
    "#---------------------\n",
    "def encode_b64(bytestring):\n",
    "    # Encode and decode data as base64 (to store until we know what to do with it)\n",
    "    import base64\n",
    "    urlSafeEncodedBytes = base64.urlsafe_b64encode(bytestring)\n",
    "    urlSafeEncodedStr = str(urlSafeEncodedBytes, 'utf-8')\n",
    "    return(urlSafeEncodedStr)\n",
    "\n",
    "def decode_b64(b64string):\n",
    "    # Encode and decode data as base64 (to store until we know what to do with it)\n",
    "    import base64\n",
    "    bytestring = base64.urlsafe_b64decode(b64string)\n",
    "    return(bytestring)\n",
    "\n",
    "def read_raw_file(input_fn):\n",
    "    import json\n",
    "    \n",
    "    outdf = [ ]\n",
    "    with open(input_fn) as json_file:\n",
    "        jsondata = json.load(json_file)\n",
    "        for p in jsondata['scan']:\n",
    "            outdf.append(p['timestamp'])\n",
    "            outdf.append(p['t_cmos_before'])\n",
    "            outdf.append(p['t_chip_before'])\n",
    "            outdf.append(p['t_obj_before'])\n",
    "            outdf.append(p['t_cmos_after'])\n",
    "            outdf.append(p['t_chip_after'])\n",
    "            outdf.append(p['t_obj_after'])\n",
    "            outdf.append(p['part1'])\n",
    "            outdf.append(decode_b64(p['part1']))\n",
    "            outdf.append(decode_b64(p['part2']))\n",
    "            outdf.append(decode_b64(p['part3']))\n",
    "            outdf.append(p['part3'])\n",
    "    return(outdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x00\\x00\\x00\\x00\\xe87p\\xe8Z\\xbc\\xe7\\x02Q\\xf6:e\\xf4\\n\\x7f@;@\\xe3\\xd9\\xa6I^\\xdc\\x8e\\xdbF%%\\xac\\xbbyB\\x90\\xd03\\xd5\\x96y\\x9e@>R\\n\\x0c\\xca\\xe0\\xf7@\\x8c{\\xd1\\xcdHQ\\xc8;/\\x8d\\x9e\\xc8\\x85h>\\xc4\\x10\\xf5\\xb3#\"]\\xefo\\xa8\\xdbfHk\\x86\\x9cX\\xecz\\x9a\\xba\\xab\\xae\\xb52I\\x89\\x00d\\x17\\xbf\\x16\\x87\\xbby\\xd9\\xa7\\xe0f\\x97\\xebvXb\\x0b\\x12\\x17\\x92\\x81\\xdf\\xa8J\\xa5F\\x12)\\x8a\\xcb\\xf0\\xe7\\x98\\x1d\\xd1\\x05\\x14\\xc3[\\x9dT\\xb9\\xf6\\xb8\\x82\\xa49\\x1d\\x84\\xca\\xc9\\xc3[\\x19\\xc5\\xc4$\\x9de\\xe8j>K[\\x9d\\xa5\\x9ff\\xf0J\\')\\xea\\xec\\nH\\xf2\\xfa\\xd9\\xb5G\\x12\\xd6VT\\x8ct\\x9d)$\\xbcn\" c\\x9a\\x14\\x01\\xba\\xcf\\xfd\\xe6\\xf9\\x14\\x99 \\xa1\\xdc\\xc0\\xb9}T\\xea{\\x04\\x8e\\xc7\\x10\\x11\\xc6\\xfeI\\xa9\\x9d\\x8d\\x00z\\x12\\xe7\\x15\\\\\\xe6\\x86\\x88\\x88\\xab\\xa4\\x89\\x86\\xd9\\xd41\\'\\xdaZy\\xe4z\\xb6\\x97\\xb1\\x9a\\xbejr\\xb2;K\\x82\\xc2\"=\\xa0\\x98z\\x92\\xd7\\x1e\\xe3\\x97YF5;\\\\\\xa1\\xc0\\xd4\\x86\\xc8K\\x0e\\xa1\\x80(\\xbd`K\\xccD\\'\\x0b\\xbfL\\xe0\\x8c\\\\n\\xf5\"\\xb1\\xdf)\\x9e!O28\\x94\\x85e\\x0e\\xc8=\\xe1\\xba\\xfc\\xf99\\xbc\\xe6e\\xc0\\xfa\\xccF\\xaa\\x16\\x04%0+\\xf1\\xad\\xef\\x97Db\\x9bg\\x11\\xd6\\tc\\xf5\\x85\\xe2\\x10vp\\xa3*\\xaf\\xdf\\xd9vy\\xe2<tJ\\xb7A\\xb2\\xa9\\x03K\\xb4)\\xddN\\xc2jt#@\\xa5\\x91\\xfd7\\xcd\\xce\\x150\\xfc\\xba\\x99c\\xad\\x08s\\xb3\\x94\\x91\\xfb\\x89m\\xd3+\\x10\\xe0\\xd5\\xf8\\x81*\\x0f\\xed<\\xe2\\xa6\\xfdK\\x87\\xdf\\x9cq\\xaf\\xaa2\\x08\\x92\\x9a\\x98\\xc2\\xe0(\\xd1\\xd8a\\xf2q\\xac>\\x01\\xddIb\\xdfa\\xe0\\x9d\\xc2&;\\xf2\\x9d@\\xf6\\xb6\\x02\\xf6@\\x190\\x05i\\x13\\x96\\x07\\xfd\\xf2\\x02w\\xd6\\xe0\\xcfXb\\x12\\xe3\\xbb3\\x92\\xa2\\xe2z\\x1a\\xccG\\x1a@\\xdc\\xd9z_\\xe3%\\tz+H29\\xd7\\xac\\xda5[q\\xce\\x13\\'\\xe9\\rd\\xe4\\xb2\\xa9P\\xeb\\x96\\xf6\\x8e\\xd1\\xec)\\x8e\\xfa\\x1e\\xb8\\xf3\\xdf\\x1d\\x14\\xd0*EL\\x85F\\xfa;\\xb7EA\\tV&\\xab\\xdd\\x10\\xa3\\x8c\\xc0\\x96)\\x85;\"\\xae\\xe9\\x8d!P\\x01\\xa4\\xe7y\\xf1W\\x87\\x1b\\x98Q\\xb1a\\xa8\\xf8\\xab\\x80\\xad\\xefS\\xea3\\x12\\xb5[\\x08\\x16\\xab;Tn\\x94sR\\x89G\\x94\\xfb\\x85\\xb2v\\xbc\\xc4\\x1fb\\xfb\\x08\\x1b\\xd9\\xbc\\xbd\\x83\\x81\\x175\\x10=\\xeb\\xb5\\xc0\\x8ce\\xa7t\\x843z\\xaf\\xebW\\xd8\\xcd\\x86\\xb4\\xf1K.\\x7f|\\x1f\\xeca\\x06?\\xb39\\xddj>\\xfc\\xab\\xa47\\x81X\\xc2>\\x125\\xa9!\\x88\\x9c\\x8e\\xb5\\x7f!\\x99R\\x11\\x0f\\xeb\\xf4+\\x99,\\xc4\\xac\\xe7\\x92\\xb5]\\xa9\\xde\\xd6\\x10\\xac&8I\\xa5\\xbaV\\r\\x0cz\\x0e\\x17\\x80\\xe9M\\xfa\\x87\\x88\\xe4\\xf0\\xebJ\\xfc\\xf1?-\\xe0\\x19 X\\xe5\\r4\\x17\\xe2#{\\xb1\\xbd\\xa0\\xab\\xf1pD\\xadZ\\xb9D?K\\xd8]\\x8a\\xf08\\x8dr\\xf6Z\\x86-C\\xc3\\xc8\\xac\\xf9\\xca0\\xec\\xc7\\xe9\\x88?p\\t\\xe6N\\xae\\xc7\\x81J\\xe8\\xd0pf\\xeex\\x1b~\\x00\\xb2\\xfc\\x9e\\xa6\\xbd\\xe1\\x15\\x80\\x92\\xe9(\\xd1\\xba\\x80x\\x14o\\x90\\xa8U\\x82p\\'\\x88\\xa0w\\'7\\x13\\xfc\\x8d<Y\\x9f\\x146f8\\x07l\\xaf\\xa4\"F<:\\xef\\x12\\x027@r\\x1dd\\xe8\\xf9*\\x9a\\xa8i\\xf6|\\xd9\\xed\\xf4\\xebf\\xcf`\\xafh\\xde\\xd3#\\x1b\\xf4\\xe9x\\xb4\\xbc\\xfa\\x90)\\xd1rE\\xbfa\\x01o\\x00z\\x08\\'\\x9f8\\xec7\\xba\\xbfS?}\\x80\\xe4Q\\xf9\\xe3N\\xd2{\\xb0\\xd1\\x14\\xf5p\\xa2\\x0e`k\\x98\\xed9\\xac\\x0b\\x05t\\xf1\\xe4D\\xcf<n8\\xa5\\x19H\\xe4\\x87\\x7f4\\xdcf\\xb0\\xcc\\x04W\\x0e\\xc4;\\x9b\\xac\\xae\\x1aK\\x9c?\\x0c\\xf4aI\\xf4\\x1fY|3\\xf9\\xec+\\x81^\\x9a\\x1fb%%\\xa12|\\xcfHw\\xb3\\xd3\\xa7\\xdd\\xe4\\xb2b\\x1c$R1<\\x9b\\x85\\x7f\\xac%\\x02\\x172\\xc7\\xc4\\xae\\xe0RKx\\x8d!\\xf2\\x8e\\x87\\xcd\\x1d\\xe4A\\x80\\xd33\\x00\\x1d\\'qy\\x7f\\xcav\\x8eaD3&5\\xb0\\x92\\x9b\\xd6\\t.\\xd7\\x81@\\x0b\\xa9\\xbcTz\\xe43\\xd2\\xe2\\xa1\\x86;\\xb26\\x99\\xc1!\\xec\\x848=`\\xd3\\xee%\\xf4*\\t\\xaf*\\x19v\\xe5M:d\\xd7L\\xd7+\\x1a\\xc5^\\x7f\\xeb/\\xee\\xab\\xe4G,\\xfea\\x8f\\x06=\\xc7\\xaf\\x14\\xdd\\xc9\\xe3S\\x07<\\xc5\\xcb\\x9f\\xefF\\x1b\\xec\\\\a*\\xb7\\xdf\\xbc\\xac\\xdfd\\x06\\xfc\\xb8\\xef\\xb9\\xcf\\xf8?\\xe5\\x15\\xb5\\x15\\x83\\xe8a\\xc3=N\\x12\\xa9T\\x1d\\xef\\x98E\\xa2_}\\xd4\\xac\\xb6\\xb5\\xac\\x89s4\\xb9j\\xa16s\\xeb\\xdaW\\x17\\xf6\\x17\\x03\\x95V\\r\\xde:\\xbdr\\x94\\x82Z\\xadU\\xd5%\\'\\xac\\xcb\\xfa\\x02\\x9cgy\\x06_25\\xf9&\\xbb\\ny\\xf4\\x96z\\x8f\\x01\\xce.}l\\x1b\\xfe\\x14\\xc6+\\x82\\xd0\\x1cj\\x03\\x9f[\\xfa\\xb0\\xcb\\xa1\\xab\\x1b\\x1e\\x1d\\xa1\\xddH~|eQ\\xd5\\xd8_H\\xaet\\xe1\\x8c[;\\xad\\x85\\xc5\\xe7\\x941O\\xd2\\x1f5\\x87\\xce\\xeb\\xa2\\xb4\\x1e,\\x90#<c\\x02\\xc5lN\\xc6)\\x18\\xaf\\xc1\\xba\\xeb\\x1e\\x0ej\\x07qT\\xf9\\xdd\\xbe%\\xc4\\xba\\xca\\xb6\\x14\\x96\\x92PG\\xdf\\xc9\\xa8\\x1cQ\\xbc\\xae\\xc3\\xc5\\xd3\\x03|Q\\xc1\\x9d_x1\\xa3\\x0f\\x9c\\xcb\\xff\\x83\\xfa5\\xd3|\\xdd\\x94F\\xd0\\x84\\xeb\\x8fi\\x87\\x7f\\xbb\\x87oY\\x10\\x05\\x00\\xa8a\\xb9\\x96\\xe0\\xe4\\x17\\xa0L9I\\x95\\xc4\\xfe\\x1c\\x86\\x04\\x04\\xbd<\\x12\\x1b\\xec\\xbf\\x88\\x93\\xbe%\\xfe\\t\\x83\\x15\\x9eZkb\\xbct\\x86\\xfe\\x0c\\xdc\\xc4\\x1aR\\xba\\xeaVC\\xca>M\\xa5\\x1d\\xe3\\xb65a\\xbe\\xe1\\x9f\\x80\\xc4~\\xde\\x11H\\x8c\\xf1E\\x19\\xf7\\x0c\\xe7\\x80\\\\m\\x8a\\xb6\\xd5\\xb8f]\\xdd\\xf8l\\xc4]h\\xf6\\x847\\xfc:\\t\\xb5\\xb7\\x0eFT4:J\\xc9\\x8b-b\\x9d\\x03\\xa4|2\\x81x\\xe3\\xde\\xee\\x9a\\x89\\xafL\\xd3x\\x7fZ\\x10f\\x06k\\xd4\\x92\\xe3\\x9b\\x9d\\x03\\x8d7\\x193\\x8f\\xd6\\xe0\\xf9\\xc6\\n\\x13\\xec\\xe2\\xb7\\xe5\\xc8\\x99\\x97\\xb3 \\xc0\\xb1G\\x00\\x18\\xab;R\\x94\\\\\\x93\\\\\\x85\\xd1\\xe8\\x8e\\xef\\xfe\\x99\\xfd\\xb5\\x00+\\x06\\xf2q@\\xc8\\x92l%F\\x8bw,~\\x98\\x988\\xd7\\xd8\\x93\\xacj\\xde\\x01=\\xfe\\xb5\\xb97*R\\x990\\xf1\\x8d\\xc1\\xc7\\x91\\xd0n\\xa1\\xd8p\\x9c=34\\xf3\\x8b\\xe3&5\\x19\\x0cap\\x9e 7_\\x173:\\t\\xbb}\\xddB\\x07\\x89\\x03\\xf4\\x19\\xb9\\x07]\\x84\\x95h\\x1c\\xc6O\\x94\\x03\\x03\\xd6x\\x08L\\xc3\\xef\\xf0E\\x13\\x04+\\x1b\\xe3\\xb2\\x0f\\xc4\\xf1\\x8co\\n\\xdc?[\\x18\\xe3\\x99\\xf9\\xf6\\x04\\x82\\x94\\xe4\\x8a\\xd2\\n\\x8b\\x80\\x01\\r\\x08\\xec\\x08\\x0eO\\t\\xc9\\x9d\\xefk.x\\xec\\xfa\\xd4\\xec\\xc5\\xec\\x80B~N\\x88/\\x90\\xdd\\xdb\\x89\\x95\\x92Q\\x96\\x1fk\\x9e\\xd9zf\\x8f\\xd4\\x97\\xc7\\x93r\\xe9\\x16\\xa1x\\x9e~\\x8e\\xce)\\xb6@j\\x9f?\\xd5)jo\\x03\\xdb\\x06\\x83\\xe3\\xb2\\xd8\\xf0vm\\x12\\x93Nd\\x03\\x81\\xe7\\x98\\xec\\x8d2\\xc8\\xe2\\xcd\\x04\\xabO\\xae\\xe2+F\\xbb+Jz\"\\xaa\\x9d\\x81\\x0b\\x96\\xda\\xc09\\x07Z\\x94\\x81\\xc8\\x9d\\xff\\xb9o\\x8f\\x18\\x84u\\x07\\xc9\\x9a\\xaf\\xf0\\x89q\\xf6c\\x84\\x9b\\xd5\\xc3\\xbai\\xec\\xad\\x9f\\xad\\xd4Z\\x16\\xc0U\\x92\\x04\\xc5\\xad\\xe4\\xfe\\xd3\\xb6\\xd4\\xe4H\\xe8\\xf9xv2\\x97\\x92\\xe0\\xe0\\xe6\\\\\\xb0\\xa1\\x1deW\\xa0^9X\\x02\\xd9\\xfd\\xd9\\xfdk\\x01aI\\x05\\x03\\xf8\\xe7\\xea'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "b'n\\x00\\x00\\x00\\xc0\\x02\\xa1f6\\xcc\\xc6a*\\xe3\\x91\\x19.\\xbf&\\x85/\\x9a\\xcb&\"$c\\xf0N4&\\xefM\\x07\\xe6I`\\xd6z!Ps\\xe6a\\xb7\\x08&\\x80\\xffu\\xde\\xc2\\x1f\\x94\\x0e\\xf2\\xf7\\x1f`%\\xc0\\xb1\\xf2\\x89/+\\xd5\\xf4\\x99Qt\\x9b\\x8b\\xb5U\\xdd\\xe2f\\x922\\xbd\\xb8(\\x98A}\\x87g\\x0b\\xd9@\\xf6\\xe8\\xb1G\\x84QZR(0\\xe4F\\x92Z\\xc4]\\xc8\\xf4\\xa0\\x1bjT[z\\xdf\\x18\\xf2\\xaa\\x14\"\\x07\\x7f\\x19\\x90\\xcb\\xf0\\xc1iv\\xe3\\xc4pdYMyo|7\\xbe\\xd9\\xa4\\xba\\xc6\\xce\\\\\\\\%PN\\xcd\\x06L\\xf4\\x87\\x0f?\\xb3?\\xf1\\xf6\\xed\\xe8\\x1d\\xcax\\x88\\xe2\\x9d\\x8e\\xf4m{\\xad\\xd3\\x8d\\xc6\\xfd2\\x03\\xb4\\xa6\\xb7AL,9\\x1d\\x84G\\x14\\xe9\\xb2\\xfd\\x94\\xd5<+\\xeb\\x0fb{\\xfa1w\\x8b\\xe1\\xad/\\x95\\xc5d9\\x9bS\\xd0hj;\\xc4\\xee\\xbe\\x99\\xc9\\xec\\x1eG\\xd1\\xa7\\xc6\\x93\\x7f ,<CF\\x88\\xf6*%\\xecIoA\\xf4\\xec|\\xe0\\x14\\x90\\xf2\\xc9O\\xc7__\\xf3\\xa2\\xe5_\\x87\\x15;\\xba\\xf5\\xbai\\x8cR\\xd7\\xe3\\xb0\\x94\\tL\\xd3\\x08\\x07\\xcb\\xdb\\xa9\\x19\\x0e\\xc6\\x89\\xae\\xcfL\\xd7\\xf8\\xe7\\xec\\xa0{1-\\xc5\\xd8\\x1c\\xc2\\xfeBV\\x11\\xfd\\xf5\\xcft\\x99B\\xe4)\\xd5k%4&&f\\xe5\\x7f\\xb7\\x02D\\x18%\\xaa\\x91\\x0ft\\xfdb\\x83\\x01\\xebQ\\x08OF\\x89+)C\\xdds\\x8b\\xdd\\xf1\\xd5\\rL\\xb5\\xfa\\xac\\x16m\\x80\\x1d\\xfd\\xf9T\\xa8\\xd5\\xce\\xa9\\xb9\\xb3\\xe1\\xeb\\x1dJqV\\xd6\\x94\\x1d1;\\xb02\\xd7P\\xf2\\xf4\\xac\\xbf6\\xe4O\\xffq\\xd0zG\\xb7 i\\x8ek*\\x14V\\x8cE\\xb8>\\xa6q\\xcb\\x8d\\xf3\\xdc\\xee\\x91V\\xd0\\xdb\\xfe\\x053\\xb9\\xcf\\x17\\x9b\\x19\\x00\\xb1\\x99\\xb5w8\\x14\\x0cI\\xabr\\x98\\\\\\x9d2\\xda\\'c\\xde\\xa0\\xe0c\\x1e\\x00v\\xff\\x08\\x1a!\\xb7\\x1b\\xde\\xb4\\xba\\xeb\\x06X\\x08\\xfe\\xb3\\x19c\\xfc\\xf44\\x12B-O\\xb4\\x82E\\x934\\xc09P-\\xb5\\x9dGy\\x7fA\\xc7)\\r\\xd4\\xd7[\\xa9\\xeab\\xd1e)\\x93\\xd7\\xc1\\xb2\\xe2\\x99G\\xfa{6vFST\\xf0\\xb6\\xd1\\xd9\\xdbG\\x8ep\\x8a:\\xce\\x07m\\xef\\xf0\\xc9\\xa4G\\xf6;@i#\\xb9V\\xa9+\\xd9\\xca\\xc3\\x93\\x13\\x19\\x11\\xb1\\xa7\\xf6\\x1cEt$\\xe1\\x96\\xcbG0\\xea\\x8er\\xa2\\xce\\xfa<BT~\\x9e\\xbem\\xc0)s\\xa3T/\\xeb\\x00\\xce\\x00\\xfb\\xe4\\x81$!\\xcf\\xcb\\xfd%\\xe1\\xc8)\\xdd\\x9f\\x999\\x1e\\xaa\"\\xc3\\xc0\\x89\\xea\\xe0[\\x17\\xdb\\xb9\\xab\\x91V\\xaa\\xd98\\xac<\\xd8\\x9ez\\x94\\xa0\\x1f\\xc5\\x0b\\xf3i\\xdc\\xd1\\xb3\\x16\\xb7\\x07\\x93\\xe6\\x06P4q\\xd2\\x1bx\\x19\\xeb\\xed\\xa9\\xaf\\xf7\\x06_Py!\\x82\\x16\\x9e5U\"O\\xf9\\xf3y\\xcc\\xffq\\xca\\x800\\x98\\xa7\\xc1$b\\x1b-\\xf9\\x1bz\\x94\\x93e\\x81.\\x9e\\x97\\x0esU\\xdc\\x91F\\xf2\"\\xa9U\\x8c\\xefjO\\xbc\\xab\\x01\\xf9\\xe0\\x14\\xd1$-\\xa5?\\xfdVd[\\xb3\\xb3o\\x14\\xa2\\xd2\\x97\\xea[\\x1d\\x87\\x88_J\\x99\\x0f&J\\xe3s&\\x15\\r\\xbd \\x98\\xb9\\xbe\\xaa<]}o\\x86\\x87\\xeei\\x10J\\xef?\\xce=\\xd1\\x8b#\\xdfbr\\xec\\x01\\x08H\\xdd\\xf4\\xdc\\x0f\\x9b\\xf5\\xcd\\xd1@0\\xb0\\xdc\\xbd\\xbf=\\xec \\xae\\xb2\\xe3\\xdb\\x12\\xbf\\xd2\\xed%\\xe6\\x06\\xbfk;\\xe3\\xe2\\x87\\xffX\\xa8\\x16Po\\xa3\\x13$\\xeb\\xb2\\xb9\\xec\\x97\\xe3rQ\\xf1\\xedB\\xad<\\x06`\\n\\x12\\xe1\\x0c\\xfep?\\xa4\\x98\\x131\\xd6\\xfb,\\xa5\\x9e\\xc2\\x96\\x90r\\x19\\xc3\\xc9\\x96\\x9a\\xe48\\xb2/\\x95\\xa14ez\\xd9\\xf3\\xe7\\x05_\"H\\xb3\\xa3\\x96\\xe5oM{\\x0c\\x06kA*\\n\\x08\\x92\\rO!\\xc5d\\xe0\"&[\\xd8\\xa0\\xc4S[q\\x0c\\x1c>^\"\\x0e6j$;:<\\xd0yYS\\xe9\\x0e=\\xd8\\x9et\\x10\\xb5\\xc2\\x9b\\xdd}\\xaf\\x81\\xf3g\\x8fp\\x99\\xc3!\\x96\\xb6\\xe1/\\xb6\\xa2V\\x90/\\x7f\\x80\\x96f\\xb9\\xa1\\xe3\\x91\\x17N\\x15\\xdfe%\\x95\\x82\\x82\\xa0\\xdd\\n\\xb9\\x89\\xbe4\\x9f\\xb2\\xab:4\\t\\x16\\xe0]?T\\xfb\\xcc\"\\xd0\\xcb\\xe2\\xb1\\xa2^i\\xb6\\x86\\x9aI\\x02u\\x0cq\\xff.\\xd7\\x9d\\xdep\\x82\\x93G\\x9a\\xbee\\xe9V\\x8bi\\x9c\\no;\\xfd\\xc8\\x9ez\\xbd}\\x9a\\x13o9\\xdd\\x9c4;\\xb4\\x90|\\xe9#\\xf1\\xec\\xe6r\\xa6\\t\\x1fV`\\x9e\\xf3\\xc4X\\x81F6\\x11\\xa5G(\\xa9\\xb3\\x16\\x81:\\xb3\\xc2\\x83\\x87Q\\x9c\\xc4\\x81t\\xf9\\xfcGyd\\xb4\\xd2[^\\x9fyOH\\x8f&\\x10A\\xb0n\\xe0\\xe2wA\\x14i\\'w\\xe0\\xc5\\x92\\xcc\\xf2\\x19[\\x86\\xb8\\xa8\\xcc\\xb8\\xa4u_\\xee|\\x12\\x04\\x02\\x90\\xff\\x1a\\xc1\\xd9\\xca\\xb8Rx\\xf9\\xebR`\\xbf\\xbc\\xae#v\\xb45\\xc5+X\\xad\\xa1Hi\\xeb_\\xbb\\xd4=\\xf7\\xd2\\xeec1\\x9f\\xc8\\xc3\\xb4#/\\x97\\x98\\x9f(z\\x83\\x13+\\x863Y\\x85$\\x0bP\\xe4\\x87\\xbc\\xbd\\x8a\\x1e5\\xa7\\xaa\\xe1A\\x90B\\xe6\\xc4\\xb0g\\xe6\\xe9\\xb7\\xb1\\x126\\xeac\\x80HaHe\\xc5\\xdak\\x84\\xcd\\xc0\\x1b\\x08\\xe4e6\\xc5\\xef\\x970UxZO\\xf1C\\xcbHC\\x84\\x83\\xf3\\xf5YM\\xc8Z\\x94\\xe0~\\xa2k\\xfb\\x08\\x1f\\xf0\\x04=LF\\xa1<J^=\\xf2\\x19\\xde\\x81\\x9a3\\x08\\x00\\xdd\\xd2\\x8b\\xfb\\x8d0\\x06\\x160\\xcf\\xe2!(\\x05\\xf7@\\x8au\\xb8\\x9el\\xd9\\x07\\x9e\\xb5u\\xd0\\xd3\\xad#\\xa9\\x1c\\xe9w~\\xe4@\\xc0\\x84\\xee\\xeeN\\xe1\\x1cYX5w\\xe9\\x1f\\xb3?d\\x85\\xdab #\\x1d\\xc7\\x1a\\xf8H\\xff\\x8e]\\x0c\\xc5_<\\xf8N\\xabk\\x03\\xdf\\x7fQ\\xb0\\x1b[&\\xd9y\\xed\\xf7\\xbc\\xba0\\xabf\\xa5\\x03W\\xb9\\xfb\\xbe\\x88wki\\xdc\\x1e\\x12\\xa4\\xea\\xab\\xa3\\xa9\\xad\\x1e\\'\\xae\\x97\\xe1\\x88/T\\xf7\\x04\\xb7e\\xdc?\\xe2\\xddv\\x95Z~@\\xfd\\x1avT\\xac\\x7f%\\xa8?\\x81\\xba\\x8a\\xa2\\x82I\\xfb\\xca/K\\xdc\\xd8\\x80\\x02-\\xceB\\t\\xb2\\rs\\x85\\x96t\\xecBJ\\x97u\\x07n\\x1f\\x17\\xe1\\xf0\\xa1\\x01\\xb5\\x91?:\\xec\\x0f0\\xbf\\x05\\xed\\xe4\\xd5\\xcfR\\xcf\\xfe\\xe6\\x13\\xde\\xab,\\x8e/\\x03\\x8a\\xd8&\\xe1\\xad\\x1c\\x1fR]\\xd6c\\xc1\\xa3{\\xc2\\xcc\\xc5\\xe3.\\xf7\\xfcq{\\xbc\\x1b#\\x8e7\\xbeCS\\xe7\\xd8f\\xc5\\xe0n\"4\\xccm\\xc2\\xa1\\xa4\\x064\\xf1;\\xacX\\xf1\\x1c\\'\\xa2\\xf7b\\xa4\\x81gO\\xc6\\x08K\\xc8\\xab\\x1c\\xb5\\xa6L\\xd8VG\\xef&\\x1d\\xa0\\x9c\\xda\\xffa\\xe4\\xbf\\x8b<T\\x02/\\xd0\\xbf\\xad\\x94\\xc8\\xeb\\x94\\x8a%W\\x95\\x12\\x06\\xa3v\\xd1\\xd8n\\x93\\xa0I\\xc2\\x9d\\xbc\\xa7\\x890\\\\\\xc2\\x89\\xe1gkkx\\xf6\\x93\\x0e>\\xfa*\\xce\\x8b\\xb6\\x95\\xd8\\x7fM\\x14\\xfa\\xf0\\xdb\\xccGz\\xd4\\xab\\rJ\\xa2n\\xcc\\x1f\\xb4\\xff]\\xf6\\x8f$\\x0b`\\xf3\\xb7\\x01\\xb7\\x1aQ\\xaeh\\xd0\\xbe<g7\\xfa|\\xc3;\\xbbj\\x90S?\\xd1\\xd5\\xfb\\x90\\xc9\\xc5I\\xe0'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = read_raw_file(project_path_scans + input_file)\n",
    "\n",
    "display(df[8])\n",
    "display(df[10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TEST\n",
      "b'YPFUJZWmjj203izPuR+1Ly7MsUHtDyvDY5PHpTgnOZmucsvBzzci1/eQes2g/4VJ'\n",
      "-----------\n",
      "AAAAAOg3cOhavOcCUfY6ZfQKf0A7QOPZpkle3I7bRiUlrLt5QpDQM9WWeZ5APlIKDMrg90CMe9HNSFHIOy-NnsiFaD7EEPWzIyJd72-o22ZIa4acWOx6mrqrrrUySYkAZBe_Foe7edmn4GaX63ZYYgsSF5KB36hKpUYSKYrL8OeYHdEFFMNbnVS59riCpDkdhMrJw1sZxcQknWXoaj5LW52ln2bwSicp6uwKSPL62bVHEtZWVIx0nSkkvG4iIGOaFAG6z_3m-RSZIKHcwLl9VOp7BI7HEBHG_kmpnY0AehLnFVzmhoiIq6SJhtnUMSfaWnnkeraXsZq-anKyO0uCwiI9oJh6ktce45dZRjU7XKHA1IbISw6hgCi9YEvMRCcLv0zgjFxu9SKx3ymeIU8yOJSFZQ7IPeG6_Pk5vOZlwPrMRqoWBCUwK_Gt75dEYptnEdYJY_WF4hB2cKMqr9_ZdnniPHRKt0GyqQNLtCndTsJqdCNApZH9N83OFTD8upljrQhzs5SR-4lt0ysQ4NX4gSoP7Tzipv1Lh9-cca-qMgiSmpjC4CjR2GHycaw-Ad1JYt9h4J3CJjvynUD2tgL2QBkwBWkTlgf98gJ31uDPWGIS47szkqLiehrMRxpA3Nl6X-MlCXorSDI516zaNVtxzhMn6Q1k5LKpUOuW9o7R7CmO-h64898dFNAqRUyFRvo7t0VBCVYmq90Qo4zAlimFOyKu6Y0hUAGk53nxV4cbmFGxYaj4q4Ct71PqMxK1WwgWqztUbpRzUolHlPuFsna8xB9i-wgb2by9g4EXNRA967XAjGWndIQzeq_rV9jNhrTxSy5_fB_sYQY_szndaj78q6Q3gVjCPhI1qSGInI61fyGZUhEP6_QrmSzErOeStV2p3tYQrCY4SaW6Vg0Meg4XgOlN-oeI5PDrSvzxPy3gGSBY5Q00F-Ije7G9oKvxcEStWrlEP0vYXYrwOI1y9lqGLUPDyKz5yjDsx-mIP3AJ5k6ux4FK6NBwZu54G34Asvyepr3hFYCS6SjRuoB4FG-QqFWCcCeIoHcnNxP8jTxZnxQ2ZjgHbK-kIkY8Ou8SAjdAch1k6Pkqmqhp9nzZ7fTrZs9gr2je0yMb9Ol4tLz6kCnRckW_YQFvAHoIJ5847De6v1M_fYDkUfnjTtJ7sNEU9XCiDmBrmO05rAsFdPHkRM88bjilGUjkh3803GawzARXDsQ7m6yuGkucPwz0YUn0H1l8M_nsK4Femh9iJSWhMnzPSHez06fd5LJiHCRSMTybhX-sJQIXMsfEruBSS3iNIfKOh80d5EGA0zMAHSdxeX_Kdo5hRDMmNbCSm9YJLteBQAupvFR65DPS4qGGO7I2mcEh7IQ4PWDT7iX0KgmvKhl25U06ZNdM1ysaxV5_6y_uq-RHLP5hjwY9x68U3cnjUwc8xcuf70Yb7FxhKrffvKzfZAb8uO-5z_g_5RW1FYPoYcM9ThKpVB3vmEWiX33UrLa1rIlzNLlqoTZz69pXF_YXA5VWDd46vXKUglqtVdUlJ6zL-gKcZ3kGXzI1-Sa7Cnn0lnqPAc4ufWwb_hTGK4LQHGoDn1v6sMuhqxseHaHdSH58ZVHV2F9IrnThjFs7rYXF55QxT9IfNYfO66K0HiyQIzxjAsVsTsYpGK_BuuseDmoHcVT53b4lxLrKthSWklBH38moHFG8rsPF0wN8UcGdX3gxow-cy_-D-jXTfN2URtCE649ph3-7h29ZEAUAqGG5luDkF6BMOUmVxP4chgQEvTwSG-y_iJO-Jf4JgxWeWmtivHSG_gzcxBpSuupWQ8o-TaUd47Y1Yb7hn4DEft4RSIzxRRn3DOeAXG2KttW4Zl3d-GzEXWj2hDf8Ogm1tw5GVDQ6SsmLLWKdA6R8MoF4497umomvTNN4f1oQZgZr1JLjm50DjTcZM4_W4PnGChPs4rflyJmXsyDAsUcAGKs7UpRck1yF0eiO7_6Z_bUAKwbycUDIkmwlRot3LH6YmDjX2JOsat4BPf61uTcqUpkw8Y3Bx5HQbqHYcJw9MzTzi-MmNRkMYXCeIDdfFzM6Cbt93UIHiQP0GbkHXYSVaBzGT5QDA9Z4CEzD7_BFEwQrG-OyD8TxjG8K3D9bGOOZ-fYEgpTkitIKi4ABDQjsCA5PCcmd72sueOz61OzF7IBCfk6IL5Dd24mVklGWH2ue2Xpmj9SXx5Ny6RaheJ5-js4ptkBqnz_VKWpvA9sGg-Oy2PB2bRKTTmQDgeeY7I0yyOLNBKtPruIrRrsrSnoiqp2BC5bawDkHWpSByJ3_uW-PGIR1B8mar_CJcfZjhJvVw7pp7K2frdRaFsBVkgTFreT-07bU5Ejo-Xh2MpeS4ODmXLChHWVXoF45WALZ_dn9awFhSQUD-Ofq\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Incorrect IV length (it must be 16 bytes long)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [15]\u001b[0m, in \u001b[0;36m<cell line: 46>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     44\u001b[0m \u001b[38;5;28mprint\u001b[39m(data)\n\u001b[0;32m     45\u001b[0m test \u001b[38;5;241m=\u001b[39m AESCipher(data)\n\u001b[1;32m---> 46\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mtest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecrypt\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m8032AB45611198F1\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m)\n",
      "Input \u001b[1;32mIn [15]\u001b[0m, in \u001b[0;36mAESCipher.decrypt\u001b[1;34m(self, enc)\u001b[0m\n\u001b[0;32m     23\u001b[0m enc \u001b[38;5;241m=\u001b[39m base64\u001b[38;5;241m.\u001b[39mb64decode(enc)\n\u001b[0;32m     24\u001b[0m iv \u001b[38;5;241m=\u001b[39m enc[:AES\u001b[38;5;241m.\u001b[39mblock_size]\n\u001b[1;32m---> 25\u001b[0m cipher \u001b[38;5;241m=\u001b[39m \u001b[43mAES\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnew\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mAES\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mMODE_CBC\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     26\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_unpad(cipher\u001b[38;5;241m.\u001b[39mdecrypt(enc[AES\u001b[38;5;241m.\u001b[39mblock_size:]))\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\AES.py:232\u001b[0m, in \u001b[0;36mnew\u001b[1;34m(key, mode, *args, **kwargs)\u001b[0m\n\u001b[0;32m    131\u001b[0m \u001b[38;5;124;03m\"\"\"Create a new AES cipher.\u001b[39;00m\n\u001b[0;32m    132\u001b[0m \n\u001b[0;32m    133\u001b[0m \u001b[38;5;124;03m:param key:\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    228\u001b[0m \u001b[38;5;124;03m:Return: an AES object, of the applicable mode.\u001b[39;00m\n\u001b[0;32m    229\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    231\u001b[0m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124madd_aes_modes\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m--> 232\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _create_cipher(sys\u001b[38;5;241m.\u001b[39mmodules[\u001b[38;5;18m__name__\u001b[39m], key, mode, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\__init__.py:79\u001b[0m, in \u001b[0;36m_create_cipher\u001b[1;34m(factory, key, mode, *args, **kwargs)\u001b[0m\n\u001b[0;32m     76\u001b[0m     \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m     77\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIV is not meaningful for the ECB mode\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 79\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m modes[mode](factory, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\_mode_cbc.py:287\u001b[0m, in \u001b[0;36m_create_cbc_cipher\u001b[1;34m(factory, **kwargs)\u001b[0m\n\u001b[0;32m    284\u001b[0m     iv \u001b[38;5;241m=\u001b[39m IV\n\u001b[0;32m    286\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(iv) \u001b[38;5;241m!=\u001b[39m factory\u001b[38;5;241m.\u001b[39mblock_size:\n\u001b[1;32m--> 287\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncorrect IV length (it must be \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m bytes long)\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m\n\u001b[0;32m    288\u001b[0m             factory\u001b[38;5;241m.\u001b[39mblock_size)\n\u001b[0;32m    290\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m kwargs:\n\u001b[0;32m    291\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnknown parameters for CBC: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m \u001b[38;5;28mstr\u001b[39m(kwargs))\n",
      "\u001b[1;31mValueError\u001b[0m: Incorrect IV length (it must be 16 bytes long)"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import hashlib\n",
    "from Crypto import Random\n",
    "from Crypto.Cipher import AES\n",
    "\n",
    "BS = 16\n",
    "pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS) \n",
    "unpad = lambda s : s[:-ord(s[len(s)-1:])]\n",
    "\n",
    "class AESCipher(object):\n",
    "\n",
    "    def __init__(self, key): \n",
    "        self.bs = AES.block_size\n",
    "        self.key = hashlib.sha256(key.encode()).digest()\n",
    "\n",
    "    def encrypt(self, raw):\n",
    "        raw = self._pad(raw)\n",
    "        iv = Random.new().read(AES.block_size)\n",
    "        cipher = AES.new(self.key, AES.MODE_CBC, iv)\n",
    "        return base64.b64encode(iv + cipher.encrypt(raw.encode()))\n",
    "\n",
    "    def decrypt(self, enc):\n",
    "        enc = base64.b64decode(enc)\n",
    "        iv = enc[:AES.block_size]\n",
    "        cipher = AES.new(self.key, AES.MODE_CBC, iv)\n",
    "        return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8')\n",
    "\n",
    "    def _pad(self, s):\n",
    "        return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)\n",
    "\n",
    "    @staticmethod\n",
    "    def _unpad(s):\n",
    "        return s[:-ord(s[len(s)-1:])]\n",
    "    pass\n",
    "\n",
    "print('TEST')\n",
    "#print(time.clock())\n",
    "\n",
    "test = AESCipher('This is a test')\n",
    "print(test.encrypt('8032AB45611198F1'))\n",
    "print('-----------')\n",
    "\n",
    "data = df[7]\n",
    "print(data)\n",
    "test = AESCipher(data)\n",
    "print(test.decrypt('8032AB45611198F1'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Object type <class 'str'> cannot be passed to C code",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [19]\u001b[0m, in \u001b[0;36m<cell line: 28>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     26\u001b[0m data \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;241m7\u001b[39m]\n\u001b[0;32m     27\u001b[0m test \u001b[38;5;241m=\u001b[39m AESCipher(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m8032AB45611198F1\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m---> 28\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mtest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecrypt\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m)\n",
      "Input \u001b[1;32mIn [19]\u001b[0m, in \u001b[0;36mAESCipher.decrypt\u001b[1;34m(self, enc)\u001b[0m\n\u001b[0;32m     20\u001b[0m enc \u001b[38;5;241m=\u001b[39m base64\u001b[38;5;241m.\u001b[39mb64decode(enc)\n\u001b[0;32m     21\u001b[0m iv \u001b[38;5;241m=\u001b[39m enc[:\u001b[38;5;241m16\u001b[39m]\n\u001b[1;32m---> 22\u001b[0m cipher \u001b[38;5;241m=\u001b[39m \u001b[43mAES\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnew\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mAES\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mMODE_CBC\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miv\u001b[49m\u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     23\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m unpad(cipher\u001b[38;5;241m.\u001b[39mdecrypt( enc[\u001b[38;5;241m16\u001b[39m:] ))\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\AES.py:232\u001b[0m, in \u001b[0;36mnew\u001b[1;34m(key, mode, *args, **kwargs)\u001b[0m\n\u001b[0;32m    131\u001b[0m \u001b[38;5;124;03m\"\"\"Create a new AES cipher.\u001b[39;00m\n\u001b[0;32m    132\u001b[0m \n\u001b[0;32m    133\u001b[0m \u001b[38;5;124;03m:param key:\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    228\u001b[0m \u001b[38;5;124;03m:Return: an AES object, of the applicable mode.\u001b[39;00m\n\u001b[0;32m    229\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    231\u001b[0m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124madd_aes_modes\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m--> 232\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _create_cipher(sys\u001b[38;5;241m.\u001b[39mmodules[\u001b[38;5;18m__name__\u001b[39m], key, mode, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\__init__.py:79\u001b[0m, in \u001b[0;36m_create_cipher\u001b[1;34m(factory, key, mode, *args, **kwargs)\u001b[0m\n\u001b[0;32m     76\u001b[0m     \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m     77\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIV is not meaningful for the ECB mode\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 79\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m modes[mode](factory, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\_mode_cbc.py:274\u001b[0m, in \u001b[0;36m_create_cbc_cipher\u001b[1;34m(factory, **kwargs)\u001b[0m\n\u001b[0;32m    255\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_create_cbc_cipher\u001b[39m(factory, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m    256\u001b[0m     \u001b[38;5;124;03m\"\"\"Instantiate a cipher object that performs CBC encryption/decryption.\u001b[39;00m\n\u001b[0;32m    257\u001b[0m \n\u001b[0;32m    258\u001b[0m \u001b[38;5;124;03m    :Parameters:\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    271\u001b[0m \u001b[38;5;124;03m    to be present).\u001b[39;00m\n\u001b[0;32m    272\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 274\u001b[0m     cipher_state \u001b[38;5;241m=\u001b[39m \u001b[43mfactory\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_create_base_cipher\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    275\u001b[0m     iv \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIV\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m    276\u001b[0m     IV \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124miv\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\AES.py:103\u001b[0m, in \u001b[0;36m_create_base_cipher\u001b[1;34m(dict_parameters)\u001b[0m\n\u001b[0;32m    100\u001b[0m     stop_operation \u001b[38;5;241m=\u001b[39m _raw_aes_lib\u001b[38;5;241m.\u001b[39mAES_stop_operation\n\u001b[0;32m    102\u001b[0m cipher \u001b[38;5;241m=\u001b[39m VoidPointer()\n\u001b[1;32m--> 103\u001b[0m result \u001b[38;5;241m=\u001b[39m start_operation(\u001b[43mc_uint8_ptr\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[0;32m    104\u001b[0m                          c_size_t(\u001b[38;5;28mlen\u001b[39m(key)),\n\u001b[0;32m    105\u001b[0m                          cipher\u001b[38;5;241m.\u001b[39maddress_of())\n\u001b[0;32m    106\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result:\n\u001b[0;32m    107\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mError \u001b[39m\u001b[38;5;132;01m%X\u001b[39;00m\u001b[38;5;124m while instantiating the AES cipher\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    108\u001b[0m                      \u001b[38;5;241m%\u001b[39m result)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Util\\_raw_api.py:143\u001b[0m, in \u001b[0;36mc_uint8_ptr\u001b[1;34m(data)\u001b[0m\n\u001b[0;32m    141\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m data\n\u001b[0;32m    142\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 143\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mObject type \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m cannot be passed to C code\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m \u001b[38;5;28mtype\u001b[39m(data))\n",
      "\u001b[1;31mTypeError\u001b[0m: Object type <class 'str'> cannot be passed to C code"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "from Crypto.Cipher import AES\n",
    "from Crypto import Random\n",
    "\n",
    "BS = 16\n",
    "pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS) \n",
    "unpad = lambda s : s[:-ord(s[len(s)-1:])]\n",
    "\n",
    "class AESCipher:\n",
    "    def __init__( self, key ):\n",
    "        self.key = key\n",
    "\n",
    "    def encrypt( self, raw ):\n",
    "        raw = pad(raw)\n",
    "        iv = Random.new().read( AES.block_size )\n",
    "        cipher = AES.new( self.key, AES.MODE_CBC, iv )\n",
    "        return base64.b64encode( iv + cipher.encrypt( raw ) ) \n",
    "\n",
    "    def decrypt( self, enc ):\n",
    "        enc = base64.b64decode(enc)\n",
    "        iv = enc[:16]\n",
    "        cipher = AES.new(self.key, AES.MODE_CBC, iv )\n",
    "        return unpad(cipher.decrypt( enc[16:] ))\n",
    "    pass\n",
    "\n",
    "data = df[7]\n",
    "test = AESCipher('8032AB45611198F1')\n",
    "print(test.decrypt(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'AAAAAOg3cOhavOcCUfY6ZfQKf0A7QOPZpkle3I7bRiUlrLt5QpDQM9WWeZ5APlIKDMrg90CMe9HNSFHIOy-NnsiFaD7EEPWzIyJd72-o22ZIa4acWOx6mrqrrrUySYkAZBe_Foe7edmn4GaX63ZYYgsSF5KB36hKpUYSKYrL8OeYHdEFFMNbnVS59riCpDkdhMrJw1sZxcQknWXoaj5LW52ln2bwSicp6uwKSPL62bVHEtZWVIx0nSkkvG4iIGOaFAG6z_3m-RSZIKHcwLl9VOp7BI7HEBHG_kmpnY0AehLnFVzmhoiIq6SJhtnUMSfaWnnkeraXsZq-anKyO0uCwiI9oJh6ktce45dZRjU7XKHA1IbISw6hgCi9YEvMRCcLv0zgjFxu9SKx3ymeIU8yOJSFZQ7IPeG6_Pk5vOZlwPrMRqoWBCUwK_Gt75dEYptnEdYJY_WF4hB2cKMqr9_ZdnniPHRKt0GyqQNLtCndTsJqdCNApZH9N83OFTD8upljrQhzs5SR-4lt0ysQ4NX4gSoP7Tzipv1Lh9-cca-qMgiSmpjC4CjR2GHycaw-Ad1JYt9h4J3CJjvynUD2tgL2QBkwBWkTlgf98gJ31uDPWGIS47szkqLiehrMRxpA3Nl6X-MlCXorSDI516zaNVtxzhMn6Q1k5LKpUOuW9o7R7CmO-h64898dFNAqRUyFRvo7t0VBCVYmq90Qo4zAlimFOyKu6Y0hUAGk53nxV4cbmFGxYaj4q4Ct71PqMxK1WwgWqztUbpRzUolHlPuFsna8xB9i-wgb2by9g4EXNRA967XAjGWndIQzeq_rV9jNhrTxSy5_fB_sYQY_szndaj78q6Q3gVjCPhI1qSGInI61fyGZUhEP6_QrmSzErOeStV2p3tYQrCY4SaW6Vg0Meg4XgOlN-oeI5PDrSvzxPy3gGSBY5Q00F-Ije7G9oKvxcEStWrlEP0vYXYrwOI1y9lqGLUPDyKz5yjDsx-mIP3AJ5k6ux4FK6NBwZu54G34Asvyepr3hFYCS6SjRuoB4FG-QqFWCcCeIoHcnNxP8jTxZnxQ2ZjgHbK-kIkY8Ou8SAjdAch1k6Pkqmqhp9nzZ7fTrZs9gr2je0yMb9Ol4tLz6kCnRckW_YQFvAHoIJ5847De6v1M_fYDkUfnjTtJ7sNEU9XCiDmBrmO05rAsFdPHkRM88bjilGUjkh3803GawzARXDsQ7m6yuGkucPwz0YUn0H1l8M_nsK4Femh9iJSWhMnzPSHez06fd5LJiHCRSMTybhX-sJQIXMsfEruBSS3iNIfKOh80d5EGA0zMAHSdxeX_Kdo5hRDMmNbCSm9YJLteBQAupvFR65DPS4qGGO7I2mcEh7IQ4PWDT7iX0KgmvKhl25U06ZNdM1ysaxV5_6y_uq-RHLP5hjwY9x68U3cnjUwc8xcuf70Yb7FxhKrffvKzfZAb8uO-5z_g_5RW1FYPoYcM9ThKpVB3vmEWiX33UrLa1rIlzNLlqoTZz69pXF_YXA5VWDd46vXKUglqtVdUlJ6zL-gKcZ3kGXzI1-Sa7Cnn0lnqPAc4ufWwb_hTGK4LQHGoDn1v6sMuhqxseHaHdSH58ZVHV2F9IrnThjFs7rYXF55QxT9IfNYfO66K0HiyQIzxjAsVsTsYpGK_BuuseDmoHcVT53b4lxLrKthSWklBH38moHFG8rsPF0wN8UcGdX3gxow-cy_-D-jXTfN2URtCE649ph3-7h29ZEAUAqGG5luDkF6BMOUmVxP4chgQEvTwSG-y_iJO-Jf4JgxWeWmtivHSG_gzcxBpSuupWQ8o-TaUd47Y1Yb7hn4DEft4RSIzxRRn3DOeAXG2KttW4Zl3d-GzEXWj2hDf8Ogm1tw5GVDQ6SsmLLWKdA6R8MoF4497umomvTNN4f1oQZgZr1JLjm50DjTcZM4_W4PnGChPs4rflyJmXsyDAsUcAGKs7UpRck1yF0eiO7_6Z_bUAKwbycUDIkmwlRot3LH6YmDjX2JOsat4BPf61uTcqUpkw8Y3Bx5HQbqHYcJw9MzTzi-MmNRkMYXCeIDdfFzM6Cbt93UIHiQP0GbkHXYSVaBzGT5QDA9Z4CEzD7_BFEwQrG-OyD8TxjG8K3D9bGOOZ-fYEgpTkitIKi4ABDQjsCA5PCcmd72sueOz61OzF7IBCfk6IL5Dd24mVklGWH2ue2Xpmj9SXx5Ny6RaheJ5-js4ptkBqnz_VKWpvA9sGg-Oy2PB2bRKTTmQDgeeY7I0yyOLNBKtPruIrRrsrSnoiqp2BC5bawDkHWpSByJ3_uW-PGIR1B8mar_CJcfZjhJvVw7pp7K2frdRaFsBVkgTFreT-07bU5Ejo-Xh2MpeS4ODmXLChHWVXoF45WALZ_dn9awFhSQUD-Ofq'\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Incorrect IV length (it must be 16 bytes long)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [36]\u001b[0m, in \u001b[0;36m<cell line: 35>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     33\u001b[0m \u001b[38;5;28mprint\u001b[39m(data)\n\u001b[0;32m     34\u001b[0m test \u001b[38;5;241m=\u001b[39m AESCipher(data)\n\u001b[1;32m---> 35\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mtest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecrypt\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m8032AB45611198F1\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m)\n",
      "Input \u001b[1;32mIn [36]\u001b[0m, in \u001b[0;36mAESCipher.decrypt\u001b[1;34m(self, enc)\u001b[0m\n\u001b[0;32m     19\u001b[0m enc \u001b[38;5;241m=\u001b[39m base64\u001b[38;5;241m.\u001b[39mb64decode(enc)\n\u001b[0;32m     20\u001b[0m iv \u001b[38;5;241m=\u001b[39m enc[:AES\u001b[38;5;241m.\u001b[39mblock_size]\n\u001b[1;32m---> 21\u001b[0m cipher \u001b[38;5;241m=\u001b[39m \u001b[43mAES\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnew\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mAES\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mMODE_CBC\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     22\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_unpad(cipher\u001b[38;5;241m.\u001b[39mdecrypt(enc[AES\u001b[38;5;241m.\u001b[39mblock_size:]))\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\AES.py:232\u001b[0m, in \u001b[0;36mnew\u001b[1;34m(key, mode, *args, **kwargs)\u001b[0m\n\u001b[0;32m    131\u001b[0m \u001b[38;5;124;03m\"\"\"Create a new AES cipher.\u001b[39;00m\n\u001b[0;32m    132\u001b[0m \n\u001b[0;32m    133\u001b[0m \u001b[38;5;124;03m:param key:\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    228\u001b[0m \u001b[38;5;124;03m:Return: an AES object, of the applicable mode.\u001b[39;00m\n\u001b[0;32m    229\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    231\u001b[0m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124madd_aes_modes\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m--> 232\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _create_cipher(sys\u001b[38;5;241m.\u001b[39mmodules[\u001b[38;5;18m__name__\u001b[39m], key, mode, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\__init__.py:79\u001b[0m, in \u001b[0;36m_create_cipher\u001b[1;34m(factory, key, mode, *args, **kwargs)\u001b[0m\n\u001b[0;32m     76\u001b[0m     \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m     77\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIV is not meaningful for the ECB mode\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 79\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m modes[mode](factory, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\_mode_cbc.py:287\u001b[0m, in \u001b[0;36m_create_cbc_cipher\u001b[1;34m(factory, **kwargs)\u001b[0m\n\u001b[0;32m    284\u001b[0m     iv \u001b[38;5;241m=\u001b[39m IV\n\u001b[0;32m    286\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(iv) \u001b[38;5;241m!=\u001b[39m factory\u001b[38;5;241m.\u001b[39mblock_size:\n\u001b[1;32m--> 287\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncorrect IV length (it must be \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m bytes long)\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m\n\u001b[0;32m    288\u001b[0m             factory\u001b[38;5;241m.\u001b[39mblock_size)\n\u001b[0;32m    290\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m kwargs:\n\u001b[0;32m    291\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnknown parameters for CBC: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m \u001b[38;5;28mstr\u001b[39m(kwargs))\n",
      "\u001b[1;31mValueError\u001b[0m: Incorrect IV length (it must be 16 bytes long)"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import hashlib\n",
    "from Crypto import Random #pycrypto\n",
    "from Crypto.Cipher import AES\n",
    "\n",
    "class AESCipher(object):\n",
    "\n",
    "    def __init__(self, key): \n",
    "        self.bs = 32\n",
    "        self.key = hashlib.sha256(key).digest()\n",
    "\n",
    "    def encrypt(self, raw):\n",
    "        raw = self._pad(raw)\n",
    "        iv = Random.new().read(AES.block_size)\n",
    "        cipher = AES.new(self.key, AES.MODE_CBC, iv)\n",
    "        return base64.b64encode(iv + cipher.encrypt(raw))\n",
    "\n",
    "    def decrypt(self, enc):\n",
    "        enc = base64.b64decode(enc)\n",
    "        iv = enc[:AES.block_size]\n",
    "        cipher = AES.new(self.key, AES.MODE_CBC, iv)\n",
    "        return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8')\n",
    "\n",
    "    def _pad(self, s):\n",
    "        return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)\n",
    "\n",
    "    @staticmethod\n",
    "    def _unpad(s):\n",
    "        return s[:-ord(s[len(s)-1:])]\n",
    "    pass\n",
    "\n",
    "data = df[7].encode(\"utf8\")\n",
    "print(data)\n",
    "test = AESCipher(data)\n",
    "print(test.decrypt('8032AB45611198F1'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'8032AB45611198F1'\n",
      "8032AB45611198F1\n",
      "hi\n",
      "enc_str: h1b00XahAY1r+kr/+YPwMQ==\n",
      "dec str: hi\n"
     ]
    }
   ],
   "source": [
    "from Crypto.Cipher import AES\n",
    "\n",
    "class AESCipher:\n",
    "    class InvalidBlockSizeError(Exception):\n",
    "        \"\"\"Raised for invalid block sizes\"\"\"\n",
    "        pass\n",
    "\n",
    "    def __init__(self, key):\n",
    "        self.key = key.encode('utf-8')\n",
    "        self.iv = bytes(key[0:16], 'utf-8')\n",
    "        print(self.key)\n",
    "        print(key[0:16])\n",
    "\n",
    "    def __pad(self, text):\n",
    "        text_length = len(text)\n",
    "        amount_to_pad = AES.block_size - (text_length % AES.block_size)\n",
    "        if amount_to_pad == 0:\n",
    "            amount_to_pad = AES.block_size\n",
    "        pad = chr(amount_to_pad)\n",
    "        out_text = text + pad * amount_to_pad\n",
    "        return out_text.encode('utf-8')\n",
    "\n",
    "    def __unpad(self, text):\n",
    "        pad = ord(text[-1])\n",
    "        #pad = text[-1]\n",
    "        return text[:-pad]\n",
    "\n",
    "    def encrypt( self, raw ):\n",
    "        raw = self.__pad(raw)\n",
    "        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)\n",
    "        return base64.b64encode(cipher.encrypt(raw)) \n",
    "\n",
    "    def decrypt( self, enc ):\n",
    "        enc = base64.b64decode(enc)\n",
    "        #cipher = AES.new(self.key, AES.MODE_CTR)#, self.iv )\n",
    "        cipher = AES.new(self.key, AES.MODE_CBC, self.iv )\n",
    "        #return(cipher.decrypt(enc))\n",
    "        return self.__unpad(cipher.decrypt(enc).decode(\"utf-8\"))\n",
    "\n",
    "e = AESCipher('8032AB45611198F1') #, 16\n",
    "secret_data = \"hi\"\n",
    "print(secret_data)\n",
    "enc_str = e.encrypt(secret_data)\n",
    "print('enc_str: ' + enc_str.decode())\n",
    "dec_str = e.decrypt(enc_str)\n",
    "print('dec str: ' + dec_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Data must be padded to 16 byte boundary in CBC mode",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [82]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m data \u001b[38;5;241m=\u001b[39m df[\u001b[38;5;241m7\u001b[39m]\n\u001b[1;32m----> 2\u001b[0m dec_str \u001b[38;5;241m=\u001b[39m \u001b[43me\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecrypt\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdec str:\u001b[39m\u001b[38;5;124m'\u001b[39m, dec_str)\n",
      "Input \u001b[1;32mIn [81]\u001b[0m, in \u001b[0;36mAESCipher.decrypt\u001b[1;34m(self, enc)\u001b[0m\n\u001b[0;32m     36\u001b[0m cipher \u001b[38;5;241m=\u001b[39m AES\u001b[38;5;241m.\u001b[39mnew(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkey, AES\u001b[38;5;241m.\u001b[39mMODE_CBC, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39miv )\n\u001b[0;32m     37\u001b[0m \u001b[38;5;66;03m#return(cipher.decrypt(enc))\u001b[39;00m\n\u001b[1;32m---> 38\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__unpad(\u001b[43mcipher\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecrypt\u001b[49m\u001b[43m(\u001b[49m\u001b[43menc\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n",
      "File \u001b[1;32m~\\.conda\\envs\\scio\\lib\\site-packages\\Crypto\\Cipher\\_mode_cbc.py:246\u001b[0m, in \u001b[0;36mCbcMode.decrypt\u001b[1;34m(self, ciphertext, output)\u001b[0m\n\u001b[0;32m    244\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result:\n\u001b[0;32m    245\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m:\n\u001b[1;32m--> 246\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mData must be padded to \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m byte boundary in CBC mode\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mblock_size)\n\u001b[0;32m    247\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mError \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m while decrypting in CBC mode\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m result)\n\u001b[0;32m    249\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m output \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
      "\u001b[1;31mValueError\u001b[0m: Data must be padded to 16 byte boundary in CBC mode"
     ]
    }
   ],
   "source": [
    "data = df[7]\n",
    "dec_str = e.decrypt(data)\n",
    "print('dec str:', dec_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "112.0"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1800-8)/16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "import binascii\n",
    "import gzip\n",
    "print(gzip.decompress(binascii.a2b_base64(b\"H4sIAAAAAAAA//NIzcnJVwjPL8pJAQBWsRdKCwAAAA==\")))\n",
    "\n",
    "import zlib\n",
    "zlib.decompress(bytearray(df[7]), 15+32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_int(data):\n",
    "    # Unpacks with an offset\n",
    "    temp = [ ]\n",
    "    data_length = len(data)\n",
    "    for j in range( data_length ):\n",
    "        temp.append( int(data[j]) )\n",
    "    return(temp)\n",
    "\n",
    "list_of_ints1 = convert_to_int(df[7])\n",
    "list_of_ints2 = convert_to_int(df[8])\n",
    "list_of_ints3 = convert_to_int(df[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "from plotnine import *\n",
    "from plotnine.data import *\n",
    "\n",
    "plt = ggplot()\n",
    "plt = plt + geom_histogram(aes(list_of_ints1), binwidth=1, fill='blue', alpha=0.2)\n",
    "plt = plt + geom_histogram(aes(list_of_ints2), binwidth=1, fill='green', alpha=0.2)\n",
    "plt = plt + geom_histogram(aes(list_of_ints3), binwidth=1, fill='red', alpha=0.2)\n",
    "plt = plt + theme_bw()\n",
    "plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn_list = sorted(glob.glob(project_path_scans + '*', recursive=True))\n",
    "\n",
    "# Create output path name\n",
    "#project_path_output = output_path + project_path.split('/')[-2] + '/'\n",
    "\n",
    "# Empty df to add data to\n",
    "df = pd.DataFrame([]) \n",
    "\n",
    "# For all files in the directory\n",
    "for fn_i, fn in enumerate(fn_list):\n",
    "    # Show status message\n",
    "    if(fn_i % 1 == 0): # % 20 to show every 20th file being loaded\n",
    "        print( '{:<07}'.format(str(round(fn_i * 100 / len(fn_list), 4))) + \"%\\t\\t\" + fn.split('\\\\')[-2] + '/' + fn.split('\\\\')[-1]) # Show status\n",
    "    \n",
    "    # Read raw data from file\n",
    "    data = read_raw_file(fn)\n",
    "    \n",
    "    p1 = convert_to_int(data[7])\n",
    "    p2 = convert_to_int(data[8])\n",
    "    p3 = convert_to_int(data[9])\n",
    "    temp = pd.DataFrame(list(zip(p1, p2, p3)), columns=['part1','part2','part3'])\n",
    "    temp['scan_id'] = fn_i\n",
    "    temp = temp.reset_index()\n",
    "    df = pd.concat([df, temp], axis=0, ignore_index=True)\n",
    "    \n",
    "display(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt = ggplot(df, aes(x='part1', y=after_stat('count')))\n",
    "plt = plt + geom_histogram(binwidth=1, alpha=0.4)\n",
    "plt = plt + theme_bw() + facet_wrap('scan_id')\n",
    "plt\n",
    "ggsave(plt, 'part1.png', units='cm', width=30, height=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt = ggplot(df, aes(x='part2', y=after_stat('count')))\n",
    "plt = plt + geom_histogram(binwidth=1, alpha=0.4)\n",
    "plt = plt + theme_bw() + facet_wrap('scan_id')\n",
    "plt\n",
    "ggsave(plt, 'part2.png', units='cm', width=30, height=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt = ggplot(df, aes(x='part3', y=after_stat('count')))\n",
    "plt = plt + geom_histogram(binwidth=1, alpha=0.4)\n",
    "plt = plt + theme_bw() + facet_wrap('scan_id')\n",
    "plt\n",
    "ggsave(plt, 'part3.png', units='cm', width=30, height=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = df.loc[df['scan_id'] == 1, 'part1']\n",
    "y = df.loc[df['scan_id'] == 0, 'part1']\n",
    "\n",
    "df_wide_p1 = df.pivot(['index'], columns='scan_id',values='part1').add_prefix('scan_')\n",
    "\n",
    "\n",
    "plt = ggplot(df_wide_p1)\n",
    "plt = plt + geom_point(aes(x='scan_0', y='scan_1'), colour='red', alpha=0.2)\n",
    "plt = plt + geom_point(aes(x='scan_0', y='scan_2'), colour='green', alpha=0.2)\n",
    "plt = plt + geom_point(aes(x='scan_0', y='scan_3'), colour='blue', alpha=0.2)\n",
    "plt = plt + geom_point(aes(x='scan_0', y='scan_4'), colour='purple', alpha=0.2)\n",
    "plt = plt + geom_point(aes(x='scan_0', y='scan_5'), colour='yellow', alpha=0.2)\n",
    "plt = plt + theme_bw()\n",
    "plt = plt + labs(x='Scan 0', y='Scans 1-5')\n",
    "print(plt)\n",
    "ggsave(plt, 'scan1_vs_2-6.png', units='cm', width=30, height=15)\n",
    "\n",
    "plt = ggplot(df)\n",
    "plt = plt + geom_point(aes(x='part1', y='part2', colour='scan_id'), alpha=0.2)\n",
    "plt = plt + theme_bw()\n",
    "print(plt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# XOR pairs\n",
    "\n",
    "\n",
    "result1 = convert_to_int(bytes(a ^ b for (a, b) in zip(df_wide_p1['scan_0'], df_wide_p1['scan_1'])))\n",
    "result2 = convert_to_int(bytes(a ^ b for (a, b) in zip(df_wide_p1['scan_0'], df_wide_p1['scan_2'])))\n",
    "#print(result1)\n",
    "#print(result2)\n",
    "result1 = convert_to_int(bytes(a ^ b for (a, b) in zip(df.loc[df['scan_id'] == 1, 'part1'], df.loc[df['scan_id'] == 1, 'part2'])))\n",
    "result2 = convert_to_int(bytes(a ^ b for (a, b) in zip(df.loc[df['scan_id'] == 2, 'part1'], df.loc[df['scan_id'] == 2, 'part2'])))\n",
    "\n",
    "\n",
    "plt = ggplot()\n",
    "plt = plt + geom_point(aes(x=result1, y=result2), alpha=0.2)\n",
    "plt = plt + theme_bw()\n",
    "print(plt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OLD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To identify the OS\n",
    "import platform\n",
    "\n",
    "# To identify the device\n",
    "import glob\n",
    "import re\n",
    "import os\n",
    "\n",
    "# Exceptions / Assert errors\n",
    "import sys\n",
    "\n",
    "# Reading the SCIO through USB serial port\n",
    "import serial\n",
    "from serial.tools import list_ports_common\n",
    "\n",
    "READ_DATA = 2        #02\n",
    "READ_TEMPERATURE = 4 #04\n",
    "READ_BATTERY = 5     #05\n",
    "SET_READY = 14       #0e\n",
    "SET_LED = 11         #0b\n",
    "PROTOCOL = -70       #ba\n",
    "READ_BLE_ID = -124\n",
    "READ_DEV_ID = 1\n",
    "#RESET_LED = 50 # Does this work?\n",
    "# The 3 readings are: sample, sampleDark, sampleGradient\n",
    "# Whitereference is the scan of the box\n",
    "\n",
    "def find_scio_dev():\n",
    "    scio_dev = ''\n",
    "    # Check the platform\n",
    "    # https://dzone.com/articles/linux-system-mining-python\n",
    "    if(platform.uname().system == 'Linux'):\n",
    "        # TODO: Add check in case multiple /dev/ttyACMs ports are available #######################\n",
    "        for device in glob.glob('/dev/*'):\n",
    "            for pattern in ['ttyACM*']:\n",
    "                if re.compile(pattern).match(os.path.basename(device)):\n",
    "                    print('Device:           {0}'.format(device))\n",
    "                    scio_dev = device\n",
    "                    #manufacturer = self.read_line(device, 'manufacturer')\n",
    "                    #product = self.read_line(device, 'product')\n",
    "                    #print(manufacturer)\n",
    "                    #print(product)\n",
    "    elif(platform.uname().system == 'Windows'):\n",
    "        # TODO: Add check in case multiple COM ports are available\n",
    "        import serial.tools.list_ports as port_list\n",
    "        if(port_list.comports()):\n",
    "            scio_dev = port_list.comports()[0][0]\n",
    "    else:\n",
    "        log.error('This program currently only works on Linux & Windows.')\n",
    "        log.error('--> You are running ' + platform.uname().system + '.')\n",
    "        log.error('--> Exiting...')\n",
    "        quit()\n",
    "    if scio_dev == '':\n",
    "        print('No ttyACM (Linux) or COM (Windows) was detected: Is the SCIO on?')\n",
    "        quit()\n",
    "    # TODO: Add a check or manufacturer to determine that this is really the scio and not some arduino\n",
    "    log.info('Using port: ' + scio_dev)\n",
    "    return(scio_dev)\n",
    "\n",
    "def encode_b64(bytestring):\n",
    "    # Encode and decode data as base64 (to store until we know what to do with it)\n",
    "    import base64\n",
    "    urlSafeEncodedBytes = base64.urlsafe_b64encode(bytestring)\n",
    "    urlSafeEncodedStr = str(urlSafeEncodedBytes, 'utf-8')\n",
    "    return(urlSafeEncodedStr)\n",
    "\n",
    "def decode_b64(b64string):\n",
    "    # Encode and decode data as base64 (to store until we know what to do with it)\n",
    "    import base64\n",
    "    bytestring = base64.urlsafe_b64decode(b64string)\n",
    "    return(bytestring)\n",
    "\n",
    "def raw_read(filename):\n",
    "    import json\n",
    "    \n",
    "    outdf = [ ]\n",
    "    with open(filename) as json_file:\n",
    "        jsondata = json.load(json_file)\n",
    "        for p in jsondata['scan']:\n",
    "            outdf.append(p['timestamp'])\n",
    "            outdf.append(p['t_cmos_before'])\n",
    "            outdf.append(p['t_chip_before'])\n",
    "            outdf.append(p['t_obj_before'])\n",
    "            outdf.append(p['t_cmos_after'])\n",
    "            outdf.append(p['t_chip_after'])\n",
    "            outdf.append(p['t_obj_after'])\n",
    "            outdf.append(decode_b64(p['part1']))\n",
    "            outdf.append(decode_b64(p['part2']))\n",
    "            outdf.append(decode_b64(p['part3']))\n",
    "    return(outdf)\n",
    "        \n",
    "def raw_write(temp_before_df, temp_after_df, scan_df, filename):\n",
    "    # Saves a single scan as raw data to JSON\n",
    "    from datetime import datetime\n",
    "    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')\n",
    "    \n",
    "    # create the json file\n",
    "    jsondata = {}\n",
    "    jsondata['scan'] = []\n",
    "    jsondata['scan'].append({\n",
    "        'timestamp': timestamp,\n",
    "        't_cmos_before': temp_before_df[0], # cmosTemperature, chipTemperature, objectTemperature\n",
    "        't_chip_before': temp_before_df[1],\n",
    "        't_obj_before':  temp_before_df[2],\n",
    "        't_cmos_after': temp_after_df[0],\n",
    "        't_chip_after': temp_after_df[1],\n",
    "        't_obj_after':  temp_after_df[2],\n",
    "        'part1': encode_b64(scan_df[0]),\n",
    "        'part2': encode_b64(scan_df[1]),\n",
    "        'part3': encode_b64(scan_df[2])\n",
    "    })\n",
    "    \n",
    "    # Write data to JSON file\n",
    "    import json\n",
    "    with open(filename, 'w') as outfile:\n",
    "        json.dump(jsondata, outfile, indent=4)\n",
    "    \n",
    "def protocol_message(cmd):\n",
    "    byte_command = b'' # empty initialisation\n",
    "    if(cmd == SET_LED):\n",
    "        # Setting the LED colour is special (longer command)\n",
    "        byte_command = struct.pack('<bbbbbbbbbbbbbbb',1,PROTOCOL,cmd,9,0,0,0,0,0,0,0,0,0,0)\n",
    "    else:\n",
    "        byte_command = struct.pack('<bbbbb',1,PROTOCOL,cmd,0,0)\n",
    "    return(byte_command)\n",
    "\n",
    "def read_data(scio_dev, command):\n",
    "    # Relevant functions\n",
    "    def decode_temperature(msg, message_length):\n",
    "        num_vars = message_length / 4 # divide by 4 because we are dealing with longs\n",
    "        data_struct = '<' + str(int(num_vars)) + 'L' # This is '<3l' or '<lll'\n",
    "        # Convert bytes to unsigned int\n",
    "        message_data = struct.unpack(data_struct, msg)\n",
    "        # Convert to temperatures\n",
    "        cmosTemperature = (message_data[0] - 375.22) / 1.4092 # Does this make sense? It's from the disassembled Android app...\n",
    "        chipTemperature = (message_data[1]) / 100\n",
    "        objectTemperature = message_data[2] / 100\n",
    "        temperature_df = [cmosTemperature, chipTemperature, objectTemperature]\n",
    "        return(temperature_df)\n",
    "    \n",
    "    def decode_dev_id(msg, message_length):\n",
    "        print(message_length)\n",
    "        print(msg)\n",
    "        print(len(msg))\n",
    "        #data_struct = '<8s8sH'\n",
    "        data_struct = '<H'\n",
    "        dev_df = struct.unpack(data_struct, msg[16:18])\n",
    "        print(dev_df)\n",
    "        return(dev_df)\n",
    "    \n",
    "    def decode_ble_id(msg, message_length):\n",
    "        #print(message_length)\n",
    "        print(msg)\n",
    "        print(msg[0:8])\n",
    "        print(msg[8:10]) # BLE firmware version\n",
    "        print(msg[10:50].decode('utf-8') ) # Unknown ID\n",
    "        print(msg[50:66].decode('utf-8') ) # device name\n",
    "        print(msg[66:131].decode('utf-8') ) # i2s tag\n",
    "        #data_struct = '<8sL16s64s'\n",
    "        data_struct = '<8sH40s16s64s'\n",
    "        ble_df = list(struct.unpack(data_struct, msg))\n",
    "        ble_df[2] = ble_df[2].decode('utf-8').strip()\n",
    "        ble_df[3] = ble_df[3].decode('utf-8').strip('\\x00')\n",
    "        ble_df[4] = ble_df[4].decode('utf-8').strip()\n",
    "        data_struct = '<8B'\n",
    "        ble_df = struct.unpack(data_struct, msg[0:8])\n",
    "        print(list(map(chr, ble_df)))\n",
    "        #print(''.join(r'\\x%02X' % ord(ch) for ch in msg[0:8] ))\n",
    "        print(ble_df)\n",
    "        return(ble_df)\n",
    "    \n",
    "    # Send reading command\n",
    "    # - - - - - - - - - - -\n",
    "    \n",
    "    # Create the message\n",
    "    byte_msg = protocol_message(command)\n",
    "    \n",
    "    # Open serial connection\n",
    "    try:\n",
    "        ser = serial.Serial(scio_dev)\n",
    "    except OSError as error:\n",
    "        log.error(error)\n",
    "        quit()\n",
    "    \n",
    "    # write the message to the serial device\n",
    "    ser.write(byte_msg)\n",
    "    \n",
    "    # Read the response\n",
    "    # - - - - - - - - - - -\n",
    "    \n",
    "    # Start reading the response\n",
    "    s = ser.read(1)\n",
    "    message_type    = struct.unpack('<b',s)[0]\n",
    "    \n",
    "    # Error check\n",
    "    assert (message_type == PROTOCOL), 'Wrong message type: {}'.format(message_type)\n",
    "    \n",
    "    # Data type\n",
    "    s = ser.read(1)\n",
    "    message_content = struct.unpack('<b',s)[0]\n",
    "    if(message_content == READ_TEMPERATURE):\n",
    "        log.debug('Receiving temperature data: ' + str(message_content))\n",
    "        # Data length\n",
    "        s = ser.read(2)\n",
    "        message_length = struct.unpack('<H',s)[0]\n",
    "        # Read the number of values specified by the message length\n",
    "        s = ser.read(message_length)\n",
    "        ser.close()\n",
    "        # decode that data\n",
    "        temperature_df = decode_temperature(s, message_length)\n",
    "        return(temperature_df)  # cmosTemperature, chipTemperature, objectTemperature\n",
    "    elif(message_content == READ_DATA):\n",
    "        raw_df = [ ]\n",
    "        log.debug('Receiving scan data: ' + str(message_content))\n",
    "        # get rid of first 2 sets to get\n",
    "        for i in range(3):\n",
    "            log.debug('--> Part: ' + str(i+1))\n",
    "            if(i > 0):\n",
    "                s = ser.read(1)\n",
    "                message_type    = struct.unpack('<b',s)[0]\n",
    "                s = ser.read(1)\n",
    "                message_content = struct.unpack('<b',s)[0]\n",
    "            s = ser.read(2)\n",
    "            message_length = struct.unpack('<H',s)[0]\n",
    "            s = ser.read(message_length)\n",
    "            raw_df.append(s)\n",
    "        ser.close()\n",
    "        return(raw_df)\n",
    "    elif(message_content == READ_DEV_ID):\n",
    "        s = ser.read(2)\n",
    "        message_length = struct.unpack('<H',s)[0]\n",
    "        # Read the number of values specified by the message length\n",
    "        s = ser.read(message_length)\n",
    "        ser.close()\n",
    "        # decode that data\n",
    "        dev_df = decode_dev_id(s, message_length)\n",
    "    elif(message_content == READ_BLE_ID):\n",
    "        s = ser.read(2)\n",
    "        message_length = struct.unpack('<H',s)[0]\n",
    "        # Read the number of values specified by the message length\n",
    "        s = ser.read(message_length)\n",
    "        ser.close()\n",
    "        # decode that data\n",
    "        ble_df = decode_ble_id(s, message_length)\n",
    "    else:\n",
    "        log.debug('Receiving unknown message: ' + str(message_content))\n",
    "        \n",
    "    # This divides one list by another\n",
    "    #print([n/d for n, d in zip(df[0], df[2])])\n",
    "    \n",
    "def decode_data(raw_df):\n",
    "    # 40-bit decoding functions\n",
    "    def getU32(data, index):\n",
    "        dat = data[index:(index+4)]\n",
    "        return float( ((( int(dat[0] & 255)) + (( int(dat[1] & 255)) << 8)) + (( int(dat[2] & 255)) << 16)) + (( int(dat[3] & 255)) << 24) )\n",
    "        \n",
    "    def getU32_le(data, index):\n",
    "        dat = data[index:(index+4)]\n",
    "        return float( ((( int(dat[3] & 255)) + (( int(dat[2] & 255)) << 8)) + (( int(dat[1] & 255)) << 16)) + (( int(dat[0] & 255)) << 24) )\n",
    "            \n",
    "    def unpackU32(data, header):\n",
    "        # Assuming 414 bands (4*414=1656). It is possible that the SCIO has more bands, but is noisy on both ends\n",
    "        temp = [ ]\n",
    "        footer = 476 - header\n",
    "        if(len(data) == 1656):\n",
    "            footer = 332 - header;\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/4) ):\n",
    "            temp.append( getU32(data, j*4+header) )\n",
    "        return(temp)\n",
    "        \n",
    "    # 40-bit decoding functions\n",
    "    def getU40(data, index):\n",
    "        dat = data[index:(index+4)]\n",
    "        return float( ((( int(dat[0] & 255)) + (( int(dat[1] & 255)) << 8)) + (( int(dat[2] & 255)) << 16)) + (( int(dat[3] & 255)) << 24) + (( int(dat[4] & 255)) << 32) )\n",
    "            \n",
    "    def unpackU40(data, header):\n",
    "        temp = [ ]\n",
    "        footer = 145 - header\n",
    "        if(len(data) == 1656):\n",
    "            footer = 0;\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/5) ):\n",
    "            temp.append( getU40(data, j*5+header) / 100000000)\n",
    "        return(temp)\n",
    "        \n",
    "    def getU40_le(data, index):\n",
    "        dat = data[index:(index+5)]\n",
    "        return float( ((( int(dat[4] & 255)) + (( int(dat[3] & 255)) << 8)) + (( int(dat[2] & 255)) << 16)) + (( int(dat[1] & 255)) << 24) + (( int(dat[0] & 255)) << 32) )\n",
    "        \n",
    "    def unpackU40_le(data, header):\n",
    "        temp = [ ]\n",
    "        footer = 145 - header\n",
    "        if(len(data) == 1656):\n",
    "            footer = 0;\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/5) ):\n",
    "            temp.append( getU40_le(data, j*5+header) / 100000000)\n",
    "        return(temp)\n",
    "        \n",
    "    # Function to try to decode\n",
    "    def decode(raw_df, header):\n",
    "        df = [ ]\n",
    "        for part in range(len(raw_df)):\n",
    "            if(part == 2):\n",
    "                header = 0\n",
    "            df.append( unpackU32(raw_df[part], header) ) #df.append( unpackU40(raw_df[part], header) )\n",
    "        return(df)\n",
    "\n",
    "    def unpackU32b(data, header, footer):\n",
    "        # Unpacks with an offset\n",
    "        temp = [ ]\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/4) ):\n",
    "            temp.append( getU32b(data, j*4+header) ) # Was getU32(\n",
    "        return(temp)\n",
    "        \n",
    "    def getU64(data, index):\n",
    "        dat = data[index:(index+8)]\n",
    "        out = struct.unpack('<Q', dat)\n",
    "        return(out[0])\n",
    "    \n",
    "    def unpackU64(data, header, footer):\n",
    "        # Unpacks with an offset\n",
    "        temp = [ ]\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/8) ):\n",
    "            temp.append( getU64(data, j*8+header) )\n",
    "        return(temp)\n",
    "        \n",
    "    # iterate over possible number of headers in order to find solution\n",
    "    # U64\n",
    "    num_vars = 207\n",
    "    var_size = 8\n",
    "    diff_scan = len(raw_df[0]) - num_vars*var_size\n",
    "    print('diff_scan: ' + str(diff_scan))\n",
    "    diff_cal =  len(raw_df[2]) - num_vars*var_size\n",
    "    print('diff_cal:  ' + str(diff_cal))\n",
    "    solution = False\n",
    "    for i in range(diff_scan+1):\n",
    "        #if(solution):\n",
    "        #    break\n",
    "        print(i, diff_scan - i)\n",
    "        df = [ ]\n",
    "        df.append(unpackU64(raw_df[0], i, diff_scan - i)) # scan\n",
    "        df.append(unpackU64(raw_df[2], 0, 0))  # calibration\n",
    "        reflectance = [n/d for n, d in zip(df[0], df[1])]\n",
    "        if(all(k <= 1.0 for k in reflectance)):\n",
    "            solution = True\n",
    "            log.debug('Solution with scan header ' + str(i) )\n",
    "            break\n",
    "    \n",
    "    # U32\n",
    "    num_vars = 331\n",
    "    var_size = 4\n",
    "    diff_scan = len(raw_df[0]) - num_vars*var_size\n",
    "    print('diff_scan: ' + str(diff_scan))\n",
    "    diff_cal =  len(raw_df[2]) - num_vars*var_size\n",
    "    print('diff_cal:  ' + str(diff_cal))\n",
    "    solution = False\n",
    "    for i in range(diff_scan+1):\n",
    "        for j in range(diff_cal+1):\n",
    "            #if(solution):\n",
    "            #    break\n",
    "            print(i, diff_scan - i, j, diff_cal - j)\n",
    "            df = [ ]\n",
    "            df.append(unpackU32b(raw_df[0], j, diff_cal - j)) # scan\n",
    "            df.append(unpackU32b(raw_df[2], i, diff_scan - i))  # calibration\n",
    "            reflectance = [n/d for n, d in zip(df[0], df[1])]\n",
    "            if(all(k <= 1.0 for k in reflectance)):\n",
    "                solution = True\n",
    "                log.debug('Solution with scan header ' + str(i) + ' and cal. header ' + str(j))\n",
    "                break\n",
    "        \n",
    "    solution = False\n",
    "    for h in range(332): #range(145):\n",
    "        reflectance = [ ]\n",
    "        df = decode(raw_df,h)\n",
    "        reflectance.append([n/d for n, d in zip(df[0], df[2])])\n",
    "        reflectance.append([n/d for n, d in zip(df[1], df[2])])\n",
    "        if(all(i <= 1.0 for i in reflectance[0])):\n",
    "            solution = True\n",
    "            log.debug('Solution with header ' + str(header))\n",
    "    if(not solution):\n",
    "        log.debug('No solution found')\n",
    "    print(reflectance)\n",
    "    return(reflectance)\n",
    "\n",
    "def decode_data2(raw_df, cal_df):\n",
    "    # 40-bit decoding functions\n",
    "    def getU32(data, index):\n",
    "        dat = data[index:(index+4)]\n",
    "        return float( ((( int(dat[0] & 255)) + (( int(dat[1] & 255)) << 8)) + (( int(dat[2] & 255)) << 16)) + (( int(dat[3] & 255)) << 24) )\n",
    "        \n",
    "    def getU32b(data, index):\n",
    "        dat = data[index:(index+4)]\n",
    "        out = struct.unpack('<q', dat)\n",
    "        return(out[0])\n",
    "        \n",
    "    def getU32_le(data, index):\n",
    "        dat = data[index:(index+4)]\n",
    "        return float( ((( int(dat[3] & 255)) + (( int(dat[2] & 255)) << 8)) + (( int(dat[1] & 255)) << 16)) + (( int(dat[0] & 255)) << 24) )\n",
    "            \n",
    "    def unpackU32(data, header):\n",
    "        # Assuming 414 bands (4*414=1656). It is possible that the SCIO has more bands, but is noisy on both ends\n",
    "        temp = [ ]\n",
    "        footer = 476 - header\n",
    "        if(len(data) == 1656):\n",
    "            footer = 332 - header;\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/4) ):\n",
    "            temp.append( getU32(data, j*4+header) )\n",
    "        return(temp)\n",
    "        \n",
    "    # 40-bit decoding functions\n",
    "    def getU40(data, index):\n",
    "        dat = data[index:(index+4)]\n",
    "        return float( ((( int(dat[0] & 255)) + (( int(dat[1] & 255)) << 8)) + (( int(dat[2] & 255)) << 16)) + (( int(dat[3] & 255)) << 24) + (( int(dat[4] & 255)) << 32) )\n",
    "            \n",
    "    def unpackU40(data, header):\n",
    "        temp = [ ]\n",
    "        footer = 145 - header\n",
    "        if(len(data) == 1656):\n",
    "            footer = 0;\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/5) ):\n",
    "            temp.append( getU40(data, j*5+header) / 100000000)\n",
    "        return(temp)\n",
    "        \n",
    "    def getU40_le(data, index):\n",
    "        dat = data[index:(index+5)]\n",
    "        return float( ((( int(dat[4] & 255)) + (( int(dat[3] & 255)) << 8)) + (( int(dat[2] & 255)) << 16)) + (( int(dat[1] & 255)) << 24) + (( int(dat[0] & 255)) << 32) )\n",
    "        \n",
    "    def unpackU40_le(data, header):\n",
    "        temp = [ ]\n",
    "        footer = 145 - header\n",
    "        if(len(data) == 1656):\n",
    "            footer = 0;\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/5) ):\n",
    "            temp.append( getU40_le(data, j*5+header) / 100000000)\n",
    "        return(temp)\n",
    "        \n",
    "    # Function to try to decode\n",
    "    def decode(raw_df, header):\n",
    "        df = [ ]\n",
    "        for part in range(len(raw_df)):\n",
    "            if(part == 2):\n",
    "                header = 0\n",
    "            df.append( unpackU32(raw_df[part], header) ) #df.append( unpackU40(raw_df[part], header) )\n",
    "        return(df)\n",
    "\n",
    "    def unpackU32b(data, header, footer):\n",
    "        # Unpacks with an offset\n",
    "        temp = [ ]\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/4) ):\n",
    "            temp.append( getU32(data, j*4+header) )\n",
    "        return(temp)\n",
    "    \n",
    "        \n",
    "    def getU64(data, index):\n",
    "        dat = data[index:(index+8)]\n",
    "        out = struct.unpack('<Q', dat)\n",
    "        return(out[0])\n",
    "    \n",
    "    def unpackU64(data, header, footer):\n",
    "        # Unpacks with an offset\n",
    "        temp = [ ]\n",
    "        data_length = len(data) - header - footer\n",
    "        for j in range( int(data_length/8) ):\n",
    "            temp.append( getU64(data, j*8+header) )\n",
    "        return(temp)\n",
    "        \n",
    "    # iterate over possible number of headers in order to find solution\n",
    "    # U64\n",
    "    num_vars = 331\n",
    "    var_size = 5\n",
    "    diff_scan = len(raw_df[0]) - num_vars*var_size\n",
    "    print('diff_scan: ' + str(diff_scan))\n",
    "    diff_cal =  len(cal_df[0]) - num_vars*var_size\n",
    "    print('diff_cal:  ' + str(diff_cal))\n",
    "    solution = False\n",
    "    for i in range(diff_scan+1):\n",
    "        for j in range(diff_cal+1):\n",
    "            #if(solution):\n",
    "            #    break\n",
    "            print('U40', i, diff_scan - i, j, diff_cal - j)\n",
    "            df = [ ]\n",
    "            df.append(unpackU64(raw_df[0], i, diff_scan - i)) # scan\n",
    "            df.append(unpackU64(cal_df[0], j, diff_cal - j))  # calibration # shourld be j\n",
    "            reflectance = [n/d for n, d in zip(df[0], df[1])]\n",
    "            if(all(k <= 1.0 for k in reflectance)):\n",
    "                solution = True\n",
    "                log.debug('Solution with scan header ' + str(i) )\n",
    "                break\n",
    "            break # DEBUG\n",
    "    print('U40 not found')\n",
    "    \n",
    "    # U32\n",
    "    num_vars = 331\n",
    "    var_size = 4\n",
    "    diff_scan = len(raw_df[0]) - num_vars*var_size\n",
    "    print('diff_scan: ' + str(diff_scan))\n",
    "    diff_cal =  len(cal_df[0]) - num_vars*var_size\n",
    "    print('diff_cal:  ' + str(diff_cal))\n",
    "    solution = False\n",
    "    for i in range(1, diff_scan+1):\n",
    "        for j in range(1, diff_cal+1):\n",
    "            #if(solution):\n",
    "            #    break\n",
    "            print('U32', i, diff_scan - i, j, diff_cal - j)\n",
    "            df = [ ]\n",
    "            df.append(unpackU32b(raw_df[0], j, diff_cal - j)) # scan\n",
    "            df.append(unpackU32b(cal_df[0], i, diff_scan - i))  # calibration\n",
    "            reflectance = [n/d for n, d in zip(df[0], df[1])]\n",
    "            if(all(k <= 1.0 for k in reflectance)):\n",
    "                solution = True\n",
    "                log.debug('Solution with scan header ' + str(i) + ' and cal. header ' + str(j))\n",
    "                break\n",
    "            break # DEBUG\n",
    "        \n",
    "    diff = len(raw_df[0]) - num_vars*var_size\n",
    "    solution = False\n",
    "    for h in range(1, diff+1): #range(145):\n",
    "        df = [ ]\n",
    "        df.append(unpackU32b(raw_df[0], i, diff - i)) # scan\n",
    "        df.append(unpackU32b(cal_df[0], i, diff - i))  # calibration\n",
    "        df.append(unpackU32b(raw_df[1], i, diff - i)) # scan\n",
    "        df.append(unpackU32b(cal_df[1], i, diff - i))  # calibration\n",
    "        reflectance = [ ]\n",
    "        reflectance.append([n/d for n, d in zip(df[0], df[1])])\n",
    "        reflectance.append([n/d for n, d in zip(df[2], df[3])])\n",
    "        temp = [ ]\n",
    "        temp.append([(a+b)/2 for a, b in zip(df[0], df[2])])\n",
    "        temp.append([(a+b)/2 for a, b in zip(df[1], df[3])])\n",
    "        reflectance = [ ]\n",
    "        reflectance.append([n/d for n, d in zip(temp[0], temp[1])])\n",
    "        if(all(i <= 1.0 for i in reflectance[0])):\n",
    "            solution = True\n",
    "            log.debug('Solution with header ' + str(header))\n",
    "    if(not solution):\n",
    "        log.debug('No solution found')\n",
    "    print(reflectance)\n",
    "    return(reflectance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the raw json file\n",
    "json_df = raw_read(project_path_scans + input_file)\n",
    "df = json_df[7:10] # Element 10 is not included...\n",
    "scan_df = decode_data2(df, scan_cal_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OLD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main_fct(calibrate, infile, outfile, calfile, protocol, raw):\n",
    "    if(calibrate): # DEBUG!!!\n",
    "        log.debug('We were told to calibrate')\n",
    "    log.info('Input/output')\n",
    "        \n",
    "    # Find the home folder (temporary)\n",
    "    from pathlib import Path\n",
    "    json_dir = str(Path.home())\n",
    "    \n",
    "    # Check if we need to scan\n",
    "    if(infile is not None):\n",
    "        # Input comes from a file\n",
    "        log.info('--> Input through:    ' + json_dir + '/' + infile)\n",
    "        log.info('--> Output file name: ' + 'N/A')\n",
    "        # Read the raw json file\n",
    "        json_df = scio.raw_read(json_dir + '/' + infile)\n",
    "        scan_raw_df = json_df[7:10] # Element 10 is not included...\n",
    "    else:\n",
    "        # We have to scan (Only USB currently works)\n",
    "        log.info('--> Input through:    ' + protocol)\n",
    "        log.info('--> Output file name: ' + outfile)\n",
    "        \n",
    "        # Try to find the device\n",
    "        scio_device = scio.find_scio_dev()\n",
    "    \n",
    "        # https://makersportal.com/blog/2018/2/25/python-datalogger-reading-the-serial-output-from-arduino-to-analyze-data-using-pyserial\n",
    "        try: # Make sure to close the serial port if it was still open\n",
    "            ser.close()\n",
    "        except:\n",
    "            pass\n",
    "    \n",
    "        # Read temperature before scanning\n",
    "        temp_before_df = scio.read_data(scio_device, 4) # 4 = read temperature\n",
    "        log.info('CMOS T: {:.3f}'.format(temp_before_df[0])) # cmosTemperature, chipTemperature, objectTemperature\n",
    "        log.info('Chip T: {:.3f}'.format(temp_before_df[1]))\n",
    "        log.info('Obj. T: {:.3f}'.format(temp_before_df[2]))\n",
    "    \n",
    "        # Scan and decode\n",
    "        scan_raw_df = scio.read_data(scio_device, 2) # 2 = read data\n",
    "    \n",
    "        # Read temperature after scanning\n",
    "        temp_after_df = scio.read_data(scio_device, 4)\n",
    "    \n",
    "        # Path to output file within home directory\n",
    "        if(outfile == 'scio-scan'):\n",
    "            # The default file name was given!\n",
    "            log.info('WARNING! The default file was used. Any existing previous file will be overwritten!')\n",
    "            \n",
    "        # Save the file\n",
    "        log.debug('Writing raw scan to: ' + json_dir + '/' + outfile + '.json')\n",
    "        # Saves the raw data. In the end, I'll want to save the scan as a CSV\n",
    "        scio.raw_write(temp_before_df, temp_after_df, scan_raw_df, json_dir + '/' + outfile + '.json')\n",
    "    \n",
    "    #print(scio.read_data(scio_device, 1)) # Read device ID\n",
    "    #print(scio.read_data(scio_device, -124)) # Read BLE ID\n",
    "    \n",
    "    if(calfile is not None):\n",
    "        # read calibration file\n",
    "        log.info('--> Calibration file name: ' + 'N/A')\n",
    "        # Read the raw json file\n",
    "        json_df = scio.raw_read(json_dir + '/' + calfile)\n",
    "        scan_cal_df = json_df[7:10] # Element 10 is not included...\n",
    "    \n",
    "    log.info('Trying to decode data')\n",
    "    #scan_df = scio.decode_data(scan_raw_df) # DOES NOT YET WORK\n",
    "    scan_df = scio.decode_data2(scan_raw_df, scan_cal_df)\n",
    "    #print(scan_df) #DEBUG\n",
    "    #log.debug('Number of scans in data:  ' + str(len(scan_df)))\n",
    "    #log.debug('Number of variables/scan: ' + str(len(scan_df[0])))\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_fn  = './01_rawdata/scan_json/skin.json'\n",
    "output_fn = ''\n",
    "\n",
    "main_fct(False, infile, outfile, calfile, protocol, raw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "scio",
   "language": "python",
   "name": "scio"
  },
  "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": 4
}