Tensorflow Rx chat-bot (response).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# things we need for NLP\n",
    "import nltk\n",
    "from nltk.stem.lancaster import LancasterStemmer\n",
    "stemmer = LancasterStemmer()\n",
    "\n",
    "# things we need for Tensorflow\n",
    "import numpy as np\n",
    "import tflearn\n",
    "import tensorflow as tf\n",
    "import random\n",
    "# initialize tf\n",
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Rx and biz lookup functions\n",
    "# this would normally be in separate Class or web-services\n",
    "\n",
    "# using fonefinder.net for cell location lookups\n",
    "#       yellowpages.com for biz lookups\n",
    "#       GoodRx.com for Rx pricing\n",
    "\n",
    "from bs4 import BeautifulSoup\n",
    "import json\n",
    "import httplib2\n",
    "http = httplib2.Http()\n",
    "\n",
    "# reverse lookup on cellnumber\n",
    "def lookup_number(cellnum):\n",
    "    # scrape city location from phone #\n",
    "    npa = nxx = thoublock = None\n",
    "    # handle +1xxxxxxxxxx pattern\n",
    "    if cellnum[0] == '+' and len(cellnum) == 12:\n",
    "        npa = cellnum[2:5]\n",
    "        nxx = cellnum[5:8]\n",
    "        thoublock = cellnum[8:12]\n",
    "    # handle 1xxxxxxxxxx pattern\n",
    "    elif cellnum[0] == '1' and len(cellnum) == 11:\n",
    "        npa = cellnum[1:4]\n",
    "        nxx = cellnum[4:7]\n",
    "        thoublock = cellnum[7:11]\n",
    "    # handle 10-digit pattern\n",
    "    elif len(cellnum) == 10:\n",
    "        npa = cellnum[0:3]\n",
    "        nxx = cellnum[3:6]\n",
    "        thoublock = cellnum[6:10]\n",
    "\n",
    "    if npa:\n",
    "        status, resp = http.request(\"http://www.fonefinder.net/findome.php?npa=%s&nxx=%s&thoublock=%s&usaquerytype=Search+by+Number\" % (npa, nxx, thoublock))\n",
    "        # convert bytes to string\n",
    "        resp = resp.decode('utf8').strip()\n",
    "        \n",
    "        city_begin = resp.index(\"findcity.php\")\n",
    "        city_begin = resp.index(\"=\", city_begin) +1\n",
    "        city_end = resp.index(\"&\", city_begin)\n",
    "\n",
    "        state_begin = resp.index(\"&state\", city_begin)\n",
    "        state_begin = resp.index(\"=\", state_begin) +1\n",
    "        state_end = resp.index(\"'>\", state_begin)\n",
    "\n",
    "        return {\"city\": resp[city_begin:city_end], \"state\":resp[state_begin:state_end] }\n",
    "\n",
    "    return\n",
    "\n",
    "# scrape YP for business address information\n",
    "def find_biz(term, location, debug=False):\n",
    "    biz_list = []\n",
    "    term_url = term.replace(' ', '+')\n",
    "    location = location.replace(' ', '+')\n",
    "\n",
    "    url = \"http://www.yellowpages.com/search?search_terms=%s&geo_location_terms=%s&s=distance\" % (term_url, location)\n",
    "    if debug: print (url)\n",
    "        \n",
    "    status, response = http.request(url)\n",
    "    r = response.decode(\"utf-8\")\n",
    "    \n",
    "    body = r.index('<body')\n",
    "    \n",
    "    if term in r[body:]:     \n",
    "        term = r.index(term, body)\n",
    "        \n",
    "        # handle no results\n",
    "        if \"No results\" in r:\n",
    "            return []\n",
    "        \n",
    "        address_lbl = 'class=\"street-address\">'\n",
    "        address_ptr = r.index(address_lbl, term) +len(address_lbl)\n",
    "        address = r[address_ptr: r.index('<', address_ptr)]\n",
    "        if debug: print (address)\n",
    "        \n",
    "        locality_lbl = 'class=\"locality\">'\n",
    "        locality_ptr = r.index(locality_lbl, term) +len(locality_lbl)\n",
    "        locality = r[locality_ptr: r.index('<', locality_ptr)].replace(\",&nbsp;\", \"\")\n",
    "        if debug: print (locality)\n",
    "        \n",
    "        region_lbl = 'itemprop=\"addressRegion\">'\n",
    "        region_ptr = r.index(region_lbl, term) +len(region_lbl)\n",
    "        region = r[region_ptr: r.index('<', region_ptr)]\n",
    "        if debug: print (region)\n",
    "        \n",
    "        zip_lbl = 'itemprop=\"postalCode\">'\n",
    "        zip_ptr = r.index(zip_lbl, term) +len(zip_lbl)\n",
    "        zip = r[zip_ptr: r.index('<', zip_ptr)]\n",
    "        if debug: print (zip)\n",
    "        \n",
    "        biz_list.append({\"address\":address, \"city\":locality, \"state\":region, \"zip\":zip})\n",
    "\n",
    "    return biz_list\n",
    "\n",
    "# look for drug name suggestions\n",
    "def look_for_suggestions(resp):\n",
    "    try:\n",
    "        # look for list of possible matches\n",
    "        any_loc = resp.index(\"<p>Any of these sound right?\")\n",
    "        any_loc = resp.index('\">', any_loc) +2\n",
    "        suggest = resp[any_loc:resp.index('<', any_loc)]\n",
    "        # if multiple words, return first\n",
    "        if len(suggest.split(\" \")) > 1:\n",
    "            return suggest.split(\" \")[0]\n",
    "        else:\n",
    "            # if name is correct then return it\n",
    "            return suggest\n",
    "    except:\n",
    "        # return blank if any issues\n",
    "        print (\"error in look_for_suggestions()\")\n",
    "        return \"\"\n",
    "\n",
    "# find prices for Rx in the soup content\n",
    "def find_prices(soup):\n",
    "    priceRows = soup.find_all(\"div\", {\"event-id\": \"priceRow\"})\n",
    "    price_list = []\n",
    "    \n",
    "    for p in priceRows:\n",
    "        line = {}\n",
    "        if p.find(\"div\", {\"class\" : \"store-name\"}):\n",
    "            line['store'] = p.find(\"div\", {\"class\": \"store-name\"}).string\n",
    "            if p.find(\"div\", {\"class\": \"drug-qualifier\"}):\n",
    "                line['qualifier'] = p.find(\"div\", {\"class\": \"drug-qualifier\"}).string\n",
    "            else:\n",
    "                line['qualifier'] = ''\n",
    "\n",
    "            # the 1st price is cash, 2nd (if applicable) is coupon\n",
    "            if p.find(\"span\", {\"class\": \"drug-price\"}):\n",
    "                line['price'] = p.findAll(\"span\", {\"class\": \"drug-price\"})[-1].find(\"span\", {\"class\":\"font-weight-medium\"}).string\n",
    "            else:\n",
    "                line['price'] = \"0\"\n",
    "            \n",
    "            if len(p.find(\"span\", {\"class\": \"drug-price\"})) == 2:\n",
    "                line['cash-price'] = p.findAll(\"span\", {\"class\": \"drug-price\"})[0].find(\"span\", {\"class\":\"font-weight-medium\"}).string\n",
    "            else:\n",
    "                line['cash-price'] = \"0\"\n",
    "\n",
    "            coupon_section = p.find(\"button\")\n",
    "        \n",
    "            if coupon_section.has_attr('data-href'):\n",
    "                line['href'] = \"https://www.goodrx.com\" +coupon_section['data-href']\n",
    "            else:\n",
    "                line['href'] = ''\n",
    "            \n",
    "            # ignore membership types\n",
    "            if 'Membership' not in line['qualifier'] and line['price'] != '$':\n",
    "                price_list.append(line)\n",
    "\n",
    "    return price_list\n",
    "\n",
    "# scrape GoodRx for name of Rx\n",
    "def lookup_GoodRx_name(drug, r=None):\n",
    "    if not r:\n",
    "        status, response = http.request(\"https://www.goodrx.com/%s\" % drug.replace(' ','+') )\n",
    "        r = response.decode(\"utf-8\")\n",
    "    # check for failed lookup\n",
    "    if \"everywhere\" in r:\n",
    "        return look_for_suggestions(r)\n",
    "    else:\n",
    "        return drug\n",
    "\n",
    "# scrape GoodRx for drug prices\n",
    "def lookup_GoodRx_prices(drug, dosage=None):\n",
    "    prices = []\n",
    "    if dosage:\n",
    "        status, response = http.request(\"https://www.goodrx.com/%s?dosage=%s\" % (drug, dosage))\n",
    "    else:\n",
    "        status, response = http.request(\"https://www.goodrx.com/%s\" % drug)\n",
    "                                            \n",
    "    soup = BeautifulSoup(response, 'html.parser')\n",
    "    resp = response.decode(\"utf-8\")\n",
    "    # check for failed lookup\n",
    "    if lookup_GoodRx_name(drug, resp) != drug:\n",
    "        print (\"do you mean '%s'?\" % lookup_GoodRx_name(drug, resp))\n",
    "    else:\n",
    "        price_list = find_prices(soup)\n",
    "        price_list = sorted(price_list, key=lambda k: float(k['price']))\n",
    "        price_range = \"Price range: $%s - $%s\" % (price_list[0]['price'], price_list[len(price_list)-1]['price'])\n",
    "        for p in price_list:\n",
    "            prices.append({\"store\": p['store'], \"price\": p['price'], \"cash-price\": p['cash-price'], \"qualifier\": p['qualifier'], \"href\": p['href']})\n",
    "        return price_range, prices\n",
    "\n",
    "# lookup location for business near city/state on a price list\n",
    "def lookup_biz_list(price_list, city, state, debug=False):\n",
    "    if not price_list:\n",
    "        return {}\n",
    "    \n",
    "    PRICE_RANGE = 1.3   # within 30% of lowest price\n",
    "    result_list = []\n",
    "    # skip 1st entry (price range)\n",
    "    for p in price_list:\n",
    "        store = p['store']\n",
    "        # clean up store labels\n",
    "        if \"(CVS)\" in store:\n",
    "            store = store.replace('(CVS)', '')\n",
    "        if \"Pharmacy\" in store:\n",
    "            store = store.replace('Pharmacy', '')\n",
    "        if 'Sams' in store:\n",
    "            store = store.replace('Sams', \"Sam's\")\n",
    "        if 'Rite-Aid' in store:\n",
    "            store = store.replace('Rite-Aid', 'Rite Aid')\n",
    "\n",
    "        if debug: print (store, city, state)\n",
    "        biz = find_biz(term = store, location = city + '+' + state, debug=debug)\n",
    "        \n",
    "        if biz:\n",
    "            #print (p['store'], '$'+p['price'], biz[0]['city'], biz[0]['state'], biz[0]['address'], \"{0:.2f}mi\".format(biz[0]['distance']) )\n",
    "            result_list.append({\"store\": p['store'], \"price\": p['price'], \"cash-price\": p['cash-price'], \"city\": biz[0]['city'], \"address\": biz[0]['address'], \"state\": biz[0]['state'], \"coupon\": p['href']})\n",
    "\n",
    "            # once we have first biz, break (list provided needs to be sorted by price)\n",
    "            break\n",
    "\n",
    "    if result_list:\n",
    "        cheapest_coupon = sorted([r for r in result_list if float(r['price']) < float(result_list[0]['price'])*PRICE_RANGE], key=lambda k: float(k['price']))\n",
    "        cheapest_cash = sorted([r for r in result_list if float(r['price']) < float(result_list[0]['price'])*PRICE_RANGE], key=lambda k: float(k['cash-price']))\n",
    "\n",
    "        return {\"best-coupon\": cheapest_coupon[0], \"best-cash\": cheapest_cash[0], \"list\": result_list}\n",
    "    \n",
    "# figure out best price\n",
    "def best_price(price_list, city, state, debug=False):\n",
    "    # first sorted by price\n",
    "    prices = sorted(price_list, key=lambda k: float(k['price']))\n",
    "    if debug: print (\"searching for best coupon price\")\n",
    "    best_coupon = lookup_biz_list(prices, city, state, debug=debug)['best-coupon']\n",
    "    # first sorted by cash-price\n",
    "    prices = sorted(prices, key=lambda k: float(k['cash-price']))\n",
    "    if debug: print (\"searching for best cash price\")\n",
    "    best_cash = lookup_biz_list(prices, city, state, debug=debug)['best-cash']\n",
    "    \n",
    "    # try comparing prices, if error return coupon price\n",
    "    try:\n",
    "        if float(best_cash['cash-price']) <= float(best_coupon['price']):\n",
    "            best_cash['price'] = best_cash['cash-price']\n",
    "            best_cash['type'] = 'cash'\n",
    "            best_cash.pop(\"cash-price\", 'one price')\n",
    "            best_cash.pop(\"coupon\", 'no coupon')\n",
    "            return best_cash\n",
    "        else:\n",
    "            best_coupon['type'] = 'coupon'\n",
    "            best_coupon.pop(\"cash-price\", 'no price')\n",
    "            return best_coupon\n",
    "    except:\n",
    "        best_coupon['type'] = 'coupon'\n",
    "        best_coupon.pop(\"cash-price\", 'no price')\n",
    "        return best_coupon\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# restore all of our data structures\n",
    "import pickle\n",
    "data = pickle.load( open( \"Rx_training_data\", \"rb\" ) )\n",
    "words = data['words']\n",
    "classes = data['classes']\n",
    "train_x = data['train_x']\n",
    "train_y = data['train_y']\n",
    "\n",
    "# import our chat-bot intents file\n",
    "import json\n",
    "with open('intents_Rx.json') as json_data:\n",
    "    intents = json.load(json_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Build neural network structure\n",
    "net = tflearn.input_data(shape=[None, len(train_x[0])])\n",
    "net = tflearn.fully_connected(net, 8)\n",
    "net = tflearn.fully_connected(net, 8)\n",
    "net = tflearn.fully_connected(net, len(train_y[0]), activation='softmax')\n",
    "net = tflearn.regression(net)\n",
    "\n",
    "# Define model and setup tensorboard\n",
    "model = tflearn.DNN(net, tensorboard_dir='tflearn_logs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# clean up a sentence with stemming and lower-case\n",
    "def clean_up_sentence(sentence):\n",
    "    # tokenize the pattern\n",
    "    sentence_words = nltk.word_tokenize(sentence)\n",
    "    # stem each word\n",
    "    sentence_words = [stemmer.stem(word.lower()) for word in sentence_words]\n",
    "    return sentence_words\n",
    "\n",
    "# return bag of words array: 0 or 1 for each word in the bag that exists in the sentence\n",
    "def bow(sentence, words, show_details=False):\n",
    "    # tokenize the pattern\n",
    "    sentence_words = clean_up_sentence(sentence)\n",
    "    # bag of words\n",
    "    bag = [0]*len(words)  \n",
    "    for s in sentence_words:\n",
    "        for i,w in enumerate(words):\n",
    "            if w == s: \n",
    "                bag[i] = 1\n",
    "                if show_details:\n",
    "                    print (\"found in bag: %s\" % w)\n",
    "\n",
    "    return(np.array(bag))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# load our saved model\n",
    "model.load('./Rxmodel.tflearn')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# create a dictionary to hold user context\n",
    "context = {}\n",
    "\n",
    "# ignore classifications with a probability BELOW a set threshold \n",
    "ERROR_THRESHOLD = 0.25\n",
    "\n",
    "# generate an intent classification for a sentence\n",
    "def classify(sentence):\n",
    "    # generate probabilities from the model\n",
    "    results = model.predict([bow(sentence, words)])[0]\n",
    "    # filter out predictions below a threshold\n",
    "    results = [[i,r] for i,r in enumerate(results) if r>ERROR_THRESHOLD]\n",
    "    # sort by strength of probability\n",
    "    results.sort(key=lambda x: x[1], reverse=True)\n",
    "    return_list = []\n",
    "    for r in results:\n",
    "        return_list.append((classes[r[0]], r[1]))\n",
    "    # return tuple of intent and probability\n",
    "    return return_list\n",
    "\n",
    "# process contextual response, userID is unique cell # (eg. SMS conversation)\n",
    "def response(sentence, userID='5612779900', show_details=False):\n",
    "    # establish a context for each unique userID (cell #)\n",
    "    if userID not in context:\n",
    "        context[userID] = {}\n",
    "    \n",
    "    # check if the most recent context is a get... if so we take the response\n",
    "    if 'context' in context[userID] and 'get' in context[userID]['context']:\n",
    "        # the label is what's after the 'get'\n",
    "        label = context[userID]['context'].replace('get', '')\n",
    "        context[userID][label] = sentence\n",
    "        # transfer control to the corresponding intent to handle the response\n",
    "        next_intent = \"handle%s\" % label\n",
    "        results = [(next_intent, 1.0)]\n",
    "    \n",
    "    else:\n",
    "        results = classify(sentence)\n",
    "    # loop as long as there are matches to process\n",
    "    while results:\n",
    "        for i in intents['intents']:\n",
    "            # find a tag matching the first result\n",
    "            if i['tag'] == results[0][0]:\n",
    "                # set context for this intent if necessary\n",
    "                if 'context' in i:\n",
    "                    if show_details: print ('context:', i['context'])\n",
    "                    \n",
    "                    # handle an informational context\n",
    "                    if 'handle' in i['context']:\n",
    "                        label = i['context'].replace('handle', '')\n",
    "                        location = lookup_number(userID)\n",
    "                        if show_details:\n",
    "                            print ('    location', userID, location)  \n",
    "                        \n",
    "                        # get GoodRx store/price list\n",
    "                        _, price_list = lookup_GoodRx_prices(lookup_GoodRx_name(context[userID][label]))\n",
    "                        if show_details:\n",
    "                            print ('    looking up', context[userID][label])\n",
    "\n",
    "                        best = None\n",
    "                        if price_list:\n",
    "                            # determine the best price for our location\n",
    "                            best = best_price(price_list, location['city'], location['state'])\n",
    "\n",
    "                        if show_details:\n",
    "                            print (best)\n",
    "                        if best:\n",
    "                            # formulate response\n",
    "                            response = \"best price on %s is $%s (%s) at %s, %s %s\" % \\\n",
    "                                       (lookup_GoodRx_name(context[userID][label]), best['price'], best['type'], \\\n",
    "                                        best['store'], best['address'], best['city'])\n",
    "                            if 'coupon' in best:\n",
    "                                context[userID]['coupon'] = best['coupon']\n",
    "                            del context[userID]['context']\n",
    "                            return response\n",
    "                        \n",
    "                    # handle a coupon request\n",
    "                    elif 'coupon' in i['context']:\n",
    "                        if 'coupon' in context[userID]:\n",
    "                            response = \"use this coupon: %s\" % context[userID]['coupon']\n",
    "                            del context[userID]['coupon']\n",
    "                            return response\n",
    "\n",
    "                    else:\n",
    "                        context[userID]['context'] = i['context']\n",
    "\n",
    "                if show_details: print ('tag:', i['tag'])\n",
    "                # a random response from the intent\n",
    "                if i['responses']:\n",
    "                    return print(random.choice(i['responses']))\n",
    "\n",
    "        results.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'city': 'JUPITER', 'state': 'FL'}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lookup_number('5612779900')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'address': '2144 W Indiantown Rd',\n",
       "  'city': 'Jupiter',\n",
       "  'state': 'FL',\n",
       "  'zip': '33458'}]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_biz('Walmart', 'Jupiter FL')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lipitor'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lookup_GoodRx_name('lipator')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Price range: $40.56 - $61.65',\n",
       " [{'cash-price': '40.56',\n",
       "   'href': 'https://www.goodrx.com/coupon/dispatch/AWMziVOCiFlqvtP7z3odkXZpVeSXa9C2wtY8CmilXWPxrpiVwf3djSPezii8utNNDfwN7ybmovzaZNofZw_PtwPL2FmknVMrFXimLMk6-xjTtQts55hHLg%3D%3D',\n",
       "   'price': '40.56',\n",
       "   'qualifier': 'with free Coupon',\n",
       "   'store': 'Costco'},\n",
       "  {'cash-price': '110',\n",
       "   'href': 'https://www.goodrx.com/coupon/dispatch/qaErjeUjT4CpPyTHK_XuwAenlnHUw0N2lmNuQQn_lXIKplfLwtV1E-XUmXsC00co-qXancbo8BkGdkwaI3UOJGvkq5UxQi6WfqH-8pyQ3B8k3epVl4KeCA%3D%3D',\n",
       "   'price': '40.56',\n",
       "   'qualifier': 'with free Coupon',\n",
       "   'store': 'Safeway'},\n",
       "  {'cash-price': '103',\n",
       "   'href': 'https://www.goodrx.com/coupon/dispatch/9Tw7GeJkdYKYHN5fl4qG1gycslG9l85MwkMdFJ61kpvJEn8YPH_s18I0j7N6ks_KhcwJ-8O6L2MBFAWtVYRkPwcuDJW4lbTbdMyQkk9X5dfisrB6',\n",
       "   'price': '40.91',\n",
       "   'qualifier': 'with free Coupon',\n",
       "   'store': 'Kroger Pharmacy'},\n",
       "  {'cash-price': '41.00',\n",
       "   'href': 'https://www.goodrx.com/coupon/dispatch/kZquF9cmQgjTz53Jb7cEbWCrATlMdII1fajhmP6teinnqqwLcBrZy38VFCwWj3tpjv4oN3kJaUhI1qUP-BqVYf_OihZ20kn2PTuP',\n",
       "   'price': '41.00',\n",
       "   'qualifier': 'with free Discount',\n",
       "   'store': 'Walgreens'},\n",
       "  {'cash-price': '84',\n",
       "   'href': 'https://www.goodrx.com/coupon/dispatch/PBYxFOW2PEZzHvGWCEV3xZPxCBJjTeVKYuAHmAezQP4Kwpkg-PGzYX8iGbPsywdidg4h7nh7Sac1MTN-fVMsHFzBa4EDVFEqR0v7lluEgPU0',\n",
       "   'price': '45.46',\n",
       "   'qualifier': 'with free Coupon',\n",
       "   'store': 'CVS Pharmacy'},\n",
       "  {'cash-price': '84',\n",
       "   'href': 'https://www.goodrx.com/coupon/dispatch/NfsDCnb9h_0XF-3UPgU7pFUGUpdl6tUrkJ2r_5ikW-cWnSwPJgMELikyEabwES6dTOfw6sGR9aM6WaFFCZ7JrfpKiXupSGkn4xA%3D',\n",
       "   'price': '48.10',\n",
       "   'qualifier': 'with free Coupon',\n",
       "   'store': 'Target (CVS)'},\n",
       "  {'cash-price': '55.70',\n",
       "   'href': 'https://www.goodrx.com/coupon/dispatch/_XCxXdwS9wJRIyvCoRJ-dhugEwhNXP7byJfhjSTkSQzpaoXmCZfci_mINgJ-x2afgpIX0UScz7ZZqOOZlDA5JPeTAQ1LWjpD2pU%3D',\n",
       "   'price': '55.70',\n",
       "   'qualifier': 'with free Discount',\n",
       "   'store': 'Walmart'},\n",
       "  {'cash-price': '61.65',\n",
       "   'href': 'https://www.goodrx.com/coupon/dispatch/Vtxrl_2fP3hAIXnsQh-N8s1Iy4Sd2yVDS2MTNw2X6UOgIyseu7337a9AjL-uFx1z9Z6zUNaaq5C4tsra1_G-jIoirhlBAr3JHhXOJZV2',\n",
       "   'price': '61.65',\n",
       "   'qualifier': 'with free Coupon',\n",
       "   'store': 'Kmart'}])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lookup_GoodRx_prices('adderall')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'address': '3250 Northlake Blvd',\n",
       " 'city': 'Palm Beach Gardens',\n",
       " 'price': '40.56',\n",
       " 'state': 'FL',\n",
       " 'store': 'Costco',\n",
       " 'type': 'cash'}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = \"adderall\"\n",
    "_, price_list = lookup_GoodRx_prices(lookup_GoodRx_name(name))\n",
    "if price_list:\n",
    "    best = best_price(price_list, \"Jupiter\", \"FL\")\n",
    "\n",
    "best"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('greeting', 0.9999843835830688)]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classify('hi there, anyone home?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi there\n"
     ]
    }
   ],
   "source": [
    "response('hi there, anyone home?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's the name of the medication?\n"
     ]
    }
   ],
   "source": [
    "response('looking for inexpensive meds')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "context: handleRx\n",
      "    location 5612779900 {'state': 'FL', 'city': 'JUPITER'}\n",
      "    looking up lipitor\n",
      "{'store': 'Safeway', 'city': 'Jupiter', 'price': '10.55', 'coupon': 'https://www.goodrx.com/coupon/dispatch/yGeOpPGn-I_h93JIaT2CzDwiQiKzZog2fh4rR7svd2brqqRdqFEBWyoHXq6q4lFHnThY_dRpgFdawV3LVbwc1uxKyZYDBPrWU4vveERmFXyUyA%3D%3D', 'address': '709 Commerce Way W', 'type': 'coupon', 'state': 'FL'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'best price on lipitor is $10.55 (coupon) at Safeway, 709 Commerce Way W Jupiter'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response('lipitor', show_details=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'5612779900': {'Rx': 'lipitor',\n",
       "  'coupon': 'https://www.goodrx.com/coupon/dispatch/yGeOpPGn-I_h93JIaT2CzDwiQiKzZog2fh4rR7svd2brqqRdqFEBWyoHXq6q4lFHnThY_dRpgFdawV3LVbwc1uxKyZYDBPrWU4vveERmFXyUyA%3D%3D'}}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'use this coupon: https://www.goodrx.com/coupon/dispatch/yGeOpPGn-I_h93JIaT2CzDwiQiKzZog2fh4rR7svd2brqqRdqFEBWyoHXq6q4lFHnThY_dRpgFdawV3LVbwc1uxKyZYDBPrWU4vveERmFXyUyA%3D%3D'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response('can I have the coupon?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'5612779900': {'Rx': 'lipitor'}}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's the name of the medication?\n"
     ]
    }
   ],
   "source": [
    "response('looking for inexpensive meds')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'best price on Adderall is $40.56 (cash) at Costco, 3250 Northlake Blvd Palm Beach Gardens'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response('Aderal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'5612779900': {'Rx': 'Aderal'}}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorry, no coupon\n"
     ]
    }
   ],
   "source": [
    "response('may I have the coupon?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My pleasure\n"
     ]
    }
   ],
   "source": [
    "response('thanks for your help')"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}