{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment 01 - Mongo\n",
    "*DBMS for Analytics*\n",
    "\n",
    "**Due: Tuesday, February 10th, at midnight**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Notes:*\n",
    " - All code should follow the PEP 8 Style Guide for Python\n",
    " - Assignment should be submitted using jupyter notebooks\n",
    "  - File name should follow “{Your Name} – Assignment_XX_Submission”\n",
    "  - Each Task should be contained in its own cell\n",
    "  - Each Task should be properly commented\n",
    "  - Each Task should print out the answer to the Task if appropriate\n",
    "  - Sample submission can be found on blackboard\n",
    "  - **Not following these standards may result in lost points**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Assignment Description\n",
    "For this assignment we are going to use our Mongo database of Elon Musk tweets to identify whether Elon is more/less active on twitter during the weeks leading up to a major event.\n",
    "\n",
    "To accomplish this, we will need to implement the following:\n",
    " 1. Create a method to pull tweets that occured within a set timerange from a given date\n",
    " 2. Create a method to randomly pull ranges of tweets (when blacking out certain ranges)\n",
    " 3. Pull data from each respective approach to create event_tweets and non_event_tweet datasets\n",
    " 4. Use a variety of analysis tools to determine the relationship between the two datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from datetime import datetime, timedelta\n",
    "\n",
    "from pymongo import MongoClient\n",
    "\n",
    "client = MongoClient(host='18.219.151.47', #host is the hostname for the database\n",
    "                     port=27017, #port is the port number that mongo is running on\n",
    "                     username='student', #username for the db\n",
    "                     password='emse6992pass', #password for the db\n",
    "                     authSource='emse6992') #Since our user only exists for the emse6992 db, we need to specify this\n",
    "\n",
    "db = client.emse6992\n",
    "stats_coll = db.twitter_statuses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 1\n",
    "Write a function, ***get_tweets_daterange(screen_name, date, days_before, days_after)***, that takes a user's **screen_name** and will pull all tweets that occur *x* **days_before** and *y* **days_after** the provided **date** from the ***twitter_statuses*** collection for the given user.\n",
    "\n",
    "Example:\n",
    "`get_tweets_daterange('elonmusk', \"2020-10-28\", 14, 14)` would get all tweets made by *elonmusk* between 2020-10-14 - 2020-11-11 from the ***twitter_statuses*** collection, which should return 33 tweets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_tweets_daterange(screen_name, date, days_before, days_after):\n",
    "    \"\"\"This function returns a list of tweets that fall inbetween date-days_before\n",
    "    and date + days_after\n",
    "    \n",
    "    Args:\n",
    "        screen_name (str): screen name of twitter user\n",
    "        date (str): Date in the 'YYYY-MM-DD' format\n",
    "        days_before (int): number of days prior to `date` to consider\n",
    "        days_after (int): number of days after `date` to consider\n",
    "        \n",
    "    Returns:\n",
    "        list: A list of all the tweets that meet the conditions\n",
    "    \"\"\"\n",
    "    \n",
    "    # Your code\n",
    "    date_input = datetime.strptime(date, '%Y-%m-%d')\n",
    "    date_start = date_input - timedelta(days=days_before)\n",
    "    date_end = date_input + timedelta(days=days_after)\n",
    "\n",
    "    doc_date = stats_coll.find({\n",
    "        \"$and\": [\n",
    "            {'user.screen_name': screen_name},\n",
    "            {\"created_at\": {\"$gte\": date_start}},\n",
    "            {\"created_at\": {\"$lte\": date_end}}\n",
    "        ]\n",
    "    })\n",
    "    \n",
    "    return doc_date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-3-9ddbe4438f08>:2: DeprecationWarning: count is deprecated. Use Collection.count_documents instead.\n",
      "  fi.count()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fi = get_tweets_daterange('elonmusk', \"2020-10-28\", 14, 14)\n",
    "fi.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2\n",
    "Write a function, ***get_random_date(min_date, max_date)***, that will generate a random date that falls within **min_date** and **max_date**.\n",
    "\n",
    "Ensure the output of this function conforms to the _\"YYYY-MM-DD\"_ format used for the **get_tweets_daterange()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Space work\n",
    "random.seed(10) # To provide consistent randomness\n",
    "\n",
    "def get_random_date(min_date, max_date):\n",
    "    \"\"\"This function returns a random date inbetween min_date and max_date\n",
    "    \n",
    "    Args:\n",
    "        min_date (str): Earliset date to consider - in the 'YYYY-MM-DD' format\n",
    "        max_date (str): Latest date to consider - in the 'YYYY-MM-DD' format\n",
    "        \n",
    "    Returns:\n",
    "        str: Random date - in the 'YYYY-MM-DD' format\n",
    "    \"\"\"\n",
    "    \n",
    "    # Your code\n",
    "    start_date = datetime.strptime(min_date, '%Y-%m-%d')\n",
    "    end_date = datetime.strptime(max_date, '%Y-%m-%d')\n",
    "\n",
    "    num_dates = (end_date - start_date).days\n",
    "    \n",
    "    random_number = random.randrange(num_dates)\n",
    "    random_date = start_date + timedelta(days=random_number)\n",
    "    \n",
    "    date_str = random_date.strftime(\"%Y-%m-%d\")\n",
    "    \n",
    "    return date_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2020-12-03'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = get_random_date(\"2020-10-28\", \"2020-12-28\")\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3\n",
    "Using the two functions from task 1 & 2, create two datasets using `days_before = 14`, `dayse_after = 7` and `screen_name = 'elonmusk'`.\n",
    " - `major_events_dataset` - a collection of **get_tweets_daterange()** for the provided **major_events**\n",
    " - `random_events_dataset` - a collection of **get_tweets_daterange()** for at least 10 randomly generated dats\n",
    "   - Use `min_date = \"2020-01-01\"` and `max_date = \"2021-01-01\"` for all calls to **get_random_date()**\n",
    "   \n",
    "Each dataset should be a python list where each element in the list is a result from **get_tweets_daterange()**\n",
    "\n",
    "Example:\n",
    "```python\n",
    "major_events_dataset = [\n",
    "    get_tweets_daterange(...,\"2020-10-28\",...),\n",
    "    get_tweets_daterange(...,\"2020-05-30\",...),\n",
    "    ....\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "major_events = [\"2020-10-28\", \"2020-05-30\", \"2021-01-07\"]\n",
    "major_events_dataset=[]\n",
    "random_events_dataset=[]\n",
    "\n",
    "for i in major_events:\n",
    "    major_events_dataset += get_tweets_daterange('elonmusk', i, 14, 7)\n",
    "\n",
    "list_date = []\n",
    "for i in range(10):\n",
    "    list_date.append(get_random_date(\"2020-01-01\", \"2021-01-01\"))\n",
    "\n",
    "for i in list_date:\n",
    "    random_events_dataset += get_tweets_daterange('elonmusk', i, 14, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2020-10-22',\n",
       " '2020-01-08',\n",
       " '2020-04-15',\n",
       " '2020-08-24',\n",
       " '2020-09-08',\n",
       " '2020-05-22',\n",
       " '2020-11-30',\n",
       " '2020-03-23',\n",
       " '2020-01-18',\n",
       " '2020-09-23']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 4\n",
    "From each dataset, create a histogram of the average tweets/week for each daterange.\n",
    "\n",
    "This means the histogram for the major_events_dataset would only comprise of 3 values:\n",
    " - The avg. tweets/week for 2020-10-28, 2020-05-30, and 20201-01-07.\n",
    " \n",
    "For the major events you should get `[5.666666666666667, 14.333333333333334, 7.666666666666667]`\n",
    "\n",
    "_Note: For this you are welcome to use matplotlib, seaborn, or any other python plotting package._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-9-af041dd35f86>:4: DeprecationWarning: count is deprecated. Use Collection.count_documents instead.\n",
      "  avg_tweet_final += [avg_tweet_num.count()/3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[5.666666666666667, 14.333333333333334, 7.666666666666667]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_tweet_final = []\n",
    "for i in major_events:\n",
    "    avg_tweet_num = get_tweets_daterange('elonmusk', i, 14, 7)\n",
    "    avg_tweet_final += [avg_tweet_num.count()/3]\n",
    "\n",
    "avg_tweet_final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-10-7e82e139db28>:4: DeprecationWarning: count is deprecated. Use Collection.count_documents instead.\n",
      "  avg_tweet_final_2 += [avg_tweet_num_2.count()/3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[6.0,\n",
       " 0.0,\n",
       " 9.333333333333334,\n",
       " 13.666666666666666,\n",
       " 11.333333333333334,\n",
       " 16.666666666666668,\n",
       " 9.333333333333334,\n",
       " 11.0,\n",
       " 0.0,\n",
       " 10.333333333333334]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_tweet_final_2 = []\n",
    "for i in list_date:\n",
    "    avg_tweet_num_2 = get_tweets_daterange('elonmusk', i, 14, 7)\n",
    "    avg_tweet_final_2 += [avg_tweet_num_2.count()/3]\n",
    "\n",
    "avg_tweet_final_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-11-2072104b1784>:8: DeprecationWarning: count is deprecated. Use Collection.count_documents instead.\n",
      "  avg_tweet_final += [avg_tweet_num.count()/3]\n",
      "<ipython-input-11-2072104b1784>:12: DeprecationWarning: count is deprecated. Use Collection.count_documents instead.\n",
      "  avg_tweet_final_2 += [avg_tweet_num_2.count()/3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "avg_tweet_final = []\n",
    "avg_tweet_final_2 = []\n",
    "\n",
    "for i in major_events:\n",
    "    avg_tweet_num = get_tweets_daterange('elonmusk', i, 14, 7)\n",
    "    avg_tweet_final += [avg_tweet_num.count()/3]\n",
    "\n",
    "for i in list_date:\n",
    "    avg_tweet_num_2 = get_tweets_daterange('elonmusk', i, 14, 7)\n",
    "    avg_tweet_final_2 += [avg_tweet_num_2.count()/3]\n",
    "\n",
    "data_major = [major_events, avg_tweet_final]\n",
    "column_names_m = data_major.pop(0)\n",
    "df_major_event = pd.DataFrame(data_major, columns=column_names_m)\n",
    "df_lists_major = df_major_event.unstack().apply(pd.Series)\n",
    "df_lists_major.plot.bar(rot=0, cmap=plt.cm.jet, fontsize=8, width=0.7, figsize=(8,4))\n",
    "\n",
    "data_random = [list_date, avg_tweet_final_2]\n",
    "column_names_r = data_random.pop(0)\n",
    "df_random_event = pd.DataFrame(data_random, columns=column_names_r)\n",
    "df_lists_random = df_random_event.unstack().apply(pd.Series)\n",
    "df_lists_random.plot.bar(rot=40, cmap=plt.cm.jet, fontsize=8, width=0.7, figsize=(8,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 5\n",
    "Repeat the steps for Task 4, but this time plot the data based on average characters/week for each daterange.\n",
    "\n",
    "For the major events you should get `[435.0, 1259.0, 575.6666666666666]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_chars(txt):\n",
    "    result = 0\n",
    "    for char in txt:\n",
    "        result += 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[435.0, 1259.0, 575.6666666666666]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_tweet_char_num = []\n",
    "\n",
    "for i in major_events:\n",
    "    avg_tweet_char = []\n",
    "    avg_tweet_char += get_tweets_daterange('elonmusk', i, 14, 7)\n",
    "    \n",
    "    num_char = 0\n",
    "    for doc in range(len(avg_tweet_char)):\n",
    "        ab = count_chars(avg_tweet_char[doc]['text'])\n",
    "        num_char += ab \n",
    "\n",
    "    avg_tweet_char_num += [num_char/3]\n",
    "\n",
    "avg_tweet_char_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[608.0,\n",
       " 0.0,\n",
       " 736.0,\n",
       " 1007.0,\n",
       " 950.3333333333334,\n",
       " 1489.0,\n",
       " 642.3333333333334,\n",
       " 1045.6666666666667,\n",
       " 0.0,\n",
       " 970.0]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_tweet_char_num_ran = []\n",
    "\n",
    "for i in list_date:\n",
    "    avg_tweet_char_ran = []\n",
    "    avg_tweet_char_ran += get_tweets_daterange('elonmusk', i, 14, 7)\n",
    "    \n",
    "    num_char_ran = 0\n",
    "    for doc in range(len(avg_tweet_char_ran)):\n",
    "        ab_ran = count_chars(avg_tweet_char_ran[doc]['text'])\n",
    "        num_char_ran += ab_ran \n",
    "\n",
    "    avg_tweet_char_num_ran += [num_char_ran/3]\n",
    "\n",
    "avg_tweet_char_num_ran"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_major_char = [major_events, avg_tweet_char_num]\n",
    "column_names_m_char = data_major_char.pop(0)\n",
    "df_major_event_char = pd.DataFrame(data_major_char, columns=column_names_m_char)\n",
    "df_lists_major_char = df_major_event_char.unstack().apply(pd.Series)\n",
    "df_lists_major_char.plot.bar(rot=0, cmap=plt.cm.jet, fontsize=8, width=0.7, figsize=(8,4))\n",
    "\n",
    "data_random_char = [list_date, avg_tweet_char_num_ran]\n",
    "column_names_r_char = data_random_char.pop(0)\n",
    "df_random_event_char = pd.DataFrame(data_random_char, columns=column_names_r_char)\n",
    "df_lists_random_char = df_random_event_char.unstack().apply(pd.Series)\n",
    "df_lists_random_char.plot.bar(rot=40, cmap=plt.cm.jet, fontsize=8, width=0.7, figsize=(8,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 6\n",
    "Answer the following questions in the cell below using markdown.\n",
    " 1. From the data, do you believe Elon was more/less active during major events? Please support your position using evidence from the previous tasks.\n",
    " 2. What could we do to improve this experiment?\n",
    "   - Your response could talk about data collection/aggregation, method of analysis, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your response:\n",
    "Base on the comparison with the ten random daterange's average tweet counts, Elon Musk's tweeting patterns do not change much. Since the major event dates have the count of (4, 14, 8) is in the range of (0 - 17), there is no clear sign of changing in his behavior.  \n",
    "\n",
    "From the data both on the average tweets count and range_date count, it is hard to dertermine if he is more active or not during the major events. Since only using the data from the 10 random datarange is not sufficient to support any conclusion, we will need to have more data of the year to discover if he tweets more on major events. For example, we can calculate the average number of tweets' count of one week instead of three weeks. Then we can compare the figures to see if the average tweet count on the major event weeks have a much bigger numbers than other normal weeks. Similarly, we can also collect the tweet count on daily bases from a year range to discover Elon Musk's tweeting pattern. "
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}