etc/notebooks/declarativewidgets/meetup_outreach_demo/meetup-outreach.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 2,
        "hidden": false,
        "row": 0,
        "width": 6
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "# Meetup Outreach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "This notebook shows how you can use [Spark Streaming](http://spark.apache.org/streaming/) to acquire and process data from the [meetup.com RSVP API](http://www.meetup.com/meetup_api/docs/stream/2/rsvps/#websockets), then display it in an actionable dashboard using [declarative widgets](https://github.com/jupyter-incubator/declarativewidgets). In contrast with our [other streaming demo](../../stream_demo/streaming-demo.ipynb), this notebook provides less tutorial instruction, but has a more realistic use case:\n",
    "\n",
    "> You have a product or service that you want to promote. One way of doing this is through local meetups. There are already some meetups affiliated with your offering, but you want to increase attendance. You could search meetup.com for other meetups related to your own and message attendees. However, you worry about spamming people with irrelevant and untimely information.\n",
    "\n",
    "> Instead, you create a notebook that continuously identifies people actively RSVPing for meetups near to your own and with themes similar to yours. You also code this notebook to track *conversions*, people whom you contact that later RSVP for your meetup. You deploy this notebook as a dashboard and actively monitor it. You pick and choose who to contact from the identified attendees in a timely manner, while they're thinking about other meetups. You track successful conversions to see what contact strategies work and which do not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "On your first visit to this notebook, you'll need to at least put your meetup.com API key in the configuration section. We recommend that you execute one cell at a time as you read along. Later, if you  just want to see the demo, select *Cell > Run All* from the menu bar. Once you've run all of the cells, select *View > View Dashboard* and then click on the **Stream** toggle to start the data stream.\n",
    "\n",
    "**Table of Contents**\n",
    "\n",
    "1. [Configuration](#Configuration)\n",
    "2. [Upcoming Meetups](#Upcoming-Meetups)\n",
    "3. [RSVPs Stream](#RSVPs-Stream)\n",
    "    1. [Conversions](#Conversions)\n",
    "4. [Widgets](#Widgets)\n",
    "    1. [Meetups List](#Meetups-List)\n",
    "    2. [Dashboard Heading](#Dashboard-Heading)\n",
    "    2. [Total RSVPs Plot](#Total-RSVPs-Plot)\n",
    "    3. [Candidates List](#Candidates-List)\n",
    "5. [Setup Streaming](#Setup-streaming)\n",
    "6. [Demo Mode](#Demo-Mode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\" style=\"margin-top: 10px\">\n",
    "<p><strong>Note</strong><p>\n",
    "\n",
    "<p>We've condensed all of the demo logic into a single notebook for educational purposes. If you want to turn this into a scalable, multi-tenant dashboard, you'll want to separate the stream processing portions from the dashboard view. That way, multiple dashboard instances can pull from the same processed data stream instead of recomputing it.</p>\n",
    "\n",
    "<p>Requires Declarative Widgets v0.6.0+.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import shutil\n",
    "import tempfile\n",
    "import os\n",
    "import time\n",
    "import json\n",
    "import sys\n",
    "from tornado.websocket import websocket_connect\n",
    "from pyspark import SparkContext\n",
    "from pyspark.streaming import StreamingContext\n",
    "from datetime import datetime, timedelta\n",
    "import matplotlib.pyplot as plt\n",
    "from functools import reduce, partial\n",
    "\n",
    "from declarativewidgets import channel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {}
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "import declarativewidgets as widgets\n",
    "\n",
    "widgets.init()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "## Configuration\n",
    "\n",
    "The Meetup API requires authentication. You can get your API key [here](https://secure.meetup.com/meetup_api/key/). Enter the key below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "API_KEY = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "The topic on which to search for our upcoming meetups."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "PROD_TOPIC = 'bluemix'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "How often (in seconds) to update the upcoming meetups list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "PROD_TIMER = 3600"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "To determine potential matches, define a relevant topic list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "RELEVANT_TOPICS = ['paas', 'cloud', 'cloud-computing', 'cloud-foundry', 'devops', 'internet-of-things', 'data-analytics', 'saas-software-as-a-service', 'iaas-infrastructure-as-a-service', 'openstack', 'docker', 'nodejs']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "Threshold (in km). Candidates farther away than this distance from one of the upcoming meetups are discarded:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "DIST_THRESHOLD = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "Span of time over which to calculate change in meetups RSVP counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "MU_CHANGE_CUTOFF = timedelta(weeks=1)\n",
    "MU_CHANGE_LABEL = 'Change in last week'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "For **demo** purposes, define this to `True`. The notebook will randomly select to \"contact\" a candidate from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "DEMO = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "## Upcoming Meetups\n",
    "\n",
    "The code in this section queries the meetup API for your upcoming meetups using a topic string of interest (e.g., `bluemix`). These are the meetups at which you're trying to increase attendance. The code here polls the meetup.com API open events endpoint on a long interval to show the increase / decrease of RSVPs at your meetups.\n",
    "\n",
    "We don't take advantage of Spark streaming for these actions because the data is small and rarely changing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "from html.parser import HTMLParser\n",
    "import tornado.ioloop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "# list of Meetup Event records; result of search on PROD_TOPIC keywords\n",
    "upcoming_meetups = []\n",
    "\n",
    "# dict indexed by Meetup Event ID; each entry is a list of\n",
    "# [datetime, total count of \"yes\" RSVPs, total count of conversions]\n",
    "rsvp_count_history = {}\n",
    "\n",
    "# list of tuples containing the \"yes\" RSVP counts for all of the\n",
    "# upcoming meetups, as well as the total conversions\n",
    "total_rsvp_count = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "mu_events_url = \"https://api.meetup.com/2/open_events\"\n",
    "params = {'topic':PROD_TOPIC, 'key':API_KEY}\n",
    "loop = tornado.ioloop.IOLoop.current()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class MLStripper(HTMLParser):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.reset()\n",
    "        self.fed = []\n",
    "    def handle_data(self, d):\n",
    "        self.fed.append(d)\n",
    "    def get_data(self):\n",
    "        return ''.join(self.fed)\n",
    "\n",
    "def strip_tags(html):\n",
    "    s = MLStripper()\n",
    "    s.feed(html)\n",
    "    return s.get_data()\n",
    "\n",
    "def get_venue(x):\n",
    "    if 'venue' not in x:\n",
    "        return '-'\n",
    "\n",
    "    v = x['venue']\n",
    "    city = v['city']\n",
    "    if v['country'] == 'us':\n",
    "        return '{}, {}'.format(city, v['state'])\n",
    "    else:\n",
    "        return '{} ({})'.format(city, v['country'].upper())\n",
    "\n",
    "def map_mus(x):\n",
    "    x['description'] = strip_tags(x['description']) if 'description' in x else ''\n",
    "    x['group']['url'] = \"http://meetup.com/{}\".format(x['group']['urlname'])\n",
    "    x['venue_loc'] = get_venue(x)\n",
    "    return x\n",
    "\n",
    "def update_meetups_values():\n",
    "    global upcoming_meetups\n",
    "    global rsvp_count_history\n",
    "    global total_rsvp_count\n",
    "\n",
    "    now = datetime.now()\n",
    "    cutoff = now - MU_CHANGE_CUTOFF\n",
    "    \n",
    "    for mu in upcoming_meetups:\n",
    "        id = mu['id']\n",
    "        prev_conv_count = 0 # running total for conversions\n",
    "        if id not in rsvp_count_history:\n",
    "            rsvp_count_history[id] = []\n",
    "        else:\n",
    "            # carry previous conversions count forward\n",
    "            prev_conv_count = rsvp_count_history[id][-1][2]\n",
    "\n",
    "        # store the RSVP count for each event at this time\n",
    "        rsvp_count_history[id].append([now, mu['yes_rsvp_count'], prev_conv_count])\n",
    "        # cleanup old rsvp history values\n",
    "        rsvp_count_history[id] = list(filter(lambda x: x[0] > cutoff, rsvp_count_history[id]))\n",
    "\n",
    "        # save change in rsvp count over time span\n",
    "        mu['change_over_time'] = rsvp_count_history[id][-1][1] - rsvp_count_history[id][0][1]\n",
    "\n",
    "    # update the total number of RSVPs for all of upcoming meetups\n",
    "    total_rsvp_count.append((now,\n",
    "            reduce(lambda x, y: x + y['yes_rsvp_count'], upcoming_meetups, 0),\n",
    "            reduce(lambda x, y: x + y[-1][2], rsvp_count_history.values(), 0)\n",
    "    ))\n",
    "    # cleanup old values\n",
    "    list(filter(lambda x: x[0] > cutoff, total_rsvp_count))\n",
    "\n",
    "def refresh_meetups_list():\n",
    "    '''\n",
    "    Update the data for the upcoming meetup events. Once invoked, will run every\n",
    "    PROD_TIMER seconds.\n",
    "    \n",
    "    Publishes data on the 'meetups' and 'plots' channels.\n",
    "    '''\n",
    "    global upcoming_meetups\n",
    "\n",
    "    # request updated meetups data\n",
    "    r = requests.get(mu_events_url, params=params)\n",
    "    upcoming_meetups = list(map(map_mus, r.json()['results']))\n",
    "    # update values, comparing old vs new data\n",
    "    update_meetups_values()\n",
    "    # reschedule\n",
    "    loop.call_later(PROD_TIMER, refresh_meetups_list)\n",
    "\n",
    "    # broadcast the updated list\n",
    "    channel('meetups').set('list', upcoming_meetups)\n",
    "    fig = plot_total_rsvps(total_rsvp_count)\n",
    "    channel('plots').set('total_rsvp_plot', fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "## RSVPs Stream\n",
    "\n",
    "Here we define functions for identifying users that may also be interested in attending your meetups. The code here works relies on a Spark streaming context hooked to the meetup.com RSVP stream. It selects candidates assocated with RSVPs that meet all of these conditions:\n",
    "\n",
    "1. The RSVP is affirmative\n",
    "2. The RSVP has at least one of the RELEVANT_TOPICS\n",
    "3. The RSVP is to a venue within DIST_THRESHOLD of one of your meetup venues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "conversions = [];\n",
    "\n",
    "def process_rsvps(ssc, queue):\n",
    "    '''Initiates processing of the RSVPs stream.'''\n",
    "    msgs = ssc.textFileStream(queue)\n",
    "    \n",
    "    # Each event is a JSON blob. Parse it. Filter it.\n",
    "    rsvps = msgs.map(lambda json_str: json.loads(json_str))\n",
    "\n",
    "    process_candidates(rsvps)\n",
    "    process_conversions(rsvps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "def process_candidates(rsvps):\n",
    "    '''\n",
    "    Generate a list of candidates from the incoming stream, filtering on\n",
    "    relevant topics and distance.\n",
    "    '''\n",
    "    filtered_rsvps = filter_rsvps(rsvps)\n",
    "    candidate_rsvps = compute_closeness(filtered_rsvps)\n",
    "    member_data = get_members(candidate_rsvps)\n",
    "    gen_candidate_list(member_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def filter_rsvps(rsvps):\n",
    "    '''\n",
    "    Filter out RSVPs that don't have our relevant topics,\n",
    "    contain PROD_TOPIC or are not \"yes\" responses.\n",
    "    '''\n",
    "    return rsvps.filter(topic_filter)\n",
    "\n",
    "def topic_filter(rsvp):\n",
    "    return (rsvp['response'] == 'yes' and\n",
    "            all(topic['urlkey'] != PROD_TOPIC for topic in rsvp['group']['group_topics']) and\n",
    "            any(topic['urlkey'] in RELEVANT_TOPICS for topic in rsvp['group']['group_topics']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# from http://www.johndcook.com/blog/python_longitude_latitude/\n",
    "import math\n",
    "\n",
    "def distance_on_unit_sphere(lat1, long1, lat2, long2):\n",
    "    '''Returns distance (in km) between two points on globe'''\n",
    " \n",
    "    # Convert latitude and longitude to \n",
    "    # spherical coordinates in radians.\n",
    "    degrees_to_radians = math.pi/180.0\n",
    "         \n",
    "    # phi = 90 - latitude\n",
    "    phi1 = (90.0 - lat1)*degrees_to_radians\n",
    "    phi2 = (90.0 - lat2)*degrees_to_radians\n",
    "         \n",
    "    # theta = longitude\n",
    "    theta1 = long1*degrees_to_radians\n",
    "    theta2 = long2*degrees_to_radians\n",
    "         \n",
    "    # Compute spherical distance from spherical coordinates.\n",
    "         \n",
    "    # For two locations in spherical coordinates \n",
    "    # (1, theta, phi) and (1, theta', phi')\n",
    "    # cosine( arc length ) = \n",
    "    #    sin phi sin phi' cos(theta-theta') + cos phi cos phi'\n",
    "    # distance = rho * arc length\n",
    "     \n",
    "    cos = (math.sin(phi1)*math.sin(phi2)*math.cos(theta1 - theta2) + \n",
    "           math.cos(phi1)*math.cos(phi2))\n",
    "    arc = math.acos( cos )\n",
    " \n",
    "    # Remember to multiply arc by the radius of the earth \n",
    "    # in your favorite set of units to get length.\n",
    "    #return arc\n",
    "    return arc * 6371  # radius earth = 6,371 km"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def compute_closeness(rsvps):\n",
    "    '''\n",
    "    Compute how close the candidate is to our list of upcoming events. If they\n",
    "    are farther away than DIST_THRESHOLD, filter them out.\n",
    "    '''\n",
    "    return (rsvps\n",
    "            .map(add_closest_mu)\n",
    "            .filter(lambda x: x['cmu_dist'] < DIST_THRESHOLD))\n",
    "\n",
    "def add_closest_mu(rsvp):\n",
    "    # save closest upcoming meetup\n",
    "    cmu = None\n",
    "    cmu_dist = sys.maxsize\n",
    "    # loop through our upcoming events, looking for closest\n",
    "    for mu in upcoming_meetups:\n",
    "        m = mu['group']\n",
    "        r = rsvp['group']\n",
    "        dist = distance_on_unit_sphere(m['group_lat'], m['group_lon'], r['group_lat'], r['group_lon'])\n",
    "        if dist < cmu_dist:\n",
    "            cmu = mu\n",
    "            cmu_dist = dist\n",
    "    # store this data in the RSVP record\n",
    "    rsvp['cmu'] = cmu\n",
    "    rsvp['cmu_dist'] = cmu_dist\n",
    "    return rsvp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def get_members(rsvps):\n",
    "    '''Create a member record from the RSVP record.'''\n",
    "    return rsvps.map(map_rsvp_to_member)\n",
    "\n",
    "def map_rsvp_to_member(rsvp):\n",
    "    member = ({\n",
    "        'member_id': rsvp['member']['member_id'],\n",
    "        'event': rsvp['event'],\n",
    "        'member': rsvp['member'],\n",
    "        'cmu': ({\n",
    "            'id': rsvp['cmu']['id'],\n",
    "            'name': rsvp['cmu']['name'],\n",
    "            'event_url': rsvp['cmu']['event_url']\n",
    "        }),\n",
    "        'cmu_dist': rsvp['cmu_dist']\n",
    "    })\n",
    "    # use a fallback photo for those members without one\n",
    "    if 'photo' not in member['member'] or member['member']['photo'] is None:\n",
    "        member['member']['photo'] = 'http://photos4.meetupstatic.com/img/noPhoto_50.png'\n",
    "    return member"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def gen_candidate_list(rsvps):\n",
    "    '''Publish the candidates list (member records), which notifies the UI.'''\n",
    "    rsvps.foreachRDD(update_cand_list)\n",
    "\n",
    "def update_cand_list(rsvps_rdd):\n",
    "    channel('candidates').set('cand_list', rsvps_rdd.collect())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "### Conversions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "We keep track of candidates that we have contacted. If we later see that such a candidate has made an RSVP for one of our upcoming events, we count this as a \"conversion\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "def process_conversions(rsvps):\n",
    "    '''Check the RSVP stream for \"converted\" members, updating our running total.'''\n",
    "    conversion_stream = rsvps.filter(lambda x: x['response'] == 'yes' and \n",
    "            any(topic['urlkey'] == PROD_TOPIC for topic in x['group']['group_topics']) and\n",
    "            x['member']['member_id'] in conversions)\n",
    "    conversion_stream.foreachRDD(rdd_update_conversions_count)\n",
    "\n",
    "def rdd_update_conversions_count(rdd):\n",
    "    for rsvp in rdd.collect():\n",
    "        muid = rsvp['event']['event_id']\n",
    "        if muid in rsvp_count_history:\n",
    "            # increment conversions counter in *latest* entry\n",
    "            rsvp_count_history[muid][-1][2] += 1\n",
    "        # TODO what do we do if `rsvp_count_history` doesn't have `muid`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "def candidate_contacted(id):\n",
    "    '''\n",
    "    Callback which can be used by the UI to update the list of candidates\n",
    "    we have contacted.\n",
    "    Works in conjunction with the <template> which follows.\n",
    "    '''\n",
    "    conversions.append(id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<template is=\"urth-core-bind\">\n",
    "    <urth-core-function id=\"candidateContacted\" ref=\"candidate_contacted\" arg-id=\"{{member_id}}\"></urth-core-function>\n",
    "</template"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "## Widgets\n",
    "\n",
    "In this section we import some basic widets and use them to define custom widgets for displaying meetup information in tabular form. These widgets could be defined outside the notebook and imported here to keep the notebook slimmer, but in the interest of having everything in one spot, they're done inline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<link rel=\"import\" href=\"urth_components/iron-resizable-behavior/iron-resizable-behavior.html\"\n",
    "    is=\"urth-core-import\" package=\"PolymerElements/iron-resizable-behavior\">\n",
    "<link rel=\"import\" href=\"urth_components/iron-list/iron-list.html\"\n",
    "    is=\"urth-core-import\" package=\"PolymerElements/iron-list\">\n",
    "<link rel=\"import\" href=\"urth_components/paper-toggle-button/paper-toggle-button.html\"\n",
    "    is=\"urth-core-import\" package=\"PolymerElements/paper-toggle-button\">\n",
    "<link rel=\"import\" href=\"urth_components/paper-material/paper-material.html\"\n",
    "    is=\"urth-core-import\" package=\"PolymerElements/paper-material\">\n",
    "<link rel=\"import\" href=\"urth_components/dynamic-list/dynamic-list.html\"\n",
    "    is=\"urth-core-import\" package=\"/home/jovyan/work/meetup_outreach_demo/widgets/dynamic-list\">\n",
    "<link rel=\"import\" href=\"urth_components/upcoming-meetups/upcoming-meetups.html\"\n",
    "    is=\"urth-core-import\" package=\"/home/jovyan/work/meetup_outreach_demo/widgets/upcoming-meetups\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "List local files here so they will be accessible when deployed:\n",
    "```\n",
    "dynamic-list.html\n",
    "upcoming-meetups.html\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "### Meetups List\n",
    "\n",
    "This widget creates a fancy table view showing your meetups and the change in RSVPs to them over the configured window of time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 18,
        "hidden": false,
        "row": 5,
        "width": 6
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<template is=\"urth-core-bind\" channel=\"meetups\" id=\"meetups-list-tmpl\">\n",
    "    <upcoming-meetups items=\"[[list]]\" change-label=\"[[change_label]]\"/>\n",
    "</template>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "## Dashboard Heading\n",
    "\n",
    "This widget summarizes the topic used to track your meetups and the parameters used to filter the RSVP stream."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 1,
        "height": 3,
        "hidden": false,
        "row": 2,
        "width": 10
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<template is=\"urth-core-bind\" channel=\"meetups\">\n",
    "    <style>\n",
    "        .topics-desc {\n",
    "            font-size: larger;\n",
    "        }\n",
    "        .topics-desc span {\n",
    "            font-style: italic;\n",
    "        }\n",
    "    </style>\n",
    "    <div class=\"topics-desc\">\n",
    "       Showing upcoming meetups for the <span>[[upcoming_label]]</span> topic. Meetup candidates are generated using the following topic filters: <span>[[cand_topics_label]]</span>\n",
    "    </div>\n",
    "</template>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "### Total RSVPs Plot\n",
    "\n",
    "This plot shows the total RSVPs for your upcoming meetups and highlights the RSVPs that are due to conversions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "def plot_total_rsvps(list):\n",
    "    '''\n",
    "    Create a stacked plot where the total is the number of RSVPs over a period of time,\n",
    "    and the top layer are \"converted\" RSVPs.\n",
    "    '''\n",
    "    X = [i[0] for i in list]\n",
    "    Y = [[i[1] - i[2] for i in list],  [i[2] for i in list]]\n",
    "\n",
    "    fig, ax = plt.subplots(1,1,figsize=(10,7))\n",
    "    ax.stackplot(X, *Y, baseline='zero', colors=['#2fa6e4','#82d1f5'])\n",
    "    ax.set_title('Total RSVPs for Upcoming Meetups')\n",
    "    fig.tight_layout()\n",
    "    plt.close()\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 14,
        "hidden": false,
        "row": 23,
        "width": 6
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<template is=\"urth-core-bind\" channel=\"plots\">\n",
    "    <img src={{total_rsvp_plot}}>\n",
    "</template>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "#### Initial call to update Upcoming Meetups list\n",
    "\n",
    "We have to put code for configuring the frontend widgets after their definition because widgets cannot yet pull existing data off of channel when instantiated. When [issue 35](https://github.com/jupyter-incubator/declarativewidgets/issues/35) is resolved, we can move this code up nearer to the configuration section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "refresh_meetups_list()\n",
    "channel('meetups').set('change_label', MU_CHANGE_LABEL)\n",
    "channel('meetups').set('upcoming_label', PROD_TOPIC)\n",
    "channel('meetups').set('cand_topics_label', ', '.join(RELEVANT_TOPICS))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "### Candidates List\n",
    "\n",
    "This widget creates a fancy table view showing candidates for your meetups. It can operate in one of two modes:\n",
    "\n",
    "1. Live update - table refreshes every time new candidates are identified in the stream\n",
    "2. Click to update - table shows the number of new candidates but only shows them when the user clicks the number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 6,
        "height": 32,
        "hidden": false,
        "row": 5,
        "width": 6
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<template is=\"urth-core-bind\" channel=\"candidates\">\n",
    "    <dynamic-list items=\"[[cand_list]]\" id-prop=\"member_id\" heading=\"Meetup Candidates\"></dynamic-list>\n",
    "</template>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "## Setup streaming\n",
    "\n",
    "Finally, we define functions and a simple toggle switch widget for connecting a streaming Spark context to the meetup.com RSVP stream."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def create_streaming_context(checkpoint_dir, sample_rate):\n",
    "    '''\n",
    "    Creates a new SparkContext and SparkStreamingContext. Done in a function\n",
    "    to allow repeated start/stop of the streaming. Returns the streaming\n",
    "    context instance.\n",
    "    \n",
    "    :param checkpoint_dir: Directory to use to track Spark job state\n",
    "    :param sample_rate: Stream sampling rate in seconds\n",
    "    '''\n",
    "    # create a local SparkContext to start using as many CPUs as we can\n",
    "    sc = SparkContext('local[*]')\n",
    "    \n",
    "    # wrap it in a StreamingContext that collects from the stream\n",
    "    ssc = StreamingContext(sc, sample_rate)\n",
    "\n",
    "    # Setup a checkpoint directory to keep total counts over time.\n",
    "    ssc.checkpoint(os.path.join(checkpoint_dir, '.checkpoint'))\n",
    "    \n",
    "    return ssc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class FileRingReceiver(object):\n",
    "    '''\n",
    "    Hack around lack of custom DStream receivers in Python: \n",
    "    Create a ring buffer of UTF-8 text files on disk.\n",
    "    '''\n",
    "    def __init__(self, max_batches=10):\n",
    "        self.queue = tempfile.mkdtemp()\n",
    "        self.batch_count = 0\n",
    "        self.max_batches = max_batches\n",
    "        \n",
    "    def __del__(self):\n",
    "        self.destroy()\n",
    "        \n",
    "    def put(self, text):\n",
    "        # ignore sentinels\n",
    "        if text is None: return\n",
    "        with open(os.path.join(self.queue, str(self.batch_count)), 'w', encoding='utf-8') as f:\n",
    "            f.write(text)\n",
    "        if self.batch_count >= self.max_batches:\n",
    "            oldest = str(self.batch_count - self.max_batches)\n",
    "            os.remove(os.path.join(self.queue, str(oldest)))\n",
    "        self.batch_count += 1\n",
    "        \n",
    "    def destroy(self):\n",
    "        shutil.rmtree(self.queue, ignore_errors=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "conn_future = None\n",
    "ssc = None\n",
    "receiver = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def start_stream():\n",
    "    '''\n",
    "    Creates a websocket client that pumps events into a ring buffer queue. Creates\n",
    "    a SparkStreamContext that reads from the queue. Creates the events, topics, and\n",
    "    venues DStreams, setting the widget channel publishing functions to iterate over\n",
    "    RDDs in each. Starts the stream processing.\n",
    "    '''\n",
    "    global conn_future\n",
    "    global ssc\n",
    "    global receiver\n",
    "    \n",
    "    receiver = FileRingReceiver(max_batches=100)  \n",
    "    conn_future = websocket_connect('ws://stream.meetup.com/2/rsvps', on_message_callback=receiver.put)\n",
    "    ssc = create_streaming_context(receiver.queue, 5)\n",
    "    process_rsvps(ssc, receiver.queue)\n",
    "    ssc.start()\n",
    "    \n",
    "def shutdown_stream():\n",
    "    '''\n",
    "    Shuts down the websocket, stops the streaming context, and cleans up the file ring.\n",
    "    '''\n",
    "    global conn_future\n",
    "    global ssc\n",
    "    global receiver\n",
    "    \n",
    "    conn_future.result().close()\n",
    "    ssc.stop()\n",
    "    receiver.destroy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 6,
        "height": 2,
        "hidden": false,
        "row": 0,
        "width": 6
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<template is=\"urth-core-bind\">\n",
    "    <urth-core-function id=\"streamFunc\" ref=\"start_stream\"></urth-core-function>\n",
    "    <urth-core-function id=\"shutdownFunc\" ref=\"shutdown_stream\"></urth-core-function>\n",
    "</template>\n",
    "\n",
    "<style is=\"custom-style\">\n",
    "    paper-toggle-button {\n",
    "        --default-primary-color: green;\n",
    "    }\n",
    "    \n",
    "    paper-toggle-button:hover {\n",
    "        cursor: pointer;\n",
    "    }\n",
    "        \n",
    "    .toggle-btn-container {\n",
    "        display: flex;\n",
    "        justify-content: flex-end;\n",
    "        margin: 1em 0;\n",
    "    }\n",
    "    \n",
    "    #stream-label {\n",
    "        font-size: larger;\n",
    "        margin: 0;\n",
    "        padding: 0 0.5em;\n",
    "    }\n",
    "</style>\n",
    "\n",
    "<div class=\"toggle-btn-container\">\n",
    "    <paper-toggle-button id=\"stream-btn\"></paper-toggle-button>\n",
    "    <label id=\"stream-label\">Stream</label>\n",
    "</div>\n",
    "\n",
    "<script>\n",
    "    $('#stream-btn').on('change', function() {\n",
    "        if ($(this).attr('checked')) {\n",
    "            // start streaming\n",
    "            console.warn('Starting Spark Streaming');\n",
    "            $('#streamFunc').get(0).invoke();\n",
    "        } else {\n",
    "            // stop streaming\n",
    "            console.warn('Stopping Spark Streaming');\n",
    "            $('#shutdownFunc').get(0).invoke();\n",
    "        }\n",
    "    });\n",
    "</script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "## Demo Mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "In order to run a standalone demo, the following code will (if `DEMO` is set to `True`) periodically simulate a mouse click on the contact button for a random candidate in the list. This will make it so that the rest of the code considers this as a \"conversion\". Over time, as \"converted\" members also sign up for one of the upcoming events in our list, the plot will show two different colors, the top one signifying the number of \"converted\" candidates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<urth-core-channel name=\"demo\" id=\"demoChan\"></urth-core-channel>\n",
    "<script>\n",
    "    (function() {\n",
    "        var demoChan = document.getElementById('demoChan');\n",
    "        demoChan.watch('on', function(e) {\n",
    "            console.log('STARTING DEMO MODE');\n",
    "            setInterval(function() {\n",
    "                var list = document.querySelector('dynamic-list');\n",
    "                if (list) {\n",
    "                    list._simulateContactClick();\n",
    "                }\n",
    "            }, 60000);\n",
    "            demoTmpl.removeEventListener('channelSetItem', startDemoMode);\n",
    "        });\n",
    "    })();\n",
    "</script>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "if DEMO:\n",
    "    channel('demo').set('on', 1)"
   ]
  }
 ],
 "metadata": {
  "extensions": {
   "jupyter_dashboards": {
    "activeView": "grid_default",
    "version": 1,
    "views": {
     "grid_default": {
      "cellMargin": 10,
      "defaultCellHeight": 20,
      "maxColumns": 12,
      "name": "grid",
      "type": "grid"
     },
     "report_default": {
      "name": "report",
      "type": "report"
     }
    }
   }
  },
  "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
}