Lecture6 Notes 062424.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "95ed7ad3-c609-4ee9-9d0c-f512d48dc860",
   "metadata": {},
   "source": [
    "## Functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5daef3c-09b1-47fa-a6b1-f745341a05d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# General syntax\n",
    "\n",
    "def fucntion_name(input_arg1, input_arg2,..., input_argn):{be explicit with what the function is doing}\n",
    "    code line 1\n",
    "    code line 2 \n",
    "    return return_variable #Optional \n",
    "\n",
    "# Usage \n",
    "function_name(a1, a2, ..., an)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "05ec94be-c017-4cd3-a4aa-23660b864754",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function with no input arguments or return statements \n",
    "# No input in this fucntion. \n",
    "def helloworld():\n",
    "    print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "039dc45b-399a-41bc-bca0-516762eb45c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "helloworld()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8a0a7e4-1c6e-4b12-bd2f-0324a7f4c718",
   "metadata": {},
   "outputs": [],
   "source": [
    "# because is a function you got to put the () at the end in oder to get it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0ef4639c-cda8-46d0-8b94-3df2157d99d5",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "helloworld() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[6], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m helloworld(\u001b[38;5;241m5\u001b[39m)\n",
      "\u001b[1;31mTypeError\u001b[0m: helloworld() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "helloworld(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "36fc57c9-7e03-4b0e-a4e4-c0c36d3fa3d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def square_fucntion(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "718eb68e-ddc5-41f2-9a0a-78fde29d5659",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_fucntion(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "335d9204-6827-44d0-829b-a93993ffacc9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_fucntion(7.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "997cf33b-e43f-406e-a2af-15b2cf0acd7a",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for ** or pow(): 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[14], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m square_fucntion(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mData\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "Cell \u001b[1;32mIn[8], line 2\u001b[0m, in \u001b[0;36msquare_fucntion\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msquare_fucntion\u001b[39m(x):\n\u001b[1;32m----> 2\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m x\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "square_fucntion('Data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a7201a9-fa0b-44b0-b407-4189281937f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Because it's a mathematical function it will give an error. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "160badf4-d9eb-43d0-8693-8dcdfbeed9f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# calling the function somethign else \n",
    "\n",
    "y = square_fucntion(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "96438e6d-bf4f-44f2-b12b-88c5d0fc03ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a62089b0-7578-419b-99cd-11930a73dde4",
   "metadata": {},
   "source": [
    "## Exercise \n",
    "\n",
    "#### Write a fucntion and for loop to take a list of integers and return a list of the squares of all integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "140945d4-5326-4953-a21b-2b1f2dd9fb1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 4, 25]\n"
     ]
    }
   ],
   "source": [
    "a = [ 3, 2, 5]\n",
    "u = []\n",
    "for x in a: \n",
    "    u.append(square_fucntion(x))\n",
    "print(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9348390-bdf5-4760-a90e-bda92cbaae33",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Why is it not working??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2b412dd7-8e0b-4779-a85f-bb3abded0082",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 225, 400, 625]\n"
     ]
    }
   ],
   "source": [
    "# How professor did it: For Loop \n",
    "lst = [10, 15, 20, 25] \n",
    "square_lst = []\n",
    "for i in lst:\n",
    "    square_lst.append(i**2)\n",
    "print(square_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6c61666c-36bf-4a80-812d-07043af9c06f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 225, 400, 625]\n"
     ]
    }
   ],
   "source": [
    "lst = [10, 15, 20, 25] \n",
    "square_lst = []\n",
    "for i in lst:\n",
    "    square_lst.append(square_fucntion(i))\n",
    "print(square_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6f774946-2ae9-4032-8051-81f2adb3b9cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function \n",
    "\n",
    "def square_list(input_list): \n",
    "    square_list = []\n",
    "    for i in input_list:\n",
    "        square_list.append(square_fucntion(i))\n",
    "    return square_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "929157ca-fc88-460e-bb06-95302f654806",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[25, 625]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_list([5, 25])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "dee02311-1f5d-4b49-b043-8dc510d2314e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 100, 81]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_list([1, 2, 10, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "50c3e9aa-9b8c-492d-9008-8e861dec36a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [5, 6, 7, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "30dc69e5-de0f-408c-be94-c5cf3d1015d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[25, 36, 49, 64]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square_list(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "76538d04-e111-4ca1-92cb-377cb3827160",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Give me an integer:  7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "49.0\n"
     ]
    }
   ],
   "source": [
    "# defining input function \n",
    "x = float(input(\"Give me an integer: \"))\n",
    "print(type(x)) \n",
    "print(square_fucntion(x))\n",
    "\n",
    "# Does the steps in sequence...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a2cf46b-bd4d-4a81-b3f0-b96d2e91eed7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the integer I used is 7 \n",
    "# class is float because we coverted to a float\n",
    "# then it is squared. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "dfe71a3c-d698-4f16-ad50-f1478d42ba64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Give me an integer:  5.0\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '5.0'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[41], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(\u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mGive me an integer: \u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mtype\u001b[39m(x)) \n\u001b[0;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(square_fucntion(x))\n",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: '5.0'"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Give me an integer: \"))\n",
    "print(type(x)) \n",
    "print(square_fucntion(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d146fc47-b2e6-4371-988c-63e0183d2964",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Give me an integer:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Give me an integer: \"))\n",
    "print(type(x)) \n",
    "print(square_fucntion(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92bf5654-eb04-4498-b1a2-26b36586d247",
   "metadata": {},
   "source": [
    "## Multiple Input Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "0b9d9e4a-5854-41e9-a1b2-7ed147662395",
   "metadata": {},
   "outputs": [],
   "source": [
    "def power(base, exponent):\n",
    "    return base**exponent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "5d0e8883-4df9-4669-8c07-e2302d728901",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power(5,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "673b3359-33d4-4a23-8a1d-d913c5b88fc9",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "power() missing 1 required positional argument: 'exponent'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[50], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m power(\u001b[38;5;241m5\u001b[39m)\n",
      "\u001b[1;31mTypeError\u001b[0m: power() missing 1 required positional argument: 'exponent'"
     ]
    }
   ],
   "source": [
    "power(5)\n",
    "# no default value therefore there will be an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ac6c0f0d-2091-4389-9f4e-50b066c15d13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your own power function: assume that exponent is a positive integer\n",
    "# Is this what he wants???????\n",
    "# Has to not be able to accept negative numbers. \n",
    "def power1(base, exponent):\n",
    "   if exponent < 0: \n",
    "       return(\"Exponent can not be negative!\")\n",
    "   else:\n",
    "       return(base**exponent)\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "677a7f04-e19f-4523-ad19-c05beff2a64b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power1( 2,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "804752cb-4830-4516-b42f-d1e3ca70df70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Exponent can not be negative!'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power1(2, -4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "8ebe839c-59c1-4f90-b143-0cbc9d8c2290",
   "metadata": {},
   "outputs": [],
   "source": [
    "def quotient_remainder(number,divisor):\n",
    "    return(number//divisor, number%divisor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "51da55f9-dbac-40c2-b69c-882083557119",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 6)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient_remainder(6, 72)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "a8724609-bfc9-4673-8a4a-223ecc401ab9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 0)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient_remainder(6, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "375203f9-637a-4e2e-ae43-a34a03adf034",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 7)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient_remainder(7,49)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "2c7cb11f-8610-48cb-a658-3f3c0e10ee1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77, 16)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient_remainder(1787, 23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "7f658545-8a6c-4015-8b01-4b5ff637b3dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5//3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f27364f3-ed5c-4acc-9122-d83689cc8c53",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Above it only gives you the divisor. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "4a129006-2c64-4303-b8fb-c49bfdda1792",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5%3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa07774b-f3b3-424e-a3db-36f672bcdf23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Above it only gives you the remainder. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "7f134d76-375d-482d-9a2b-db12cdaa52b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77, 16)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divmod(1787, 23)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a5dc3be-41b7-4ff5-afff-f315e52b0e7b",
   "metadata": {},
   "source": [
    "## Default Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "4dbfaaf0-8bcf-44f7-996a-7c58f62ff66f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_calculations(a, b, e= 2.71):\n",
    "    return(a**b*e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "f9dc3a22-f7ad-48ae-a51d-a1637a436c55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "219.51"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_calculations(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b83223ac-460a-4680-9f1b-c3d5e97f626d",
   "metadata": {},
   "source": [
    "## Nested Functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "194e9aaa-52fe-49a1-8abb-f0601568edef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# General Example\n",
    "# figure out the # how to do it in one\n",
    "#def outer_fucntion(input_args, .....):\n",
    "#    def inner_function(other_input_args, ...):\n",
    "#        inner function code\n",
    "#        return\n",
    "#        x = inner_fucntion(....)\n",
    "#        return(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "413efbea-92f3-4acf-a06a-5d48b31ecfb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def divisors(x): \n",
    "    count = 0\n",
    "    for i in range(1, n+1): \n",
    "        if n % i == 0: \n",
    "            count += 1\n",
    "        return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "4387861b-8a71-4055-b503-18000b16fd7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def stuff(base, exponents, translation): \n",
    "    #return to base**exponenet - translation ( purpose of the fucntion with comment) \n",
    "    def power(base, exponent):\n",
    "        return base**exponent\n",
    "        \n",
    "    output = power(base, exponents) - translation\n",
    "    return output\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1620e546-659a-41a8-a949-9c36a1a3c513",
   "metadata": {},
   "outputs": [],
   "source": [
    "# defined outer function and defined the inner function in the nested loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "c98a0deb-e7bf-4cf1-96b2-337865943e9a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stuff(5, 2, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2b119c1-b2e6-4435-97fe-6f46c5b55d13",
   "metadata": {},
   "source": [
    "## Exercise:\n",
    "### Write a fucntion that takes a positive integer and output a lsit of all prime numbers <+ that integer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "d434bfae-c2b8-42f4-9e2e-00739cf82f3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def divisors(n): \n",
    "    count = 0\n",
    "    for i in range(1, n+1): \n",
    "        if n % i == 0: \n",
    "            count += 1\n",
    "        return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "78b9595a-bc0b-41d8-a960-7b12b07253c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# How professor did it: \n",
    "def is_prime(x): \n",
    "   if divisors(x) == 2: \n",
    "       return True \n",
    "   else: \n",
    "       return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "7a8d17c2-0686-4ad3-8445-9d6a354772e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_prime(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "4adfe1fb-71df-45f1-87c6-c5687e0a457f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_prime(5)\n",
    "# Ask professor after class...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "f7d8c7e9-49e0-4edd-87f5-337b5b4f49ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_prime(x):\n",
    "    if divisors(x) == 2:\n",
    "        return True\n",
    "    else: \n",
    "        return False\n",
    "        for x in range(7, n+7):\n",
    "            if is_prime(x):\n",
    "                is_prime.append(x)\n",
    "                return primes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "06acb600-b263-42b3-a95e-852ddd6f59a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# how the professor did it: \n",
    "def list_primes(x):\n",
    "    \"\"\"\n",
    "    Return a list of all prime nubmers less than or equal to x.\n",
    "    \"\"\"\n",
    "    primes = [] \n",
    "    for i in range(2, x + 1):\n",
    "        if is_prime(i):\n",
    "            primes.append(i)\n",
    "        return primes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "e8bd99f5-51c0-4925-b692-d4df470c5f58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_primes(5)\n",
    "# check this thing out and why is not working!!!!!!!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f57f1d0-631c-4c43-81e6-1afe32066812",
   "metadata": {},
   "source": [
    "## Modules and Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86195375-0fb4-4cd3-9942-d44323e34910",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modules and Packages are the Python's libraries. i.e. a collection of constants, functions and classes. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9eeda56-50fd-436f-ad6b-88450ed3deed",
   "metadata": {},
   "source": [
    "## Importing a Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "1dd30ce6-851b-44f3-9e34-482c83f17e60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# basic imports \n",
    "import numpy \n",
    "numpy.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "a8a69a83-4cdf-442b-8b30-ed74af5ca91c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use an \"alias\" \n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "7cc22b37-5786-4549-afe0-a502b3cbf7b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "356873d2-2317-4c02-9802-2363af2c10cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing specific elements from the package/module \n",
    "\n",
    "from numpy import add, pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "a1fde763-7925-41c3-b854-63487960d763",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<ufunc 'add'>"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "3dce52b1-dd54-4f03-8e51-a67964562d27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "6f66f8ab-3345-4492-a311-3827ef9de921",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pull everything into the local namespace \n",
    "\n",
    "from numpy import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "14587d6a-7479-421c-9820-c590aa92755e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# How professor did it: For Loop \n",
      "lst = [10, 15, 20, 25] \n",
      "square_lst = []\n",
      "for i in lst:\n",
      "    square_lst.append(i**2)\n",
      "    print(square_lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: For Loop \n",
      "lst = [10, 15, 20, 25] \n",
      "square_lst = []\n",
      "for i in lst:\n",
      "    square_lst.append(i**2)\n",
      "print(square_lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    e = u.append(square_fucntion(a))\n",
      "    print(e)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    e = u.append(square_fucntion(x))\n",
      "    print(e)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_fucntion(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(y(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_function(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def square_fucntion(x):\n",
      "    return x**2\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_function(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "lst = [10, 15, 20, 25] \n",
      "square_lst = []\n",
      "for i in lst:\n",
      "    square_lst.append(square_function(i))\n",
      "print(square_lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_fucntion(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "lst = [10, 15, 20, 25] \n",
      "square_lst = []\n",
      "for i in lst:\n",
      "    square_lst.append(square_fucntion(i))\n",
      "print(square_lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_fucntion(x))\n",
      "print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Function \n",
      "\n",
      "def square_list(input_list): \n",
      "    square_list = []\n",
      "    for i in input_list:\n",
      "        square_list.append(square_fucntion(i))\n",
      "    return square_list\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "square_list([5, 25])\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "square_list([1, 2, 10, 9])\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "lst = [5, 6, 7, 8]\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "square_list(lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# defining input function \n",
      "x = float(input(\"Give me an integer: \"))\n",
      "print(type(x)) \n",
      "print(square_fucntion(x))\n",
      "\n",
      "# Does the steps in sequence....\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "x = int(input(\"Give me an integer: \"))\n",
      "print(type(x)) \n",
      "print(square_fucntion(x))\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "x = int(input(\"Give me an integer: \"))\n",
      "print(type(x)) \n",
      "print(square_fucntion(x))\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "x = int(input(\"Give me an integer: \"))\n",
      "print(type(x)) \n",
      "print(square_fucntion(x))\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def power(base, exponent):\n",
      "    return base**exponent\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(5,3)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(5)\n",
      "# no default value therefore there will be an error\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "\n",
      "def power(base, exponent):\n",
      "    exponent = 1\n",
      "    return base**exponent\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "\n",
      "def power(base, 2):\n",
      "    return base**exponent\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "\n",
      "def power(base, 2):\n",
      "    return base**2\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "\n",
      "def power(base, exponent):\n",
      "    return base**2\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "# Is this what he wants???????\n",
      "# Has to not be able to accept negative numbers. \n",
      "def power1(base, exponent):\n",
      "   if exponent < 0: \n",
      "       return(\"Exponent can not be negative!\")\n",
      "   else:\n",
      "       return(base**exponent)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power1( 2,4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(2, -4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power1(2, -4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def quotient_remainder(number,divisor):\n",
      "    return(number//divisor, number%divisor)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(6, 72)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(6, 2)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(7. 49)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(7,49)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(1787, 23)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "5//3\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "5%3\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "divmod(1787, 23)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def my_calculations(a, b, c = 2.71):\n",
      "    return(a**b*e)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "my_calculation(3,4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "my_calculations(3,4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def my_calculations(a, b, e= 2.71):\n",
      "    return(a**b*e)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "my_calculations(3,4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(x): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "stuff(5, 2, 10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def stuff(base, exponents, translation): \n",
      "    #return to base**exponenet - translation ( purpose of the fucntion with comment) \n",
      "    def power(base, exponent):\n",
      "        return base**exponent\n",
      "        \n",
      "    output = power(base, exponent) - translation\n",
      "    return output\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "stuff(5, 2, 10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def stuff(base, exponents, translation): \n",
      "    #return to base**exponenet - translation ( purpose of the fucntion with comment) \n",
      "    def power(base, exponent):\n",
      "        return base**exponent\n",
      "        \n",
      "    output = power(base, exponents) - translation\n",
      "    return output\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "stuff(5, 2, 10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) = 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(x): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime (5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(x): \n",
      "    count = 0\n",
      "    for i in range(1, x+1): \n",
      "        if x % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(n): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(n): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime(x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "# Ask professor after class....\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(::)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(0,)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(0,):\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(0,7):\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# how the professor did it: \n",
      "def list_primes(x):\n",
      "    \"\"\"\n",
      "    Return a list of all prime nubmers less than or equal to x.\n",
      "    \"\"\"\n",
      "    primes = [] \n",
      "    for i in range(2, x + 1):\n",
      "        if is_prime(i):\n",
      "            primes.append(i)\n",
      "        return primes\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "list_primes(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(n): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime(x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(7: n+7):\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(7, n+7):\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(7, n+7):\n",
      "            if is_prime(x):\n",
      "                is_prime.append(x)\n",
      "                return primes\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "list_primes(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# basic imports \n",
      "import numpy \n",
      "numpy.pi\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Use an \"alias\" \n",
      "import numpy as np\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "np.pi\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Importing specific elements from the package/module \n",
      "\n",
      "from numpy import add, pi\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "add\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "pi\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Pull everything into the local namespace \n",
      "\n",
      "from numpy import *\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "%hist\n"
     ]
    }
   ],
   "source": [
    "%hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "de80a03a-f0e0-4b7c-b6fa-2831b227792f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "78440083-6bd7-4ec9-81a6-8ce627987b8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.26.4'"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01cea19c-7f26-4f71-837e-0a72f95004cd",
   "metadata": {},
   "source": [
    "## Numpy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "069f678d-68f6-4edb-b616-5fa78f39beed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numpy arrays \n",
    "\n",
    "#- define arrays \n",
    "#- indexing and slicing \n",
    "#- create arrays \n",
    "#- array calculations \n",
    "#- the array data structure \n",
    "#- advanced numpy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "f1efe04f-0298-44c7-86fc-ffde90136783",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Introduce NumPy Arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "528940b8-a662-4522-ac00-0381231a174b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple Array Creation \n",
    "a = array([0, 1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "98e1817a-083c-4b05-ae24-1e69c2dd0e71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "703cf6b5-e323-43ba-bdc7-5dc977140d87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "a8a6498e-4807-4fff-909c-1f166800e527",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numeric type of elements \n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "993bda3c-9bfb-4570-956a-6e71f0c78776",
   "metadata": {},
   "outputs": [],
   "source": [
    "# above you are checking the data type of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "id": "f9e6ac7c-6384-4ab8-a78f-56ae36f1c2d2",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'numpy.ndarray' object has no attribute 'ddimension'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[222], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m a\u001b[38;5;241m.\u001b[39mddimension\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'ddimension'"
     ]
    }
   ],
   "source": [
    "a.ddimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "id": "421ce0de-6d9c-41c8-a384-12eb7f9b5a54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Number of Dimenstions \n",
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "id": "9651b33d-e423-4831-8cb4-acb079787a77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array Shape\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "id": "123c28dc-2606-412b-8adc-d13efd05fbd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bytes per element\n",
    "a.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "65236fa5-b9ec-43bd-81ec-047dcf2bb2dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bytes of Memory Used\n",
    "a.nbytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "id": "851d4f6b-9563-40b4-b2e3-92bc74244e92",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Array Operations \n",
    "\n",
    "a = array([1,2,3,4])\n",
    "b = array([2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "id": "c6bca6ec-6729-4659-9ec9-3010981ce385",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 5, 7, 9])"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "id": "42b3c2f3-ce44-492f-8d71-675ea92f1f8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   1,    8,   81, 1024])"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a**b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "78553fdf-f653-4237-8dea-132c8de53a13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# math fucntions \n",
    "\n",
    "# create an array from 0 to 10 \n",
    "\n",
    "x = arange(11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "id": "ae996e9e-52da-4040-9009-8b36dc10881e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d889eb1-88a9-4457-bd78-36c57a1dbbc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the a at the front of the arange makes it into an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "983be01b-cbf3-47ae-bb8f-f1c875a6fe8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = (2*pi)/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "6fbaec08-36ed-40a9-9e3e-650cf8834c3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6283185307179586"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "d4b74e2b-3c7e-4bb0-a745-b30fb1b2ee76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.62831853, 1.25663706, 1.88495559, 2.51327412,\n",
       "       3.14159265, 3.76991118, 4.39822972, 5.02654825, 5.65486678,\n",
       "       6.28318531])"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c * x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd6d6d03-2754-425e-bdfc-d800813ce19b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# in place operations ( Professor is gonna check this ) \n",
    "x *= c "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "id": "27181784-f567-4407-aa51-cba695bb3bc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# apply functions to array \n",
    "\n",
    "y = sin(x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "id": "3e608ded-187a-4e2a-901d-5e992ecd491f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ,\n",
       "       -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849,\n",
       "       -0.54402111])"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "6a7f0a3c-dc0a-432e-b394-2fe51d573560",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# How professor did it: For Loop \n",
      "lst = [10, 15, 20, 25] \n",
      "square_lst = []\n",
      "for i in lst:\n",
      "    square_lst.append(i**2)\n",
      "    print(square_lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: For Loop \n",
      "lst = [10, 15, 20, 25] \n",
      "square_lst = []\n",
      "for i in lst:\n",
      "    square_lst.append(i**2)\n",
      "print(square_lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    e = u.append(square_fucntion(a))\n",
      "    print(e)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    e = u.append(square_fucntion(x))\n",
      "    print(e)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_fucntion(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(y(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_function(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def square_fucntion(x):\n",
      "    return x**2\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_function(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "lst = [10, 15, 20, 25] \n",
      "square_lst = []\n",
      "for i in lst:\n",
      "    square_lst.append(square_function(i))\n",
      "print(square_lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_fucntion(x))\n",
      "    print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "lst = [10, 15, 20, 25] \n",
      "square_lst = []\n",
      "for i in lst:\n",
      "    square_lst.append(square_fucntion(i))\n",
      "print(square_lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [ 3, 2, 5]\n",
      "u = []\n",
      "for x in a: \n",
      "    u.append(square_fucntion(x))\n",
      "print(u)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Function \n",
      "\n",
      "def square_list(input_list): \n",
      "    square_list = []\n",
      "    for i in input_list:\n",
      "        square_list.append(square_fucntion(i))\n",
      "    return square_list\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "square_list([5, 25])\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "square_list([1, 2, 10, 9])\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "lst = [5, 6, 7, 8]\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "square_list(lst)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# defining input function \n",
      "x = float(input(\"Give me an integer: \"))\n",
      "print(type(x)) \n",
      "print(square_fucntion(x))\n",
      "\n",
      "# Does the steps in sequence....\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "x = int(input(\"Give me an integer: \"))\n",
      "print(type(x)) \n",
      "print(square_fucntion(x))\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "x = int(input(\"Give me an integer: \"))\n",
      "print(type(x)) \n",
      "print(square_fucntion(x))\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "x = int(input(\"Give me an integer: \"))\n",
      "print(type(x)) \n",
      "print(square_fucntion(x))\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def power(base, exponent):\n",
      "    return base**exponent\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(5,3)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(5)\n",
      "# no default value therefore there will be an error\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "\n",
      "def power(base, exponent):\n",
      "    exponent = 1\n",
      "    return base**exponent\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "\n",
      "def power(base, 2):\n",
      "    return base**exponent\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "\n",
      "def power(base, 2):\n",
      "    return base**2\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "\n",
      "def power(base, exponent):\n",
      "    return base**2\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Write your own power function: assume that exponent is a positive integer\n",
      "# Is this what he wants???????\n",
      "# Has to not be able to accept negative numbers. \n",
      "def power1(base, exponent):\n",
      "   if exponent < 0: \n",
      "       return(\"Exponent can not be negative!\")\n",
      "   else:\n",
      "       return(base**exponent)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power1( 2,4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power(2, -4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "power1(2, -4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def quotient_remainder(number,divisor):\n",
      "    return(number//divisor, number%divisor)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(6, 72)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(6, 2)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(7. 49)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(7,49)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "quotient_remainder(1787, 23)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "5//3\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "5%3\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "divmod(1787, 23)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def my_calculations(a, b, c = 2.71):\n",
      "    return(a**b*e)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "my_calculation(3,4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "my_calculations(3,4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def my_calculations(a, b, e= 2.71):\n",
      "    return(a**b*e)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "my_calculations(3,4)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(x): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "stuff(5, 2, 10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def stuff(base, exponents, translation): \n",
      "    #return to base**exponenet - translation ( purpose of the fucntion with comment) \n",
      "    def power(base, exponent):\n",
      "        return base**exponent\n",
      "        \n",
      "    output = power(base, exponent) - translation\n",
      "    return output\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "stuff(5, 2, 10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def stuff(base, exponents, translation): \n",
      "    #return to base**exponenet - translation ( purpose of the fucntion with comment) \n",
      "    def power(base, exponent):\n",
      "        return base**exponent\n",
      "        \n",
      "    output = power(base, exponents) - translation\n",
      "    return output\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "stuff(5, 2, 10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) = 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(x): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime (5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(x): \n",
      "    count = 0\n",
      "    for i in range(1, x+1): \n",
      "        if x % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(n): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime (x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(n): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime(x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(10)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "is_prime(5)\n",
      "# Ask professor after class....\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(::)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(0,)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(0,):\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(0,7):\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# how the professor did it: \n",
      "def list_primes(x):\n",
      "    \"\"\"\n",
      "    Return a list of all prime nubmers less than or equal to x.\n",
      "    \"\"\"\n",
      "    primes = [] \n",
      "    for i in range(2, x + 1):\n",
      "        if is_prime(i):\n",
      "            primes.append(i)\n",
      "        return primes\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "list_primes(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def divisors(n): \n",
      "    count = 0\n",
      "    for i in range(1, n+1): \n",
      "        if n % i == 0: \n",
      "            count += 1\n",
      "        return count\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# How professor did it: \n",
      "def is_prime(x): \n",
      "   if divisors(x) == 2: \n",
      "       return True \n",
      "   else: \n",
      "       return False\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(7: n+7):\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(7, n+7):\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "def is_prime(x):\n",
      "    if divisors(x) == 2:\n",
      "        return True\n",
      "    else: \n",
      "        return False\n",
      "        for x in range(7, n+7):\n",
      "            if is_prime(x):\n",
      "                is_prime.append(x)\n",
      "                return primes\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "list_primes(5)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# basic imports \n",
      "import numpy \n",
      "numpy.pi\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Use an \"alias\" \n",
      "import numpy as np\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "np.pi\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Importing specific elements from the package/module \n",
      "\n",
      "from numpy import add, pi\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "add\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "pi\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Pull everything into the local namespace \n",
      "\n",
      "from numpy import *\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "%hist\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "import numpy as np\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "np.__version_\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "np.__version__\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Introduce NumPy Arrays\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Simple Array Creation \n",
      "a = array([0, 1, 2, 3])\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "type(a)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a.dtyrpe\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a.dtype\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a.ddimension\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Number of Dimenstions \n",
      "a.ndim\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Array Shape\n",
      "a.shape\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Bytes per element\n",
      "a.itemsize\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Bytes of Memory Used\n",
      "a.nbytes\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = [1,2,3,4]\n",
      "b =[2,3,4,5]\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a + b\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Array Operations \n",
      "\n",
      "a = array([1,2,3,4])\n",
      "b = array([2,3,4,5])\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a + b\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a**b\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# math fucntions \n",
      "\n",
      "# create an array from 0 to 10 \n",
      "\n",
      "x = arange(11)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "x\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "c = (2*pi)/10\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "c\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "c * x\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# apply functions to array \n",
      "\n",
      "y = sin(x)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "y\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "%hist\n"
     ]
    }
   ],
   "source": [
    "%hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c562515-b494-4ab7-84a8-1828e10237d8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}