BFS on Wikipedia Graph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first connect to our database. <br>\n",
    "For practice or table analysis, please see the Jupyter Notebook for Checking SQL Data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import sqlite3 as sql\n",
    "import queue\n",
    "import random\n",
    "import collections\n",
    "\n",
    "database = \"sdow.sqlite\"\n",
    "connection = sql.connect(database)\n",
    "\n",
    "query_pages = '''SELECT * FROM pages'''\n",
    "df = pd.read_sql_query(query_pages, connection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>1 Degree of Separation:</b><br>\n",
    "18978754\tApple To 10031955\tSpartan_(apple)\t<br>\n",
    "<br> \n",
    "<b>2 Degrees of Separation:</b><br>\n",
    "477917      Lemur To 378661     Thermoregulation <br>\n",
    "\n",
    "<b>3 Degrees of Separation</b><br>\n",
    "11271498 Egress To 34368 Yellow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have a naive Breadth First Search. Given enough time we are assured at least the shortest path. <br>\n",
    "We continue searching past the shortest path to find as many paths as possible within i iterations. <br>\n",
    "However, this algorithm is extremely inefficient and has trouble finding connected paths for even\n",
    "3 Degrees of Separation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def BFS(start, end):\n",
    "    queue = collections.deque()\n",
    "    startid = getIDFromTitle(start)\n",
    "    endid = getIDFromTitle(end)\n",
    "    \n",
    "    if queryExistenceFromID(startid) == False: return []   \n",
    "    if queryExistenceFromID(endid) == False: return []\n",
    "    \n",
    "    all_valid_paths = list()\n",
    "    visited = [False] * (len(df)) \n",
    "    \n",
    "    print_path = [getTitle(startid)]\n",
    "    temp_path = [startid]\n",
    "    queue.append(temp_path)\n",
    "    \n",
    "    visited[hashForIndex(temp_path[0])] = True\n",
    "    \n",
    "    i=0\n",
    "    while queue and i<5000:\n",
    "        tmp_path = queue.popleft()\n",
    "        last_node = tmp_path[len(tmp_path)-1]\n",
    "        visited[hashForIndex(last_node)] = True\n",
    "        \n",
    "        if str(last_node) == str(endid):\n",
    "            all_valid_paths.append(tmp_path)\n",
    "            print(\"VALID_PATH : \",getTitles(tmp_path))\n",
    "        for neighbor in getOutgoingNeighbors(last_node):\n",
    "            if neighbor not in tmp_path and visited[hashForIndex(int(neighbor))]==False:\n",
    "                new_path = []\n",
    "                new_path = tmp_path + [neighbor]\n",
    "                queue.append(new_path)\n",
    "        i=i+1\n",
    "    return all_valid_paths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an implementation for a Multidirectional Breadth First Search. <br><br>\n",
    "We search from both the start and end of our query. When these searches meet in the middle they are <br>\n",
    "concatenated together. This process continues for i iterations to find as many paths as possible. <br>\n",
    "We are not guaranteed <b>every</b> path as Wikipedia's data is circular by nature and can provide an infinite<br>\n",
    "number of paths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiBFS(start, end):    \n",
    "    startq = collections.deque()\n",
    "    endq = collections.deque()\n",
    "    \n",
    "    startid = getIDFromTitle(start)\n",
    "    endid = getIDFromTitle(end)\n",
    "     \n",
    "    if startid == endid: return [start]    \n",
    "    if queryExistenceFromID(startid) == False: return []   \n",
    "    if queryExistenceFromID(endid) == False: return []\n",
    "\n",
    "    all_valid_paths = list()\n",
    "    \n",
    "    fwd_visited = [False] * (len(df)) \n",
    "    back_visited = [False] * (len(df))\n",
    "    \n",
    "    temp_path_start = [startid]\n",
    "    temp_path_end = [endid]\n",
    "    \n",
    "    startq.append(temp_path_start)\n",
    "    endq.append(temp_path_end)\n",
    "    \n",
    "    fwd_visited[hashForIndex(int(temp_path_start[0]))] = True\n",
    "    back_visited[hashForIndex(int(temp_path_end[0]))] = True\n",
    "    \n",
    "    i=0\n",
    "    while startq and endq and i<50:\n",
    "        if len(startq)<=len(endq):\n",
    "            if startq:\n",
    "                tmp_path_start = startq.popleft()\n",
    "                last_node = tmp_path_start[len(tmp_path_start)-1]\n",
    "                fwd_visited[int(hashForIndex(last_node))] = True\n",
    "                if str(last_node) == str(endid) or last_node in endq:\n",
    "                    all_valid_paths.append(tmp_path_start)\n",
    "                    print(\"A_VALID_PATH : \",getTitles(tmp_path_start))\n",
    "\n",
    "                for neighbor in getOutgoingNeighbors(last_node):\n",
    "                    if neighbor not in tmp_path_start and fwd_visited[hashForIndex(int(neighbor))]==False:\n",
    "                        new_path = []\n",
    "                        new_path = tmp_path_start + [neighbor]\n",
    "                        startq.append(new_path)\n",
    "        \n",
    "        else:\n",
    "            if endq:\n",
    "                tmp_path_end = endq.popleft()\n",
    "                last_node = tmp_path_end[len(tmp_path_end)-1]\n",
    "                back_visited[int(hashForIndex(last_node))] = True\n",
    "                if str(last_node) == str(startid) or last_node in startq:\n",
    "                    all_valid_paths.append(tmp_path_end)\n",
    "                    print(\"B_VALID_PATH : \",getTitles(tmp_path_end))\n",
    "\n",
    "                for neighbor in getIncomingNeighbors(last_node):\n",
    "                    if neighbor not in tmp_path_end and back_visited[hashForIndex(int(neighbor))]==False:\n",
    "                        new_path = []\n",
    "                        new_path = tmp_path_end + [neighbor]\n",
    "                        endq.append(new_path)\n",
    "                \n",
    "        i=i+1\n",
    "    return all_valid_paths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a collection of helper methods for querying our database. We conveniently have acess to neighbors,<br>\n",
    "titles, IDs, ect.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hashForIndex(id):\n",
    "    return hash(id) % len(df)\n",
    "\n",
    "#Takes in the current ID and the database. Returns the list of neighbors.\n",
    "def getOutgoingNeighbors(current):\n",
    "    neighborList = []\n",
    "    link = '''SELECT * FROM links WHERE id = ''' + str(current)\n",
    "    neigh = pd.read_sql_query(link, connection)\n",
    "    neighbors = neigh.iloc[0]['outgoing_links']\n",
    "    \n",
    "    neighbor = \"\"\n",
    "    for char in neighbors:\n",
    "        if char != '|':\n",
    "            neighbor+=char\n",
    "        else:\n",
    "            neighborList.append(neighbor)\n",
    "            neighbor = \"\"\n",
    "    return neighborList\n",
    "\n",
    "def getIncomingNeighbors(current):\n",
    "    neighborList = []\n",
    "    link = '''SELECT * FROM links WHERE id = ''' + str(current)\n",
    "    neigh = pd.read_sql_query(link, connection)\n",
    "    neighbors = neigh.iloc[0]['incoming_links']\n",
    "    \n",
    "    neighbor = \"\"\n",
    "    for char in neighbors:\n",
    "        if char != '|':\n",
    "            neighbor+=char\n",
    "        else:\n",
    "            neighborList.append(neighbor)\n",
    "            neighbor = \"\"\n",
    "    return neighborList\n",
    "\n",
    "def checkQueueForElement(queue, query):\n",
    "    element_found = False \n",
    "    temp_queue = queue\n",
    "    this_queue = queue\n",
    "    for element in range(this_queue.qsize()):\n",
    "        check = this_queue.get()\n",
    "        print(str(check[0]))\n",
    "        print(str(query))\n",
    "        if str(check[0]) == str(query):\n",
    "            element_found=True\n",
    "    return element_found\n",
    "\n",
    "def getTitle(query):\n",
    "    query_string = '''SELECT * FROM pages WHERE id = ''' + str(query)\n",
    "    title = pd.read_sql_query(query_string, connection)\n",
    "    cleaned_title = title.iloc[0]['title']\n",
    "    return cleaned_title\n",
    "\n",
    "def getTitles(querys):\n",
    "    cleaned_querys = list()\n",
    "    for query in querys:\n",
    "        query_string = '''SELECT * FROM pages WHERE id = ''' + str(query)\n",
    "        title = pd.read_sql_query(query_string, connection)\n",
    "        cleaned_title = title.iloc[0]['title']\n",
    "        cleaned_querys.append(cleaned_title)\n",
    "        \n",
    "    return cleaned_querys\n",
    "\n",
    "def getIDFromTitle(title):\n",
    "    try:\n",
    "        query = '''SELECT * FROM pages where title = ''' + \"'\" +str(title) + \"'\"\n",
    "        queryID = pd.read_sql_query(query, connection)\n",
    "        returnID = queryID.iloc[0]['id']\n",
    "        return returnID\n",
    "    except:\n",
    "        print(title + \" does not exist!\")\n",
    "\n",
    "def queryExistenceFromID(query):\n",
    "    try:\n",
    "        existence = False\n",
    "        query_string = '''SELECT * FROM pages WHERE id = ''' + str(query)\n",
    "        answer = pd.read_sql_query(query_string, connection)\n",
    "\n",
    "        if len(answer) != 0: existence = True\n",
    "\n",
    "        return existence\n",
    "    except: \n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our queries accept a String input. <br>\n",
    "Notice, we output a list of path ID's. This is more efficient then converting the ID back to <br>\n",
    "the title at this step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Austin\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:48: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A_VALID_PATH :  ['Apple', 'Spartan_(apple)']\n",
      "[[18978754, '10031955']]\n"
     ]
    }
   ],
   "source": [
    "start = 'Apple' \n",
    "end = 'Spartan_(apple)'\n",
    "valid_paths = multiBFS(start, end)\n",
    "print(valid_paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VALID_PATH :  ['Apple', 'Spartan_(apple)']\n",
      "VALID_PATH :  ['Apple', 'Applejack_(drink)', 'Spartan_(apple)']\n",
      "VALID_PATH :  ['Apple', 'Pinova', 'Spartan_(apple)']\n",
      "VALID_PATH :  ['Apple', 'Cameo_(apple)', 'Spartan_(apple)']\n",
      "VALID_PATH :  ['Apple', 'Red_Delicious', 'Spartan_(apple)']\n"
     ]
    }
   ],
   "source": [
    "valid_paths = BFS('Apple', 'Spartan_(apple)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting a collection of valid paths is nice, but it would be more descriptive if we could see the paths. <br>\n",
    "Below we use the networkx library to visualize our graph. We use a Directed Graph to display the direct <br>\n",
    "paths from our start to our finish!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 864x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import array as arr \n",
    "G = nx.DiGraph()\n",
    "            \n",
    "for path in valid_paths:\n",
    "    titled_paths = getTitles(path)\n",
    "\n",
    "    for index, title in enumerate(titled_paths[:-1]):\n",
    "        G.add_edges_from([(title, titled_paths[index+1])])\n",
    "\n",
    "pos = nx.planar_layout(G)\n",
    "nx.draw_networkx_nodes(G, pos)\n",
    "nx.draw_networkx_labels(G, pos)\n",
    "nx.draw_networkx_edges(G, pos, arrows=True,edge_color='b')\n",
    "plt.figure(3,figsize=(12,12))\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualizing the data inside a Jupyter Notebook file can be difficult. It would be nice if we could <br>\n",
    "at least zoom in on our data and have our nodes more spread out. The below function takes a graph <br>\n",
    "and saves it to a PDF file. This way large graphs are a little easier to see."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    " def save_graph(graph,file_name):\n",
    "    #initialze Figure\n",
    "    plt.figure(num=None, figsize=(40, 40), dpi=8)\n",
    "    plt.axis('off')\n",
    "    fig = plt.figure(1)\n",
    "    pos = nx.planar_layout(graph)\n",
    "    nx.draw_networkx_nodes(graph,pos)\n",
    "    nx.draw_networkx_edges(graph,pos)\n",
    "    nx.draw_networkx_labels(graph,pos)\n",
    "\n",
    "    cut = 2\n",
    "    xmax = cut * max(xx for xx, yy in pos.values())\n",
    "    ymax = cut * max(yy for xx, yy in pos.values())\n",
    "    plt.xlim(-10, xmax+10)\n",
    "    plt.ylim(-10, ymax+10)\n",
    "\n",
    "    plt.savefig(file_name)\n",
    "    plt.close()\n",
    "    del fig\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_graph(G,\"my_graph.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Below is an implementation for this project created by Jacob Wenger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This was not the inspiration for this project, but I came across this work while researching for my own project. This is a very clean and extremely efficient implementation that does a lot of the things I tried to complete in this project. The project code below must be run and then we show some examples and measure the efficiency of this algorithm. <br><br>\n",
    "This is a multidirectional BFS on the wikipedia database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Github: https://github.com/jwngr/sdow/blob/master/sdow/breadth_first_search.py <br>\n",
    "Website: https://www.sixdegreesofwikipedia.com/ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_paths(page_ids, visited_dict):\n",
    "  \"\"\"Returns a list of paths which go from the provided pages to either the source or target pages.\n",
    "  Args:\n",
    "    page_ids: The list of page IDs whose paths to get.\n",
    "  Returns:\n",
    "    list(list(int)): A list of lists of page IDs corresponding to paths from the provided page IDs\n",
    "      to the source or target pages.\n",
    "  \"\"\"\n",
    "  paths = []\n",
    "\n",
    "  for page_id in page_ids:\n",
    "    if page_id is None:\n",
    "      # If the current page ID is None, it is either the source or target page, so return an empty\n",
    "      # path.\n",
    "      return [[]]\n",
    "    else:\n",
    "      # Otherwise, recursively get the paths for the current page's children and append them to\n",
    "      # paths.\n",
    "      current_paths = get_paths(visited_dict[page_id], visited_dict)\n",
    "      for current_path in current_paths:\n",
    "        new_path = list(current_path)\n",
    "        new_path.append(page_id)\n",
    "        paths.append(new_path)\n",
    "\n",
    "  return paths\n",
    "\n",
    "\n",
    "def breadth_first_search(source_page_id, target_page_id, database):\n",
    "  \"\"\"Returns a list of shortest paths from the source to target pages by running a bi-directional\n",
    "  breadth-first search on the graph of Wikipedia pages.\n",
    "  Args:\n",
    "    source_page_id: The page at which to start the search.\n",
    "    target_page_id: The page at which to end the search.\n",
    "    database: An Database instance which contains methods to query the Wikipedia database.\n",
    "  Returns:\n",
    "    list(list(int)): A list of lists of page IDs corresponding to paths from the source page to the\n",
    "      target page.\n",
    "  \"\"\"\n",
    "  # If the source and target page IDs are identical, return the trivial path.\n",
    "  if source_page_id == target_page_id:\n",
    "    return [[source_page_id]]\n",
    "\n",
    "  paths = []\n",
    "\n",
    "  # The unvisited dictionaries are a mapping from page ID to a list of that page's parents' IDs.\n",
    "  # None signifies that the source and target pages have no parent.\n",
    "  unvisited_forward = {source_page_id: [None]}\n",
    "  unvisited_backward = {target_page_id: [None]}\n",
    "\n",
    "  # The visited dictionaries are a mapping from page ID to a list of that page's parents' IDs.\n",
    "  visited_forward = {}\n",
    "  visited_backward = {}\n",
    "\n",
    "  # Set the initial forward and backward depths to 0.\n",
    "  forward_depth = 0\n",
    "  backward_depth = 0\n",
    "\n",
    "  # Continue the breadth first search until a path has been found or either of the unvisited lists\n",
    "  # are empty.\n",
    "  while (len(paths) == 0) and ((len(unvisited_forward) != 0) and (len(unvisited_backward) != 0)):\n",
    "    # Run the next iteration of the breadth first search in whichever direction has the smaller number\n",
    "    # of links at the next level.\n",
    "    forward_links_count = database.fetch_outgoing_links_count(unvisited_forward.keys())\n",
    "    backward_links_count = database.fetch_incoming_links_count(unvisited_backward.keys())\n",
    "\n",
    "    if forward_links_count < backward_links_count:\n",
    "      #---  FORWARD BREADTH FIRST SEARCH  ---#\n",
    "      forward_depth += 1\n",
    "\n",
    "      # Fetch the pages which can be reached from the currently unvisited forward pages.\n",
    "      # The replace() bit is some hackery to handle Python printing a trailing ',' when there is\n",
    "      # only one key.\n",
    "      outgoing_links = database.fetch_outgoing_links(unvisited_forward.keys())\n",
    "\n",
    "      # Mark all of the unvisited forward pages as visited.\n",
    "      for page_id in unvisited_forward:\n",
    "        visited_forward[page_id] = unvisited_forward[page_id]\n",
    "\n",
    "      # Clear the unvisited forward dictionary.\n",
    "      unvisited_forward.clear()\n",
    "\n",
    "      for source_page_id, target_page_ids in outgoing_links:\n",
    "        for target_page_id in target_page_ids.split('|'):\n",
    "          if target_page_id:\n",
    "            target_page_id = int(target_page_id)\n",
    "            # If the target page is in neither visited forward nor unvisited forward, add it to\n",
    "            # unvisited forward.\n",
    "            if (target_page_id not in visited_forward) and (target_page_id not in unvisited_forward):\n",
    "              unvisited_forward[target_page_id] = [source_page_id]\n",
    "\n",
    "            # If the target page is in unvisited forward, add the source page as another one of its\n",
    "            # parents.\n",
    "            elif target_page_id in unvisited_forward:\n",
    "              unvisited_forward[target_page_id].append(source_page_id)\n",
    "\n",
    "    else:\n",
    "      #---  BACKWARD BREADTH FIRST SEARCH  ---#\n",
    "      backward_depth += 1\n",
    "\n",
    "      # Fetch the pages which can reach the currently unvisited backward pages.\n",
    "      incoming_links = database.fetch_incoming_links(unvisited_backward.keys())\n",
    "\n",
    "      # Mark all of the unvisited backward pages as visited.\n",
    "      for page_id in unvisited_backward:\n",
    "        visited_backward[page_id] = unvisited_backward[page_id]\n",
    "\n",
    "      # Clear the unvisited backward dictionary.\n",
    "      unvisited_backward.clear()\n",
    "\n",
    "      for target_page_id, source_page_ids in incoming_links:\n",
    "        for source_page_id in source_page_ids.split('|'):\n",
    "          if source_page_id:\n",
    "            source_page_id = int(source_page_id)\n",
    "            # If the source page is in neither visited backward nor unvisited backward, add it to\n",
    "            # unvisited backward.\n",
    "            if (source_page_id not in visited_backward) and (source_page_id not in unvisited_backward):\n",
    "              unvisited_backward[source_page_id] = [target_page_id]\n",
    "\n",
    "            # If the source page is in unvisited backward, add the target page as another one of its\n",
    "            # parents.\n",
    "            elif source_page_id in unvisited_backward:\n",
    "              unvisited_backward[source_page_id].append(target_page_id)\n",
    "\n",
    "    #---  CHECK FOR PATH COMPLETION  ---#\n",
    "    # The search is complete if any of the pages are in both unvisited backward and unvisited, so\n",
    "    # find the resulting paths.\n",
    "    for page_id in unvisited_forward:\n",
    "      if page_id in unvisited_backward:\n",
    "        paths_from_source = get_paths(unvisited_forward[page_id], visited_forward)\n",
    "        paths_from_target = get_paths(unvisited_backward[page_id], visited_backward)\n",
    "\n",
    "        for path_from_source in paths_from_source:\n",
    "          for path_from_target in paths_from_target:\n",
    "            current_path = list(path_from_source) + [page_id] + list(reversed(path_from_target))\n",
    "\n",
    "            # TODO: This line shouldn't be required, but there are some unexpected duplicates.\n",
    "            if current_path not in paths:\n",
    "              paths.append(current_path)\n",
    "\n",
    "  return paths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Database class created with helpers that fetch database information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Wrapper for reading from and writing to the SDOW database.\n",
    "\"\"\"\n",
    "\n",
    "import os.path\n",
    "import sqlite3\n",
    "\n",
    "\n",
    "class Database(object):\n",
    "  \"\"\"Wrapper for connecting to the SDOW database.\"\"\"\n",
    "\n",
    "  def __init__(self, sdow_database, searches_database):\n",
    "    if not os.path.isfile(sdow_database):\n",
    "      raise IOError('Specified SQLite file \"{0}\" does not exist.'.format(sdow_database))\n",
    "\n",
    "    if not os.path.isfile(searches_database):\n",
    "      raise IOError('Specified SQLite file \"{0}\" does not exist.'.format(searches_database))\n",
    "\n",
    "    self.sdow_conn = sqlite3.connect(sdow_database, check_same_thread=False)\n",
    "    self.searches_conn = sqlite3.connect(searches_database, check_same_thread=False)\n",
    "\n",
    "    self.sdow_cursor = self.sdow_conn.cursor()\n",
    "    self.searches_cursor = self.searches_conn.cursor()\n",
    "\n",
    "    self.sdow_cursor.arraysize = 1000\n",
    "    self.searches_cursor.arraysize = 1000\n",
    "\n",
    "  def fetch_page(self, page_title):\n",
    "    \"\"\"Returns the ID and title of the non-redirect page corresponding to the provided title,\n",
    "    handling titles with incorrect capitalization as well as redirects.\n",
    "    Args:\n",
    "      page_title: The title of the page to fetch.\n",
    "    Returns:\n",
    "      (int, str, bool): A tuple containing the page ID, title, and whether or not a redirect was\n",
    "      followed.\n",
    "      OR\n",
    "      None: If no page exists.\n",
    "    Raises:\n",
    "      ValueError: If the provided page title is invalid.\n",
    "    \"\"\"\n",
    "    sanitized_page_title = helpers.get_sanitized_page_title(page_title)\n",
    "\n",
    "    query = 'SELECT * FROM pages WHERE title = ? COLLATE NOCASE;'\n",
    "    query_bindings = (sanitized_page_title,)\n",
    "    self.sdow_cursor.execute(query, query_bindings)\n",
    "\n",
    "    # Because the above query is case-insensitive (due to the COLLATE NOCASE), multiple articles\n",
    "    # can be matched.\n",
    "    results = self.sdow_cursor.fetchall()\n",
    "\n",
    "    if not results:\n",
    "      raise ValueError(\n",
    "          'Invalid page title {0} provided. Page title does not exist.'.format(page_title))\n",
    "\n",
    "    # First, look for a non-redirect page which has exact match with the page title.\n",
    "    for current_page_id, current_page_title, current_page_is_redirect in results:\n",
    "      if current_page_title == sanitized_page_title and not current_page_is_redirect:\n",
    "        return (current_page_id, helpers.get_readable_page_title(current_page_title), False)\n",
    "\n",
    "    # Next, look for a match with a non-redirect page.\n",
    "    for current_page_id, current_page_title, current_page_is_redirect in results:\n",
    "      if not current_page_is_redirect:\n",
    "        return (current_page_id, helpers.get_readable_page_title(current_page_title), False)\n",
    "\n",
    "    # If all the results are redirects, use the page to which the first result redirects.\n",
    "    query = 'SELECT target_id, title FROM redirects INNER JOIN pages ON pages.id = target_id WHERE source_id = ?;'\n",
    "    query_bindings = (results[0][0],)\n",
    "    self.sdow_cursor.execute(query, query_bindings)\n",
    "\n",
    "    result = self.sdow_cursor.fetchone()\n",
    "\n",
    "    # TODO: This will no longer be required once the April 2018 database dump occurs since this\n",
    "    # scenario is prevented by the prune_pages_file.py Python script during the database creation.\n",
    "    if not result:\n",
    "      raise ValueError(\n",
    "          'Invalid page title {0} provided. Page title does not exist.'.format(page_title))\n",
    "\n",
    "    return (result[0], helpers.get_readable_page_title(result[1]), True)\n",
    "\n",
    "  def fetch_page_title(self, page_id):\n",
    "    \"\"\"Returns the page title corresponding to the provided page ID.\n",
    "    Args:\n",
    "      page_id: The page ID whose ID to fetch.\n",
    "    Returns:\n",
    "      str: The page title corresponding to the provided page ID.\n",
    "    Raises:\n",
    "      ValueError: If the provided page ID is invalid or does not exist.\n",
    "    \"\"\"\n",
    "    helpers.validate_page_id(page_id)\n",
    "\n",
    "    query = 'SELECT title FROM pages WHERE id = ?;'\n",
    "    query_bindings = (page_id,)\n",
    "    self.sdow_cursor.execute(query, query_bindings)\n",
    "\n",
    "    page_title = self.sdow_cursor.fetchone()\n",
    "\n",
    "    if not page_title:\n",
    "      raise ValueError(\n",
    "          'Invalid page ID \"{0}\" provided. Page ID does not exist.'.format(page_id))\n",
    "\n",
    "    return page_title[0].encode('utf-8').replace('_', ' ')\n",
    "\n",
    "  def compute_shortest_paths(self, source_page_id, target_page_id):\n",
    "    \"\"\"Returns a list of page IDs indicating the shortest path between the source and target pages.\n",
    "    Note: the provided page IDs must correspond to non-redirect pages, but that check is not made\n",
    "    for performance reasons.\n",
    "    Args:\n",
    "      source_page_id: The ID corresponding to the page at which to start the search.\n",
    "      target_page_id: The ID corresponding to the page at which to end the search.\n",
    "    Returns:\n",
    "      list(list(int)): A list of integer lists corresponding to the page IDs indicating the shortest path\n",
    "        between the source and target page IDs.\n",
    "    Raises:\n",
    "      ValueError: If either of the provided page IDs are invalid.\n",
    "    \"\"\"\n",
    "    helpers.validate_page_id(source_page_id)\n",
    "    helpers.validate_page_id(target_page_id)\n",
    "\n",
    "    return breadth_first_search(source_page_id, target_page_id, self)\n",
    "\n",
    "  def fetch_outgoing_links_count(self, page_ids):\n",
    "    \"\"\"Returns the sum of outgoing links of the provided page IDs.\n",
    "    Args:\n",
    "      page_ids: A list of page IDs whose outgoing links to count.\n",
    "    Returns:\n",
    "      int: The count of outgoing links.\n",
    "    \"\"\"\n",
    "    return self.fetch_links_count_helper(page_ids, 'outgoing_links_count')\n",
    "\n",
    "  def fetch_incoming_links_count(self, page_ids):\n",
    "    \"\"\"Returns the sum of incoming links for the provided page IDs.\n",
    "    Args:\n",
    "      page_ids: A list of page IDs whose incoming links to count.\n",
    "    Returns:\n",
    "      int: The count of incoming links.\n",
    "    \"\"\"\n",
    "    return self.fetch_links_count_helper(page_ids, 'incoming_links_count')\n",
    "\n",
    "  def fetch_links_count_helper(self, page_ids, incoming_or_outgoing_links_count):\n",
    "    \"\"\"Returns the sum of outgoing or incoming links for the provided page IDs.\n",
    "    Args:\n",
    "      page_ids: A list of page IDs whose outgoing or incoming links to count.\n",
    "    Returns:\n",
    "      int: The count of outgoing or incoming links.\n",
    "    \"\"\"\n",
    "    page_ids = str(tuple(page_ids)).replace(',)', ')')\n",
    "\n",
    "    # There is no need to escape the query parameters here since they are never user-defined.\n",
    "    query = 'SELECT SUM({0}) FROM links WHERE id IN {1};'.format(\n",
    "        incoming_or_outgoing_links_count, page_ids)\n",
    "    self.sdow_cursor.execute(query)\n",
    "\n",
    "    return self.sdow_cursor.fetchone()[0]\n",
    "\n",
    "  def fetch_outgoing_links(self, page_ids):\n",
    "    \"\"\"Returns a list of tuples of page IDs representing outgoing links from the list of provided\n",
    "    page IDs to other pages.\n",
    "    Args:\n",
    "      page_ids: A list of page IDs whose outgoing links to fetch.\n",
    "    Returns:\n",
    "      list(int, int): A lists of integer tuples representing outgoing links from the list of\n",
    "        provided page IDs to other pages.\n",
    "    \"\"\"\n",
    "    return self.fetch_links_helper(page_ids, 'outgoing_links')\n",
    "\n",
    "  def fetch_incoming_links(self, page_ids):\n",
    "    \"\"\"Returns a list of tuples of page IDs representing incoming links from the list of provided\n",
    "    page IDs to other pages.\n",
    "    Args:\n",
    "      page_ids: A list of page IDs whose incoming links to fetch.\n",
    "    Returns:\n",
    "      list(int, int): A lists of integer tuples representing incoming links from the list of\n",
    "        provided page IDs to other pages.\n",
    "    \"\"\"\n",
    "    return self.fetch_links_helper(page_ids, 'incoming_links')\n",
    "\n",
    "  def fetch_links_helper(self, page_ids, outcoming_or_incoming_links):\n",
    "    \"\"\"Helper function which handles duplicate logic for fetch_outgoing_links() and\n",
    "    fetch_incoming_links().\n",
    "    Args:\n",
    "      page_ids: A list of page IDs whose links to fetch.\n",
    "      outcoming_or_incoming_links: String which indicates whether to fetch outgoing (\"source_id\") or\n",
    "        incoming (\"target_id\") links.\n",
    "    Returns:\n",
    "      list(int, int): A cursor of a lists of integer tuples representing links from the list of\n",
    "        provided page IDs to other pages.\n",
    "    \"\"\"\n",
    "    # Convert the page IDs into a string surrounded by parentheses for insertion into the query\n",
    "    # below. The replace() bit is some hackery to handle Python printing a trailing ',' when there\n",
    "    # is only one key.\n",
    "    page_ids = str(tuple(page_ids)).replace(',)', ')')\n",
    "\n",
    "    # There is no need to escape the query parameters here since they are never user-defined.\n",
    "    query = 'SELECT id, {0} FROM links WHERE id IN {1};'.format(\n",
    "        outcoming_or_incoming_links, page_ids)\n",
    "    self.sdow_cursor.execute(query)\n",
    "\n",
    "    return self.sdow_cursor\n",
    "\n",
    "  def insert_result(self, search):\n",
    "    \"\"\"Inserts a new search result into the searches table.\n",
    "    Args:\n",
    "      results: A dictionary containing search information.\n",
    "    Returns: \n",
    "      None\n",
    "    \"\"\"\n",
    "    paths_count = len(search['paths'])\n",
    "\n",
    "    if paths_count == 0:\n",
    "      degrees_count = 'NULL'\n",
    "    else:\n",
    "      degrees_count = len(search['paths'][0]) - 1\n",
    "\n",
    "    # There is no need to escape the query parameters here since they are never user-defined.\n",
    "    query = 'INSERT INTO searches VALUES ({source_id}, {target_id}, {duration}, {degrees_count}, {paths_count}, CURRENT_TIMESTAMP);'.format(\n",
    "        source_id=search['source_id'],\n",
    "        target_id=search['target_id'],\n",
    "        duration=search['duration'],\n",
    "        degrees_count=degrees_count,\n",
    "        paths_count=paths_count,\n",
    "    )\n",
    "    self.searches_conn.execute(query)\n",
    "    self.searches_conn.commit()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have loaded in all of our functions, lets go for an example. <br> <br>\n",
    "11271498 Egress To 34368 Yellow <br><br>\n",
    "All we need is to apply an id infor the breadth first search implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[11271498, 46380, 31990, 34368],\n",
       " [11271498, 46380, 42852, 34368],\n",
       " [11271498, 46380, 98132, 34368]]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newdb = Database(database,database)\n",
    "breadth_first_search(11271498, 34368, newdb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This provides as many close paths as possible in string id form and runs extremely quickly. Let us use the graph implementation we used in Part A to display."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Austin\\Anaconda3\\lib\\site-packages\\networkx\\drawing\\layout.py:923: FutureWarning: arrays to stack must be passed as a \"sequence\" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.\n",
      "  pos = np.row_stack((pos[x] for x in node_list))\n",
      "C:\\Users\\Austin\\Anaconda3\\lib\\site-packages\\networkx\\drawing\\nx_pylab.py:579: MatplotlibDeprecationWarning: \n",
      "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n",
      "  if not cb.iterable(width):\n",
      "C:\\Users\\Austin\\Anaconda3\\lib\\site-packages\\networkx\\drawing\\nx_pylab.py:676: MatplotlibDeprecationWarning: \n",
      "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n",
      "  if cb.iterable(node_size):  # many node sizes\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 864x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import array as arr \n",
    "\n",
    "valid_paths = breadth_first_search(11271498, 34368, newdb)\n",
    "G = nx.DiGraph()\n",
    "            \n",
    "for path in valid_paths:\n",
    "    titled_paths = getTitles(path)\n",
    "\n",
    "    for index, title in enumerate(titled_paths[:-1]):\n",
    "        G.add_edges_from([(title, titled_paths[index+1])])\n",
    "\n",
    "pos = nx.planar_layout(G)\n",
    "nx.draw_networkx_nodes(G, pos)\n",
    "nx.draw_networkx_labels(G, pos)\n",
    "nx.draw_networkx_edges(G, pos, arrows=True,edge_color='b')\n",
    "plt.figure(3,figsize=(12,12))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, we can save the image by using our save graph function for graph G generated before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_graph(G,\"my_graph.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us check some interesting metrics for the fast implementation of the BFS algorithm. We start by getting a random collection of 5 words in our database. We get all permutations of these items for about 20 queries total."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "query_pages = '''SELECT * FROM pages WHERE is_redirect=0'''\n",
    "df = pd.read_sql_query(query_pages, connection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>title</th>\n",
       "      <th>is_redirect</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>142356</td>\n",
       "      <td>311431</td>\n",
       "      <td>Joseph_Thompson</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2337177</td>\n",
       "      <td>18944370</td>\n",
       "      <td>Doug_Boyd</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3200602</td>\n",
       "      <td>28159310</td>\n",
       "      <td>Short_Circuit_II_(album)</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3876873</td>\n",
       "      <td>36270080</td>\n",
       "      <td>Tylosis_hilaris</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3846333</td>\n",
       "      <td>35974688</td>\n",
       "      <td>WTIM</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               id                     title  is_redirect\n",
       "142356     311431           Joseph_Thompson            0\n",
       "2337177  18944370                 Doug_Boyd            0\n",
       "3200602  28159310  Short_Circuit_II_(album)            0\n",
       "3876873  36270080           Tylosis_hilaris            0\n",
       "3846333  35974688                      WTIM            0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wordselection = df.sample(n = 5)\n",
    "wordselection.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get every possible permutations of words to search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import itertools\n",
    "word_combinations = list(itertools.permutations(wordselection['id'], 2))\n",
    "len(word_combinations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will iterate over all permutations of beginning and ending paths. 100,000 total items should take about 13 hours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import time\n",
    "index = 0\n",
    "data = []\n",
    "for combination in word_combinations:\n",
    "    start = time.perf_counter()\n",
    "    valid_paths = breadth_first_search(combination[0], combination[1], newdb)\n",
    "    end = time.perf_counter() \n",
    "    begin = getTitle(combination[0])\n",
    "    goal = getTitle(combination[1])\n",
    "    if valid_paths:\n",
    "        data.append([combination, begin, goal, len(valid_paths),valid_paths, len(valid_paths[0]),valid_paths[0], \n",
    "                      end-start])\n",
    "    else:\n",
    "        data.append([combination, begin, goal, len(valid_paths),valid_paths, 0,[], \n",
    "                      end-start])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have generated some metrics, we can examine the distribution of path links. <br>\n",
    "We put our results into a dataframe for easy analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "analysis = pd.DataFrame(data, columns = ['Combination','Start Title','Goal Title','Paths Found', \n",
    "                                         'All Paths', 'Shortest Path Length', 'Shortest Path',\n",
    "                                        'Time Taken']) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Combination</th>\n",
       "      <th>Start Title</th>\n",
       "      <th>Goal Title</th>\n",
       "      <th>Paths Found</th>\n",
       "      <th>All Paths</th>\n",
       "      <th>Shortest Path Length</th>\n",
       "      <th>Shortest Path</th>\n",
       "      <th>Time Taken</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>(311431, 18944370)</td>\n",
       "      <td>Joseph_Thompson</td>\n",
       "      <td>Doug_Boyd</td>\n",
       "      <td>1</td>\n",
       "      <td>[[311431, 54673095, 6484538, 20595373, 18944370]]</td>\n",
       "      <td>5</td>\n",
       "      <td>[311431, 54673095, 6484538, 20595373, 18944370]</td>\n",
       "      <td>0.017822</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>(311431, 28159310)</td>\n",
       "      <td>Joseph_Thompson</td>\n",
       "      <td>Short_Circuit_II_(album)</td>\n",
       "      <td>1</td>\n",
       "      <td>[[311431, 52934078, 528282, 147778, 2768827, 2...</td>\n",
       "      <td>6</td>\n",
       "      <td>[311431, 52934078, 528282, 147778, 2768827, 28...</td>\n",
       "      <td>0.071939</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>(311431, 36270080)</td>\n",
       "      <td>Joseph_Thompson</td>\n",
       "      <td>Tylosis_hilaris</td>\n",
       "      <td>383</td>\n",
       "      <td>[[311431, 37237849, 307, 18023, 518913, 186667...</td>\n",
       "      <td>9</td>\n",
       "      <td>[311431, 37237849, 307, 18023, 518913, 1866675...</td>\n",
       "      <td>2.020500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>(311431, 35974688)</td>\n",
       "      <td>Joseph_Thompson</td>\n",
       "      <td>WTIM</td>\n",
       "      <td>0</td>\n",
       "      <td>[]</td>\n",
       "      <td>0</td>\n",
       "      <td>[]</td>\n",
       "      <td>0.001044</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>(18944370, 311431)</td>\n",
       "      <td>Doug_Boyd</td>\n",
       "      <td>Joseph_Thompson</td>\n",
       "      <td>36</td>\n",
       "      <td>[[18944370, 27766, 19009060, 72243, 18969184, ...</td>\n",
       "      <td>6</td>\n",
       "      <td>[18944370, 27766, 19009060, 72243, 18969184, 3...</td>\n",
       "      <td>0.890053</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Combination      Start Title                Goal Title  Paths Found  \\\n",
       "0  (311431, 18944370)  Joseph_Thompson                 Doug_Boyd            1   \n",
       "1  (311431, 28159310)  Joseph_Thompson  Short_Circuit_II_(album)            1   \n",
       "2  (311431, 36270080)  Joseph_Thompson           Tylosis_hilaris          383   \n",
       "3  (311431, 35974688)  Joseph_Thompson                      WTIM            0   \n",
       "4  (18944370, 311431)        Doug_Boyd           Joseph_Thompson           36   \n",
       "\n",
       "                                           All Paths  Shortest Path Length  \\\n",
       "0  [[311431, 54673095, 6484538, 20595373, 18944370]]                     5   \n",
       "1  [[311431, 52934078, 528282, 147778, 2768827, 2...                     6   \n",
       "2  [[311431, 37237849, 307, 18023, 518913, 186667...                     9   \n",
       "3                                                 []                     0   \n",
       "4  [[18944370, 27766, 19009060, 72243, 18969184, ...                     6   \n",
       "\n",
       "                                       Shortest Path  Time Taken  \n",
       "0    [311431, 54673095, 6484538, 20595373, 18944370]    0.017822  \n",
       "1  [311431, 52934078, 528282, 147778, 2768827, 28...    0.071939  \n",
       "2  [311431, 37237849, 307, 18023, 518913, 1866675...    2.020500  \n",
       "3                                                 []    0.001044  \n",
       "4  [18944370, 27766, 19009060, 72243, 18969184, 3...    0.890053  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "analysis.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we save our dataframe to a csv for future analysis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "analysis.to_csv(r'C:\\Users\\Austin\\Desktop\\permutations2.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us also consider an alternate way of selecting articles. Previously we only were able to use 350 articles with their permutations. Combinations are less interesting because we end up with a lot of the same initial path. Let's try using a larger number of articles but only pairing them once (1000 articles for 1000 pairs). We use a smaller example here to save time producing the dataset. <br><br>\n",
    "We show 20 articles for a quick example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>title</th>\n",
       "      <th>is_redirect</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>5410057</td>\n",
       "      <td>55059946</td>\n",
       "      <td>What_(song)</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2315841</td>\n",
       "      <td>18771956</td>\n",
       "      <td>Stanisławów,_Gmina_Oporów</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>600208</td>\n",
       "      <td>2337249</td>\n",
       "      <td>Gilbert_Highet</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1805810</td>\n",
       "      <td>13048961</td>\n",
       "      <td>Laetitia_Zonzambé</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5193169</td>\n",
       "      <td>52199525</td>\n",
       "      <td>Isa_Gendargenoevsky</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               id                      title  is_redirect\n",
       "5410057  55059946                What_(song)            0\n",
       "2315841  18771956  Stanisławów,_Gmina_Oporów            0\n",
       "600208    2337249             Gilbert_Highet            0\n",
       "1805810  13048961          Laetitia_Zonzambé            0\n",
       "5193169  52199525        Isa_Gendargenoevsky            0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from itertools import compress \n",
    "query_pages = '''SELECT * FROM pages WHERE is_redirect=0'''\n",
    "df = pd.read_sql_query(query_pages, connection)\n",
    "wordselection = df.sample(n = 20)\n",
    "wordselection.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs = []\n",
    "for i in range(len(wordselection)):\n",
    "    pairs.append([wordselection.iloc[i].loc['id'],\n",
    "                wordselection.iloc[(i+1)%len(wordselection)].loc['id']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "data = []\n",
    "index = 0\n",
    "for combination in pairs:\n",
    "    start = time.perf_counter()\n",
    "    valid_paths = breadth_first_search(combination[0], combination[1], newdb)\n",
    "    end = time.perf_counter() \n",
    "    begin = getTitle(combination[0])\n",
    "    goal = getTitle(combination[1])\n",
    "    if valid_paths:\n",
    "        data.append([combination, begin, goal, len(valid_paths),valid_paths, len(valid_paths[0]),valid_paths[0], \n",
    "                      end-start])\n",
    "    else:\n",
    "        data.append([combination, begin, goal, len(valid_paths),valid_paths, 0,[], \n",
    "                      end-start])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "analysis = pd.DataFrame(data, columns = ['Combination','Start Title','Goal Title','Paths Found', \n",
    "                                         'All Paths', 'Shortest Path Length', 'Shortest Path',\n",
    "                                        'Time Taken']) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Combination</th>\n",
       "      <th>Start Title</th>\n",
       "      <th>Goal Title</th>\n",
       "      <th>Paths Found</th>\n",
       "      <th>All Paths</th>\n",
       "      <th>Shortest Path Length</th>\n",
       "      <th>Shortest Path</th>\n",
       "      <th>Time Taken</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>[55059946, 18771956]</td>\n",
       "      <td>What_(song)</td>\n",
       "      <td>Stanisławów,_Gmina_Oporów</td>\n",
       "      <td>730</td>\n",
       "      <td>[[55059946, 5407, 108163, 22936, 1957973, 1877...</td>\n",
       "      <td>7</td>\n",
       "      <td>[55059946, 5407, 108163, 22936, 1957973, 18771...</td>\n",
       "      <td>2.172969</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>[18771956, 2337249]</td>\n",
       "      <td>Stanisławów,_Gmina_Oporów</td>\n",
       "      <td>Gilbert_Highet</td>\n",
       "      <td>82</td>\n",
       "      <td>[[18771956, 8439, 148363, 79616, 2337249], [18...</td>\n",
       "      <td>5</td>\n",
       "      <td>[18771956, 8439, 148363, 79616, 2337249]</td>\n",
       "      <td>1.140130</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>[2337249, 13048961]</td>\n",
       "      <td>Gilbert_Highet</td>\n",
       "      <td>Laetitia_Zonzambé</td>\n",
       "      <td>1</td>\n",
       "      <td>[[2337249, 68736, 32706, 2259929, 13048961]]</td>\n",
       "      <td>5</td>\n",
       "      <td>[2337249, 68736, 32706, 2259929, 13048961]</td>\n",
       "      <td>0.043115</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>[13048961, 52199525]</td>\n",
       "      <td>Laetitia_Zonzambé</td>\n",
       "      <td>Isa_Gendargenoevsky</td>\n",
       "      <td>1</td>\n",
       "      <td>[[13048961, 5478, 25391, 185576, 31057937, 521...</td>\n",
       "      <td>6</td>\n",
       "      <td>[13048961, 5478, 25391, 185576, 31057937, 5219...</td>\n",
       "      <td>0.304113</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>[52199525, 6882681]</td>\n",
       "      <td>Isa_Gendargenoevsky</td>\n",
       "      <td>Bugatti_(disambiguation)</td>\n",
       "      <td>78</td>\n",
       "      <td>[[52199525, 6095, 19344654, 45661106, 4497, 68...</td>\n",
       "      <td>6</td>\n",
       "      <td>[52199525, 6095, 19344654, 45661106, 4497, 688...</td>\n",
       "      <td>0.809970</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Combination                Start Title                 Goal Title  \\\n",
       "0  [55059946, 18771956]                What_(song)  Stanisławów,_Gmina_Oporów   \n",
       "1   [18771956, 2337249]  Stanisławów,_Gmina_Oporów             Gilbert_Highet   \n",
       "2   [2337249, 13048961]             Gilbert_Highet          Laetitia_Zonzambé   \n",
       "3  [13048961, 52199525]          Laetitia_Zonzambé        Isa_Gendargenoevsky   \n",
       "4   [52199525, 6882681]        Isa_Gendargenoevsky   Bugatti_(disambiguation)   \n",
       "\n",
       "   Paths Found                                          All Paths  \\\n",
       "0          730  [[55059946, 5407, 108163, 22936, 1957973, 1877...   \n",
       "1           82  [[18771956, 8439, 148363, 79616, 2337249], [18...   \n",
       "2            1       [[2337249, 68736, 32706, 2259929, 13048961]]   \n",
       "3            1  [[13048961, 5478, 25391, 185576, 31057937, 521...   \n",
       "4           78  [[52199525, 6095, 19344654, 45661106, 4497, 68...   \n",
       "\n",
       "   Shortest Path Length                                      Shortest Path  \\\n",
       "0                     7  [55059946, 5407, 108163, 22936, 1957973, 18771...   \n",
       "1                     5           [18771956, 8439, 148363, 79616, 2337249]   \n",
       "2                     5         [2337249, 68736, 32706, 2259929, 13048961]   \n",
       "3                     6  [13048961, 5478, 25391, 185576, 31057937, 5219...   \n",
       "4                     6  [52199525, 6095, 19344654, 45661106, 4497, 688...   \n",
       "\n",
       "   Time Taken  \n",
       "0    2.172969  \n",
       "1    1.140130  \n",
       "2    0.043115  \n",
       "3    0.304113  \n",
       "4    0.809970  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "analysis.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "analysis.to_csv(r'C:\\Users\\Austin\\Desktop\\randompairs2.csv', index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the notebook titled Analysis on BFS Output we take the time to look through our collected data more closely. Hopefully we can draw some interesting conclusions between the two datasets."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}