2020-03-15_interactive_data_visualization_with_bokeh.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Notebook Author: [Trenton McKinney](https://trenton3983.github.io/)\n",
    "- Course: **[DataCamp: Interactive Data Visualization with Bokeh](https://learn.datacamp.com/courses/interactive-data-visualization-with-bokeh)**\n",
    "- This [notebook](https://github.com/trenton3983/DataCamp/blob/master/2020-03-15_interactive_data_visualization_with_bokeh.ipynb) was created as a reproducible reference.\n",
    "- The material is from the course\n",
    "- I completed the exercises\n",
    "- If you find the content beneficial, consider a [DataCamp Subscription](https://www.datacamp.com/pricing?period=yearly).\n",
    "- I added a function (**`create_dir_save_file`**) to automatically download and save the required data (`data/2020-03-15_interactive_data_visualization_with_bokeh`) and image (`Images/2020-03-15_interactive_data_visualization_with_bokeh`) files.\n",
    "- The notebook code has be updated to work with Bokeh 3.4.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Course Description\n",
    "\n",
    "Bokeh is an interactive data visualization library for Python, and other languages, that targets modern web browsers for presentation. It can create versatile, data-driven graphics and connect the full power of the entire Python data science stack to create rich, interactive visualizations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from pprint import pprint as pp\n",
    "from itertools import combinations\n",
    "from pathlib import Path\n",
    "import requests\n",
    "import numpy as np\n",
    "from bokeh.io import output_notebook, curdoc  # output_file\n",
    "from bokeh.plotting import figure, show\n",
    "from bokeh.sampledata.iris import flowers\n",
    "from bokeh.sampledata.iris import flowers as iris_df\n",
    "from bokeh.models import ColumnDataSource, HoverTool, CategoricalColorMapper, Slider, Column, Select\n",
    "from bokeh.models import CheckboxGroup, RadioGroup, Toggle, Button\n",
    "from bokeh.models import TabPanel, Tabs\n",
    "from bokeh.layouts import row, column, gridplot\n",
    "from bokeh.palettes import Spectral6\n",
    "from bokeh.themes import Theme\n",
    "import yaml\n",
    "\n",
    "output_notebook()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pandas Configuration Options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', 200)\n",
    "pd.set_option('display.max_rows', 300)\n",
    "pd.set_option('display.expand_frame_repr', True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dir_save_file(dir_path: Path, url: str):\n",
    "    \"\"\"\n",
    "    Check if the path exists and create it if it does not.\n",
    "    Check if the file exists and download it if it does not.\n",
    "    \"\"\"\n",
    "    if not dir_path.parents[0].exists():\n",
    "        dir_path.parents[0].mkdir(parents=True)\n",
    "        print(f'Directory Created: {dir_path.parents[0]}')\n",
    "    else:\n",
    "        print('Directory Exists')\n",
    "        \n",
    "    if not dir_path.exists():\n",
    "        r = requests.get(url, allow_redirects=True)\n",
    "        open(dir_path, 'wb').write(r.content)\n",
    "        print(f'File Created: {dir_path.name}')\n",
    "    else:\n",
    "        print('File Exists')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = Path('data/2020-03-15_interactive_data_visualization_with_bokeh')\n",
    "images_dir = Path('Images/2020-03-15_interactive_data_visualization_with_bokeh')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# AAPL Stock\n",
    "aapl_url = 'https://assets.datacamp.com/production/repositories/401/datasets/313eb985cce85923756a128e49d7260a24ce6469/aapl.csv'\n",
    "# Automobile miles per gallon\n",
    "auto_url = 'https://assets.datacamp.com/production/repositories/401/datasets/2a776ae9ef4afc3f3f3d396560288229e160b830/auto-mpg.csv'\n",
    "# Gapminder\n",
    "gap_url = 'https://assets.datacamp.com/production/repositories/401/datasets/09378cc53faec573bcb802dce03b01318108a880/gapminder_tidy.csv'\n",
    "# Blood glucose levels\n",
    "glucose_url = 'https://assets.datacamp.com/production/repositories/401/datasets/edcedae3825e0483a15987248f63f05a674244a6/glucose.csv'\n",
    "# Female literacy and birth rate\n",
    "female_url = 'https://assets.datacamp.com/production/repositories/401/datasets/5aae6591ddd4819dec17e562f206b7840a272151/literacy_birth_rate.csv'\n",
    "# Olympic medals (100m sprint)\n",
    "sprint_url = 'https://assets.datacamp.com/production/repositories/401/datasets/68b7a450b34d1a331d4ebfba22069ce87bb5625d/sprint.csv'\n",
    "# State coordinates\n",
    "state_url = 'https://github.com/trenton3983/DataCamp/blob/master/data/2020-03-15_interactive_data_visualization_with_bokeh/state_coordinates.xlsx?raw=true'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets = [aapl_url, auto_url, gap_url, glucose_url, female_url, sprint_url, state_url]\n",
    "data_paths = list()\n",
    "\n",
    "for data in datasets:\n",
    "    file_name = data.split('/')[-1].replace('?raw=true', '')\n",
    "    data_path = data_dir / file_name\n",
    "    create_dir_save_file(data_path, data)\n",
    "    data_paths.append(data_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DataFrames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aapl = pd.read_csv(data_paths[0])\n",
    "aapl.drop('Unnamed: 0', axis=1, inplace=True)\n",
    "aapl['date'] = pd.to_datetime(aapl['date'])\n",
    "auto = pd.read_csv(data_paths[1])\n",
    "gap = pd.read_csv(data_paths[2])\n",
    "gluc = pd.read_csv(data_paths[3])\n",
    "gluc['datetime'] = pd.to_datetime(gluc['datetime'])\n",
    "gluc.set_index('datetime', inplace=True, drop=True)\n",
    "lit = pd.read_csv(data_paths[4])\n",
    "lit = lit.iloc[0:162, :]\n",
    "lit[['female literacy', 'fertility']] = lit[['female literacy', 'fertility']].astype('float')\n",
    "lit.columns = [x.strip() for x in lit.columns]  # Country has a whitespace at the end\n",
    "run = pd.read_csv(data_paths[5])\n",
    "state_coor_dict = {state: pd.read_excel(data_paths[6], sheet_name=state) for state in ['az', 'co', 'nm', 'ut']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "# Basic plotting with Bokeh\n",
    "\n",
    "This chapter provides an introduction to basic plotting with Bokeh. You will create your first plots, learn about different data formats Bokeh understands, and make visual customizations for selections and mouse hovering.\n",
    "\n",
    "**What is [Bokeh](https://docs.bokeh.org/en/latest/index.html#)?**\n",
    "\n",
    "* [Bokeh at a Glance](https://bokeh.org/)\n",
    "* [Real Python: Interactive Data Visualization in Python With Bokeh](https://realpython.com/courses/interactive-data-visualization-python-bokeh/) by [Christopher Bailey](https://twitter.com/digiglean)\n",
    "* Interactive visualization, controls, and tools\n",
    "* Versatile and high-level graphics\n",
    "* High-level statistical charts\n",
    "* Streaming, dynamic, large data\n",
    "* For the browser, with or without a server\n",
    "* **No JavaScript**\n",
    "\n",
    "**What you will learn**\n",
    "\n",
    "* Basic plotting with `bokeh.plotting`\n",
    "* Layouts, interactions, and annotations\n",
    "* Statistical charting with `bokeh.charts`\n",
    "* Interactive data applications in the browser\n",
    "* Case Study: A Gapminder explorer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting with glyphs\n",
    "\n",
    "**What are Glyphs**\n",
    "\n",
    "* Visual shapes\n",
    " * circles, squares, triangles\n",
    " * rectangles, lines, wedges\n",
    "* With properties a!ached to data\n",
    " * coordinates (x,y)\n",
    " * size, color, transparency\n",
    " \n",
    "**Typical usage**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot = figure(height=300, width=400, tools='pan,box_zoom,reset')\n",
    "plot.scatter(x=[1, 2, 3, 4, 5], y=[8, 6, 5, 2, 3], color='violet')\n",
    "# output_file('circle.html')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Glyph properties**\n",
    "\n",
    "* Lists, arrays, sequences of values\n",
    "* Single fixed values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot = figure(height=400, width=400, )\n",
    "plot.scatter(x=10, y=[2, 5, 8, 12], size=[10, 20, 30, 40])\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Markers**\n",
    "\n",
    "* asterisk()\n",
    "* circle()\n",
    "* circle_cross()\n",
    "* circle_x()\n",
    "* cross()\n",
    "* diamond()\n",
    "* diamond_cross()\n",
    "* inverted_triangle()\n",
    "* square()\n",
    "* square_cross()\n",
    "* square_x()\n",
    "* triangle()\n",
    "* x()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are glyphs?\n",
    "\n",
    "In Bokeh, visual properties of shapes are called glyphs. The visual properties of these glyphs such as position or color can be assigned single values, for example `x=10` or `fill_color='red'`.\n",
    "\n",
    "What other kinds of values can glyph properties be set to in normal usage?\n",
    "\n",
    "**Answer the question**\n",
    "\n",
    "* ~~Dictionaries~~\n",
    "* **Sequences (lists, arrays): Multiple glyphs can be drawn by setting glyph properties to ordered sequences of values.**\n",
    "* ~~Sets~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A simple scatter plot\n",
    "\n",
    "In this example, you're going to make a scatter plot of female literacy vs fertility using data from the [European Environmental Agency](https://www.eea.europa.eu/data-and-maps/figures/correlation-between-fertility-and-female-education). This dataset highlights that countries with low female literacy have high birthrates. The x-axis data has been loaded for you as `fertility` and the y-axis data has been loaded as `female_literacy`.\n",
    "\n",
    "Your job is to create a figure, assign x-axis and y-axis labels, and plot `female_literacy` vs `fertility` using the circle glyph.\n",
    "\n",
    "After you have created the figure, in this exercise and the ones to follow, play around with it! Explore the different options available to you on the tab to the right, such as \"Pan\", \"Box Zoom\", and \"Wheel Zoom\". You can click on the question mark sign for more details on any of these tools.\n",
    "\n",
    "Note: You may have to scroll down to view the lower portion of the figure.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import the `figure` function from `bokeh.plotting`, and the `output_file` and `show` functions from `bokeh.io`.\n",
    "* Create the figure `p` with `figure()`. It has two parameters: `x_axis_label` and `y_axis_label`.\n",
    "* Add a circle glyph to the figure `p` using the function `p.scatter()` where the inputs are, in order, the x-axis data and y-axis data.\n",
    "* Use the `output_file()` function to specify the name `'fert_lit.html'` for the output file.\n",
    "* Create and display the output file using `show()` and passing in the figure `p`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fertility = lit['fertility']\n",
    "female_literacy = lit['female literacy']\n",
    "\n",
    "# Create the figure: p\n",
    "p = figure(height=300, x_axis_label='fertility (children per woman)', y_axis_label='female_literacy (% population)')\n",
    "\n",
    "# Add a circle glyph to the figure p\n",
    "p.scatter(fertility, female_literacy)\n",
    "\n",
    "# Call the output_file() function and specify the name of the file\n",
    "# output_file('fert_lit.html')\n",
    "\n",
    "# Display the plot\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A scatter plot with different shapes\n",
    "\n",
    "By calling multiple glyph functions on the same figure object, we can overlay multiple data sets in the same figure.\n",
    "\n",
    "In this exercise, you will plot female literacy vs fertility for two different regions, Africa and Latin America. Each set of x and y data has been loaded separately for you as `fertility_africa`, `female_literacy_africa`, `fertility_latinamerica`, and `female_literacy_latinamerica`.\n",
    "\n",
    "Your job is to plot the Latin America data with the `circle()` glyph, and the Africa data with the `x()` glyph.\n",
    "\n",
    "figure has already been imported for you from `bokeh.plotting`.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Create the figure `p` with the `figure()` function. It has two parameters: `x_axis_label` and `_axis_label`.\n",
    "* Add a circle glyph to the figure `p` using the function `p.scatter()` where the inputs are the x and y data from Latin America: `fertility_latinamerica` and `female_literacy_latinamerica`.\n",
    "* Add an x glyph to the figure `p` using the function `p.x()` where the inputs are the x and y data from Africa: `fertility_africa` and `female_literacy_africa`.\n",
    "* The code to create, display, and specify the name of the output file has been written for you, so after adding the x glyph, hit 'Submit Answer' to view the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lit.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fertility_africa = lit[lit.Continent == 'AF']['fertility']\n",
    "fertility_latinamerica = lit[lit.Continent == 'LAT']['fertility']\n",
    "female_literacy_africa = lit[lit.Continent == 'AF']['female literacy']\n",
    "female_literacy_latinamerica = lit[lit.Continent == 'LAT']['female literacy']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the figure: p\n",
    "p = figure(height=300, x_axis_label='fertility (children per woman)', y_axis_label='female literacy (% population)')\n",
    "\n",
    "# Add a circle glyph to the figure p\n",
    "p.scatter(fertility_latinamerica, female_literacy_latinamerica)\n",
    "\n",
    "# Add an x glyph to the figure p\n",
    "p.scatter(fertility_africa, female_literacy_africa, marker='x', color='red')\n",
    "\n",
    "# Specify the name of the file\n",
    "# output_file('fert_lit_separate.html')\n",
    "\n",
    "# Display the plot\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Customizing your scatter plots\n",
    "\n",
    "The three most important arguments to customize scatter glyphs are `color`, `size`, and `alpha`. Bokeh accepts colors as hexadecimal strings, tuples of RGB values between 0 and 255, and any of the 147 [CSS color names](https://147colors.com/). Size values are supplied in screen space units with 100 meaning the size of the entire figure.\n",
    "\n",
    "The `alpha` parameter controls transparency. It takes in floating point numbers between 0.0, meaning completely transparent, and 1.0, meaning completely opaque.\n",
    "\n",
    "In this exercise, you'll plot female literacy vs fertility for Africa and Latin America as red and blue circle glyphs, respectively.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Using the Latin America data (`fertility_latinamerica` and `female_literacy_latinamerica`), add a `blue` circle glyph of `size=10` and `alpha=0.8` to the figure `p`. To do this, you will need to specify the `color`, `size` and `alpha` keyword arguments inside `p.scatter()`.\n",
    "* Using the Africa data (`fertility_africa` and `female_literacy_africa`), add a `red` circle glyph of `size=10` and `alpha=0.8` to the figure `p`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the figure: p\n",
    "p = figure(height=300, x_axis_label='fertility (children per woman)', y_axis_label='female_literacy (% population)')\n",
    "\n",
    "# Add a blue circle glyph to the figure p\n",
    "p.scatter(fertility_latinamerica, female_literacy_latinamerica, color='blue', size=10, alpha=0.8)\n",
    "\n",
    "# Add a red circle glyph to the figure p\n",
    "p.scatter(fertility_africa, female_literacy_africa, color='red', size=10, alpha=0.8)\n",
    "\n",
    "# Specify the name of the file\n",
    "# output_file('fert_lit_separate_colors.html')\n",
    "\n",
    "# Display the plot\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional glyphs\n",
    "\n",
    "**Lines**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3,4,5]\n",
    "y = [8,6,5,2,3]\n",
    "plot = figure(height=300)\n",
    "plot.line(x, y, line_width=3)\n",
    "# output_file('line.html')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lines and Markers Together**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3,4,5]\n",
    "y = [8,6,5,2,3]\n",
    "plot = figure(height=300)\n",
    "plot.line(x, y, color='purple', line_width=2)\n",
    "plot.scatter(x, y, color='purple', fill_color='white', size=10)\n",
    "# output_file('line.html')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Patches**\n",
    "\n",
    "* Useful for showing geographic regions\n",
    "* Data given as “list of lists”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = [[1,1,2,2], [2,2,4], [2,2,3,3]]\n",
    "ys = [[2,5,5,2], [3,5,5], [2,3,4,2]]\n",
    "plot = figure(height=300)\n",
    "plot.patches(xs, ys, fill_color=['red', 'blue','green'], line_color='white')\n",
    "# output_file('patches.html')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Other glyphs**\n",
    "\n",
    "* annulus()\n",
    "* annular_wedge()\n",
    "* wedge()\n",
    "* rect()\n",
    "* quad()\n",
    "* vbar()\n",
    "* hbar()\n",
    "* image()\n",
    "* image_rgba()\n",
    "* image_url()\n",
    "* patch()\n",
    "* patches()\n",
    "* line()\n",
    "* multi_line()\n",
    "* circle()\n",
    "* oval()\n",
    "* ellipse()\n",
    "* arc()\n",
    "* quadratic()\n",
    "* bezier()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lines\n",
    "\n",
    "We can draw lines on Bokeh plots with the `line()` glyph function.\n",
    "\n",
    "In this exercise, you'll plot the daily adjusted closing price of Apple Inc.'s stock (AAPL) from 2000 to 2013.\n",
    "\n",
    "The data points are provided for you as lists. `date` is a list of [datetime objects](https://docs.python.org/3.5/library/datetime.html) to plot on the x-axis and `price` is a list of prices to plot on the y-axis.\n",
    "\n",
    "Since we are plotting dates on the x-axis, you must add `x_axis_type='datetime'` when creating the figure object.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import the `figure` function from `bokeh.plotting`.\n",
    "* Create a figure `p` using the `figure()` function with `x_axis_type` set to `'datetime'`. The other two parameters are `x_axis_label` and `y_axis_label`.\n",
    "* Plot `date` and `price` along the x- and y-axes using `p.line()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a figure with x_axis_type=\"datetime\": p\n",
    "p = figure(height=300, x_axis_type=\"datetime\", x_axis_label='Date', y_axis_label='US Dollars')\n",
    "\n",
    "# Plot date along the x axis and price along the y axis\n",
    "p.line(aapl['date'], aapl['adj_close'], line_color='green')\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('line.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lines and markers\n",
    "\n",
    "Lines and markers can be combined by plotting them separately using the same data points.\n",
    "\n",
    "In this exercise, you'll plot a line and circle glyph for the AAPL stock prices. Further, you'll adjust the `fill_color` keyword argument of the `circle()` glyph function while leaving the `line_color` at the default value.\n",
    "\n",
    "The `date` and `price` lists are provided. The Bokeh figure object p that you created in the previous exercise has also been provided.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Plot `date` along the x-axis and `price` along the y-axis with `p.line()`.\n",
    "* With `date` on the x-axis and `price` on the y-axis, use `p.scatter()` to add a `'white'` circle glyph of size `4`. To do this, you will need to specify the `fill_color` and `size` arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aapl_mar_jul_2000 = aapl[(aapl['date'] >= '2000-01') & (aapl['date'] < '2000-08')]\n",
    "aapl_mar_jul_2000.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a figure with x_axis_type=\"datetime\": p\n",
    "p = figure(height=300, x_axis_type=\"datetime\", x_axis_label='Date', y_axis_label='US Dollars')\n",
    "\n",
    "# Plot date along the x axis and price along the y axis\n",
    "p.line(aapl_mar_jul_2000['date'], aapl_mar_jul_2000['adj_close'])\n",
    "\n",
    "# With date on the x-axis and price on the y-axis, add a white circle glyph of size 4\n",
    "p.scatter(aapl_mar_jul_2000['date'], aapl_mar_jul_2000['adj_close'], fill_color='white', size=4)\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('line.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Patches\n",
    "\n",
    "In Bokeh, extended geometrical shapes can be plotted by using the `patches()` glyph function. The patches glyph takes as input a list-of-lists collection of numeric values specifying the vertices in x and y directions of each distinct patch to plot.\n",
    "\n",
    "In this exercise, you will plot the state borders of Arizona, Colorado, New Mexico and Utah. The latitude and longitude vertices for each state have been prepared as lists.\n",
    "\n",
    "Your job is to plot longitude on the x-axis and latitude on the y-axis. The figure object has been created for you as `p`.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Create a list of the longitude positions for each state as `x`. This has already been done for you.\n",
    "* Create a list of the latitude positions for each state as `y`. The variable names for the latitude positions are `az_lats`, `co_lats`, `nm_lats`, and `ut_lats`.\n",
    "* Use the `.patches()` method to add the patches glyph to the figure `p`. Supply the `x` and `y` lists as arguments along with a `line_color` of `'white'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "az_lons = state_coor_dict['az'].az_lons\n",
    "az_lats = state_coor_dict['az'].az_lats\n",
    "co_lons = state_coor_dict['co'].co_lons\n",
    "co_lats = state_coor_dict['co'].co_lats\n",
    "nm_lons = state_coor_dict['nm'].nm_lons\n",
    "nm_lats = state_coor_dict['nm'].nm_lats\n",
    "ut_lons = state_coor_dict['ut'].ut_lons\n",
    "ut_lats = state_coor_dict['ut'].ut_lats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of az_lons, co_lons, nm_lons and ut_lons: x\n",
    "x = [az_lons, co_lons, nm_lons, ut_lons]\n",
    "\n",
    "# Create a list of az_lats, co_lats, nm_lats and ut_lats: y\n",
    "y = [az_lats, co_lats, nm_lats, ut_lats]\n",
    "\n",
    "# Add patches to figure p with line_color=white for x and y\n",
    "p = figure(height=400, width=400)\n",
    "p.patches(x, y, line_color='white')\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('four_corners.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data formats\n",
    "\n",
    "**Python Basic Types**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3,4,5]\n",
    "y = [8,6,5,2,3]\n",
    "plot = figure(height=300)\n",
    "plot.line(x, y, line_width=3)\n",
    "plot.scatter(x, y, fill_color='white', size=10)\n",
    "# output_file('basic.html')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NumPy Arrays**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 10, 1000)\n",
    "y = np.sin(x) + np.random.random(1000) * 0.2\n",
    "plot = figure(height=300)\n",
    "plot.line(x, y)\n",
    "# output_file('numpy.html')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pandas**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Flowers is a Pandas DataFrame\n",
    "plot = figure(height=300)\n",
    "plot.scatter(flowers['petal_length'], flowers['sepal_length'], size=10)\n",
    "# output_file('pandas.html')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Column Data Source**\n",
    "\n",
    "* Common fundamental data structure for Bokeh\n",
    "* Maps string column names to sequences of data\n",
    "* Often created automatically for you\n",
    "* Can be shared between glyphs to link selections\n",
    "* Extra columns can be used with hover tooltips"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from bokey.models import ColumnDataSource  # imported at the top of the notebook\n",
    "source = ColumnDataSource(data={'x': [1,2,3,4,5],\n",
    "                                'y': [8,6,5,2,3]})\n",
    "source.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = ColumnDataSource(iris_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting data from NumPy arrays\n",
    "\n",
    "In the previous exercises, you made plots using data stored in lists. You learned that Bokeh can plot both numbers and datetime objects.\n",
    "\n",
    "In this exercise, you'll generate NumPy arrays using `np.linspace()` and `np.cos()` and plot them using the circle glyph.\n",
    "\n",
    "`np.linspace()` is a function that returns an array of evenly spaced numbers over a specified interval. For example, `np.linspace(0, 10, 5)` returns an array of `5` evenly spaced samples calculated over the interval `[0, 10]`. `np.cos(x)` calculates the element-wise cosine of some array x.\n",
    "\n",
    "For more information on NumPy functions, you can refer to the [NumPy User Guide](https://numpy.org/doc/stable/reference/index.html) and [NumPy Reference](https://numpy.org/doc/stable/user/index.html#user).\n",
    "\n",
    "The figure `p` has been provided for you.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `numpy` as `np`.\n",
    "* Create an array `x` using `np.linspace()` with `0`, `5`, and `100` as inputs.\n",
    "* Create an array `y` using `np.cos()` with `x` as input.\n",
    "* Add circles at `x` and `y` using `p.scatter()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create array using np.linspace: x\n",
    "x = np.linspace(0, 5, 100)\n",
    "\n",
    "# Create array using np.cos: y\n",
    "y = np.cos(x)\n",
    "\n",
    "# Add circles at x and y\n",
    "p = figure(height=300)\n",
    "p.scatter(x, y)\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('numpy.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting data from Pandas DataFrames\n",
    "\n",
    "You can create Bokeh plots from Pandas DataFrames by passing column selections to the glyph functions.\n",
    "\n",
    "Bokeh can plot floating point numbers, integers, and datetime data types. In this example, you will read a CSV file containing information on 392 automobiles manufactured in the US, Europe and Asia from 1970 to 1982.\n",
    "\n",
    "The CSV file is provided for you as ``'auto.csv'``.\n",
    "\n",
    "Your job is to plot miles-per-gallon (``mpg``) vs horsepower (``hp``) by passing Pandas column selections into the ``p.scatter()`` function. Additionally, each glyph will be colored according to values in the ``color`` column.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `pandas` as `pd`.\n",
    "* Use the `read_csv()` function of `pandas` to read in `'auto.csv'` and store it in the DataFrame `df`.\n",
    "* Import `figure` from `bokeh.plotting`.\n",
    "* Use the `figure()` function to create a figure `p` with the x-axis labeled `'HP'` and the y-axis labeled `'MPG'`.\n",
    "* Plot `mpg` (on the y-axis) vs `hp` (on the x-axis) by `color` using `p.scatter()`. Note that the x-axis should be specified before the y-axis inside `p.scatter()`. You will need to use Pandas DataFrame indexing to pass in the columns. For example, to access the `color` column, you can use `df['color']`, and then pass it in as an argument to the `color` parameter of `p.scatter()`. Also specify a `size` of `10`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the figure: p\n",
    "p = figure(height=400, x_axis_label='HP', y_axis_label='MPG')\n",
    "\n",
    "# Plot mpg vs hp by color\n",
    "p.scatter(auto.hp, auto.mpg, size=10, color=auto.color)\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('auto-df.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Bokeh ColumnDataSource\n",
    "\n",
    "The `ColumnDataSource` is a table-like data object that maps string column names to sequences (columns) of data. It is the central and most common data structure in Bokeh.\n",
    "\n",
    "Which of the following statements about `ColumnDataSource` objects is true?\n",
    "\n",
    "**Answer the question**\n",
    "\n",
    "* **All columns in a ColumnDataSource must have the same length.**\n",
    "* ~~ColumnDataSource objects cannot be shared between different plots.~~\n",
    "* ~~ColumnDataSource objects are interchangeable with Pandas DataFrames.~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Bokeh ColumnDataSource (continued)\n",
    "\n",
    "You can create a `ColumnDataSource` object directly from a Pandas DataFrame by passing the DataFrame to the class initializer.\n",
    "\n",
    "In this exercise, we have imported pandas as `pd` and read in a data set containing all Olympic medals awarded in the 100 meter sprint from 1896 to 2012. A `color` column has been added indicating the CSS colorname we wish to use in the plot for every data point.\n",
    "\n",
    "Your job is to import the `ColumnDataSource` class, create a new `ColumnDataSource` object from the DataFrame `df`, and plot circle glyphs with `'Year'` on the x-axis and `'Time'` on the y-axis. Color each glyph by the `color` column.\n",
    "\n",
    "The figure object `p` has already been created for you.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import the ``ColumnDataSource`` class from ``bokeh.plotting``.\n",
    "* Use the ``ColumnDataSource()`` function to make a new ColumnDataSource object called ``source`` from the DataFrame ``df``.\n",
    "* Use `p.scatter()` to plot circle glyphs on the figure `p` with `'Year'` on the x-axis and `'Time'` on the y-axis.\n",
    " * Make the size of the circles `8`, and use `color='color'` to ensure each glyph is colored by the `color` column.\n",
    " * Make sure to specify `source=source` so that the ColumnDataSource object is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "run.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a ColumnDataSource from df: source\n",
    "source = ColumnDataSource(run)\n",
    "\n",
    "# Add circle glyphs to the figure p\n",
    "p = figure(height=400, x_axis_label='Race Year', y_axis_label='Race Run Time (seconds)', title='100 Meter Sprint Run Times: 1896 - 2012')\n",
    "p.scatter('Year', 'Time', source=source, size=8, color='color')\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('sprint.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customizing glyphs\n",
    "\n",
    "**Selection appearance**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot = figure(height=400, tools='box_select, lasso_select, reset')\n",
    "plot.scatter(iris_df.petal_length, iris_df.sepal_length, selection_color='red', nonselection_fill_alpha=0.2, nonselection_fill_color='grey')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hover appearance**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(365)\n",
    "a = np.random.random_sample(1000)\n",
    "b = np.random.random_sample(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hover = HoverTool(tooltips=None, mode='hline')\n",
    "plot = figure(height=400, tools=[hover, 'crosshair'])\n",
    "# x and y are lists of random points\n",
    "plot.scatter(a, b, size=8, hover_color='magenta')\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Color mapping**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = ColumnDataSource(iris_df)\n",
    "mapper = CategoricalColorMapper( factors=['setosa', 'virginica', 'versicolor'], palette=['red', 'green', 'blue'])\n",
    "plot = figure(height=400, x_axis_label='petal_length', y_axis_label='sepal_length')\n",
    "plot.scatter('petal_length', 'sepal_length', size=10, source=source, color={'field': 'species', 'transform': mapper})\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection and non-selection glyphs\n",
    "\n",
    "In this exercise, you're going to add the `box_select` tool to a figure and change the selected and non-selected circle glyph properties so that selected glyphs are red and non-selected glyphs are transparent blue.\n",
    "\n",
    "You'll use the ColumnDataSource object of the Olympic Sprint dataset you made in the last exercise. It is provided to you with the name `source`.\n",
    "\n",
    "After you have created the figure, be sure to experiment with the Box Select tool you added! As in previous exercises, you may have to scroll down to view the lower portion of the figure.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Create a figure `p` with an x-axis label of `'Year'`, y-axis label of `'Time'`, and the `'box_select'` tool. To add the 'box_select' tool, you have to specify the keyword argument `tools='box_select'` inside the `figure()` function.\n",
    "* Now that you have added `'box_select'` to `p`, add in circle glyphs with `p.scatter()` such that the selected glyphs are red and non-selected glyphs are transparent blue. This can be done by specifying `'red'` as the argument to `selection_color` and `0.1` to `nonselection_alpha`. Remember to also pass in the arguments for the `x` (`'Year'`), `y` (`'Time'`), and `source` parameters of `p.scatter()`.\n",
    "* Click 'Submit Answer' to output the file and show the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a ColumnDataSource from df: source\n",
    "source = ColumnDataSource(run)\n",
    "\n",
    "# Create a figure with the \"box_select\" tool: p\n",
    "p = figure(height=400, x_axis_label='Year', y_axis_label='Time', tools='box_select, reset')\n",
    "\n",
    "# Add circle glyphs to the figure p with the selected and non-selected properties\n",
    "p.scatter('Year', 'Time', source=source, selection_color='red', nonselection_alpha=0.1)\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('selection_glyph.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hover glyphs\n",
    "\n",
    "Now let's practice using and customizing the hover tool.\n",
    "\n",
    "In this exercise, you're going to plot the blood glucose levels for an unknown patient. The blood glucose levels were recorded every 5 minutes on October 7th starting at 3 minutes past midnight.\n",
    "\n",
    "The date and time of each measurement are provided to you as `x` and the blood glucose levels in mg/dL are provided as `y`.\n",
    "\n",
    "A bokeh figure is also provided in the workspace as `p`.\n",
    "\n",
    "Your job is to add a circle glyph that will appear red when the mouse is hovered near the data points. You will also add a customized hover tool object to the plot.\n",
    "\n",
    "When you're done, play around with the hover tool you just created! Notice how the points where your mouse hovers over turn red.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `HoverTool` from `bokeh.models`.\n",
    "* Add a circle glyph to the existing figure `p` for `x` and `y` with a `size` of `10`, `fill_color` of `'grey'`, alpha of `0.1`, `line_color` of `None`, `hover_fill_color` of `'firebrick'`, `hover_alpha` of `0.5`, and `hover_line_color` of `'white'`.\n",
    "* Use the `HoverTool()` function to create a HoverTool called `hover` with `tooltips=None` and `mode='vline'`.\n",
    "* Add the HoverTool `hover` to the figure `p` using the `p.add_tools()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gluc.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add circle glyphs to figure p\n",
    "p = figure(height=400, width=800, x_axis_type=\"datetime\", x_axis_label='Date', y_axis_label='Glucose Level', tools=[])\n",
    "\n",
    "p.scatter(gluc.index, gluc.glucose, size=10,\n",
    "         fill_color='grey', alpha=0.1, line_color=None,\n",
    "         hover_fill_color='purple', hover_alpha=0.5,\n",
    "         hover_line_color='white')\n",
    "\n",
    "# Create a HoverTool: hover\n",
    "hover = HoverTool(tooltips=None, mode='vline')\n",
    "\n",
    "# Add the hover tool to the figure p\n",
    "p.add_tools(hover)\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('hover_glyph.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colormapping\n",
    "\n",
    "The final glyph customization we'll practice is using the CategoricalColorMapper to color each glyph by a categorical property.\n",
    "\n",
    "Here, you're going to use the automobile dataset to plot miles-per-gallon vs weight and color each circle glyph by the region where the automobile was manufactured.\n",
    "\n",
    "The `origin` column will be used in the ColorMapper to color automobiles manufactured in the US as blue, Europe as red and Asia as green.\n",
    "\n",
    "The automobile data set is provided to you as a Pandas DataFrame called `df`. The figure is provided for you as `p`.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `CategoricalColorMapper` from `bokeh.models`.\n",
    "* Convert the DataFrame `df` to a ColumnDataSource called `source`. This has already been done for you.\n",
    "* Make a CategoricalColorMapper object called `color_mapper` with the `CategoricalColorMapper()` function. It has two parameters here: `factors` and `palette`.\n",
    "* Add a `circle` glyph to the figure `p` to plot `'mpg'` (on the y-axis) vs `'weight'` (on the x-axis). Remember to pass in `source` and `'origin'` as arguments to `source` and `legend`. For the `color` parameter, use `dict(field='origin', transform=color_mapper)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "auto.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert df to a ColumnDataSource: source\n",
    "source = ColumnDataSource(auto)\n",
    "\n",
    "# Make a CategoricalColorMapper object: color_mapper\n",
    "color_mapper = CategoricalColorMapper(factors=['Europe', 'Asia', 'US'],\n",
    "                                      palette=['red', 'green', 'blue'])\n",
    "\n",
    "# Add a circle glyph to the figure p\n",
    "p = figure(height=400, x_axis_label='Vehicle Weight', y_axis_label='MPG')\n",
    "p.scatter('weight', 'mpg', source=source, color=dict(field='origin', transform=color_mapper), legend_field='origin')\n",
    "\n",
    "# Specify the name of the output file and show the result\n",
    "# output_file('colormap.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "# Layouts, Interactions, and Annotations\n",
    "\n",
    "Learn how to combine multiple Bokeh plots into different kinds of layouts on a page, how to easily link different plots together, and how to add annotations such as legends and hover tooltips."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to layouts\n",
    "\n",
    "**Arranging multiple plots**\n",
    "\n",
    "* Arrange plots (and controls) visually on a page:\n",
    " * rows, columns\n",
    " * grid arrangements\n",
    " * tabbed layouts\n",
    " \n",
    "**Rows of plots**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = ColumnDataSource(iris_df)\n",
    "\n",
    "# Flowers is a Pandas DataFrame\n",
    "p1 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. sepal length')\n",
    "p1.scatter('petal_length', 'sepal_length', source=source, color='blue')\n",
    "p2 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. sepal width')\n",
    "p2.scatter('petal_length', 'sepal_width', source=source, color='green')\n",
    "p3 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. petal width')\n",
    "p3.scatter('petal_length', 'petal_width', source=source, color='red')\n",
    "layout = row(p1, p2, p3)\n",
    "# output_file('row.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Columns of plots**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "layout = column(p1, p2, p3)\n",
    "# output_file('column.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nested Layouts**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "layout = row(column(p1, p2), p3)\n",
    "# output_file('nested.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating rows of plots\n",
    "\n",
    "Layouts are collections of Bokeh figure objects.\n",
    "\n",
    "In this exercise, you're going to create two plots from the Literacy and Birth Rate data set to plot fertility vs female literacy and population vs female literacy.\n",
    "\n",
    "By using the `row()` method, you'll create a single layout of the two figures.\n",
    "\n",
    "Remember, as in the previous chapter, once you have created your figures, you can interact with them in various ways.\n",
    "\n",
    "In this exercise, you may have to scroll sideways to view both figures in the row layout. Alternatively, you can view the figures in a new window by clicking on the expand icon to the right of the \"Bokeh plot\" tab.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `row` from the `bokeh.layouts` module.\n",
    "* Create a new figure `p1` using the `figure()` function and specifying the two parameters `x_axis_label` and `y_axis_label`.\n",
    "* Add a circle glyph to `p1`. The x-axis data is `'fertility'` and y-axis data is `'female_literacy'`. Be sure to also specify `source=source`.\n",
    "* Create a new figure `p2` using the `figure()` function and specifying the two parameters `x_axis_label` and `y_axis_label`.\n",
    "* Add a `circle()` glyph to `p2`, specifying the `x` and `y` parameters.\n",
    "* Put `p1` and `p2` into a horizontal layout using `row()`.\n",
    "* Click 'Submit Answer' to output the file and show the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lit.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = ColumnDataSource(lit)\n",
    "\n",
    "# Create the first figure: p1\n",
    "p1 = figure(height=300, x_axis_label='fertility (children per woman)', y_axis_label='female literacy (% population)')\n",
    "\n",
    "# Add a circle glyph to p1\n",
    "p1.scatter('fertility', 'female literacy', source=source)\n",
    "\n",
    "# Create the second figure: p2\n",
    "p2 = figure(height=300, x_axis_label='population', y_axis_label='female literacy (% population)')\n",
    "\n",
    "# Add a circle glyph to p2\n",
    "p2.scatter('population', 'female literacy', source=source)\n",
    "\n",
    "# Put p1 and p2 into a horizontal row: layout\n",
    "layout = row(p1, p2)\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('fert_row.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating columns of plots\n",
    "\n",
    "In this exercise, you're going to use the `column()` function to create a single column layout of the two plots you created in the previous exercise.\n",
    "\n",
    "Figure `p1` has been created for you.\n",
    "\n",
    "In this exercise and the ones to follow, you may have to scroll down to view the lower portion of the figure.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `column` from the `bokeh.layouts` module.\n",
    "* The figure `p1` has been created for you. Create a new figure `p2` with an x-axis label of `'population'` and y-axis label of `'female_literacy (% population)'`.\n",
    "* Add a circle glyph to the figure `p2`.\n",
    "* Put `p1` and `p2` into a vertical layout using `column()`.\n",
    "* Click 'Submit Answer' to output the file and show the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a blank figure: p1\n",
    "p1 = figure(height=300, x_axis_label='fertility (children per woman)', y_axis_label='female literacy (% population)')\n",
    "\n",
    "# Add circle scatter to the figure p1\n",
    "p1.scatter('fertility', 'female literacy', source=source)\n",
    "\n",
    "# Create a new blank figure: p2\n",
    "p2 = figure(height=300, x_axis_label='population', y_axis_label='female literacy (% population)')\n",
    "\n",
    "# Add circle scatter to the figure p2\n",
    "p2.scatter('population', 'female literacy', source=source)\n",
    "\n",
    "# Put plots p1 and p2 in a column: layout\n",
    "layout = column(p1, p2)\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('fert_column.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nesting rows and columns of plots\n",
    "\n",
    "You can create nested layouts of plots by combining row and column layouts. In this exercise, you'll make a 3-plot layout in two rows using the auto-mpg data set. Three plots have been created for you of average mpg vs year (`avg_mpg`), mpg vs hp (`mpg_hp`), and mpg vs weight (`mpg_weight`).\n",
    "\n",
    "Your job is to use the `row()` and `column()` functions to make a two-row layout where the first row will have only the average mpg vs year plot and the second row will have mpg vs hp and mpg vs weight plots as columns.\n",
    "\n",
    "By using the `sizing_mode` argument, you can scale the widths to fill the whole figure.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `row` and `column` from `bokeh.layouts`.\n",
    "* Create a row layout called `row2` with the figures `mpg_hp` and `mpg_weight` in a list and set `sizing_mode='scale_width'`.\n",
    "* Create a column layout called `layout` with the figure `avg_mpg` and the row layout `row2` in a list and set `sizing_mode='scale_width'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "auto.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_mpg_df = pd.DataFrame(auto.groupby('yr')['mpg'].mean()).reset_index()\n",
    "avg_mpg_source = ColumnDataSource(avg_mpg_df)\n",
    "\n",
    "auto_source = ColumnDataSource(auto)\n",
    "\n",
    "avg_mpg = figure(height=150, x_axis_label='year', y_axis_label='mean mpg')\n",
    "avg_mpg.line('yr', 'mpg', source=avg_mpg_source)\n",
    "\n",
    "mpg_hp = figure(height=300, x_axis_label='hp', y_axis_label='mpg')\n",
    "mpg_hp.scatter('hp', 'mpg', source=auto_source)\n",
    "\n",
    "mpg_weight = figure(height=300, x_axis_label='weight', y_axis_label='mpg')\n",
    "mpg_weight.scatter('weight', 'mpg', source=auto_source)\n",
    "\n",
    "# Make a row layout that will be used as the second row: row2\n",
    "row2 = row([mpg_hp, mpg_weight], sizing_mode='scale_width')\n",
    "\n",
    "# Make a column layout that includes the above row layout: layout\n",
    "layout = column([avg_mpg, row2], sizing_mode='scale_width')\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('layout_custom.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced layouts\n",
    "\n",
    "**Gridplots**\n",
    "\n",
    "* Give a “list of rows” for layout\n",
    "* can use None as a placeholder\n",
    "* Accepts `toolbar_location`, which can be set to `'above'`, `'below'`, `'left'`, or `'right'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = ColumnDataSource(iris_df)\n",
    "\n",
    "# Flowers is a Pandas DataFrame\n",
    "p1 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. sepal length')\n",
    "p1.scatter(flowers['petal_length'], flowers['sepal_length'], color='blue')\n",
    "p2 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. sepal width')\n",
    "p2.scatter(flowers['petal_length'], flowers['sepal_width'], color='green')\n",
    "p3 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. petal width')\n",
    "p3.scatter(flowers['petal_length'], flowers['petal_width'], color='red')\n",
    "\n",
    "layout = gridplot([[None, p1], [p2, p3]], toolbar_location=None)\n",
    "# output_file('nested.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tabbed Layouts**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from bokeh.models.widgets import Tabs, Panel  # done at the top of the notebook\n",
    "\n",
    "first = TabPanel(child=row(p1, p2), title='first')\n",
    "second = TabPanel(child=row(p3), title='second')\n",
    "# Put the Panels in a Tabs object\n",
    "tabs = Tabs(tabs=[first, second])\n",
    "# output_file('tabbed.html')\n",
    "show(tabs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Investigating the layout API\n",
    "\n",
    "Bokeh layouts allow for positioning items visually in the page presented to the user. What kinds of objects can be put into Bokeh layouts?\n",
    "\n",
    "**Answer the question**\n",
    "\n",
    "* ~~Plots~~\n",
    "* ~~Widgets~~\n",
    "* ~~Other Layouts~~\n",
    "* **All of the above: Plots, widgets and nested sub-layouts can be handled.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Gridded Layouts\n",
    "\n",
    "Regular grids of Bokeh plots can be generated with `gridplot`.\n",
    "\n",
    "In this example, you're going to display four plots of fertility vs female literacy for four regions: Latin America, Africa, Asia and Europe.\n",
    "\n",
    "Your job is to create a list-of-lists for the four Bokeh plots that have been provided to you as `p1`, `p2`, `p3` and `p4`. The list-of-lists defines the row and column placement of each plot.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `gridplot` from the `bokeh.layouts` module.\n",
    "* Create a list called `row1` containing plots `p1` and `p2`.\n",
    "* Create a list called `row2` containing plots `p3` and `p4`.\n",
    "* Create a gridplot using `row1` and `row2`. You will have to pass in `row1` and `row2` in the form of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lit_la = lit[lit.Continent == 'LAT']\n",
    "lit_af = lit[lit.Continent == 'AF']\n",
    "lit_as = lit[lit.Continent == 'ASI']\n",
    "lit_eu = lit[lit.Continent == 'EUR']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from bokeh.layouts import gridplot  ## done at the top of the notebook\n",
    "\n",
    "p1 = figure(height=300, width=300, x_axis_label='fertility (children per woman)', y_axis_label='female_literacy (% population)', title='Latin America')\n",
    "p1.scatter(lit_la['fertility'], lit_la['female literacy'])\n",
    "p2 = figure(height=300, width=300, x_axis_label='fertility (children per woman)', y_axis_label='female_literacy (% population)', title='Africa')\n",
    "p2.scatter(lit_af['fertility'], lit_af['female literacy'])\n",
    "p3 = figure(height=300, width=300, x_axis_label='fertility (children per woman)', y_axis_label='female_literacy (% population)', title='Asia')\n",
    "p3.scatter(lit_as['fertility'], lit_as['female literacy'])\n",
    "p4 = figure(height=300, width=300, x_axis_label='fertility (children per woman)', y_axis_label='female_literacy (% population)', title='Europe')\n",
    "p4.scatter(lit_eu['fertility'], lit_eu['female literacy'])\n",
    "\n",
    "# Create a list containing plots p1 and p2: row1\n",
    "row1 = [p1, p2]\n",
    "\n",
    "# Create a list containing plots p3 and p4: row2\n",
    "row2 = [p3, p4]\n",
    "\n",
    "# Create a gridplot using row1 and row2: layout\n",
    "layout = gridplot([row1, row2])\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('grid.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Starting tabbed layouts\n",
    "\n",
    "Tabbed layouts can be created in Bokeh by placing plots or layouts in Panels.\n",
    "\n",
    "In this exercise, you'll take the four fertility vs female literacy plots from the last exercise and make a `Panel()` for each.\n",
    "\n",
    "No figure will be generated in this exercise. Instead, you will use these panels in the next exercise to build and display a tabbed layout.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `Panel` from `bokeh.models.widgets`.\n",
    "* Create a new panel `tab1` with child `p1` and a title of `'Latin America'`.\n",
    "* Create a new panel `tab2` with child `p2` and a title of `'Africa'`.\n",
    "* Create a new panel `tab3` with child `p3` and a title of `'Asia'`.\n",
    "* Create a new panel `tab4` with child `p4` and a title of `'Europe'`.\n",
    "* Click submit to check your work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Panel from bokeh.models.widgets\n",
    "# from bokeh.models.widgets import Panel  # done at the top of the notebook\n",
    "\n",
    "# Create tab1 from plot p1: tab1\n",
    "tab1 = TabPanel(child=p1, title='Latin America')\n",
    "\n",
    "# Create tab2 from plot p2: tab2\n",
    "tab2 = TabPanel(child=p2, title='Africa')\n",
    "\n",
    "# Create tab3 from plot p3: tab3\n",
    "tab3 = TabPanel(child=p3, title='Asia')\n",
    "\n",
    "# Create tab4 from plot p4: tab4\n",
    "tab4 = TabPanel(child=p4, title='Europe')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Displaying tabbed layouts\n",
    "\n",
    "Tabbed layouts are collections of Panel objects. Using the figures and Panels from the previous two exercises, you'll create a tabbed layout to change the region in the fertility vs female literacy plots.\n",
    "\n",
    "Your job is to create the layout using `Tabs()` and assign the `tabs` keyword argument to your list of Panels. The Panels have been created for you as `tab1`, `tab2`, `tab3` and `tab4`.\n",
    "\n",
    "After you've displayed the figure, explore the tabs you just added! The \"Pan\", \"Box Zoom\" and \"Wheel Zoom\" tools are also all available as before.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `Tabs` from `bokeh.models.widgets`.\n",
    "* Create a `Tabs` layout called `layout` with `tab1`, `tab2`, `tab3`, and `tab4`.\n",
    "* Click 'Submit Answer' to output the file and show the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Tabs from bokeh.models.widgets\n",
    "# from bokeh.models.widgets import Tabs  # done at the top of the notebook\n",
    "\n",
    "# Create a Tabs layout: layout\n",
    "layout = Tabs(tabs=[tab1, tab2, tab3, tab4])\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('tabs.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linking plots together\n",
    "\n",
    "- With the ability to display multiple plots at once, we might want to link them together in various ways\n",
    "- Bokeh has a variety of methods to achieve very sophisticated linked interactions.\n",
    "- In this section we'll take a look at two of the simplest to use capabilities:\n",
    "\n",
    "**Linking axes**\n",
    "\n",
    "1. Linked panning: if we present more than one plot, we might wish for the displayed ranges of the plots to stay synchronized.\n",
    " - To share any range between plot, assign the x_range or y_range property from one plot to another plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = ColumnDataSource(iris_df)\n",
    "\n",
    "# Flowers is a Pandas DataFrame\n",
    "plot1 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. sepal length')\n",
    "plot1.scatter(flowers['petal_length'], flowers['sepal_length'], color='blue')\n",
    "plot2 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. sepal width')\n",
    "plot2.scatter(flowers['petal_length'], flowers['sepal_width'], color='green')\n",
    "plot3 = figure(width=300, height=300, toolbar_location=None, title='petal length vs. petal width')\n",
    "plot3.scatter(flowers['petal_length'], flowers['petal_width'], color='red')\n",
    "\n",
    "plot3.x_range = plot2.x_range = plot1.x_range\n",
    "plot3.y_range = plot2.y_range = plot1.y_range\n",
    "layout = row(plot1, plot2, plot3)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Linking selections**\n",
    "\n",
    "2. Linked brushing\n",
    " - This is when one set of points is highlighted on one plot, and the corresponding points in a second plot also become highlighted.\n",
    " - It's necessary that the plots share data with the same shape.\n",
    "- The visualizations share the same column data source, so the selections will be linked by default.\n",
    "- Linked brushing can be a great way to enable users to explore connections between different dimensions of a data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = ColumnDataSource(iris_df)\n",
    "tool_list = ['lasso_select', 'tap', 'reset', 'save']\n",
    "plot1 = figure(title='petal length vs. sepal length', height=300, width=300, tools=tool_list)\n",
    "plot1.scatter('petal_length', 'sepal_length', color='blue', source=source)\n",
    "plot2 = figure(title='petal length vs. sepal width', height=300, width=300, tools=tool_list)\n",
    "plot2.scatter('petal_length', 'sepal_width', color='green', source=source)\n",
    "plot3 = figure(title='petal length vs. petal width', height=300, width=300, tools=tool_list)\n",
    "plot3.scatter('petal_length', 'petal_width', line_color='red', fill_color=None, source=source)\n",
    "plot3.x_range = plot2.x_range = plot1.x_range\n",
    "plot3.y_range = plot2.y_range = plot1.y_range\n",
    "layout = row(plot1, plot2, plot3)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linked axes\n",
    "\n",
    "Linking axes between plots is achieved by sharing `range` objects.\n",
    "\n",
    "In this exercise, you'll link four plots of female literacy vs fertility so that when one plot is zoomed or dragged, one or more of the other plots will respond.\n",
    "\n",
    "The four plots `p1`, `p2`, `p3` and `p4` along with the `layout` that you created in the last section have been provided for you.\n",
    "\n",
    "Your job is link `p1` with the three other plots by assignment of the `.x_range` and `.y_range` attributes.\n",
    "\n",
    "After you have linked the axes, explore the plots by clicking and dragging along the x or y axes of any of the plots, and notice how the linked plots change together.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Link the `x_range` of `p2` to `p1`.\n",
    "* Link the `y_range` of `p2` to `p1`.\n",
    "* Link the `x_range` of `p3` to `p1`.\n",
    "* Link the `y_range` of `p4` to `p1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Relies on plots (`p1`, `p2`, `p3`, and `p4`) from [Creating Gridded Layouts](#creating-gridded-layouts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Link the x_range of p2 to p1: p2.x_range\n",
    "p2.x_range = p1.x_range\n",
    "\n",
    "# Link the y_range of p2 to p1: p2.y_range\n",
    "p2.y_range = p1.y_range\n",
    "\n",
    "# Link the x_range of p3 to p1: p3.x_range\n",
    "p3.x_range = p1.x_range\n",
    "\n",
    "# Link the y_range of p4 to p1: p4.y_range\n",
    "p4.y_range = p1.y_range\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('linked_range.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linked brushing\n",
    "\n",
    "By sharing the same `ColumnDataSource` object between multiple plots, selection tools like BoxSelect and LassoSelect will highlight points in both plots that share a row in the ColumnDataSource.\n",
    "\n",
    "In this exercise, you'll plot female literacy vs fertility and population vs fertility in two plots using the same ColumnDataSource.\n",
    "\n",
    "After you have built the figure, experiment with the Lasso Select and Box Select tools. Use your mouse to drag a box or lasso around points in one figure, and notice how points in the other figure that share a row in the ColumnDataSource also get highlighted.\n",
    "\n",
    "Before experimenting with the Lasso Select, however, click the Bokeh plot pop-out icon to pop out the figure so that you can definitely see everything that you're doing.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Create a `ColumnDataSource` object called `source` from the `data` DataFrame.\n",
    "* Create a new figure `p1` using the `figure()` function. In addition to specifying the parameters `x_axis_label` and `y_axis_label`, you will also have to specify the BoxSelect and LassoSelect selection tools with `tools='box_select,lasso_select'`.\n",
    "* Add a circle glyph to `p1`. The x-axis data is `fertility` and y-axis data is `female literacy`. Be sure to also specify `source=source`.\n",
    "* Create a second figure `p2` similar to how you created `p1`.\n",
    "* Add a circle glyph to `p2`. The x-axis data is `fertility` and y-axis data is `population`. Be sure to also specify `source=source`.\n",
    "* Create a row layout of figures `p1` and `p2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create ColumnDataSource: source\n",
    "source = ColumnDataSource(lit)\n",
    "\n",
    "# Create the first figure: p1\n",
    "p1 = figure(height=400, width=400, x_axis_label='fertility (children per woman)', y_axis_label='female literacy (% population)',\n",
    "            tools='box_select,lasso_select')\n",
    "\n",
    "# Add a circle glyph to p1\n",
    "p1.scatter('fertility', 'female literacy', source=source)\n",
    "\n",
    "# Create the second figure: p2\n",
    "p2 = figure(height=400, width=400, x_axis_label='fertility (children per woman)', y_axis_label='population (millions)',\n",
    "            tools='box_select,lasso_select')\n",
    "\n",
    "# Add a circle glyph to p2\n",
    "p2.scatter('fertility', 'population', source=source)\n",
    "\n",
    "# Create row layout of figures p1 and p2: layout\n",
    "layout = row(p1, p2)\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('linked_brush.html')\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Annotations and guides\n",
    "\n",
    "**What are they?**\n",
    "\n",
    "* Help relate scale information to the viewer\n",
    " * Axes, Grids (default on most plots)\n",
    "* Explain the visual encodings that are used\n",
    " * Legends\n",
    "* Drill down into details not visible in the plot\n",
    " * Hover Tooltips\n",
    " \n",
    "**Legends**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source = ColumnDataSource(iris_df)\n",
    "mapper = CategoricalColorMapper( factors=['setosa', 'virginica', 'versicolor'], palette=['red', 'green', 'blue'])\n",
    "plot = figure(height=400, width=400)\n",
    "plot.scatter('petal_length', 'sepal_length', size=10, source=source,\n",
    "            color={'field': 'species', 'transform': mapper}, legend_field='species')\n",
    "plot.legend.location = 'top_left'\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hover Tooltips**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hover = HoverTool(tooltips=[('species name', '@species'), ('petal length', '@petal_length'), ('sepal length', '@sepal_length'),])\n",
    "plot = figure(height=400, width=400, tools=[hover, 'pan', 'wheel_zoom'])\n",
    "plot.scatter('petal_length', 'sepal_length', size=10, source=source,\n",
    "            color={'field': 'species', 'transform': mapper}, legend_field='species')\n",
    "plot.legend.location = 'top_left'\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to create legends\n",
    "\n",
    "Legends can be added to any glyph by using the `legend` keyword argument.\n",
    "\n",
    "In this exercise, you will plot two `circle` glyphs for female literacy vs fertility in Africa and Latin America.\n",
    "\n",
    "Two ColumnDataSources called `latin_america` and `africa` have been provided.\n",
    "\n",
    "Your job is to plot two `circle` glyphs for these two objects with `fertility` on the x axis and `female_literacy` on the y axis and add the `legend` values. The figure `p` has been provided for you.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Add a `red` circle glyph to the figure `p` using the `latin_america` ColumnDataSource. Specify a `size` of `10` and `legend` of `Latin America`.\n",
    "* Add a `blue` circle glyph to the figure `p` using the `africa` ColumnDataSource. Specify a `size` of `10` and `legend` of `Africa`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "latin_america = ColumnDataSource(lit[lit.Continent == 'LAT'])\n",
    "africa = ColumnDataSource(lit[lit.Continent == 'AF'])\n",
    "\n",
    "p = figure(height=400, width=800, title='Female Literacy vs. Fertility', x_axis_label='fertility (children per women)', y_axis_label='literacy (% of population)')\n",
    "\n",
    "# Add the first circle glyph to the figure p\n",
    "p.scatter('fertility', 'female literacy', source=latin_america, size=10, color='red', legend_label='Latin America')\n",
    "\n",
    "# Add the second circle glyph to the figure p\n",
    "p.scatter('fertility', 'female literacy', source=africa, size=10, color='blue', legend_label='Africa')\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('fert_lit_groups.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Positioning and styling legends\n",
    "\n",
    "Properties of the `legend` can be changed by using the legend member attribute of a Bokeh figure after the glyphs have been plotted.\n",
    "\n",
    "In this exercise, you'll adjust the background color and legend location of the female literacy vs fertility plot from the previous exercise.\n",
    "\n",
    "The figure object `p` has been created for you along with the circle glyphs.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Use `p.legend.location` to adjust the legend location to be on the `'bottom_left'`.\n",
    "* Use `p.legend.background_fill_color` to set the background color of the legend to `'lightgray'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign the legend to the bottom left: p.legend.location\n",
    "p.legend.location = 'bottom_left'\n",
    "\n",
    "# Fill the legend background with the color 'lightgray': p.legend.background_fill_color\n",
    "p.legend.background_fill_color = 'lightgray'\n",
    "\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hover tooltips for exposing details\n",
    "\n",
    "When configuring hover tools, certain pre-defined fields such as mouse position or glyph index can be accessed with `$` - prefixed names, for example `$x`, `$index`. But tooltips can display values from arbitrary columns in a `ColumnDataSource`.\n",
    "\n",
    "What is the correct format to display values from a column `\"sales\"` in a hover tooltip?\n",
    "\n",
    "**Answer the question**\n",
    "\n",
    "* ~~`&{sales}`~~\n",
    "* ~~`%sales%`~~\n",
    "* **`@sales`**\n",
    "* **The @ prefix denotes the name of a column to display values from.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding a hover tooltip\n",
    "\n",
    "Working with the `HoverTool` is easy for data stored in a ColumnDataSource.\n",
    "\n",
    "In this exercise, you will create a `HoverTool` object and display the country for each circle glyph in the figure that you created in the last exercise. This is done by assigning the `tooltips` keyword argument to a list-of-tuples specifying the label and the column of values from the ColumnDataSource using the `@` operator.\n",
    "\n",
    "The figure object has been prepared for you as `p`.\n",
    "\n",
    "After you have added the hover tooltip to the figure, be sure to interact with it by hovering your mouse over each point to see which country it represents.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import the `HoverTool` class from `bokeh.models`.\n",
    "* Use the `HoverTool()` function to create a `HoverTool` object called `hover` and set the `tooltips` argument to be `[('Country','@Country')]`.\n",
    "* Use `p.add_tools()` with your `HoverTool` object to add it to the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a HoverTool object: hover\n",
    "hover = HoverTool(tooltips=[('Country','@Country ')])\n",
    "\n",
    "# Add the HoverTool object to figure p\n",
    "p.add_tools(hover)\n",
    "\n",
    "# Specify the name of the output_file and show the result\n",
    "# output_file('hover.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building interactive apps with Bokeh\n",
    "\n",
    "Bokeh server applications allow you to connect all of the powerful Python libraries for data science and analytics, such as NumPy and pandas to create rich, interactive Bokeh visualizations. Learn about Bokeh's built-in widgets, how to add them to Bokeh documents alongside plots, and how to connect everything to real Python code using the Bokeh server."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Bokeh Server"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Understanding Bokeh apps\n",
    "\n",
    "The main purpose of the Bokeh server is to synchronize python objects with web applications in a browser, so that rich, interactive data applications can be connected to powerful PyData libraries such as NumPy, SciPy, Pandas, and scikit-learn.\n",
    "\n",
    "What sort of properties can the Bokeh server automatically keep in sync?\n",
    "\n",
    "**Answer the question**\n",
    "\n",
    "* ~~Only data source objects.~~\n",
    "* ~~Only glyph properties.~~\n",
    "* **Any property of any Bokeh object.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bokeh server will automatically keep every property of any Bokeh object in sync.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the current document\n",
    "Let's get started with building an interactive Bokeh app. This typically begins with importing the `curdoc`, or \"current document\", function from `bokeh.io`. This current document will eventually hold all the plots, controls, and layouts that you create. Your job in this exercise is to use this function to add a single plot to your application.\n",
    "\n",
    "In the video, Bryan described the process for running a Bokeh app using the `bokeh serve` command line tool. In this chapter and the one that follows, the DataCamp environment does this for you behind the scenes. Notice that your code is part of a `script.py` file. When you hit 'Submit Answer', you'll see in the IPython Shell that we call `bokeh serve script.py` for you.\n",
    "\n",
    "Remember, as in the previous chapters, that there are different options available for you to interact with your plots, and as before, you may have to scroll down to view the lower portion of the plots.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `curdoc` from `bokeh.io` and `figure` from `bokeh.plotting`.\n",
    "* Create a new plot called `plot` using the `figure()` function.\n",
    "* Add a line to the plot using `[1,2,3,4,5]` as the `x` coordinates and `[2,5,4,6,7]` as the `y` coordinates.\n",
    "* Add the `plot` to the current document using `curdoc().add_root()`. It needs to be passed in as an argument to `add_root()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new plot: plot\n",
    "plot = figure(width=300, height=300)\n",
    "\n",
    "# Add a line to the plot\n",
    "plot.line(x=[1,2,3,4,5], y=[2,5,4,6,7])\n",
    "\n",
    "# Add the plot to the current document\n",
    "curdoc().add_root(plot)\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add a single slider\n",
    "\n",
    "In the previous exercise, you added a single plot to the \"current document\" of your application. In this exercise, you'll practice adding a layout to your current document.\n",
    "\n",
    "Your job here is to create a single slider, use it to create a widgetbox layout, and then add this layout to the current document.\n",
    "\n",
    "The slider you create here cannot be used for much, but in the later exercises, you'll use it to update your plots!\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `curdoc` from `bokeh.io`, `widgetbox` from `bokeh.layouts`, and `Slide`r from `bokeh.models`.\n",
    "* Create a slider called `slider` by using the `Slider()` function and specifying the parameters `title`, `start`, `end`, `step`, and `value`.\n",
    "* Use the slider to create a widgetbox layout called `layout`.\n",
    "* Add the layout to the current document using `curdoc().add_root()`. It needs to be passed in as an argument to `add_root()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a slider: slider\n",
    "slider = Slider(title='my slider', start=0, end=10, step=0.1, value=2)\n",
    "\n",
    "# Create a widgetbox layout: layout\n",
    "layout = Column(slider)  # widgetbox is deprecated\n",
    "\n",
    "# Add the layout to the current document\n",
    "curdoc().add_root(layout)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple sliders in one document\n",
    "\n",
    "Having added a single slider in a widgetbox layout to your current document, you'll now add multiple sliders into the current document.\n",
    "\n",
    "Your job in this exercise is to create two sliders, add them to a widgetbox layout, and then add the layout into the current document.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Create the first slider, `slider1`, using the `Slider()` function. Give it a title of `'slider1'`. Have it `start` at `0`, `end` at `10`, with a `step` of `0.1` and initial `value` of `2`.\n",
    "* Create the second slider, `slider2`, using the `Slider()` function. Give it a title of `'slider2'`. Have it `start` at `10`, `end` at `100`, with a `step` of `1` and initial `value` of `20`.\n",
    "* Use `slider1` and `slider2` to create a widgetbox layout called `layout`.\n",
    "* Add the layout to the current document using `curdoc().add_root()`. This has already been done for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create first slider: slider1\n",
    "slider1 = Slider(title='slider1', start=0, end=10, step=0.1, value=2)\n",
    "\n",
    "# Create second slider: slider2\n",
    "slider2 = Slider(title='slider2', start=10, end=100, step=1, value=20)\n",
    "\n",
    "# Add slider1 and slider2 to a widgetbox\n",
    "layout = Column(slider1, slider2)\n",
    "\n",
    "# Add the layout to the current document\n",
    "curdoc().add_root(layout)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Connecting sliders to plots\n",
    "\n",
    "**A slider example**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # doesn't work in Jupyter as configured\n",
    "# imported at the top of the notebook\n",
    "# from bokeh.io import curdoc\n",
    "# from bokeh.layouts import column\n",
    "# from bokeh.models import ColumnDataSource, Slider\n",
    "# from bokeh.plotting import figure\n",
    "# from numpy.random import random\n",
    "\n",
    "N = 300\n",
    "np.random.seed(365)\n",
    "source = ColumnDataSource(data={'x': np.random.random(N), 'y': np.random.random(N)})\n",
    "\n",
    "# Create plots and widgets\n",
    "plot = figure()\n",
    "plot.scatter(x= 'x', y='y', source=source)\n",
    "slider = Slider(start=100, end=1000, value=N,\n",
    "step=10, title='Number of points')\n",
    "\n",
    "# Add callback to widgets\n",
    "def callback(attr, old, new):\n",
    "    N = slider.value\n",
    "    source.data={'x': np.random.random(N), 'y': np.random.random(N)}\n",
    "    \n",
    "slider.on_change('value', callback)\n",
    "\n",
    "# Arrange plots and widgets in layouts\n",
    "layout = column(slider, plot)\n",
    "curdoc().add_root(layout)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* See [Running a Bokeh Server](https://docs.bokeh.org/en/latest/docs/user_guide/server.html)\n",
    "* The previous code doesn't function in a Jupyter Notebook, for the stated reason shown above.\n",
    "* [stack**overflow**: How to link a multiselect widget to a datatable using bokeh in a jupyter notebook?](https://stackoverflow.com/questions/50826750/how-to-link-a-multiselect-widget-to-a-datatable-using-bokeh-in-a-jupyter-noteboo/50850057#50850057) and [Embedding a Bokeh server in a Notebook](https://github.com/bokeh/bokeh/blob/master/examples/howto/server_embed/notebook_embed.ipynb) resolve the issue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "\n",
    "from bokeh.themes import Theme\n",
    "import yaml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    N = 300\n",
    "    np.random.seed(365)\n",
    "    source = ColumnDataSource(data={'x': np.random.random(N), 'y': np.random.random(N)})\n",
    "\n",
    "    # Create plots and widgets\n",
    "    plot = figure()\n",
    "    plot.scatter(x= 'x', y='y', source=source)\n",
    "    slider = Slider(start=100, end=1000, value=N, step=10, title='Number of points')\n",
    "\n",
    "    # Add callback to widgets\n",
    "    def callback(attr, old, new):\n",
    "        N = slider.value\n",
    "        source.data={'x': np.random.random(N), 'y': np.random.random(N)}\n",
    "\n",
    "    slider.on_change('value', callback)\n",
    "\n",
    "    doc.add_root(column(slider, plot))\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 350\n",
    "                width: 350\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Bokeh callbacks can be added to any property and the function always has the same format:\n",
    " - three parameters, `attr`, `old`, and `new`, that provice the name of the attribute that changed, as well as the old and new values.\n",
    "- The Bokeh server will supply these values whenever it calls one of your callbacks.\n",
    "- In this callback we read off the value from the slider with `N = slider.value`\n",
    "- Then, we create a new data dictionary for our column data source with new numpy arrays of random points.\n",
    "- The number of points is determined by the slider value.\n",
    "- Setting the `data` attribute on the column source is the only action required to update the plot.\n",
    "- No special trigger or commands are required.\n",
    " - Bokeh will notice the change, and synchronize the new values in the browser session, causing the plot to update and the reflect the new data automatically.\n",
    "- Callbacks like this are attached to Bokeh objects (like sliders) using the `on_change` method.\n",
    " - We call `on_change` with the name of the property we'd like to watch as the first argument, and the `callback` as the second.\n",
    " - In this case we want our callbacks to execute whenever the `value` of the slider changes, so we call `slider.on_change` with the arguments `value` and `callback`.\n",
    "- For our application we want the slider above the plot, so we call `column` with `slider` and then `plot` as arguments to get the vertical layout we desire.\n",
    "- Then we call `curdoc().add_root(layout)`, which adds the layout (and all that it contains) to our current document.\n",
    "- Nothing else is needed except to run the application and use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding callbacks to sliders\n",
    "\n",
    "Callbacks are functions that a user can define, like `def callback(attr, old, new)`, that can be called automatically when some property of a Bokeh object (e.g., the `value` of a `Slider`) changes.\n",
    "\n",
    "How are callbacks added for the ``value`` property of ``Slider`` objects?\n",
    "\n",
    "**Answer the question**\n",
    "\n",
    "* ~~By passing a callback function to the `callback` method.~~\n",
    "* **By passing a callback function to the `on_change` method.**\n",
    " - **A callback is added by calling `myslider.on_change('value', callback)`.**\n",
    "* ~~By assigning the callback function to the `Slider.update` property.~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to combine Bokeh models into layouts\n",
    "\n",
    "Let's begin making a Bokeh application that has a simple slider and plot, that also updates the plot based on the slider.\n",
    "\n",
    "In this exercise, your job is to first explicitly create a ColumnDataSource. You'll then combine a plot and a slider into a single column layout, and add it to the current document.\n",
    "\n",
    "After you are done, notice how in the figure you generate, the slider will not actually update the plot, because a widget callback has not been defined. You'll learn how to update the plot using widget callbacks in the next exercise.\n",
    "\n",
    "All the necessary modules have been imported for you. The plot is available in the workspace as `plot`, and the `slider` is available as slider.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Create a ColumnDataSource called `source`. Explicitly specify the `data` parameter of `ColumnDataSource()` with `{'x': x, 'y': y}`.\n",
    "* Add a line to the figure `plot`, with `'x'` and `'y'` from the ColumnDataSource.\n",
    "* Combine the slider and the plot into a column layout called `layout`. Be sure to first create a widgetbox layout using `widgetbox()` with `slider` and pass that into the `column()` function along with `plot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "x = np.array([  0.3       ,   0.33244147,   0.36488294,   0.39732441,\n",
    "         0.42976589,   0.46220736,   0.49464883,   0.5270903 ,\n",
    "         0.55953177,   0.59197324,   0.62441472,   0.65685619,\n",
    "         0.68929766,   0.72173913,   0.7541806 ,   0.78662207,\n",
    "         0.81906355,   0.85150502,   0.88394649,   0.91638796,\n",
    "         0.94882943,   0.9812709 ,   1.01371237,   1.04615385,\n",
    "         1.07859532,   1.11103679,   1.14347826,   1.17591973,\n",
    "         1.2083612 ,   1.24080268,   1.27324415,   1.30568562,\n",
    "         1.33812709,   1.37056856,   1.40301003,   1.43545151,\n",
    "         1.46789298,   1.50033445,   1.53277592,   1.56521739,\n",
    "         1.59765886,   1.63010033,   1.66254181,   1.69498328,\n",
    "         1.72742475,   1.75986622,   1.79230769,   1.82474916,\n",
    "         1.85719064,   1.88963211,   1.92207358,   1.95451505,\n",
    "         1.98695652,   2.01939799,   2.05183946,   2.08428094,\n",
    "         2.11672241,   2.14916388,   2.18160535,   2.21404682,\n",
    "         2.24648829,   2.27892977,   2.31137124,   2.34381271,\n",
    "         2.37625418,   2.40869565,   2.44113712,   2.4735786 ,\n",
    "         2.50602007,   2.53846154,   2.57090301,   2.60334448,\n",
    "         2.63578595,   2.66822742,   2.7006689 ,   2.73311037,\n",
    "         2.76555184,   2.79799331,   2.83043478,   2.86287625,\n",
    "         2.89531773,   2.9277592 ,   2.96020067,   2.99264214,\n",
    "         3.02508361,   3.05752508,   3.08996656,   3.12240803,\n",
    "         3.1548495 ,   3.18729097,   3.21973244,   3.25217391,\n",
    "         3.28461538,   3.31705686,   3.34949833,   3.3819398 ,\n",
    "         3.41438127,   3.44682274,   3.47926421,   3.51170569,\n",
    "         3.54414716,   3.57658863,   3.6090301 ,   3.64147157,\n",
    "         3.67391304,   3.70635452,   3.73879599,   3.77123746,\n",
    "         3.80367893,   3.8361204 ,   3.86856187,   3.90100334,\n",
    "         3.93344482,   3.96588629,   3.99832776,   4.03076923,\n",
    "         4.0632107 ,   4.09565217,   4.12809365,   4.16053512,\n",
    "         4.19297659,   4.22541806,   4.25785953,   4.290301  ,\n",
    "         4.32274247,   4.35518395,   4.38762542,   4.42006689,\n",
    "         4.45250836,   4.48494983,   4.5173913 ,   4.54983278,\n",
    "         4.58227425,   4.61471572,   4.64715719,   4.67959866,\n",
    "         4.71204013,   4.74448161,   4.77692308,   4.80936455,\n",
    "         4.84180602,   4.87424749,   4.90668896,   4.93913043,\n",
    "         4.97157191,   5.00401338,   5.03645485,   5.06889632,\n",
    "         5.10133779,   5.13377926,   5.16622074,   5.19866221,\n",
    "         5.23110368,   5.26354515,   5.29598662,   5.32842809,\n",
    "         5.36086957,   5.39331104,   5.42575251,   5.45819398,\n",
    "         5.49063545,   5.52307692,   5.55551839,   5.58795987,\n",
    "         5.62040134,   5.65284281,   5.68528428,   5.71772575,\n",
    "         5.75016722,   5.7826087 ,   5.81505017,   5.84749164,\n",
    "         5.87993311,   5.91237458,   5.94481605,   5.97725753,\n",
    "         6.009699  ,   6.04214047,   6.07458194,   6.10702341,\n",
    "         6.13946488,   6.17190635,   6.20434783,   6.2367893 ,\n",
    "         6.26923077,   6.30167224,   6.33411371,   6.36655518,\n",
    "         6.39899666,   6.43143813,   6.4638796 ,   6.49632107,\n",
    "         6.52876254,   6.56120401,   6.59364548,   6.62608696,\n",
    "         6.65852843,   6.6909699 ,   6.72341137,   6.75585284,\n",
    "         6.78829431,   6.82073579,   6.85317726,   6.88561873,\n",
    "         6.9180602 ,   6.95050167,   6.98294314,   7.01538462,\n",
    "         7.04782609,   7.08026756,   7.11270903,   7.1451505 ,\n",
    "         7.17759197,   7.21003344,   7.24247492,   7.27491639,\n",
    "         7.30735786,   7.33979933,   7.3722408 ,   7.40468227,\n",
    "         7.43712375,   7.46956522,   7.50200669,   7.53444816,\n",
    "         7.56688963,   7.5993311 ,   7.63177258,   7.66421405,\n",
    "         7.69665552,   7.72909699,   7.76153846,   7.79397993,\n",
    "         7.8264214 ,   7.85886288,   7.89130435,   7.92374582,\n",
    "         7.95618729,   7.98862876,   8.02107023,   8.05351171,\n",
    "         8.08595318,   8.11839465,   8.15083612,   8.18327759,\n",
    "         8.21571906,   8.24816054,   8.28060201,   8.31304348,\n",
    "         8.34548495,   8.37792642,   8.41036789,   8.44280936,\n",
    "         8.47525084,   8.50769231,   8.54013378,   8.57257525,\n",
    "         8.60501672,   8.63745819,   8.66989967,   8.70234114,\n",
    "         8.73478261,   8.76722408,   8.79966555,   8.83210702,\n",
    "         8.86454849,   8.89698997,   8.92943144,   8.96187291,\n",
    "         8.99431438,   9.02675585,   9.05919732,   9.0916388 ,\n",
    "         9.12408027,   9.15652174,   9.18896321,   9.22140468,\n",
    "         9.25384615,   9.28628763,   9.3187291 ,   9.35117057,\n",
    "         9.38361204,   9.41605351,   9.44849498,   9.48093645,\n",
    "         9.51337793,   9.5458194 ,   9.57826087,   9.61070234,\n",
    "         9.64314381,   9.67558528,   9.70802676,   9.74046823,\n",
    "         9.7729097 ,   9.80535117,   9.83779264,   9.87023411,\n",
    "         9.90267559,   9.93511706,   9.96755853,  10.        ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = [np.sin(1/y) for y in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create ColumnDataSource: source\n",
    "source = ColumnDataSource(data={'x': x, 'y': y})\n",
    "\n",
    "# create slider\n",
    "slider = Slider(title='scale', start=1, end=10, step=1, value=1)\n",
    "\n",
    "# Add a line to the plot\n",
    "plot = figure()\n",
    "plot.line('x', 'y', source=source)\n",
    "\n",
    "# Create a column layout: layout\n",
    "# layout = column(widgetbox(slider), plot)  # Deprecated\n",
    "layout = Column(slider, plot)\n",
    "\n",
    "# Add the layout to the current document\n",
    "curdoc().add_root(layout)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Since a widget callback hasn't been defined here, the slider does not update the figure.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learn about widget callbacks\n",
    "\n",
    "You'll now learn how to use widget callbacks to update the state of a Bokeh application, and in turn, the data that is presented to the user.\n",
    "\n",
    "Your job in this exercise is to use the slider's `on_change()` function to update the plot's data from the previous example. NumPy's `sin()` function will be used to update the y-axis data of the plot.\n",
    "\n",
    "Now that you have added a widget callback, notice how as you move the slider of your app, the figure also updates!\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Define a callback function `callback` with the parameters `attr`, `old`, `new`.\n",
    "* Read the current value of `slider` as a variable `scale`. You can do this using `slider.value`.\n",
    "* Compute values for the updated y using `np.sin(scale/x)`.\n",
    "* Update `source.data` with the new data dictionary. The value for `'x'` remains the same, but `'y'` should be set to the updated value.\n",
    "* Attach the callback to the `'value'` property of `slider`. This can be done using `on_change()` and passing in `'value'` and `callback`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # doesn't work in Jupyter as configured\n",
    "def callback(attr, old, new):\n",
    "\n",
    "    # Read the current value of the slider: scale\n",
    "    scale = slider.value\n",
    "\n",
    "    # Compute the updated y using np.sin(scale/x): new_y\n",
    "    new_y = np.sin(scale/x)\n",
    "\n",
    "    # Update source with the new data values\n",
    "    source.data = {'x': x, 'y': new_y}\n",
    "\n",
    "# Attach the callback to the 'value' property of slider\n",
    "slider.on_change('value', callback)\n",
    "\n",
    "# Create layout and add to current document\n",
    "layout = column(widgetbox(slider), plot)\n",
    "curdoc().add_root(layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    # Create ColumnDataSource: source\n",
    "    source = ColumnDataSource(data={'x': x, 'y': y})\n",
    "\n",
    "    # create slider\n",
    "    slider = Slider(title='scale', start=1, end=10, step=1, value=1)\n",
    "\n",
    "    # Add a line to the plot\n",
    "    plot = figure(height=400, width=400)\n",
    "    plot.line('x', 'y', source=source)\n",
    "\n",
    "    # Add callback to widgets\n",
    "    def callback(attr, old, new):\n",
    "        # Read the current value of the slider: scale\n",
    "        scale = slider.value\n",
    "\n",
    "        # Compute the updated y using np.sin(scale/x): new_y\n",
    "        new_y = np.sin(scale/x)\n",
    "\n",
    "        # Update source with the new data values\n",
    "        source.data = {'x': x, 'y': new_y}\n",
    "\n",
    "    slider.on_change('value', callback)\n",
    "\n",
    "    doc.add_root(column(slider, plot))\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 350\n",
    "                width: 350\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Updating plots from dropdowns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "\n",
    "from bokeh.io import curdoc\n",
    "from bokeh.layouts import column\n",
    "from bokeh.modles import ColumnDataSource, Select\n",
    "from bokeh.plotting import figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # doesn't work in Jupyter as configured\n",
    "\n",
    "N = 1000\n",
    "source = ColumnDataSource(data={'x': np.random.random(N), 'y': np.random.random(N)})\n",
    "\n",
    "# Create plots and widgets\n",
    "plot = figure(height=400, width=400)\n",
    "plot.scatter(x='x', y='y', source=source)\n",
    "\n",
    "menu = Select(options=['uniform', 'normal', 'lognormal'], value='uniform', title='Distribution')\n",
    "\n",
    "# Add callback to widgets\n",
    "def callback(attr, old, new):\n",
    "    if menu.value == 'uniform':\n",
    "        f=np.random.random\n",
    "    elif menu.value == 'normal':\n",
    "        f=np.random.normal\n",
    "    else:\n",
    "        f=np.random.lognormal\n",
    "    source.data={'x': f(size=N), 'y': f(size=N)}\n",
    "\n",
    "menu.on_change('value', callback)\n",
    "\n",
    "# Arrange plots and widgets in layouts\n",
    "layout = column(menu, plot)\n",
    "\n",
    "curdoc().add_root(layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    \n",
    "    N = 1000\n",
    "    source = ColumnDataSource(data={'x': np.random.random(N), 'y': np.random.random(N)})\n",
    "\n",
    "    # Create plots and widgets\n",
    "    plot = figure(height=400, width=400)\n",
    "    plot.scatter(x='x', y='y', source=source)\n",
    "\n",
    "    menu = Select(options=['uniform', 'normal', 'lognormal'], value='uniform', title='Distribution')\n",
    "\n",
    "    # Add callback to widgets\n",
    "    def callback(attr, old, new):\n",
    "        if menu.value == 'uniform':\n",
    "            f=np.random.random\n",
    "        elif menu.value == 'normal':\n",
    "            f=np.random.normal\n",
    "        else:\n",
    "            f=np.random.lognormal\n",
    "        source.data={'x': f(size=N), 'y': f(size=N)}\n",
    "\n",
    "    menu.on_change('value', callback)\n",
    "    \n",
    "    doc.add_root(column(menu, plot))\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 400\n",
    "                width: 400\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating data sources from dropdown callbacks\n",
    "\n",
    "You'll now learn to update the plot's data using a drop down menu instead of a slider. This would allow users to do things like select between different data sources to view.\n",
    "\n",
    "The ColumnDataSource `source` has been created for you along with the plot. Your job in this exercise is to add a drop down menu to update the plot's data.\n",
    "\n",
    "All necessary modules have been imported for you.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Define a callback function called `update_plot` with the parameters `attr`, `old`, `new`.\n",
    " * If the `new` selection is `'female_literacy'`, update the `'y'` value of the ColumnDataSource to `female_literacy`. Else, `'y'` should be `population`.\n",
    " * `'x'` remains `fertility` in both cases.\n",
    "* Create a dropdown select widget using `Select()`. Specify the parameters `title`, `options`, and `value`. The `options` are `'female_literacy'` and `'population'`, while the `value` is `'female_literacy'`.\n",
    "* Attach the callback to the `'value'` property of `select`. This can be done using `on_change()` and passing in `'value'` and `update_plot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "from bokeh.models import ColumnDataSource, Select"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fertility = lit.fertility\n",
    "female_literacy = lit['female literacy']\n",
    "population = lit.population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # doesn't work in Jupyter as configured\n",
    "\n",
    "# Create ColumnDataSource: source\n",
    "source = ColumnDataSource(data={\n",
    "    'x' : fertility,\n",
    "    'y' : female_literacy\n",
    "})\n",
    "\n",
    "# Create a new plot: plot\n",
    "plot = figure()\n",
    "\n",
    "# Add circles to the plot\n",
    "plot.scatter('x', 'y', source=source)\n",
    "\n",
    "# Define a callback function: update_plot\n",
    "def update_plot(attr, old, new):\n",
    "    # If the new Selection is 'female_literacy', update 'y' to female_literacy\n",
    "    if new == 'female_literacy': \n",
    "        source.data = {\n",
    "            'x' : fertility,\n",
    "            'y' : female_literacy\n",
    "        }\n",
    "    # Else, update 'y' to population\n",
    "    else:\n",
    "        source.data = {\n",
    "            'x' : fertility,\n",
    "            'y' : population\n",
    "        }\n",
    "\n",
    "# Create a dropdown Select widget: select    \n",
    "select = Select(title=\"distribution\", options=['female_literacy', 'population'], value='female_literacy')\n",
    "\n",
    "# Attach the update_plot callback to the 'value' property of select\n",
    "select.on_change('value', update_plot)\n",
    "\n",
    "# Create layout and add to current document\n",
    "layout = row(select, plot)\n",
    "curdoc().add_root(layout)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    # Create ColumnDataSource: source\n",
    "    source = ColumnDataSource(data={\n",
    "        'x' : fertility,\n",
    "        'y' : female_literacy\n",
    "    })\n",
    "\n",
    "    # Create a new plot: plot\n",
    "    plot = figure()\n",
    "\n",
    "    # Add circles to the plot\n",
    "    plot.scatter('x', 'y', source=source)\n",
    "\n",
    "    # Define a callback function: update_plot\n",
    "    def update_plot(attr, old, new):\n",
    "        # If the new Selection is 'female_literacy', update 'y' to female_literacy\n",
    "        if new == 'female_literacy': \n",
    "            source.data = {\n",
    "                'x' : fertility,\n",
    "                'y' : female_literacy\n",
    "            }\n",
    "        # Else, update 'y' to population\n",
    "        else:\n",
    "            source.data = {\n",
    "                'x' : fertility,\n",
    "                'y' : population\n",
    "            }\n",
    "\n",
    "    # Create a dropdown Select widget: select    \n",
    "    select = Select(title=\"distribution\", options=['female_literacy', 'population'], value='female_literacy')\n",
    "\n",
    "    # Attach the update_plot callback to the 'value' property of select\n",
    "    select.on_change('value', update_plot)\n",
    "    \n",
    "    doc.add_root(row(select, plot))\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 400\n",
    "                width: 400\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Synchronize two dropdowns\n",
    "\n",
    "Here, you'll practice using a dropdown callback to update another dropdown's options. This will allow you to customize your applications even further and is a powerful addition to your toolbox.\n",
    "\n",
    "Your job in this exercise is to create two dropdown select widgets and then define a callback such that one dropdown is used to update the other dropdown.\n",
    "\n",
    "All modules necessary have been imported.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Create `select1`, the first dropdown select widget. Specify the parameters `title`, `options`, and `value`.\n",
    "* Create `select2`, the second dropdown select widget. Specify the parameters `title`, `options`, and `value`.\n",
    "* Inside the callback function, if `select1.value` equals `'A'`, update the options of `select2` to `['1', '2', '3']` and set its `.value` to `'1'`.\n",
    "* If `select1.value` does not equal `'A'`, update the options of `select2` to `['100', '200', '300']` and set its value to `'100'`.\n",
    "* Attach the callback to the `'value'` property of `select1`. This can be done using `on_change()` and passing in `'value'` and `callback`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "\n",
    "# Create two dropdown Select widgets: select1, select2\n",
    "select1 = Select(title='First', options=['A', 'B'], value='A')\n",
    "select2 = Select(title='Second', options=['1', '2', '3'], value='1')\n",
    "\n",
    "# Define a callback function: callback\n",
    "def callback(attr, old, new):\n",
    "    # If select1 is 'A' \n",
    "    if select1.value == 'A':\n",
    "        # Set select2 options to ['1', '2', '3']\n",
    "        select2.options = ['1', '2', '3']\n",
    "\n",
    "        # Set select2 value to '1'\n",
    "        select2.value = '1'\n",
    "    else:\n",
    "        # Set select2 options to ['100', '200', '300']\n",
    "        select2.options = ['100', '200', '300']\n",
    "\n",
    "        # Set select2 value to '100'\n",
    "        select2.value = '100'\n",
    "\n",
    "# Attach the callback to the 'value' property of select1\n",
    "select1.on_change('value', callback)\n",
    "\n",
    "# Create layout and add to current document\n",
    "layout = widgetbox(select1, select2)\n",
    "curdoc().add_root(layout)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    # Create two dropdown Select widgets: select1, select2\n",
    "    select1 = Select(title='First', options=['A', 'B'], value='A')\n",
    "    select2 = Select(title='Second', options=['1', '2', '3'], value='1')\n",
    "\n",
    "    # Define a callback function: callback\n",
    "    def callback(attr, old, new):\n",
    "        # If select1 is 'A' \n",
    "        if select1.value == 'A':\n",
    "            # Set select2 options to ['1', '2', '3']\n",
    "            select2.options = ['1', '2', '3']\n",
    "\n",
    "            # Set select2 value to '1'\n",
    "            select2.value = '1'\n",
    "        else:\n",
    "            # Set select2 options to ['100', '200', '300']\n",
    "            select2.options = ['100', '200', '300']\n",
    "\n",
    "            # Set select2 value to '100'\n",
    "            select2.value = '100'\n",
    "\n",
    "    # Attach the callback to the 'value' property of select1\n",
    "    select1.on_change('value', callback)\n",
    "    \n",
    "    doc.add_root(Column(select1, select2))\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 400\n",
    "                width: 400\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Buttons\n",
    "\n",
    "- Instead of `on_change`, we add the button callback using `button.on_click(update)`\n",
    "\n",
    "```python\n",
    "from bokeh.models import Button\n",
    "button = Button(label='press me')\n",
    "def update():\n",
    "    # Do something interesting\n",
    "button.on_click(update)\n",
    "```\n",
    "**Button Types**\n",
    "- There are a few different button types in addition to plain buttons.\n",
    "\n",
    "```python\n",
    "from bokeh.models import CheckboxGroup, RadioGroup, Toggle\n",
    "toggle = Toggle(label='Some on/off', button_type='success')\n",
    "checkbox = CheckboxGroup(labels=['foo', 'bar', 'baz'])\n",
    "radio = RadioGroup(labels=['2000', '2010', '2020'])\n",
    "def callback(active):\n",
    "    # Active tells which button is active\n",
    "```\n",
    "\n",
    "- The previous sample code creates toggle, checkbox and radiogroup buttons.\n",
    "- These buttons have the notion of an active state: is the button currently on or off, and for checkbox and radiogroups, *which* buttons are on or off?\n",
    "- Bokeh expects callbacks for these types of buttons to take a single parameter, 'active', and when the server executes the callback it will use this parameter to provide information about which buttons are currently active.\n",
    "\n",
    "![button_types](https://raw.githubusercontent.com/trenton3983/DataCamp/master/Images/2020-03-15_interactive_data_visualization_with_bokeh/button_types.JPG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Button widgets\n",
    "\n",
    "It's time to practice adding buttons to your interactive visualizations. Your job in this exercise is to create a button and use its `on_click()` method to update a plot.\n",
    "\n",
    "All necessary modules have been imported for you. In addition, the ColumnDataSource with data `x` and `y` as well as the figure have been created for you and are available in the workspace as `source` and `plot`.\n",
    "\n",
    "When you're done, be sure to interact with the button you just added to your plot, and notice how it updates the data!\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Create a button called `button` using the function `Button()` with the label `'Update Data'`.\n",
    "* Define an update callback `update()` with no arguments.\n",
    "* Compute new y values using the code provided.\n",
    "* Update the ColumnDataSource data dictionary `source.data` with the new `'y'` value.\n",
    "* Add the update callback to the button using `on_click()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    # Create ColumnDataSource: source\n",
    "    N = 200\n",
    "    x = list(np.arange(0, 10.01, 0.05025126))\n",
    "    source = ColumnDataSource(data={'x' : x, 'y' : np.sin(x) + np.random.random(N)})\n",
    "\n",
    "    # Create a new plot: plot\n",
    "    plot = figure()\n",
    "\n",
    "    # Add circles to the plot\n",
    "    plot.scatter('x', 'y', source=source)\n",
    "\n",
    "\n",
    "    # Create a Button with label 'Update Data'\n",
    "    button = Button(label='Update Data')\n",
    "\n",
    "    # Define an update callback with no arguments: update\n",
    "    def update():\n",
    "\n",
    "        # Compute new y values: y\n",
    "        y = np.sin(x) + np.random.random(N)\n",
    "\n",
    "        # Update the ColumnDataSource data dictionary\n",
    "        source.data = {'x': x, 'y': y}\n",
    "\n",
    "    # Add the update callback to the button\n",
    "    button.on_click(update)\n",
    "\n",
    "#     # Create layout and add to current document\n",
    "#     layout = column(widgetbox(button), plot)\n",
    "#     curdoc().add_root(layout)\n",
    "    \n",
    "    doc.add_root(Column(button, plot))\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 400\n",
    "                width: 400\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Button styles\n",
    "\n",
    "You can also get really creative with your `Button` widgets.\n",
    "\n",
    "In this exercise, you'll practice using CheckboxGroup, RadioGroup, and Toggle to add multiple `Button` widgets with different styles.\n",
    "\n",
    "`curdoc` and `widgetbox` have already been imported for you.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `CheckboxGroup`, `RadioGroup`, `Toggle` from `bokeh.models`.\n",
    "* Add a Toggle called `toggle` using the `Toggle()` function with `button_type` `'success'` and `label` `'Toggle button'`.\n",
    "* Add a CheckboxGroup called `checkbox` using the `CheckboxGroup()` function with `labels=['Option 1', 'Option 2', 'Option 3']`.\n",
    "* Add a RadioGroup called `radio` using the `RadioGroup()` function with `labels=['Option 1', 'Option 2', 'Option 3']`.\n",
    "* Add a widgetbox containing the Toggle `toggle`, CheckboxGroup `checkbox`, and RadioGroup `radio` to the current document."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "\n",
    "# Import CheckboxGroup, RadioGroup, Toggle from bokeh.models\n",
    "from bokeh.models import CheckboxGroup, RadioGroup, Toggle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a Toggle: toggle\n",
    "toggle = Toggle(label='Toggle button', button_type='success')\n",
    "\n",
    "# Add a CheckboxGroup: checkbox\n",
    "checkbox = CheckboxGroup(labels=['Option 1', 'Option 2', 'Option 3'])\n",
    "\n",
    "# Add a RadioGroup: radio\n",
    "radio = RadioGroup(labels=['Option 1', 'Option 2', 'Option 3'])\n",
    "\n",
    "# Add widgetbox(toggle, checkbox, radio) to the current document\n",
    "layout = Column(toggle, checkbox, radio)\n",
    "curdoc().add_root(layout)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hosting applications for wider audiences\n",
    "\n",
    "- [Running a Bokeh Server](https://docs.bokeh.org/en/latest/docs/user_guide/server.html)\n",
    "- Bokeh applications can be published on [Anaconda Cloud](https://anaconda.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Putting It All Together! A Case Study\n",
    "\n",
    "In this final chapter, you'll build a more sophisticated Bokeh data exploration application from the ground up based on the famous Gapminder dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time to put it all together!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introducing the project dataset\n",
    "\n",
    "For the final chapter, you'll be looking at some of the Gapminder datasets combined into one tidy file called \"gapminder_tidy.csv\". This data set is available as a pandas DataFrame under the variable name data.\n",
    "\n",
    "It is always a good idea to begin with some Exploratory Data Analysis. Pandas has a number of built-in methods that help with this. For example, data.head() displays the first five rows/entries of data, while data.tail() displays the last five rows/entries. data.shape gives you information about how many rows and columns there are in the data set. Another particularly useful method is data.info(), which provides a concise summary of data, including information about the number of entries, columns, data type of each column, and number of non-null entries in each column.\n",
    "\n",
    "Use the IPython Shell and the pandas methods mentioned above to explore this data set. How many entries and columns does this data set have?\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* ~~7 entries, 10111 columns.~~\n",
    "* **10111 entries, 7 columns.**\n",
    "* ~~9000 entries, 7 columns.~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**There are 10111 entries, or rows, and 7 columns in the data set. Both the `data.info()` and `data.shape` methods provide this information.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some exploratory plots of the data\n",
    "\n",
    "Here, you'll continue your Exploratory Data Analysis by making a simple plot of Life Expectancy vs Fertility for the year 1970.\n",
    "\n",
    "Your job is to import the relevant Bokeh modules and then prepare a ColumnDataSource object with the fertility, life and Country columns, where you only select the rows with the index value 1970.\n",
    "\n",
    "Remember, as with the figures you generated in previous chapters, you can interact with your figures here with a variety of tools.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import output_file and show from bokeh.io, figure from bokeh.plotting, and HoverTool and ColumnDataSource from bokeh.models.\n",
    "* Make a ColumnDataSource called source with:\n",
    " * 'x' set to the fertility column.\n",
    " * 'y' set to the life column.\n",
    " * 'country' set to the Country column.\n",
    "* For all columns, select the rows with index value 1970. This can be done using data.loc[1970].column_name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "from bokeh.io import output_file, show\n",
    "from bokeh.plotting import figure\n",
    "from bokeh.models import HoverTool, ColumnDataSource"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gap.set_index('Year', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make the ColumnDataSource: source\n",
    "source = ColumnDataSource(data={\n",
    "    'x'       : gap.loc[1970].fertility,\n",
    "    'y'       : gap.loc[1970].life,\n",
    "    'country' : gap.loc[1970].Country,\n",
    "})\n",
    "\n",
    "# Create the figure: p\n",
    "p = figure(title='1970', x_axis_label='Fertility (children per woman)', y_axis_label='Life Expectancy (years)',\n",
    "           height=400, width=700,\n",
    "           tools=[HoverTool(tooltips='@country')])\n",
    "\n",
    "# Add a circle glyph to the figure p\n",
    "p.scatter(x='x', y='y', source=source)\n",
    "\n",
    "# Output the file and show the figure\n",
    "# output_file('gapminder.html')\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Starting the app"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Beginning with just a plot\n",
    "\n",
    "Let's get started on the Gapminder app. Your job is to make the `ColumnDataSource` object, prepare the plot, and add circles for Life expectancy vs Fertility. You'll also set x and y ranges for the axes.\n",
    "\n",
    "As in the previous chapter, the DataCamp environment executes the `bokeh serve` command to run the app for you. When you hit 'Submit Answer', you'll see in the IPython Shell that `bokeh serve script.py` gets called to run the app. This is something to keep in mind when you are creating your own interactive visualizations outside of the DataCamp environment.\n",
    "\n",
    "Instructions\n",
    "\n",
    "* Make a `ColumnDataSource` object called `source` with `'x'`, `'y'`, `'country'`, `'pop'` and `'region'` keys. The Pandas selections are provided for you.\n",
    "* Save the minimum and maximum values of the life expectancy column `data.life` as `ymin` and `ymax`. As a guide, you can refer to the way we saved the minimum and maximum values of the fertility column `data.fertility` as `xmin` and `xmax`.\n",
    "* Create a plot called `plot` by specifying the `title`, setting `plot_height` to `400`, `plot_width` to `700`, and adding the `x_range` and `y_range` parameters.\n",
    "* Add circle glyphs to the plot. Specify an `fill_alpha` of `0.8` and `source=source`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "\n",
    "from bokeh.io import curdoc\n",
    "from bokeh.models import ColumnDataSource\n",
    "from bokeh.plotting import figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make the ColumnDataSource: source\n",
    "source = ColumnDataSource(data={\n",
    "    'x'       : gap.loc[1970].fertility,\n",
    "    'y'       : gap.loc[1970].life,\n",
    "    'country' : gap.loc[1970].Country,\n",
    "    'pop'     : (gap.loc[1970].population / 20000000) + 2,\n",
    "    'region'  : gap.loc[1970].region,\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the minimum and maximum values of the fertility column: xmin, xmax\n",
    "xmin, xmax = min(gap.fertility), max(gap.fertility)\n",
    "\n",
    "# Save the minimum and maximum values of the life expectancy column: ymin, ymax\n",
    "ymin, ymax = min(gap.life), max(gap.life)\n",
    "\n",
    "# Create the figure: plot\n",
    "plot = figure(title='Gapminder Data for 1970', height=400, width=700,\n",
    "              x_range=(xmin, xmax), y_range=(ymin, ymax))\n",
    "\n",
    "# Add circle glyphs to the plot\n",
    "plot.scatter(x='x', y='y', fill_alpha=0.8, source=source)\n",
    "\n",
    "# Set the x-axis label\n",
    "plot.xaxis.axis_label ='Fertility (children per woman)'\n",
    "\n",
    "# Set the y-axis label\n",
    "plot.yaxis.axis_label = 'Life Expectancy (years)'\n",
    "\n",
    "# Add the plot to the current document and add a title\n",
    "curdoc().add_root(plot)\n",
    "curdoc().title = 'Gapminder'\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notice how life expectancy seems to go down as fertility goes up? It would be interesting to see how this varies by continent. In the next exercise, you'll do this by shading each glyph by its continent.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enhancing the plot with some shading\n",
    "\n",
    "Now that you have the base plot ready, you can enhance it by coloring each circle glyph by continent.\n",
    "\n",
    "Your job is to make a list of the unique regions from the data frame, prepare a `ColorMapper`, and add it to the circle glyph.\n",
    "\n",
    "Instructions\n",
    "\n",
    "* Make a list of the unique values from the `region` column. You can use the `unique()` and `tolist()` methods on `data.region` to do this.\n",
    "* Import `CategoricalColorMapper` from `bokeh.models` and the `Spectral6` palette from `bokeh.palettes`.\n",
    "* Use the `CategoricalColorMapper()` function to make a color mapper called `color_mapper` with `factors=regions_list` and `palette=Spectral6` (_spelled with the **letter** l, not the number 16_).\n",
    "* Add the color mapper to the circle glyph as a dictionary with `dict(field='region', transform=color_mapper)` as the argument passed to the `color` parameter of `plot.scatter()`. Also set the `legend_label` parameter to be the `'region'`.\n",
    "* Set the `legend.location` attribute of `plot` to `'top_right'` (i.e. `plot.____`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "\n",
    "from bokeh.models import CategoricalColorMapper\n",
    "from bokeh.palettes import Spectral6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a list of the unique values from the region column: regions_list\n",
    "regions_list = gap.region.unique()\n",
    "\n",
    "# Make a color mapper: color_mapper\n",
    "color_mapper = CategoricalColorMapper(factors=regions_list, palette=Spectral6)\n",
    "\n",
    "# Add the color mapper to the circle glyph\n",
    "plot.scatter(x='x', y='y', fill_alpha=0.8, source=source,\n",
    "            color=dict(field='region', transform=color_mapper),\n",
    "            legend_field='region')\n",
    "\n",
    "# Set the legend.location attribute of the plot to 'top_right'\n",
    "plot.legend.location = 'bottom_left'\n",
    "\n",
    "# Add the plot to the current document and add the title\n",
    "curdoc().add_root(plot)\n",
    "curdoc().title = 'Gapminder'\n",
    "show(plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The plot provides a lot more information now that you have added the shading. The next step is to add a slider to control the year. This will let you interactively visualize the change over the last few decades.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding a slider to vary the year\n",
    "\n",
    "Until now, we've been plotting data only for 1970. In this exercise, you'll add a slider to your plot to change the year being plotted. To do this, you'll create an `update_plot()` function and associate it with a slider to select values between 1970 and 2010.\n",
    "\n",
    "After you are done, you may have to scroll to the right to view the entire plot. As you play around with the slider, notice that the title of the plot is not updated along with the year. This is something you'll fix in the next exercise!\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import the `widgetbox` and `row` functions from `bokeh.layouts`, and the `Slider` function from `bokeh.models`.\n",
    "* Define the `update_plot` callback function with parameters `attr`, `old` and `new`.\n",
    "* Set the `yr` name to `slider.value` and set `source.data = new_data`.\n",
    "* Make a slider object called `slider` using the `Slider()` function with a `start` year of `1970`, `end` year of `2010`, `step` of `1`, `value` of `1970`, and `title` of `'Year'`.\n",
    "* Attach the callback to the `'value'` property of slider. This can be done using `on_change()` and passing in `'value'` and `update_plot`.\n",
    "* Make a row `layout` of `widgetbox(slider)` and `plot` and add it to the current document."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "\n",
    "from bokeh.layouts import widgetbox, row\n",
    "from bokeh.models import Slider"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # doesn't work in Jupyter as configured\n",
    "\n",
    "# Define the callback function: update_plot\n",
    "def update_plot(attr, old, new):\n",
    "    # Set the yr name to slider.value and new_data to source.data\n",
    "    yr = slider.value\n",
    "    new_data = {'x'       : gap.loc[yr].fertility,\n",
    "                'y'       : gap.loc[yr].life,\n",
    "                'country' : gap.loc[yr].Country,\n",
    "                'pop'     : (gap.loc[yr].population / 20000000) + 2,\n",
    "                'region'  : gap.loc[yr].region}\n",
    "    source.data = new_data\n",
    "\n",
    "\n",
    "# Make a slider object: slider\n",
    "slider = Slider(start=1970, end=2010, step=1, value=1970, title='Year')\n",
    "\n",
    "# Attach the callback to the 'value' property of slider\n",
    "slider.on_change('value', update_plot)\n",
    "\n",
    "# Make a row layout of widgetbox(slider) and plot and add it to the current document\n",
    "layout = row(Column(slider), plot)\n",
    "curdoc().add_root(layout)\n",
    "show(layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    \n",
    "    source = ColumnDataSource(data={'x'       : gap.loc[1970].fertility,\n",
    "                                    'y'       : gap.loc[1970].life,\n",
    "                                    'country' : gap.loc[1970].Country,\n",
    "                                    'pop'     : (gap.loc[1970].population / 20000000) + 2,\n",
    "                                    'region'  : gap.loc[1970].region})\n",
    "    \n",
    "    # Make a list of the unique values from the region column: regions_list\n",
    "    regions_list = gap.region.unique()\n",
    "\n",
    "    # Make a color mapper: color_mapper\n",
    "    color_mapper = CategoricalColorMapper(factors=regions_list, palette=Spectral6)\n",
    "    \n",
    "    # Save the minimum and maximum values of the fertility column: xmin, xmax\n",
    "    xmin, xmax = min(gap.fertility), max(gap.fertility)\n",
    "\n",
    "    # Save the minimum and maximum values of the life expectancy column: ymin, ymax\n",
    "    ymin, ymax = min(gap.life), max(gap.life)\n",
    "\n",
    "    # Add the color mapper to the circle glyph\n",
    "    plot = figure(title='Gapminder Data for 1970', height=400, width=700,\n",
    "                  x_range=(xmin, xmax), y_range=(ymin, ymax))\n",
    "    plot.scatter(x='x', y='y', fill_alpha=0.8, source=source,\n",
    "                color=dict(field='region', transform=color_mapper),\n",
    "                legend_field='region')\n",
    "\n",
    "    # Set the legend.location attribute of the plot to 'top_right'\n",
    "    plot.legend.location = 'bottom_left'\n",
    "\n",
    "    # Define the callback function: update_plot\n",
    "    def update_plot(attr, old, new):\n",
    "        # Set the yr name to slider.value and new_data to source.data\n",
    "        yr = slider.value\n",
    "        new_data = {'x'       : gap.loc[yr].fertility,\n",
    "                    'y'       : gap.loc[yr].life,\n",
    "                    'country' : gap.loc[yr].Country,\n",
    "                    'pop'     : (gap.loc[yr].population / 20000000) + 2,\n",
    "                    'region'  : gap.loc[yr].region}\n",
    "        source.data = new_data\n",
    "\n",
    "\n",
    "    # Make a slider object: slider\n",
    "    slider = Slider(start=1970, end=2010, step=1, value=1970, title='Year')\n",
    "\n",
    "    # Attach the callback to the 'value' property of slider\n",
    "    slider.on_change('value', update_plot)\n",
    "\n",
    "    # Make a row layout of widgetbox(slider) and plot and add it to the current document\n",
    "    layout = row(Column(slider), plot)\n",
    "\n",
    "    doc.add_root(layout)\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 400\n",
    "                width: 700\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Customizing based on user input\n",
    "\n",
    "Remember how in the plot from the previous exercise, the title did not update along with the slider? In this exercise, you'll fix this.\n",
    "\n",
    "In Python, you can format strings by specifying placeholders with the `%` keyword. For example, if you have a string `company = 'DataCamp'`, you can use `print('%s' % company)` to print DataCamp. Placeholders are useful when you are printing values that are not static, such as the value of the year slider. You can specify a placeholder for a number with `%d`. Here, when you're updating the plot title inside your callback function, you should make use of a placeholder so that the year displayed is in accordance with the value of the year slider.\n",
    "\n",
    "In addition to updating the plot title, you'll also create the callback function and slider as you did in the previous exercise, so you get a chance to practice these concepts further.\n",
    "\n",
    "All necessary modules have been imported for you, and as in the previous exercise, you may have to scroll to the right to view the entire figure.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Define the `update_plot` callback function with parameters `attr`, `old` and `new`.\n",
    "* Inside `update_plot()`, assign the value of the slider, `slider.value`, to `yr` and set `source.data = new_data`.\n",
    "* Inside `update_plot()`, specify `plot.title.text` to update the plot title and add it to the figure. You want the plot to update based on the value of the slider, which you have assigned above to `yr`. Make use of the placeholder syntax provided for you.\n",
    "* Make a slider object called `slider` using the `Slider()` function with a `start` year of `1970`, `end` year of `2010`, `step` of `1`, `value` of `1970`, and title of `'Year'`.\n",
    "* Attach the callback to the `'value'` property of slider. This can be done using `on_change()` and passing in `'value'` and `update_plot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    \n",
    "    source = ColumnDataSource(data={'x'       : gap.loc[1970].fertility,\n",
    "                                    'y'       : gap.loc[1970].life,\n",
    "                                    'country' : gap.loc[1970].Country,\n",
    "                                    'pop'     : (gap.loc[1970].population / 20000000) + 2,\n",
    "                                    'region'  : gap.loc[1970].region})\n",
    "    \n",
    "    # Make a list of the unique values from the region column: regions_list\n",
    "    regions_list = gap.region.unique()\n",
    "\n",
    "    # Make a color mapper: color_mapper\n",
    "    color_mapper = CategoricalColorMapper(factors=regions_list, palette=Spectral6)\n",
    "    \n",
    "    # Save the minimum and maximum values of the fertility column: xmin, xmax\n",
    "    xmin, xmax = min(gap.fertility), max(gap.fertility)\n",
    "\n",
    "    # Save the minimum and maximum values of the life expectancy column: ymin, ymax\n",
    "    ymin, ymax = min(gap.life), max(gap.life)\n",
    "\n",
    "    # Add the color mapper to the circle glyph\n",
    "    plot = figure(title='Gapminder Data for 1970', height=400, width=700,\n",
    "                  x_range=(xmin, xmax), y_range=(ymin, ymax),\n",
    "                  x_axis_label='Fertility (children per woman)', y_axis_label='Life Expectancy')\n",
    "    plot.scatter(x='x', y='y', fill_alpha=0.8, source=source,\n",
    "                color=dict(field='region', transform=color_mapper),\n",
    "                legend_field='region')\n",
    "\n",
    "    # Set the legend.location attribute of the plot to 'top_right'\n",
    "    plot.legend.location = 'bottom_left'\n",
    "\n",
    "    # Define the callback function: update_plot\n",
    "    def update_plot(attr, old, new):\n",
    "        # Assign the value of the slider: yr\n",
    "        yr = slider.value\n",
    "        # Set new_data\n",
    "        new_data = {\n",
    "            'x'       : gap.loc[yr].fertility,\n",
    "            'y'       : gap.loc[yr].life,\n",
    "            'country' : gap.loc[yr].Country,\n",
    "            'pop'     : (gap.loc[yr].population / 20000000) + 2,\n",
    "            'region'  : gap.loc[yr].region,\n",
    "        }\n",
    "        # Assign new_data to: source.data\n",
    "        source.data = new_data\n",
    "\n",
    "        # Add title to figure: plot.title.text\n",
    "        plot.title.text = f'Gapminder data for {yr}'\n",
    "\n",
    "    # Make a slider object: slider\n",
    "    slider = Slider(start=1970, end=2010, step=1, value=1970, title='Year')\n",
    "\n",
    "    # Attach the callback to the 'value' property of slider\n",
    "    slider.on_change('value', update_plot)\n",
    "\n",
    "    # Make a row layout of widgetbox(slider) and plot and add it to the current document\n",
    "    layout = row(Column(slider), plot)\n",
    "\n",
    "    doc.add_root(layout)\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 400\n",
    "                width: 700\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding more interactivity to the app"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding a hover tool\n",
    "\n",
    "In this exercise, you'll practice adding a hover tool to drill down into data column values and display more detailed information about each scatter point.\n",
    "\n",
    "After you're done, experiment with the hover tool and see how it displays the name of the country when your mouse hovers over a point!\n",
    "\n",
    "The figure and slider have been created for you and are available in the workspace as `plot` and `slider`.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Import `HoverTool` from `bokeh.models`.\n",
    "* Create a HoverTool object called `hover` with `tooltips=[('Country', '@country')]`.\n",
    "* Add the HoverTool object you created to the `plot` using `add_tools()`.\n",
    "* Create a row `layout` using `widgetbox(slider)` and `plot`.\n",
    "* Add the layout to the current document. This has already been done for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # imported at the top, don't run here.\n",
    "\n",
    "from bokeh.models import HoverTool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script false  # place inside the function in the next cell\n",
    "\n",
    "# Create a HoverTool: hover\n",
    "hover = HoverTool(tooltips=[('Country', '@country')])\n",
    "\n",
    "# Add the HoverTool to the plot\n",
    "plot.add_tools(hover)\n",
    "\n",
    "# Create layout: layout\n",
    "layout = row(widgetbox(slider), plot)\n",
    "\n",
    "# Add layout to current document\n",
    "curdoc().add_root(layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    \n",
    "    source = ColumnDataSource(data={'x'       : gap.loc[1970].fertility,\n",
    "                                    'y'       : gap.loc[1970].life,\n",
    "                                    'country' : gap.loc[1970].Country,\n",
    "                                    'pop'     : (gap.loc[1970].population / 20000000) + 2,\n",
    "                                    'region'  : gap.loc[1970].region})\n",
    "    \n",
    "    # Make a list of the unique values from the region column: regions_list\n",
    "    regions_list = gap.region.unique()\n",
    "\n",
    "    # Make a color mapper: color_mapper\n",
    "    color_mapper = CategoricalColorMapper(factors=regions_list, palette=Spectral6)\n",
    "    \n",
    "    # Save the minimum and maximum values of the fertility column: xmin, xmax\n",
    "    xmin, xmax = min(gap.fertility), max(gap.fertility)\n",
    "\n",
    "    # Save the minimum and maximum values of the life expectancy column: ymin, ymax\n",
    "    ymin, ymax = min(gap.life), max(gap.life)\n",
    "\n",
    "    # Add the color mapper to the circle glyph\n",
    "    plot = figure(title='Gapminder Data for 1970', height=400, width=700,\n",
    "                  x_range=(xmin, xmax), y_range=(ymin, ymax),\n",
    "                  x_axis_label='Fertility (children per woman)', y_axis_label='Life Expectancy')\n",
    "    plot.scatter(x='x', y='y', fill_alpha=0.8, source=source,\n",
    "                color=dict(field='region', transform=color_mapper),\n",
    "                legend_field='region')\n",
    "\n",
    "    # Set the legend.location attribute of the plot to 'top_right'\n",
    "    plot.legend.location = 'bottom_left'\n",
    "\n",
    "    # Define the callback function: update_plot\n",
    "    def update_plot(attr, old, new):\n",
    "        # Assign the value of the slider: yr\n",
    "        yr = slider.value\n",
    "        # Set new_data\n",
    "        new_data = {\n",
    "            'x'       : gap.loc[yr].fertility,\n",
    "            'y'       : gap.loc[yr].life,\n",
    "            'country' : gap.loc[yr].Country,\n",
    "            'pop'     : (gap.loc[yr].population / 20000000) + 2,\n",
    "            'region'  : gap.loc[yr].region,\n",
    "        }\n",
    "        # Assign new_data to: source.data\n",
    "        source.data = new_data\n",
    "\n",
    "        # Add title to figure: plot.title.text\n",
    "        plot.title.text = f'Gapminder data for {yr}'\n",
    "        \n",
    "    # Create a HoverTool: hover\n",
    "    hover = HoverTool(tooltips=[('Country', '@country')])\n",
    "\n",
    "    # Add the HoverTool to the plot\n",
    "    plot.add_tools(hover)\n",
    "\n",
    "    # Make a slider object: slider\n",
    "    slider = Slider(start=1970, end=2010, step=1, value=1970, title='Year')\n",
    "\n",
    "    # Attach the callback to the 'value' property of slider\n",
    "    slider.on_change('value', update_plot)\n",
    "\n",
    "    # Make a row layout of widgetbox(slider) and plot and add it to the current document\n",
    "    layout = row(Column(slider), plot)\n",
    "\n",
    "    doc.add_root(layout)\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 400\n",
    "                width: 700\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding dropdowns to the app\n",
    "\n",
    "As a final step in enhancing your application, in this exercise you'll add dropdowns for interactively selecting different data features. In combination with the hover tool you added in the previous exercise, as well as the slider to change the year, you'll have a powerful app that allows you to interactively and quickly extract some great insights from the dataset!\n",
    "\n",
    "All necessary modules have been imported, and the previous code you wrote is taken care of. In the provided sample code, the dropdown for selecting features on the x-axis has been added for you. Using this as a reference, your job in this final exercise is to add a dropdown menu for selecting features on the y-axis.\n",
    "\n",
    "Take a moment, after you are done, to enjoy exploring the visualization by experimenting with the hover tools, sliders, and dropdown menus that you have learned how to implement in this course.\n",
    "\n",
    "**Instructions**\n",
    "\n",
    "* Inside the update_plot() callback function, read in the current value of the y dropdown, y_select.\n",
    "* Use plot.yaxis.axis_label to label the y-axis as y.\n",
    "* Set the start and end range of the y-axis of plot.\n",
    "* Specify the parameters of the y_select dropdown widget: options, value, and title. The default value should be 'life'.\n",
    "* Attach the callback to the 'value' property of y_select. This can be done using on_change() and passing in 'value' and update_plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gap.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bkapp(doc):\n",
    "    \n",
    "    source = ColumnDataSource(data={'x'       : gap.loc[1970].fertility,\n",
    "                                    'y'       : gap.loc[1970].life,\n",
    "                                    'country' : gap.loc[1970].Country,\n",
    "                                    'pop'     : (gap.loc[1970].population / 20000000) + 2,\n",
    "                                    'region'  : gap.loc[1970].region})\n",
    "\n",
    "    # Make a list of the unique values from the region column: regions_list\n",
    "    regions_list = gap.region.unique()\n",
    "\n",
    "    # Make a color mapper: color_mapper\n",
    "    color_mapper = CategoricalColorMapper(factors=regions_list, palette=Spectral6)\n",
    "\n",
    "    # Save the minimum and maximum values of the fertility column: xmin, xmax\n",
    "    xmin, xmax = min(gap.fertility), max(gap.fertility)\n",
    "\n",
    "    # Save the minimum and maximum values of the life expectancy column: ymin, ymax\n",
    "    ymin, ymax = min(gap.life), max(gap.life)\n",
    "\n",
    "    # Add the color mapper to the circle glyph\n",
    "    plot = figure(title='Gapminder Data for 1970', height=400, width=700,\n",
    "                  x_range=(xmin, xmax), y_range=(ymin, ymax),\n",
    "                  x_axis_label='Fertility (children per woman)', y_axis_label='Life Expectancy')\n",
    "\n",
    "    plot.scatter(x='x', y='y', fill_alpha=0.8, source=source,\n",
    "                color=dict(field='region', transform=color_mapper),\n",
    "                legend_field='region')\n",
    "\n",
    "    # Set the legend.location attribute of the plot to 'top_right'\n",
    "#     plot.legend.location = (457, -10)\n",
    "    plot.legend.location = 'top_right'\n",
    "    plot.legend.background_fill_color = None\n",
    "    plot.legend.background_fill_alpha = 0.5\n",
    "    \n",
    "    # Define the callback: update_plot\n",
    "    def update_plot(attr, old, new):\n",
    "        # Read the current value off the slider and 2 dropdowns: yr, x, y\n",
    "        yr = slider.value\n",
    "        x = x_select.value\n",
    "        y = y_select.value\n",
    "        # Label axes of plot\n",
    "        plot.xaxis.axis_label = x\n",
    "        plot.yaxis.axis_label = y\n",
    "        # Set new_data\n",
    "        new_data = {\n",
    "            'x'       : gap.loc[yr][x],\n",
    "            'y'       : gap.loc[yr][y],\n",
    "            'country' : gap.loc[yr].Country,\n",
    "            'pop'     : (gap.loc[yr].population / 20000000) + 2,\n",
    "            'region'  : gap.loc[yr].region,\n",
    "        }\n",
    "        # Assign new_data to source.data\n",
    "        source.data = new_data\n",
    "\n",
    "        # Set the range of all axes\n",
    "        plot.x_range.start = min(gap[x])\n",
    "        plot.x_range.end = max(gap[x])\n",
    "        plot.y_range.start = min(gap[y])\n",
    "        plot.y_range.end = max(gap[y])\n",
    "\n",
    "        # Add title to plot\n",
    "        plot.title.text = f'Gapminder data for {yr}'\n",
    "\n",
    "    # Create a HoverTool: hover\n",
    "    hover = HoverTool(tooltips=[('Country', '@country')])\n",
    "\n",
    "    # Add the HoverTool to the plot\n",
    "    plot.add_tools(hover)\n",
    "\n",
    "    # Make a slider object: slider\n",
    "    slider = Slider(start=1970, end=2010, step=1, value=1970, title='Year')\n",
    "\n",
    "    # Attach the callback to the 'value' property of slider\n",
    "    slider.on_change('value', update_plot)\n",
    "\n",
    "    # Create a dropdown Select widget for the x data: x_select\n",
    "    x_select = Select(\n",
    "        options=['fertility', 'life', 'child_mortality', 'gdp'],\n",
    "        value='fertility',\n",
    "        title='x-axis data'\n",
    "    )\n",
    "\n",
    "    # Attach the update_plot callback to the 'value' property of x_select\n",
    "    x_select.on_change('value', update_plot)\n",
    "\n",
    "    # Create a dropdown Select widget for the y data: y_select\n",
    "    y_select = Select(\n",
    "        options=['fertility', 'life', 'child_mortality', 'gdp'],\n",
    "        value='life',\n",
    "        title='y-axis data'\n",
    "    )\n",
    "\n",
    "    # Attach the update_plot callback to the 'value' property of y_select\n",
    "    y_select.on_change('value', update_plot)\n",
    "\n",
    "    # Create layout and add to current document\n",
    "    layout = row(Column(slider, x_select, y_select), plot)\n",
    "    \n",
    "    doc.add_root(layout)\n",
    "\n",
    "    doc.theme = Theme(json=yaml.load(\"\"\"\n",
    "        attrs:\n",
    "            Figure:\n",
    "                background_fill_color: \"#DDDDDD\"\n",
    "                outline_line_color: white\n",
    "                toolbar_location: above\n",
    "                height: 400\n",
    "                width: 700\n",
    "            Grid:\n",
    "                grid_line_dash: [6, 4]\n",
    "                grid_line_color: white\n",
    "    \"\"\", Loader=yaml.FullLoader)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this won't disply in the HTML notebook\n",
    "show(bkapp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Certificate\n",
    "\n",
    "![](https://raw.githubusercontent.com/trenton3983/DataCamp/master/Images/2020-03-15_interactive_data_visualization_with_bokeh/2020-05-21_certificate.jpg)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}