fire-incidents-open-data-portal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Wake County Fire Incidents - Open Data Portal\n",
    " \n",
    " \n",
    " Using data from the Wake County Open Data Portal:\n",
    " \n",
    " - [Fire Incidents](https://data-wake.opendata.arcgis.com/datasets/ral::fire-incidents)\n",
    "  - All EMS-related calls (codes 300-399 and 661) are missing\n",
    "  - The entire month of October 2018 is missing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standard notebook setup\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the Fire Incidents file as a [Pandas](http://pandas.pydata.org/pandas-docs/stable/10min.html) data frame, indexed by dispatch time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded 177738 incidents\n"
     ]
    }
   ],
   "source": [
    "df = fire_incidents = pd.read_csv('data/Fire_Incidents.csv',\n",
    "                                  index_col='dispatch_date_time')\n",
    "print(\"Loaded\", len(df), \"incidents\")  # 177738"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data cleanup and filtering\n",
    "\n",
    "The raw data needs some work before we can use it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "176284\n"
     ]
    }
   ],
   "source": [
    "# Convert index to correct data type\n",
    "df.index = pd.to_datetime(df.index)\n",
    "\n",
    "# Sort rows by time, using a stable sort\n",
    "df.sort_index(inplace=True, kind='mergesort')\n",
    "\n",
    "# Filter out rows with missing/invalid dispatch times\n",
    "print(len(df[df.index.notnull()]))  # 176284\n",
    "df.drop(df.index[sum(df.index.notnull()):], inplace=True)\n",
    "\n",
    "# Count incidents by month and year\n",
    "monthly = df.groupby(pd.Grouper(freq='M')).count()\n",
    "yearly = df.groupby(pd.Grouper(freq='Y')).count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Call Volume by Month\n",
    "\n",
    "This graph shows the number of reported fire incidents per month for every month since the data began, except for the last month which usually has incomplete data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"997\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "text = \"Wake County Fire Incidents by Month\"\n",
    "p = monthly['incident_number'][:-1].plot(title=text)\n",
    "# p = plt.plot(monthly.index, monthly['incident_number'])"
   ]
  }
 ],
 "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}