Customer Service Weekly Reporting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/python\n",
    "import psycopg2\n",
    "import sys\n",
    "import pprint\n",
    "import pandas as pd\n",
    "from operator import itemgetter\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import figure\n",
    "import openpyxl\n",
    "import json\n",
    "from datetime import datetime\n",
    "from dateutil.relativedelta import relativedelta, FR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Database Query Template\n",
    "Provide shell for running queries against the database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getRecords(query):\n",
    "    conn_string = \"host='ec2-34-204-130-85.compute-1.amazonaws.com' dbname='dajagik9jf03kv' user='ufff9p79fblkso' password='pajqlppcmb52klbmpsmbtiucuqi'\"\n",
    "    # print the connection string we will use to connect\n",
    "    # print(\"Connecting to database\\n\t->%s\" % (conn_string))\n",
    " \n",
    "    # get a connection, if a connect cannot be made an exception will be raised here\n",
    "    conn = psycopg2.connect(conn_string)\n",
    " \n",
    "    # conn.cursor will return a cursor object, you can use this cursor to perform queries\n",
    "    cursor = conn.cursor()\n",
    "    \n",
    "    df = pd.read_sql_query(query ,con=conn)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Determine End Dates for the Reports\n",
    "Determines the date range for the reports. \n",
    "-0 represents the Friday of the current week\n",
    "-1 represents the previous Friday\n",
    "-2 2 Friday's ago etc.\n",
    "Please check date printout to verify that the program uses the date range you intend. The default numbers\n",
    "should work if the report is run on a Friday."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-1-18T16:00:00\n",
      "2019-2-1T14:00:00\n"
     ]
    }
   ],
   "source": [
    "# Determines the date for the previous Friday\n",
    "ref = datetime.now() + relativedelta(weekday=FR(-2))\n",
    "lastFriday = str(ref.year) + '-' + str(ref.month) + '-' + str(ref.day) + 'T16:00:00'\n",
    "\n",
    "# Determines the date for the current Friday\n",
    "ref = datetime.now() + relativedelta(weekday=FR(-0))\n",
    "curFriday = str(ref.year) + '-' + str(ref.month) + '-' + str(ref.day) + 'T14:00:00'\n",
    "\n",
    "print(lastFriday)\n",
    "print(curFriday)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "query = \"\"\" SELECT \"Claims\".\"state\" AS \"State\",\n",
    "       \"Accounts\".\"name\" AS \"Group\",\n",
    "       \"Users\".\"name\" AS \"Customer\",\n",
    "        TO_CHAR(\"Claims\".\"scheduled_window_start\", 'YYYY-MM-DD\"T\"HH24\":\"MI') AS \"Scheduled Window Start\",\n",
    "        \"Claims\".\"id\" AS \"id\"\n",
    "        FROM \"public\".\"claims\" AS \"Claims\"\n",
    "        INNER JOIN \"public\".\"groups\" AS \"Groups\" ON \"Claims\".\"group_id\" = \"Groups\".\"id\"\n",
    "        INNER JOIN \"public\".\"accounts\" AS \"Accounts\" ON \"Groups\".\"account_id\" = \"Accounts\".\"id\"\n",
    "        INNER JOIN \"public\".\"devices\" AS \"Devices\" ON \"Claims\".\"device_id\" = \"Devices\".\"id\"\n",
    "        INNER JOIN \"public\".\"users\" AS \"Users\" ON \"Devices\".\"user_id\" = \"Users\".\"id\"\n",
    "        WHERE (\"Claims\".\"resolved_at\"::DATE AT TIME ZONE 'UTC' >= \"\"\"\n",
    "query = query + \"'\" + lastFriday + \"'\"\n",
    "query = query + \"\"\" AND \"Claims\".\"resolved_at\"::DATE AT TIME ZONE 'UTC' < \"\"\"\n",
    "query = query + \"'\" + curFriday + \"')\"\n",
    "query = query + \"\"\" GROUP BY \"Claims\".\"state\",\n",
    "                     TO_CHAR(\"Claims\".\"scheduled_window_start\", 'YYYY-MM-DD\"T\"HH24\":\"MI'),\n",
    "                     \"Accounts\".\"name\",\n",
    "                     \"Users\".\"name\", \"Claims\".\"id\"\n",
    "                    ORDER BY \"State\" ASC,\n",
    "                     \"Scheduled Window Start\" DESC,\n",
    "                     \"Group\" ASC, \n",
    "                     \"Customer\" ASC \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>Percentage</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tier</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>102</td>\n",
       "      <td>79.07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>23</td>\n",
       "      <td>17.83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>3.10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       id  Percentage\n",
       "tier                 \n",
       "1     102       79.07\n",
       "2      23       17.83\n",
       "3       4        3.10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Completed claims\n",
    "\n",
    "queryc = \"\"\" select\n",
    "        repair.id id,\n",
    "        max(coalesce(condition.tier, 1)) tier\n",
    "    from claims repair\n",
    "    left join claims_claim_conditions ccc on ccc.claim_id = repair.id\n",
    "    left join claim_conditions condition on ccc.claim_condition_id = condition.id\n",
    "    where resolved_at between \"\"\"\n",
    "queryc = queryc + \"'\" + lastFriday + \"'\"\n",
    "queryc = queryc + \" and \" + \"'\" + curFriday + \"'\" + \" group by 1\"\n",
    "\n",
    "dfc = getRecords(queryc)\n",
    "dfc = dfc.groupby('tier').count()\n",
    "dfc['Percentage'] = 0.0\n",
    "Total = dfc['id'].sum()\n",
    "dfc['Percentage'] = round(100 * dfc['id'] / Total, 2)\n",
    "dfc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nameState(state):\n",
    "    if state == 0:\n",
    "        return 'Requested'\n",
    "    if state == 1:\n",
    "        return 'Scheduled'\n",
    "    if state == 2:\n",
    "        return 'In Progress'\n",
    "    if state == 3:\n",
    "        return 'Completed'\n",
    "    if state == 4:\n",
    "        return 'Canceled'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = getRecords(query)\n",
    "df.State = df.State.apply(lambda x: nameState(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>State</th>\n",
       "      <th>Group</th>\n",
       "      <th>Customer</th>\n",
       "      <th>Scheduled Window Start</th>\n",
       "      <th>id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>110</th>\n",
       "      <td>Completed</td>\n",
       "      <td>AT&amp;T</td>\n",
       "      <td>Emma Squires</td>\n",
       "      <td>2019-01-17T22:00</td>\n",
       "      <td>59ca10d2-0e21-4695-a525-19edad22bfd3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>111</th>\n",
       "      <td>Completed</td>\n",
       "      <td>Stanford University</td>\n",
       "      <td>Sandra Wong Martin</td>\n",
       "      <td>2019-01-17T18:00</td>\n",
       "      <td>cb22da56-5579-40ce-bcbc-17c9f3a023ea</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>112</th>\n",
       "      <td>Completed</td>\n",
       "      <td>Wireless Analytics</td>\n",
       "      <td>Jesus Loera</td>\n",
       "      <td>2019-01-17T17:00</td>\n",
       "      <td>9c80c54b-7923-46f6-82c7-bc76448ed9f2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>113</th>\n",
       "      <td>Canceled</td>\n",
       "      <td>T. Rowe Price</td>\n",
       "      <td>Chuma Enwonwu</td>\n",
       "      <td>2019-01-28T21:30</td>\n",
       "      <td>152ecc28-f3d1-4e57-b994-d3a54b48ee14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>114</th>\n",
       "      <td>Canceled</td>\n",
       "      <td>Rutgers</td>\n",
       "      <td>8649931818</td>\n",
       "      <td>2019-01-23T17:00</td>\n",
       "      <td>fb4f58d5-572d-498e-a2be-f0c7bcd47321</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         State                Group            Customer  \\\n",
       "110  Completed                 AT&T        Emma Squires   \n",
       "111  Completed  Stanford University  Sandra Wong Martin   \n",
       "112  Completed   Wireless Analytics         Jesus Loera   \n",
       "113   Canceled        T. Rowe Price       Chuma Enwonwu   \n",
       "114   Canceled              Rutgers          8649931818   \n",
       "\n",
       "    Scheduled Window Start                                    id  \n",
       "110       2019-01-17T22:00  59ca10d2-0e21-4695-a525-19edad22bfd3  \n",
       "111       2019-01-17T18:00  cb22da56-5579-40ce-bcbc-17c9f3a023ea  \n",
       "112       2019-01-17T17:00  9c80c54b-7923-46f6-82c7-bc76448ed9f2  \n",
       "113       2019-01-28T21:30  152ecc28-f3d1-4e57-b994-d3a54b48ee14  \n",
       "114       2019-01-23T17:00  fb4f58d5-572d-498e-a2be-f0c7bcd47321  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_groups = df.groupby('Group').count()\n",
    "df_groups.drop(['Customer', 'Scheduled Window Start', 'id'], axis=1, inplace=True)\n",
    "Total = df_groups['State'].sum()\n",
    "df_groups['% by Account'] = round(100 * df_groups['State'] / Total, 2)\n",
    "df_groups.sort_values(['State'], ascending=[False], inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = []\n",
    "states = df.groupby('State').count()\n",
    "states = states['Group']\n",
    "states.columns = ['Count']\n",
    "\n",
    "# Calculate Percentages\n",
    "try:\n",
    "    Requested = round(100 * states['Requested'] / states.sum(), 2)\n",
    "except:\n",
    "    Requested = 0.00\n",
    "    \n",
    "try:\n",
    "    Scheduled = round(100 * states['Scheduled'] / states.sum(), 2)\n",
    "except:\n",
    "    Scheduled = 0.00\n",
    "try:\n",
    "    InProgress = round(100 * states['In Progress'] / states.sum(), 2)\n",
    "except:\n",
    "    InProgress = 0.00\n",
    "    \n",
    "try:\n",
    "    Completed = round(100 * states['Completed'] / states.sum(), 2)\n",
    "except:\n",
    "    Completed = 0.00\n",
    "    \n",
    "try:\n",
    "    Canceled = round(100 * states['Canceled'] / states.sum(), 2)\n",
    "except:\n",
    "    Canceled = 0.00\n",
    "\n",
    "status.append(['Requested', Requested])\n",
    "status.append(['In Progress', InProgress])\n",
    "status.append(['Completed', Completed])\n",
    "status.append(['Scheduled', Scheduled])\n",
    "status.append(['Canceled', Canceled])\n",
    "\n",
    "states = pd.DataFrame(status)\n",
    "states.columns = ['Status', 'Percentage']\n",
    "states.sort_values(['Percentage'], ascending=[False], inplace = True)\n",
    "states.reset_index(drop = True, inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "query = \"\"\" select distinct\n",
    "        COALESCE(condition.tier, 1) as Tier, repair.id\n",
    "    from claims repair\n",
    "    left join claims_claim_conditions ccc on ccc.claim_id = repair.id\n",
    "    left join claim_conditions condition on ccc.claim_condition_id = condition.id\n",
    "    where repair.scheduled_window_start > \"\"\"\n",
    "query = query + \"'\" + lastFriday + \"'\"\n",
    "\n",
    "tiers = getRecords(query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = pd.merge(df, tiers, on = 'id')\n",
    "df_tiers = output[['State','tier','Customer','Group','Scheduled Window Start']].copy()\n",
    "df_tiers.columns = ['State', 'Tier', 'Customer', 'Group', 'Scheduled Window Start']\n",
    "df_tiers = df_tiers[df_tiers.State == 'Completed'].groupby(['Tier']).count()\n",
    "df_tiers.columns = ['Count', 'Customer', 'Group', 'Scheduled Window Start']\n",
    "Total = df_tiers['Count'].sum()\n",
    "df_tiers['Percentage by Tier'] = round(100 * df_tiers['Count'] / Total, 2)\n",
    "df_tiers.drop(['Customer', 'Group', 'Scheduled Window Start'], axis=1, inplace=True)\n",
    "df.sort_values(['Group','Scheduled Window Start'], ascending=[True, True], inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "today = datetime.now()\n",
    "df_groups.columns = ['Count', '% by Account']\n",
    "dateFile = str(today.month) + '-' + str(today.day) + '-' + str(today.year)\n",
    "filename = 'customer service ' + dateFile + '.xlsx'\n",
    "writer = pd.ExcelWriter(filename)\n",
    "df.to_excel(writer, 'Claims Data', index = False)\n",
    "states.to_excel(writer, 'States Data', index = False)\n",
    "df_tiers.to_excel(writer,'Percentage by Tier')\n",
    "df_groups.to_excel(writer, '% by Group')\n",
    "dfc.to_excel(writer, '% by Tier Completed')\n",
    "\n",
    "lstate = df.State.map(lambda x: len(x)).max() + 1\n",
    "lGroup = df.Group.map(lambda x: len(x)).max() + 1\n",
    "lCustomer = df.Customer.map(lambda x: len(x)).max() + 1\n",
    "lStart = len('Scheduled Window Start') + 2\n",
    "lid = df.id.map(lambda x: len(x)).max() \n",
    "\n",
    "ws = writer.sheets['Claims Data']\n",
    "ws.set_column(0, 1, lstate)\n",
    "ws.set_column(1, 2, lGroup)\n",
    "ws.set_column(2, 3, lCustomer)\n",
    "ws.set_column(3, 4, lStart)\n",
    "ws.set_column(4, 5, lid)\n",
    "\n",
    "lstatus = states.Status.map(lambda x: len(x)).max() + 1\n",
    "lPercentage = len('Percentage') + 1\n",
    "ws = writer.sheets['States Data']\n",
    "ws.set_column(0, 1, lstatus)\n",
    "ws.set_column(1, 2, lPercentage)\n",
    "\n",
    "ltiers = len('Percentage by Tier') + 1\n",
    "ws = writer.sheets['Percentage by Tier']\n",
    "ws.set_column(2, 3, ltiers)\n",
    "\n",
    "lGroup = df_groups.index.map(lambda x: len(x)).max() + 1\n",
    "lState = len('Count') + 1\n",
    "lAccount = len('% by Account') + 1\n",
    "ws = writer.sheets['% by Group']\n",
    "ws.set_column(0, 1, lGroup)\n",
    "ws.set_column(1, 2, lState)\n",
    "ws.set_column(2, 3, lAccount)\n",
    "\n",
    "writer.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tier moving average data\n",
    "\n",
    "queryt = \"\"\" select\n",
    "        repair.id id,\n",
    "        max(coalesce(condition.tier, 1)) tier,\n",
    "        to_date(EXTRACT(YEAR FROM \"repair\".\"resolved_at\")::text ||  EXTRACT(WEEK FROM \"repair\".\"resolved_at\"), 'yyyyww') as \"WeekOf\"\n",
    "    from claims repair\n",
    "    left join claims_claim_conditions ccc on ccc.claim_id = repair.id\n",
    "    left join claim_conditions condition on ccc.claim_condition_id = condition.id\n",
    "    where \"repair\".\"resolved_at\" > '04-01-2018' group by 1, 3 \"\"\"\n",
    "\n",
    "dft = getRecords(queryt)\n",
    "\n",
    "dft.sort_values(['WeekOf'], ascending = [True], inplace = True)\n",
    "\n",
    "dft = dft.groupby(['WeekOf','tier'])['tier'].count()\n",
    "dft = pd.DataFrame(dft)\n",
    "dft.columns = ['count']\n",
    "dft = dft.unstack()\n",
    "dft.fillna(0.0, inplace = True)\n",
    "dft['Tier 1 Percentage'] = dft['count',1] / (dft['count', 1] + dft['count', 2] + dft['count',3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 8640x6480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dft_rolling4 = dft.rolling(window = 8).mean()\n",
    "dfa = pd.merge(dft, dft_rolling4, on = 'WeekOf')\n",
    "dfa = dfa[['Tier 1 Percentage_x', 'Tier 1 Percentage_y']]\n",
    "dfa.columns = ['Tier 1 Percentage', '8 Week Rolling Mean']\n",
    "\n",
    "# Change to percent\n",
    "dfa = 100 * dfa\n",
    "plt = dfa.plot(title='Tier Data versus 8 Week Rolling Mean', rot = 75)\n",
    "plt.set_xlabel('')\n",
    "plt.set_ylabel('% Tier 1s')\n",
    "fig = figure(num=None, figsize=(8, 6), dpi=1080, facecolor='w', edgecolor='k')\n",
    "_fig = plt.get_figure()\n",
    "_fig.savefig('tierplots.png', bbox_inches='tight', dpi = 300)\n",
    "\n",
    "# # Your plot generation code here...\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "\n",
    "wb = openpyxl.load_workbook(filename)\n",
    "ws = wb.create_sheet('Tier Rolling Mean')\n",
    "img = openpyxl.drawing.image.Image('tierplots.png')\n",
    "img.height = 0.40 * img.height\n",
    "img.width = 0.40 * img.width\n",
    "ws.add_image(img, 'B3')\n",
    "\n",
    "# ws.add_image(img)\n",
    "wb.save(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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 tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"3\" halign=\"left\">count</th>\n",
       "      <th>Tier 1 Percentage</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tier</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>WeekOf</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-01-01</th>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-02</th>\n",
       "      <td>22.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.647059</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-09</th>\n",
       "      <td>28.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.651163</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-16</th>\n",
       "      <td>23.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.621622</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-04-23</th>\n",
       "      <td>27.0</td>\n",
       "      <td>19.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.574468</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           count            Tier 1 Percentage\n",
       "tier           1     2    3                  \n",
       "WeekOf                                       \n",
       "2018-01-01   2.0   0.0  0.0          1.000000\n",
       "2018-04-02  22.0  11.0  1.0          0.647059\n",
       "2018-04-09  28.0  13.0  2.0          0.651163\n",
       "2018-04-16  23.0  13.0  1.0          0.621622\n",
       "2018-04-23  27.0  19.0  1.0          0.574468"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dft.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}