Remembering1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\"><h3>Remembering Python...</h3></div>\n",
    "\n",
    "Python boots up with __builtins__ already in the namespace and checked as a part of the name resolution protocol...\n",
    "\n",
    "Using difference slices, we an check portions of a long list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['slice',\n",
      " 'sorted',\n",
      " 'staticmethod',\n",
      " 'str',\n",
      " 'sum',\n",
      " 'super',\n",
      " 'tuple',\n",
      " 'type',\n",
      " 'vars',\n",
      " 'zip']\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "# I, Python am built from types, such as builtin types:\n",
    "\n",
    "the_builtins = dir(__builtins__) # always here\n",
    "\n",
    "pprint(the_builtins[-10:])  # no need to import"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets check our understanding that the native types -- the ones we count on to build more complex types -- live in __builtins__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes I am a native type:  list\n",
      "Yes I am a native type:  tuple\n",
      "Yes I am a native type:  dict\n",
      "Yes I am a native type:  int\n",
      "Yes I am a native type:  float\n"
     ]
    }
   ],
   "source": [
    "for the_string in [\"list\", \"tuple\", \"dict\", \"int\", \"float\"]:\n",
    "    if the_string in the_builtins:\n",
    "        print(\"Yes I am a native type: \", the_string)\n",
    "        assert type(eval(the_string)) == type # all types in this club\n",
    "    else:\n",
    "        print(\"No, I'm not native: \", the_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now for something completely different, lets define a class that does substitution based on a permutation of lower-case ascii letters plus space.  Such a type is given more substantial implementation in the form of our px_class.py, which allows permutations to multiply, giving more permuations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i like python so much because it does everything\n",
      "oagoylabrwsufa uaqdisaxlipd laowamul alnlerwsofc\n",
      "i like python so much because it does everything\n"
     ]
    }
   ],
   "source": [
    "# usually up top\n",
    "from string import ascii_lowercase as all_lowers\n",
    "from random import shuffle\n",
    "\n",
    "class P:\n",
    "    \"\"\"\n",
    "    class Px is the more sophisticated version of this class\n",
    "    \"\"\"\n",
    "    def __init__(self, p=None):\n",
    "        if not p:\n",
    "            original = all_lowers + ' '\n",
    "            scrambled = list(original)\n",
    "            shuffle(scrambled)            \n",
    "            self.perm = dict(zip(original, scrambled))\n",
    "        else:\n",
    "            self.perm = p\n",
    "        \n",
    "    def __invert__(self):\n",
    "        \"\"\"reverse my perm, make a new me\"\"\"\n",
    "        reverse = dict(zip(self.perm.values(), self.perm.keys()))\n",
    "        return P(reverse)  # <-- new P instance\n",
    "        \n",
    "    def encrypt(self, s):\n",
    "        output = \"\"\n",
    "        for c in s:\n",
    "            output += self.perm[c]\n",
    "        return output\n",
    "            \n",
    "    def decrypt(self, s):\n",
    "        rev = ~self  # <-- new P instance\n",
    "        return rev.encrypt(s) # <-- symmetric key\n",
    "\n",
    "     \n",
    "p = P()\n",
    "m = \"i like python so much because it does everything\" # palindrome\n",
    "c = p.encrypt(m)\n",
    "print(m)  # plaintext\n",
    "print(c)  # ciphertext\n",
    "d = p.decrypt(c)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code below, we use a context manager to connect and disconnect from a SQLite database.  The context manager is developed from a simple generator with precisely one yield statement, using the @contextmanager decorator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sqlite3 as sql\n",
    "import os.path\n",
    "import json\n",
    "import time\n",
    "from contextlib import contextmanager\n",
    "\n",
    "PATH = \"/Users/kurner/Documents/classroom_labs/session10\"\n",
    "DB1 = os.path.join(PATH, 'periodic_table.db')\n",
    "\n",
    "def mod_date():\n",
    "    return time.mktime(time.gmtime())  # GMT time\n",
    "\n",
    "@contextmanager        \n",
    "def Connector(db):\n",
    "    try:\n",
    "        db.conn = sql.connect(db.db_name)  # connection\n",
    "        db.curs = db.conn.cursor()   # cursor\n",
    "        yield db       \n",
    "    except Exception as oops:\n",
    "        if oops[0]:\n",
    "            raise\n",
    "    db.conn.close()\n",
    "\n",
    "class elemsDB:\n",
    "    \n",
    "    def __init__(self, db_name):\n",
    "        self.db_name = db_name\n",
    "     \n",
    "    def seek(self, elem):\n",
    "        if self.conn:\n",
    "            if elem != \"all\":\n",
    "                query = (\"SELECT * FROM Elements \"\n",
    "                \"WHERE elem_symbol = '{}'\".format(elem))\n",
    "                self.curs.execute(query)\n",
    "                result = self.curs.fetchone()\n",
    "                if result:\n",
    "                    return json.dumps(list(result))\n",
    "            else:\n",
    "                query = \"SELECT * FROM Elements ORDER BY elem_protons\"\n",
    "                self.curs.execute(query)\n",
    "                result={}\n",
    "                for row in self.curs.fetchall():\n",
    "                    result[row[1]] = list(row)\n",
    "                return json.dumps(result)                \n",
    "        return \"NOT FOUND\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, we're able to seek a specific row from the Elements table, or request all of them.  In a Flask web application, the controlling argument might come from a GET request, i.e. a URL such as /api/elements?elem=H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, \"C\", \"Carbon\", 12.0107, \"Noble gas\", 1469802789, \"KTU\"]\n"
     ]
    }
   ],
   "source": [
    "output = \"\"\n",
    "with Connector(elemsDB(DB1)) as dbx:\n",
    "    output = dbx.seek(\"C\")\n",
    "\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To be continued...\n",
    "![Science Notes](http://sciencenotes.org/wp-content/uploads/2014/11/ColorfulPeriodicTable.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "b'POST SUCCESSFUL'\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "\n",
    "data = {}\n",
    "data[\"protons\"]=100\n",
    "data[\"symbol\"]=\"Kr\"\n",
    "data[\"long_name\"]=\"Kirbium\"\n",
    "data[\"mass\"]=300\n",
    "data[\"series\"]=\"Dunno\"\n",
    "data[\"secret\"]=\"DADA\" # <--- primitive authentication\n",
    "\n",
    "the_url = 'http://localhost:5000/api/elements'\n",
    "r = requests.post(the_url, data=data)\n",
    "print(r.status_code)\n",
    "print(r.content)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.1"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}