tweet bot workbook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cm_api import *\n",
    "from cm_config import config\n",
    "import datetime\n",
    "import tweepy\n",
    "from helper_funct import *\n",
    "from helper_funct1 import *\n",
    "from twitter_bot import *\n",
    "import pandas as pd\n",
    "import time\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from utility import *\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "rt = config['refresh_token']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6MTA0MTM4LCJ0aW1lc3RhbXAiOjE2MTM1MDM2MDI5MDQsImlhdCI6MTYxMzUwMzYwMiwiZXhwIjoxNjEzNTA3MjAyfQ.s57aEWsTp3Fg1GGLkH2hWuzbMaQ-tWPI9LceBKGuy2Q'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "api_token = get_api_token(rt)\n",
    "api_token"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## API Request Reset Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2021-01-20 16:20:52'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "api_reset_time(api_token)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unsigned Trending Artists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import logging\n",
    "from cm_config import config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from helper_funct1 import *\n",
    "from twitter_bot import *\n",
    "import time\n",
    "import random\n",
    "import decimal\n",
    "\n",
    "\n",
    "# ################################################\n",
    "# generate api token for chartmetric api access\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "current_date = generate_yesterday_date()\n",
    "\n",
    "before_date = generate_one_week_prior_date()\n",
    "\n",
    "data = get_tiktok_chart_data(api_token, 'tracks', current_date, 'weekly', limit=100)\n",
    "#parse data into dataframe (columns='title', 'artist', 'isrc', 'velocity', 'cm_id')\n",
    "parsed_data = parse_tiktok_data(data)\n",
    "\n",
    "#get artist id for each artist\n",
    "id_bucket = []\n",
    "for track_id in parsed_data['cm_id']:\n",
    "    artist_id = get_track_metadata(api_token, track_id)['artists'][0]['id']\n",
    "    id_bucket.append(artist_id)\n",
    "    time.sleep(1.5)\n",
    "\n",
    "# #create artist ID feature to dataframe\n",
    "parsed_data['cm_artist_id'] = id_bucket\n",
    "\n",
    "#get label info for each artist\n",
    "label_bucket = []\n",
    "for row in parsed_data.iterrows():\n",
    "    artist_id = row[1]['cm_artist_id']\n",
    "    label = get_artist_metadata(api_token, artist_id)['record_label']\n",
    "    label_bucket.append(label)\n",
    "parsed_data['label'] = label_bucket\n",
    "\n",
    "# # #collect before and after instagram follower values for each artist\n",
    "igfollow_bucket = []\n",
    "for artist in parsed_data['cm_artist_id']:\n",
    "    ig_followers = get_fan_metrics(api_token, artist, 'instagram', before_date, current_date, field='followers')['followers']\n",
    "    if len(ig_followers) > 0:\n",
    "        follow_tuple = (ig_followers[0]['value'], ig_followers[-1]['value'])\n",
    "        igfollow_bucket.append(follow_tuple)\n",
    "    else:\n",
    "        follow_tuple = (None, None)\n",
    "        igfollow_bucket.append(follow_tuple)\n",
    "        \n",
    "parsed_data['fig_before'] = [x[0] for x in igfollow_bucket]\n",
    "parsed_data['fig_after'] = [x[1] for x in igfollow_bucket]\n",
    "\n",
    "# # #collect before and after spotify listeners values for each artist\n",
    "spot_bucket = []\n",
    "for artist in parsed_data['cm_artist_id']:\n",
    "    sp_listeners = get_fan_metrics(api_token, artist, 'spotify', before_date, current_date, field='listeners')['listeners']\n",
    "    if len(sp_listeners) > 0:\n",
    "        listeners_tuple = (sp_listeners[0]['value'], sp_listeners[-1]['value'])\n",
    "        spot_bucket.append(listeners_tuple)\n",
    "    else:\n",
    "        listeners_tuple = (None, None)\n",
    "        spot_bucket.append(listeners_tuple)\n",
    "        \n",
    "parsed_data['spotl_before'] = [x[0] for x in spot_bucket]\n",
    "parsed_data['spotl_after'] = [x[1] for x in spot_bucket]\n",
    "\n",
    "parsed_data['sp_list_diff'] = parsed_data['spotl_after'] - parsed_data['spotl_before']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='fig_before', ylabel='sp_list_diff'>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAESCAYAAAAfXrn0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAc2UlEQVR4nO3df5yVdZ338df7wMDJ4ZcOAxiCI0q5YYo4kZq2rv24WTO57zTSdS1bWza3spZ+aD3aLNvH7qN2b/bOpVJK75ItE7WSyrTu9F6sh3o7sIiCayFiggjjJAwgIwznc/9xrpmGYX6cgXOdM+ec9/PxmMecc/38cHmc97m+1/f6XooIzMystmXKXYCZmZWfw8DMzBwGZmbmMDAzMxwGZmaGw8DMzKjgMJB0q6Ttkp4scPkFktZLWifp+2nXZ2ZWSVSp9xlIeiuwG7gtIk4ZZNmZwHLg/Ih4WdKkiNheijrNzCpBxZ4ZRMRK4A89p0k6UdJ9klZJekjSycmsvwa+HhEvJ+s6CMzMeqjYMOjHUuBjEXEG8CngG8n01wGvk/QbSY9Imle2Cs3MhqGR5S6gWCSNAc4G7pTUNXl08nskMBM4DzgOWCnpjRGxo8RlmpkNS1UTBuTPcnZExOw+5m0GHo2I/cCzkn5LPhweK2F9ZmbDVtU0E0VEO/k/9O8FUN5pyewfkz8rQNJE8s1GG8tQppnZsFSxYSDpduBh4PWSNku6CrgcuErS48A6YH6y+P1Am6T1wIPApyOirRx1m5kNR6l2LZWUBVaSb7sfCdwVEdf3WmY0cBtwBtAGvC8iNqVWlJmZHSLtM4NXyfftPw2YDcyTdGavZa4CXo6Ik4B/Bb6Sck1mZtZLqheQI3/asTt5W5f89D4VmQ98MXl9F7BEkmKAU5aJEydGU1NTcYs1M6tyq1ateikiGvual3pvIkkjgFXASeRv/Hq01yJTgecBIqJT0k6gAXip13YWAgsBpk+fTktLS9qlm5lVFUnP9Tcv9QvIEXEg6e55HDBX0oBDRwywnaUR0RwRzY2NfQabmZkdppL1Jkpu8HoQ6H337xZgGoCkkcB48heSzcysRFINA0mNkiYkr18DvAP4r16LrQA+kLy+BHhgoOsFZmZWfGlfMzgW+G5y3SADLI+In0q6AWiJiBXALcAySRvIDzx3aco1mZlZL2n3JloLnN7H9C/0eN0BvDfNOszMbGDVNDaR1YBcLtjUtodt7R1MHpelqaGeTEaDr2hmA3IYWMXI5YL71r3IouVr6NifI1uXYfGC2cybNcWBYHaEKnZsIqs9m9r2dAcBQMf+HIuWr2FT254yV2ZW+RwGVjG2tXd0B0GXjv05tu/qKFNFZtXDYWAVY/K4LNm6gz+y2boMk8Zmy1SRWfVwGFjFaGqoZ/GC2d2B0HXNoKmhvsyVmVU+X0C2ipHJiHmzpnDyNeeyfVcHk8a6N5FZsTgMrKJkMmJG4xhmNI4pdylmVcXNRGZm5jAwMzOHgZmZ4TAwMzMcBmZmhsPAzMxwGJiZGQ4DMzPDYWBmZjgMzMwMh4GZmeEwMDMzHAZmZobDwMzMcBiYmRkph4GkaZIelLRe0jpJH+9jmfMk7ZS0Jvn5Qpo1mZnZodJ+uE0n8MmIWC1pLLBK0i8jYn2v5R6KiAtTrsXMzPqR6plBRGyNiNXJ613AU8DUNPdpZmZDV7JrBpKagNOBR/uYfZakxyX9XNKsftZfKKlFUktra2uapZqZ1ZyShIGkMcDdwCcior3X7NXA8RFxGvBvwI/72kZELI2I5ohobmxsTLVeM7Nak3oYSKojHwTfi4gf9p4fEe0RsTt5fS9QJ2li2nWZmdkfpd2bSMAtwFMRsbifZaYkyyFpblJTW5p1mZnZwdLuTfQW4ArgCUlrkmmfA6YDRMRNwCXA1ZI6gb3ApRERKddlZmY9pBoGEfFrQIMsswRYkmYdZmY2MN+BbGZmDgMzM3MYmJkZDgMzM8NhYGZmOAzMzAyHgZmZ4TAwMzMcBmZmhsPAzMxwGJiZGQ4DMzPDYWBmZjgMzMwMh4GZmeEwMDMzHAZmZkb6j720AuVywaa2PWxr72DyuCxNDfVkMgM+JM7MrGgcBsNALhfct+5FFi1fQ8f+HNm6DIsXzGberCkOBDMrCTcTDQOb2vZ0BwFAx/4ci5avYVPbnjJXZma1wmEwDGxr7+gOgi4d+3Ns39VRporMrNY4DIaByeOyZOsO/k+RrcswaWy2TBWZWa1JNQwkTZP0oKT1ktZJ+ngfy0jSjZI2SForaU6aNQ1HTQ31LF4wuzsQuq4ZNDXUl7kyM6sVaV9A7gQ+GRGrJY0FVkn6ZUSs77HMnwMzk583A99MfteMTEbMmzWFk685l+27Opg01r2JzKy0Ug2DiNgKbE1e75L0FDAV6BkG84HbIiKARyRNkHRssm7NyGTEjMYxzGgcU+5SzKwGleyagaQm4HTg0V6zpgLP93i/OZnWe/2FkloktbS2tqZWp5lZLSpJGEgaA9wNfCIi2g9nGxGxNCKaI6K5sbGxuAWamdW41MNAUh35IPheRPywj0W2ANN6vD8umWZmZiWSdm8iAbcAT0XE4n4WWwG8P+lVdCaws9auF5iZlVvavYneAlwBPCFpTTLtc8B0gIi4CbgXuADYALwCfDDlmszMrJe0exP9Ghiwf2TSi+gjadZhZmYD8x3IZmbmMDAzM4eBmZnhMDAzMxwGZmaGw8DMzHAYmJkZDgMzM8NhYGZmOAzMzAyHgZmZ4TAwMzMcBmZmhsPAzMwoIAwkjS5FIWZmVj6FnBk8DCBpWcq1mJlZmRTycJtRkv4COFvSe3rP7Oe5xmZmVkEKCYMPA5cDE4B395oXgMPAzKzCFRIGx0bE1ZL+MyKWpl6RmZmVXCHXDD6b/P5wmoWYmVn5FHJm0CbpF8AJklb0nhkRFxW/LDMzK6VCwuBdwBxgGfA/0y3HzMzKYdAwiIh9wCOSzo6I1qFsXNKtwIXA9og4pY/55wH3AM8mk34YETcMZR9mZnbkBg0DSf8rIj4B3Copes8fpJnoO8AS4LYBlnkoIi4crA4zM0tPIc1EXTeb/ctQNx4RKyU1DXU9MzMrrUKaiVYlv/8jpRrOkvQ48ALwqYhYl9J+zMysH4U0Ez1B/uayPkXEqUew/9XA8RGxW9IFwI+Bmf3UsRBYCDB9+vQj2KWZmfVWSDNRV3v+R5LfXc1Gf8kAIVGIiGjv8fpeSd+QNDEiXupj2aXAUoDm5uYj2q+ZmR2skGai5wAkvSMiTu8x61pJq4HrDnfnkqYA2yIiJM0lfxNc2+Fuz8zMDk8hZwZdJOktEfGb5M3ZDHIHs6TbgfOAiZI2A9cDdQARcRNwCXC1pE5gL3BpRPhbv5lZiQ0lDK4i3710fPJ+B/BXA60QEZcNMn8J+a6nZmZWRgWHQdKr6LSuMIiInT3nS/pARHy3yPWZmVkJDPmxlxGxs3cQJD5ehHrMzKwMivkMZBVxW2ZmVkLFDANf+DUzq1A+MzAzs8LDQNIJg0z7TVEqMjOzkhvKmcHdfUy7q+tFRHz0yMsxM7NyKGRsopOBWcB4Se/pMWsckE2rMDMzK51C7jN4PfnxiSYA7+4xfRfw1ynUZGZmJVbI2ET3APdIOisiHi5BTWZmVmJDuWbwPySNk1Qn6VeSWiX9ZWqVmZlZyQwlDN6ZDDl9IbAJOAn4dBpFmZlZaQ0lDOqS3+8C7uxnSAozM6tAQxm19CeS/ov8UNNXS2oEOtIpy8zMSqngM4OIuA44G2iOiP3AHmB+WoWZmVnpFHKfwfkR8UDPewykg0ae+GEahZmZWekU0kz0p8ADHHyPQZfAYWBmVvEKuc/g+uT3B9Mvx8zMyqGQZqJFA82PiMXFK8fMzMqhkGaisalXYWZmZVVIM9GXCtmQpM9GxD8deUlmZlZqxXy4zXuLuC0zMyshP+nMzMzSfQaypFslbZf0ZF8rKO9GSRskrZU0p4j1mJlZgdI+M/gOMG+Adf4cmJn8LAS+WcR6DpHLBRtbd/PwMy+xsXU3udwh+WVmVpOGMjbRYO7sPSEiVkpqGmCd+cBtERHAI5ImSDo2IrYWsS4gHwT3rXuRRcvX0LE/R7Yuw+IFs5k3awqZjFu4zKy2FXxmIGmGpJ9Ieilp+rlH0oyu+RHxj4ex/6nA8z3eb06m9bX/hZJaJLW0trYOeUeb2vZ0BwFAx/4ci5avYVPbnsMo28ysugylmej7wHJgCvBa8mcCt6dRVF8iYmlENEdEc2Nj45DX39be0R0EXTr259i+ywOvmpkNJQyOiohlEdGZ/Pw7kD3C/W8BpvV4f1wyregmj8uSrTv4n5utyzBp7JH+E8zMKt9QwuDnkq6T1CTpeEmfAe6VdIykYw5z/yuA9ye9is4EdqZxvQCgqaGexQtmdwdC1zWDpob6NHZnZlZRlL92W8CC0rM93nat1HXlNSJiRq9VkHQ7cB4wEdgGXE/yxLSIuEn5sbCXkO9x9ArwwYhoGayW5ubmaGkZdLFD5HLBprY9bN/VwaSxWZoa6n3x2MxqhqRVEdHc17yh9Ca6FrgvItol/T0wB/hyRKzub4WIuGygDSa9iD4yhBqOSCYjZjSOYUbjmFLt0sysIgylmejzSRCcA5wPfJuU7wswM7PSGEoYHEh+vwv4VkT8DBhV/JLMzKzUhhIGWyTdDLyP/IXj0UNc38zMhqmh/DFfANwP/LeI2AEcA3w6jaLMzKy0Cr6AHBGv0ON5x0kX0FS6gZqZWWm5mcfMzBwGZmbmMDAzMxwGZmaGw8DMzHAYmJkZDgMzM8NhYGZmOAzMzAyHgZmZ4TAwMzMcBmZmhsPAzMxwGJiZGQ4DMzPDYWBmZjgMzMyMEoSBpHmSnpa0QdJ1fcy/UlKrpDXJz4fSqCOXCza27ubhZ15iY+tucrlIYzdmZhWp4MdeHg5JI4CvA+8ANgOPSVoREet7LXpHRHw0rTpyueC+dS+yaPkaOvbnyNZlWLxgNvNmTSGTUVq7NTOrGGmfGcwFNkTExojYB/wAmJ/yPg+xqW1PdxAAdOzPsWj5Gja17Sl1KWZmw1LaYTAVeL7H+83JtN4ulrRW0l2SphW7iG3tHd1B0KVjf45t7R3F3pWZWUUaDheQfwI0RcSpwC+B7/a1kKSFkloktbS2tg5pB0eNGkm27uB/arYuw1GjRhxmyWZm1SXtMNgC9Pymf1wyrVtEtEXEq8nbbwNn9LWhiFgaEc0R0dzY2DikIvYdOMA158/sDoRsXYZrzp/J/gO5QdY0M6sNqV5ABh4DZko6gXwIXAr8Rc8FJB0bEVuTtxcBTxW7iIb60dzR8nuuOmcGEkTAHS2/Z94pU4q9KzOzipRqGEREp6SPAvcDI4BbI2KdpBuAlohYAVwj6SKgE/gDcGWx62hqqOfaeX9ySG+ipob6Yu/KzKwiKaLy+ts3NzdHS0vLkNbJ5YJNbXvYvquDSWOzNDXUD7lbadc2trV3MHnc4W3DzKxcJK2KiOa+5qXdTDRsZDJiRuMYZjSOOaz1fa+CmVWz4dCbqGSO5C5k36tgZtWsZs4MjvSbfX/3Kmzf1XHYZxuVys1lZtWnZs4M+vtm/0zr7oLWnzwu2+e9CpPGZote63DWFaoX3PgQl33rUS648SHuW/eix3oyq3A1Ewb9fbNfv7WdffsODLp+U0M9ixfMPuhehVrskeTmMrPqVDPNRF3f7HsGQrYuwzOtu1n7wk6am44ZcP1MRsybNYWTrzm3oB5J1dqU4uYys+pUM2HQ1FDPVy85lQ3bd5MLGCE45qhR3LRyI6+fPLagbRTaI6maex71F6q11lxmVm1qppkI4MCBYOnKjSx5YAM3r9xIR2eOUSPF5HHF/UNWzU0pbi4zq041c2awqW0Pn/3REwf9gf7X//NbvnH5HE597fii7quam1KG2lxmZpWhZsKgvz/Q2ZEjGFXk0UurvSnlSG/gM7Php2aaiSaN7btraLGbiMBNKWZWeWrmzGBEBj7+tpl87Ve/676o+4UL38DIFB5p4KYUM6s0NRMGrbtfJTsywzcun8NLu15l+65XuXnlM2TrRjDt6OL/oXZTiplVkpoIg1wueGFHB1+5/+nus4Jrzp/Jvs7gcz96gtnTJviPtpnVtJoIg01te7j27rW8btIYPvTWE9n7aif12ZFc/acz+MKK9VXRy8fM7EjURBhsa+/gdZPGcNnc4/nMXY93nx186aJZNB8/vruXT7XeNWxmNpiaCIPJ47IsfOuJfCoJAsh3K71+xTpu/cCbaGqor+q7hs3MBlMTXUubGuoJos/7DF5+ZR+ZjKr6rmEzs8HURBhkMmLqhNf0eZ9Bw5hRbGzdPeBdw305kgflmJkNNzURBp2dOXZ27ONLF8066Eaw6989i3/82VNccONDdB6Igp9X4DH9zaza1EQYPL2tnd9t28OdLb/nq5ecxlcvfiPfen8zR42EtVva6dif4/P3PMFXLj61oLuG3aRkZtWmJi4g79i7n+89+hwXnjqVF3a8wtQJR/H48zs44/ijOXZ8lq07O3iubS9TJ2S5t4C7hqt5IDozq001EQavdh7gQ+fMYO++TuqzdXy6R/fST73z9dzy62d5+ZV9HFM/uqC7hqt9IDozqz2pNxNJmifpaUkbJF3Xx/zRku5I5j8qqanYNUzIjmL3q53s3neAL/90/UHNO//yi6f550tO5eYr5hQ8kJwHojOzapPqmYGkEcDXgXcAm4HHJK2IiPU9FrsKeDkiTpJ0KfAV4H3FrOOV/Qf42q9+x4fOnXHQt/ljx2d5z5zj2LJjL5PGjmbfvgO8sKtj0JvOPBCdmVWbtJuJ5gIbImIjgKQfAPOBnmEwH/hi8vouYIkkRUTRuubs6ujsDoGu5p1jx2e54szjufGBP45i+uX5p7Dkwd/xXNveQW8680B0ZlZN0m4mmgo83+P95mRan8tERCewE2jovSFJCyW1SGppbW0dUhHHjBlFti7D3as2c835M8nWZXjPnOO6gwDyTUZ/f8+TXHjq1O737iFkZrWiYrqWRsTSiGiOiObGxsYhrTsuO4Ib5p/Cy6/sY9kjz7HwrTN4/eQxffYIkg5+399NZ2Zm1STtZqItwLQe749LpvW1zGZJI4HxQFsxi5jZOI4X2zv41hXNbN25l+yokbTt7uizR1DPxin3EDKzWpH2mcFjwExJJ0gaBVwKrOi1zArgA8nrS4AHinm9AGDkyAznnjiJo+vrmDI+i4Axo0Zy/bsPviP5H/77Kfx07Zbu9+4hZGa1ItUzg4jolPRR4H5gBHBrRKyTdAPQEhErgFuAZZI2AH8gHxhFN3JkhlOmTmBj624WLnuo+yLyVefMYEQGzprRwBnTjmbO9KPdQ8jMao6K/CW8JJqbm6OlpeWw1s3lgp+sfYFr71570FPP7mj5Pf/7yrnuHWRmVUvSqoho7mteTdyB3FMmI147IX9GIEEELHvkObbu7PBwEmZWs2ouDAAa6kdzy683ejgJM7NExXQtLSYPJ2FmdrCaPDPwcBJmZgeryTAADydhZtZTTTYTmZnZwRwGZmZWu81EZmaVJJcLNrXtGXSI/cPlMDAzG+ZyueC+dS92P3t9sCH2D4ebiYapXC7Y2Lqbh595iY2tu8nlKu9OcTMrjk1te7qDANIZYt9nBsNQKb4FmFnl2Nbe0eeQ+8UcNcFnBsNQKb4FmFnlmDwu232TbJdij5rgMBiGBvoWYGa1pxSjJriZaBjq+hbgsZPMDEozaoLPDIYhj51kZr11jZpw5oyJzGgcU/Trhz4zGIY8dpKZlZrDYJjy2ElmVkpuJjIzM4eBmZk5DMzMDIeBmZnhMDAzM0ARlTcAmqRW4LnDXH0i8FIRy6kGPiaH8jE5lI/JoSrtmBwfEY19zajIMDgSkloiorncdQwnPiaH8jE5lI/JoarpmLiZyMzMHAZmZlabYbC03AUMQz4mh/IxOZSPyaGq5pjU3DUDMzM7VC2eGZiZWS8OAzMzq94wkDRP0tOSNki6ro/5oyXdkcx/VFJTGcosqQKOyZWSWiWtSX4+VI46S0nSrZK2S3qyn/mSdGNyzNZKmlPqGkutgGNynqSdPT4nXyh1jaUkaZqkByWtl7RO0sf7WKbyPycRUXU/wAjgGWAGMAp4HHhDr2X+FrgpeX0pcEe56x4Gx+RKYEm5ay3xcXkrMAd4sp/5FwA/BwScCTxa7pqHwTE5D/hpuess4fE4FpiTvB4L/LaP/3cq/nNSrWcGc4ENEbExIvYBPwDm91pmPvDd5PVdwNskVfPTYwo5JjUnIlYCfxhgkfnAbZH3CDBB0rGlqa48CjgmNSUitkbE6uT1LuApYGqvxSr+c1KtYTAVeL7H+80c+h+ve5mI6AR2Ag0lqa48CjkmABcnp7l3SZpWmtKGtUKPW605S9Ljkn4uaVa5iymVpDn5dODRXrMq/nNSrWFgh+cnQFNEnAr8kj+eOZn1tJr8GDenAf8G/Li85ZSGpDHA3cAnIqK93PUUW7WGwRag57fa45JpfS4jaSQwHmgrSXXlMegxiYi2iHg1eftt4IwS1TacFfJZqikR0R4Ru5PX9wJ1kiaWuaxUSaojHwTfi4gf9rFIxX9OqjUMHgNmSjpB0ijyF4hX9FpmBfCB5PUlwAORXAmqUoMek15tnBeRbxutdSuA9ye9Rc4EdkbE1nIXVU6SpnRdX5M0l/zfkar9IpX8W28BnoqIxf0sVvGfk5HlLiANEdEp6aPA/eR70dwaEesk3QC0RMQK8v9xl0naQP5i2aXlqzh9BR6TayRdBHSSPyZXlq3gEpF0O/neMRMlbQauB+oAIuIm4F7yPUU2AK8AHyxPpaVTwDG5BLhaUiewF7i0yr9IvQW4AnhC0ppk2ueA6VA9nxMPR2FmZlXbTGRmZkPgMDAzM4eBmZk5DMzMDIeBmdmwN9jggb2WnZ4MrPefyWgCFxSyD4eBmdnw9x1gXoHLfh5YHhGnk+8y/41CVnIYWM2RdI2kpyS93NdQ3gWsf56knw5xnXOT4Y/XSHrNUPdpta2vwQMlnSjpPkmrJD0k6eSuxYFxyevxwAuF7KMqbzozG8TfAm+PiM0l3OflwD9FxL8XsrCkkckAimb9WQp8OCJ+J+nN5M8Azge+CPxC0seAeuDthWzMZwZWUyTdRP6ZDj+X9HeSliTTT5T0iKQnJP2DpN2DbGqcpJ8lDwu6SVIm2c47JT0sabWkOyWNUf4hQQuAL0v6XjJkwT9LejLZ3/uSdc9LvuGtANZLGpEs91jS9vs36R0ZqyTJoHlnA3cmd0XfTP65CwCXAd+JiOPI3xW9rOvzORCfGVhNiYgPS5oH/BlwYY9ZXwO+FhG3S/pwAZuaC7wBeA64D3iPpP9Lvr327RGxR9K1wKKIuEHSOeQfCHOXpIuB2cBpwETgMUkrk+3OAU6JiGclLSQ/xs2bJI0GfiPpFxHx7BEeBqt8GWBHRMzuY95VJNcXIuJhSVnyn7Ptg23QzOAs4M7k9fcLWP7/JQ8KOgDcDpxD/glXbyD/R3sN+YEQj+9j3XOA2yPiQERsA/4DeFOP7Xb9sX8n+cHP1pAfP78BmDnUf5hVn2QI7WclvRe6H7t5WjL798Dbkul/AmSB1sG26TMDs8PTe1CvIP/Iw19GxGVHsN09PV4L+FhE3H8E27Mq0M/ggZcD35T0efIDCf6A/ONsPwl8S9Lfkf9cXlnIQIIOA7O8R4CLgTsobATbuZJOIN9M9D7yF/MeAb4u6aSI2CCpHpgaEb/tte5DwN9I+i5wDPlnDn8aOLnXcveTHx30gYjYL+l1wJaI2IPVlAG+YBzS3TQi1pMfaXVI3ExklvcJYJGktcBJ5B+DOpDHgCXkn/nwLPCjiGglP+z37cl2HubQP/AAPwLWkv8W9wDwmYh4sY/lvg2sB1YnNxvdjL/AWUo8hLUZIOkoYG9EhKRLgcsiYn656zIrFX/LMMs7A1iSPNVqB/BX5S3HrLR8ZmDWD0lvBJb1mvxqRLy5HPWYpclhYGZmvoBsZmYOAzMzw2FgZmY4DMzMDPj/vqCzST20coYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.scatterplot(data=parsed_data, x='fig_before', y='sp_list_diff')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 79 entries, 0 to 99\n",
      "Data columns (total 16 columns):\n",
      " #   Column         Non-Null Count  Dtype  \n",
      "---  ------         --------------  -----  \n",
      " 0   rank           79 non-null     int64  \n",
      " 1   added_at       79 non-null     object \n",
      " 2   title          79 non-null     object \n",
      " 3   artist         79 non-null     object \n",
      " 4   isrc           79 non-null     object \n",
      " 5   velocity       64 non-null     float64\n",
      " 6   cm_id          79 non-null     float64\n",
      " 7   time_on_chart  79 non-null     object \n",
      " 8   release_dates  79 non-null     object \n",
      " 9   cm_artist_id   79 non-null     int64  \n",
      " 10  label          13 non-null     object \n",
      " 11  fig_before     47 non-null     float64\n",
      " 12  fig_after      47 non-null     float64\n",
      " 13  spotl_before   77 non-null     float64\n",
      " 14  spotl_after    77 non-null     float64\n",
      " 15  sp_list_diff   77 non-null     float64\n",
      "dtypes: float64(7), int64(2), object(7)\n",
      "memory usage: 10.5+ KB\n"
     ]
    }
   ],
   "source": [
    "parsed_data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trending Artists on Tiktok (January 15 - January 21st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import logging\n",
    "from cm_config import config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from helper_funct1 import *\n",
    "from twitter_bot import *\n",
    "import time\n",
    "import random\n",
    "import decimal\n",
    "\n",
    "\n",
    "# ################################################\n",
    "# generate api token for chartmetric api access\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "current_date = generate_yesterday_date()\n",
    "\n",
    "before_date = generate_one_week_prior_date()\n",
    "\n",
    "data = get_tiktok_chart_data(api_token, 'tracks', current_date, 'weekly', limit=100)\n",
    "#parse data into dataframe (columns='title', 'artist', 'isrc', 'velocity', 'cm_id')\n",
    "parsed_data = parse_tiktok_data(data)\n",
    "\n",
    "#get artist id for each artist\n",
    "id_bucket = []\n",
    "for track_id in parsed_data['cm_id']:\n",
    "    artist_id = get_track_metadata(api_token, track_id)['artists'][0]['id']\n",
    "    id_bucket.append(artist_id)\n",
    "    time.sleep(1.5)\n",
    "\n",
    "# #create artist ID feature to dataframe\n",
    "parsed_data['cm_artist_id'] = id_bucket\n",
    "\n",
    "# #drop rows with no ID\n",
    "parsed_data2 = parsed_data.dropna(subset=['cm_artist_id'])\n",
    "parsed_data2.reset_index(inplace=True)\n",
    "parsed_data2 = parsed_data2[~parsed_data2['cm_artist_id'].isin( ['None'])].reset_index()\n",
    "# # #collect before and after listener values for each artist\n",
    "listener_bucket = []\n",
    "for artist in parsed_data2['cm_artist_id']:\n",
    "    listeners = get_fan_metrics(api_token, artist, 'spotify', before_date, current_date, field='listeners')['listeners']\n",
    "    if len(listeners) > 0:\n",
    "        follow_tuple = (listeners[0]['value'], listeners[-1]['value'])\n",
    "        listener_bucket.append(follow_tuple)\n",
    "    else:\n",
    "        follow_tuple = (None, None)\n",
    "        listener_bucket.append(follow_tuple)\n",
    "\n",
    "complete_data = parsed_data2.join(pd.DataFrame(listener_bucket, columns=['before', 'after']))\n",
    "complete_data['listener_diff'] = complete_data['after'] - complete_data['before']\n",
    "\n",
    "complete_data.drop(axis=1, columns=['level_0', 'index'], inplace=True)\n",
    "\n",
    "title, artist, artist_id, before, listener_diff = get_most_listener_gain(complete_data)\n",
    "hashartist = artist.replace(\" \", \"\",)\n",
    "hashtitle = title.replace(\" \", \"\",)\n",
    "number = insert_thousands_commas(listener_diff)\n",
    "\n",
    "#get spotify url for artist\n",
    "spot_url = get_spotify_url(api_token, artist_id)\n",
    "\n",
    "#get artist twitter handle\n",
    "handle = generate_twitter_handle(api_token, artist_id)\n",
    "\n",
    "#instantiatiate twitter bot object\n",
    "bot = instantiate_twitter_bot()\n",
    "\n",
    "if handle:\n",
    "\n",
    "    message = \"Of this week's Top trending artists on Tiktok,\\n{} had the biggest gain in Spotify listeners\\nUp {}% since last week({} more listeners)\\n#{} #{} #DataAnalytics #MusicDiscovery\\nPower by @Chartmetric\\n{}\".format(handle, round(listener_diff/before *100, 2),number,hashtitle, hashartist,spot_url)\n",
    "\n",
    "    bot.update_status(message)\n",
    "\n",
    "\n",
    "\n",
    "else:\n",
    "    message = \"Of this week's Top trending artists on Tiktok,\\n{} had the biggest gain in Spotify listeners\\nUp {}% since last week({} more listeners)\\n#{} #{} #DataAnalytics #MusicDiscovery\\nPower by @Chartmetric\\n{}\".format(artist, round(listener_diff/before *100, 2),number,hashtitle, hashartist,spot_url)\n",
    "\n",
    "    bot.update_status(message)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "complete_data['percent increase'] = (complete_data['listener_diff']/complete_data['before'])*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "complete_data['added_at'] = pd.to_datetime(complete_data['added_at']).dt.date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#collect instagram followers for january 15th and january 21\n",
    "bucket = []\n",
    "for row in complete_data.iterrows():\n",
    "    artist_id = row[1]['cm_artist_id']\n",
    "    data = get_fan_metrics(api_token, artist_id,'instagram', '2021-01-15', '2021-01-21', field='followers')['followers']\n",
    "    if len(data) > 0:\n",
    "        tup = (data[0]['value'], data[-1]['value'])\n",
    "        bucket.append(tup)\n",
    "    else:\n",
    "        tup = (None, None)\n",
    "        bucket.append(tup)   \n",
    "    \n",
    "complete_data['IG_f15'] = [x[0] for x in bucket]\n",
    "complete_data['IG_f21'] = [x[1] for x in bucket]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#collect Twitter\n",
    "bucket = []\n",
    "for row in complete_data.iterrows():\n",
    "    artist_id = row[1]['cm_artist_id']\n",
    "    data = get_fan_metrics(api_token, artist_id,'twitter', '2021-01-15', '2021-01-21', field='followers')['followers']\n",
    "    if len(data) > 0:\n",
    "        tup = (data[0]['value'], data[-1]['value'])\n",
    "        bucket.append(tup)\n",
    "    else:\n",
    "        tup = (None, None)\n",
    "        bucket.append(tup)   \n",
    "    \n",
    "complete_data['TW_f15'] = [x[0] for x in bucket]\n",
    "complete_data['TW_f21'] = [x[1] for x in bucket]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#collect tiktok followers\n",
    "bucket = []\n",
    "for row in complete_data.iterrows():\n",
    "    artist_id = row[1]['cm_artist_id']\n",
    "    data = get_fan_metrics(api_token, artist_id,'tiktok', '2021-01-15', '2021-01-21', field='followers')['followers']\n",
    "    if len(data) > 0:\n",
    "        tup = (data[0]['value'], data[-1]['value'])\n",
    "        bucket.append(tup)\n",
    "    else:\n",
    "        tup = (None, None)\n",
    "        bucket.append(tup)   \n",
    "    \n",
    "complete_data['Tiktok_f15'] = [x[0] for x in bucket]\n",
    "complete_data['Tiktok_f21'] = [x[1] for x in bucket]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "complete_data['Tiktok Status'] = complete_data['Tiktok_f15'].apply(lambda x: \"Has Tiktok\" if x > 0 else (\"No Tiktok\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "No Tiktok     48\n",
       "Has Tiktok    41\n",
       "Name: Tiktok Status, dtype: int64"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complete_data['Tiktok Status'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#read in csv file \n",
    "# complete_data = pd.read_csv('tiktok_jan2021.csv', index_col=0)\n",
    "complete_data.to_csv('tiktok_jan2021.csv', index_label='index')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 89 entries, 0 to 88\n",
      "Data columns (total 21 columns):\n",
      " #   Column            Non-Null Count  Dtype  \n",
      "---  ------            --------------  -----  \n",
      " 0   rank              89 non-null     int64  \n",
      " 1   added_at          89 non-null     object \n",
      " 2   title             89 non-null     object \n",
      " 3   artist            89 non-null     object \n",
      " 4   isrc              89 non-null     object \n",
      " 5   velocity          65 non-null     float64\n",
      " 6   cm_id             89 non-null     float64\n",
      " 7   time_on_chart     89 non-null     int64  \n",
      " 8   release_dates     89 non-null     object \n",
      " 9   cm_artist_id      89 non-null     int64  \n",
      " 10  before            88 non-null     float64\n",
      " 11  after             88 non-null     float64\n",
      " 12  listener_diff     88 non-null     float64\n",
      " 13  percent increase  88 non-null     float64\n",
      " 14  IG_f15            60 non-null     float64\n",
      " 15  IG_f21            60 non-null     float64\n",
      " 16  TW_f15            63 non-null     float64\n",
      " 17  TW_f21            63 non-null     float64\n",
      " 18  Tiktok_f15        41 non-null     float64\n",
      " 19  Tiktok_f21        41 non-null     float64\n",
      " 20  Tiktok Status     89 non-null     object \n",
      "dtypes: float64(12), int64(3), object(6)\n",
      "memory usage: 15.3+ KB\n"
     ]
    }
   ],
   "source": [
    "complete_data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min: -1,470,335\n",
      "Mean: 162,360\n",
      "Max: 10,724,863\n",
      "25th percentile: -473\n",
      "Median: 12,222\n",
      "75th percentile: 113,235\n",
      "Interquartile range (IQR): 113,708\n"
     ]
    }
   ],
   "source": [
    "#import from helper_function\n",
    "get_summary_statistics(complete_data['listener_diff'].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bull/Documents/twitter-bot-music-insights/twitter/lib/python3.8/site-packages/seaborn/_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#draw boxplot to show distribution of listener difference\n",
    "from matplotlib.pyplot import *\n",
    "\n",
    "fig = figure(figsize=(30,15))  # define the figure window\n",
    "ax1  = fig.add_subplot(111)   # define the axis\n",
    "sns.boxplot(complete_data['listener_diff'], fliersize=1,linewidth=2, whis=30,width=.75, color='yellow')\n",
    "sns.swarmplot(data=complete_data,x=complete_data['listener_diff'], color='black', size=10)\n",
    "plt.title('Top Tiktok Artists - (Jan.15 - Jan.21)', fontsize=20)\n",
    "plt.xlabel('Change in Spotify Listeners', fontsize=35)\n",
    "plt.ticklabel_format(style='plain', axis='x', ) #change xaxis from sci to plain style\n",
    "#annotate outlier data point\n",
    "plt.annotate('Olivia Rodrigo',xy=(10724863.0,0),xytext=(8211500.0,.2) ,arrowprops=dict(facecolor='red', arrowstyle='wedge'),\n",
    "                                                                                       fontsize=25)\n",
    "plt.annotate('(10,724,863 Listener Increase)',xy=(10723163.0,0),xytext=(8211500.0,.23),\n",
    "                                                                                       fontsize=15)\n",
    "plt.tick_params(axis='x', which='major', labelsize=20)\n",
    "plt.grid(axis='both')\n",
    "plt.savefig('or_boxplot.jpeg')\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bull/Documents/twitter-bot-music-insights/twitter/lib/python3.8/site-packages/seaborn/_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.pyplot import *\n",
    "\n",
    "fig = figure(figsize=(30,15))  # define the figure window\n",
    "ax1  = fig.add_subplot(111)   # define the axis\n",
    "sns.boxplot(complete_data['IG_f15'], fliersize=1,linewidth=2, whis=30,width=.75, color='yellow')\n",
    "sns.swarmplot(data=complete_data,x=complete_data['IG_f15'], color='black', size=10)\n",
    "plt.title('Top Tiktok Artists - (Jan.15 - Jan.21)', fontsize=20)\n",
    "plt.xlabel('Instagram Followers - Jan. 15th', fontsize=35)\n",
    "plt.ticklabel_format(style='plain', axis='x', ) #change xaxis from sci to plain style\n",
    "\n",
    "#annotate outlier data point\n",
    "plt.annotate('Olivia Rodrigo',xy=(4157696.0,0),xytext=(4157696.0,.2) ,arrowprops=dict(facecolor='red', arrowstyle='wedge'),\n",
    "                                                                                       fontsize=25)\n",
    "plt.annotate('(4,157,696 IG Followers)',xy=(4157696.0,0),xytext=(4157696.0,.23),\n",
    "                                                                                       fontsize=15)\n",
    "plt.tick_params(axis='x', which='major', labelsize=20)\n",
    "plt.grid(axis='both')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bull/Documents/twitter-bot-music-insights/twitter/lib/python3.8/site-packages/seaborn/_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = figure(figsize=(30,15))  # define the figure window\n",
    "ax1  = fig.add_subplot(111)   # define the axis\n",
    "sns.boxplot(complete_data['TW_f15'], fliersize=1,linewidth=2, whis=30,width=.75, color='yellow')\n",
    "sns.swarmplot(data=complete_data,x=complete_data['TW_f15'], color='black', size=10)\n",
    "plt.title('Top Tiktok Artists - (Jan.15 - Jan.21)', fontsize=20)\n",
    "plt.xlabel('Twitter Followers - Jan. 15th', fontsize=35)\n",
    "plt.ticklabel_format(style='plain', axis='x', ) #change xaxis from sci to plain style\n",
    "\n",
    "#annotate outlier data point\n",
    "plt.annotate('Olivia Rodrigo',xy=(395075.0,0),xytext=(395075.0,.2) ,arrowprops=dict(facecolor='red', arrowstyle='wedge'),\n",
    "                                                                                       fontsize=25)\n",
    "plt.annotate('(395,075 Twitter Followers)',xy=(395075.0,0),xytext=(395075.0,.23),\n",
    "                                                                                       fontsize=15)\n",
    "plt.tick_params(axis='x', which='major', labelsize=20)\n",
    "plt.grid(axis='both')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = figure(figsize=(30,15))  # define the figure window\n",
    "ax1  = fig.add_subplot(111)   # define the axis\n",
    "sns.boxplot(y='after',x='Tiktok Status', fliersize=1,linewidth=2, whis=30,width=.75, color='yellow', data=complete_data)\n",
    "sns.swarmplot(data=complete_data,y='after',x='Tiktok Status', color='black', size=10, )\n",
    "plt.title('Top Tiktok Artists - (Jan.15 - Jan.21)', fontsize=30)\n",
    "plt.xlabel('Tiktok Status', fontsize=35)\n",
    "plt.ylabel('Spotify Listeners - Jan. 21st', fontsize=20)\n",
    "plt.ticklabel_format(style='plain', axis='y', ) #change xaxis from sci to plain style\n",
    "\n",
    "#annotate outlier data point\n",
    "plt.annotate('Olivia Rodrigo',xy=(0,17935660.0),xytext=(0.23,17935660.0) ,arrowprops=dict(facecolor='red', arrowstyle='wedge'),\n",
    "                                                                                       fontsize=25)\n",
    "plt.annotate('(17,935,660 Spotify Listeners-Jan. 21)',xy=(0,17935660.0),xytext=(0.23,20935660.0),\n",
    "                                                                                       fontsize=15)\n",
    "plt.tick_params(axis='both', which='major', labelsize=20)\n",
    "plt.grid(axis='both')\n",
    "plt.savefig('tiktok_bp2.jpeg')\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = figure(figsize=(30,15))  # define the figure window\n",
    "ax1  = fig.add_subplot(111)   # define the axis\n",
    "sns.boxplot(y='before',x='Tiktok Status', fliersize=1,linewidth=2, whis=30,width=.75, color='yellow', data=complete_data)\n",
    "sns.swarmplot(data=complete_data,y='before',x='Tiktok Status', color='black', size=10, )\n",
    "plt.title('Top Tiktok Artists - (Jan.15 - Jan.21)', fontsize=30)\n",
    "plt.xlabel('Tiktok Status', fontsize=35)\n",
    "plt.ylabel('Spotify Listeners - Jan. 15th', fontsize=20)\n",
    "plt.ticklabel_format(style='plain', axis='y', ) #change xaxis from sci to plain style\n",
    "\n",
    "#annotate outlier data point\n",
    "plt.annotate('Olivia Rodrigo',xy=(0,7210797.0),xytext=(0.23,7210797.0) ,arrowprops=dict(facecolor='red', arrowstyle='wedge'),\n",
    "                                                                                       fontsize=25)\n",
    "plt.annotate('(7,210,797 Spotify Listeners-Jan. 15)',xy=(0,7210797.0),xytext=(0.23,9210797.0),\n",
    "                                                                                       fontsize=15)\n",
    "plt.tick_params(axis='both', which='major', labelsize=20)\n",
    "plt.grid(axis='both')\n",
    "plt.savefig('tiktok_bp1.jpeg')\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "index\n",
       "38    7210797.0\n",
       "Name: before, dtype: float64"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complete_data.loc[complete_data['artist'] == 'Olivia Rodrigo']['before']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['rank', 'added_at', 'title', 'artist', 'isrc', 'velocity', 'cm_id',\n",
       "       'time_on_chart', 'release_dates', 'cm_artist_id', 'before', 'after',\n",
       "       'listener_diff', 'percent increase', 'IG_f15', 'IG_f21', 'TW_f15',\n",
       "       'TW_f21', 'Tiktok_f15', 'Tiktok_f21', 'Tiktok Status'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complete_data.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Top Artists by engagement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tweepy\n",
    "from cm_config import  config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from twitter_bot import *\n",
    "import random\n",
    "import decimal\n",
    "\n",
    "# ################################################\n",
    "# generate api token for chartmetric api access\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "current_date = generate_today_date()\n",
    "\n",
    "before_date = generate_one_month_ago()\n",
    "\n",
    "data = get_tiktok_chart_data(api_token, 'tracks', current_date, 'weekly', limit=100)\n",
    "#parse data into dataframe (columns='title', 'artist', 'isrc', 'velocity', 'cm_id')\n",
    "parsed_data = parse_tiktok_data(data)\n",
    "\n",
    "#get artist id for each artist\n",
    "id_bucket = []\n",
    "for artist in parsed_data['artist']:\n",
    "    artist_id = get_artist_id(api_token, artist, 'artists')\n",
    "    id_bucket.append(artist_id)\n",
    "    time.sleep(1.5)\n",
    "    \n",
    "# #create artist ID feature to dataframe\n",
    "parsed_data['cm_artist_id'] = id_bucket\n",
    "\n",
    "# #drop rows with no ID\n",
    "parsed_data2 = parsed_data.dropna(subset=['cm_artist_id'])\n",
    "parsed_data2.reset_index(inplace=True)\n",
    "parsed_data2 = parsed_data2[~parsed_data2['cm_artist_id'].isin( ['None'])].reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_tiktok_chart_data(api_token, 'tracks', current_date, 'weekly', limit=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parsed_data2.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_tiktok_chart_data(api_token, 'tracks', one_month_ago, 'weekly', limit=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import tweepy\n",
    "import json\n",
    "import logging\n",
    "from cm_config import  config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from helper_funct1 import *\n",
    "from twitter_bot import *\n",
    "\n",
    "# ################################################\n",
    "# generate api token for chartmetric api access\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "current_date = generate_yesterday_date()\n",
    "one_month_ago = generate_one_month_ago()\n",
    "\n",
    "date_list = get_date_range(one_month_ago, current_date, 'W')\n",
    "\n",
    "#extract data for all top 100 tracks for dates given\n",
    "data_bucket = []\n",
    "for week in date_list:\n",
    "    data = get_tiktok_chart_data(api_token, 'tracks', week, 'weekly', limit=100)\n",
    "    for track in data:\n",
    "        track_tuple = (track['name'], track['tiktok_artist_names'][0], track['isrc'], track['velocity'], track['cm_track'])\n",
    "        data_bucket.append(track_tuple)\n",
    "df = pd.DataFrame(data_bucket, columns=['title', 'artist', 'isrc', 'velocity', 'cm_id'])\n",
    "#drop tracks with no isrc code\n",
    "df.dropna(subset=['isrc'], inplace=True)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get artist id for each artist\n",
    "id_bucket = []\n",
    "for track_id in df['cm_id']:\n",
    "    artist_id = get_track_metadata(api_token, track_id)['artists'][0]['id']\n",
    "    id_bucket.append(artist_id)\n",
    "    \n",
    "# #create artist ID feature to dataframe\n",
    "df['cm_artist_id'] = id_bucket\n",
    "#isolate artists with missing IDs\n",
    "missing_ids = df[df['cm_artist_id'] == 'None']\n",
    "\n",
    "#drop rows with no ID\n",
    "df2 = df.dropna(subset=['cm_artist_id'])\n",
    "df2.reset_index(inplace=True)\n",
    "df2 = df2[~df2['cm_artist_id'].isin( ['None'])].reset_index()\n",
    "\n",
    "#total wikipedia views for each artist and add to dataframe as new feature\n",
    "wiki_bucket = []\n",
    "for artist in df2['cm_artist_id']:\n",
    "    views = get_fan_metrics(api_token, artist, 'wikipedia', one_month_ago, current_date, field='views')['views']\n",
    "    total_views = count_wiki_views(views)\n",
    "    wiki_bucket.append(total_views)\n",
    "complete_data = df2.join(pd.DataFrame(wiki_bucket, columns=['wiki views']))\n",
    "\n",
    "#drop unnecessary index columns\n",
    "complete_data.drop(axis=1, columns=['level_0', 'index'], inplace=True)\n",
    "#sort dataframe by wiki views, desceninding order, reset index\n",
    "reset = complete_data.sort_values('wiki views', ascending=False).reset_index()\n",
    "\n",
    "#get title, artist, artist id, and wiki views for top artist\n",
    "title, artist, artist_id, wiki_views = get_topwiki_artist(reset)\n",
    "\n",
    "wiki_views = insert_thousands_commas(wiki_views)\n",
    "\n",
    "hashartist = artist.replace(\" \", \"\",)\n",
    "\n",
    "#get spotify url for artist\n",
    "spot_url = get_spotify_url(api_token, artist_id)\n",
    "\n",
    "#get artist twitter handle\n",
    "handle = generate_twitter_handle(api_token, artist_id)\n",
    "\n",
    "#instantiatiate twitter bot object\n",
    "bot = instantiate_twitter_bot()\n",
    "\n",
    "if handle:\n",
    "    #create message\n",
    "    message = \"Out of all the artists having tracks on TikTok's Top 100 weekly chart,\\n{} had the most views on #wikipedia\\nTotal Views: {:,d} since {}\\n#DataAnalytics #MusicDiscovery\\nPowered by @Chartmetric\\n{}\".format(handle, wiki_views, one_month_ago, spot_url)\n",
    "\n",
    "    print(message)\n",
    "else:\n",
    "    #create message\n",
    "    message = \"Out of all the artists having tracks on TikTok's Top 100 weekly chart,\\n{} had the most views on #wikipedia\\nTotal Views: {:,d} since {}\\n#DataAnalytics #MusicDiscovery\\nPowered by @Chartmetric\\n{}\".format(artist, wiki_views, one_month_ago, spot_url)\n",
    "\n",
    "    print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parsed_data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## top playlist reach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This bot collects data on top 100 trending tracks on Tiktok\n",
    "#for the current week. Then it finds the artist with the \n",
    "#largest total playlist reach on Spotify\n",
    "\n",
    "import tweepy\n",
    "from cm_config import  config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from helper_funct1 import *\n",
    "from twitter_bot import *\n",
    "import random\n",
    "import decimal\n",
    "\n",
    "# ################################################\n",
    "# generate api token for chartmetric api access\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "current_date = generate_yesterday_date()\n",
    "\n",
    "before_date = generate_one_week_prior_date()\n",
    "\n",
    "data = get_tiktok_chart_data(api_token, 'tracks', current_date, 'weekly', limit=100)\n",
    "\n",
    "#parse data into dataframe (columns=['rank', 'added_at', 'title', 'artist', 'isrc', 'velocity', 'cm_id', 'time_on_chart', 'release_dates'])\n",
    "parsed_data = parse_tiktok_data(data)\n",
    "\n",
    "#get artist id for each artist\n",
    "id_bucket = []\n",
    "for track_id in parsed_data['cm_id']:\n",
    "    artist_id = get_track_metadata(api_token, track_id)['artists'][0]['id']\n",
    "    id_bucket.append(artist_id)\n",
    "    \n",
    "# #create artist ID feature to dataframe\n",
    "parsed_data['cm_artist_id'] = id_bucket\n",
    "\n",
    "parsed_data = parsed_data.dropna(subset=['artist'])\n",
    "\n",
    "reach_list = []\n",
    "for row in parsed_data.iterrows():\n",
    "    track_id = row[1]['cm_id']\n",
    "    reach = get_playlist_reach(api_token, before_date,current_date, track_id, 'spotify', status='current')\n",
    "    reach_list.append(reach)\n",
    "    \n",
    "# create new feature for total playlist reach by map reach track id's\n",
    "parsed_data['total playlist reach'] = reach_list\n",
    "\n",
    "#sort dataset by total playlist reach\n",
    "complete_data = parsed_data.sort_values('total playlist reach', ascending=False).reset_index(drop='index')\n",
    "\n",
    "#assign values of the top playlist reach to variables\n",
    "title = complete_data['title'][0].replace(\" \", \"\",)\n",
    "artist = complete_data['artist'][0].replace(\" \", \"\",)\n",
    "reach = insert_thousands_commas(complete_data['total playlist reach'][0])\n",
    "artist_id = complete_data['cm_artist_id'][0]\n",
    "#get artist twitter handle\n",
    "handle = generate_twitter_handle(api_token, artist_id)\n",
    "\n",
    "#get spotify url for artist\n",
    "spot_url = get_spotify_url(api_token, artist_id)\n",
    "\n",
    "#instantiatiate twitter bot object\n",
    "bot = instantiate_twitter_bot()\n",
    "\n",
    "if twitter_handle:\n",
    "    message = \"Out of all the top trending tracks on TikTok this past week,\\nthe song #{} by {}\\nhad the largest playlist reach on Spotify\\nreaching {} potential followers\\n#DataAnalytics #MusicDiscovery\\nPower by @Chartmetric\\n{}\".format(title,handle,reach, spot_url)\n",
    "\n",
    "    bot.update_status(message)\n",
    "else:\n",
    "    message = \"Out of all the top trending tracks on TikTok this past week,\\nthe song #{} by {}\\nhad the largest playlist reach on Spotify\\nreaching {} potential followers\\n#DataAnalytics #MusicDiscovery\\nPower by @Chartmetric\\n{}\".format(title,artist,reach, spot_url)\n",
    "    bot.update_status(message)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "complete_data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## collect twitter handle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#instantiatiate twitter bot object\n",
    "bot = instantiate_twitter_bot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "handle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'@'+handle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date = generate_today_date()\n",
    "date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = get_spotify_charts(api_token, '2020-10-27', 'US', 'regional', 'daily')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_top200_popularity(data):\n",
    "    data_bucket = []\n",
    "    for track in data:\n",
    "        track_tuple = (track['name'], track['spotify_artist_names'], track['cm_artist'], track['spotify_popularity'])\n",
    "        data_bucket.append(track_tuple)\n",
    "\n",
    "    df = pd.DataFrame(data_bucket, columns=['title', 'artists', 'artist ids', 'current spotify popularity'])\n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this program gerates a post that contains the song with the highest velocity for the past 7-days on tiktok...most viral track\n",
    "import json\n",
    "import logging\n",
    "from cm_config import  config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from helper_funct1 import *\n",
    "from twitter_bot import *\n",
    "\n",
    "\n",
    "#################################################\n",
    "\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "#generate today's date to make api call with\n",
    "date = generate_today_date()\n",
    "\n",
    "#collects data from today's top 100 tracks on tiktok for the week\n",
    "data = get_tiktok_chart_data(api_token, 'tracks', date, 'weekly')\n",
    "\n",
    "title, artist, velocity, cm_id = parse_viral(data)\n",
    "hashartist = artist.replace(\" \", \"\",)\n",
    "\n",
    "#get chartmetric artist id\n",
    "artist_id = get_track_metadata(api_token, cm_id)['artists'][0]['id']\n",
    "\n",
    "#get spotify url for artist\n",
    "spot_url = get_spotify_url(api_token, artist_id)\n",
    "\n",
    "#get twitter handle\n",
    "handle = generate_twitter_handle(api_token, artist_id)\n",
    "\n",
    "#instantiatiate twitter bot object\n",
    "bot = instantiate_twitter_bot()\n",
    "\n",
    "\n",
    "if handle:\n",
    "    # create message\n",
    "    message = \"'{}' by {} has a velocity metric of {},\\nmaking it the most viral song this week on #tiktok #dataanalytics Powered by @Chartmetric\\n{}\".format(title, handle, round(velocity, 2), spot_url)\n",
    "\n",
    "\n",
    "    bot.update_status(message)\n",
    "\n",
    "else:\n",
    "    # create message\n",
    "    message = \"'{}' by #{} has a velocity metric of {},\\nmaking it the most viral song this week on #tiktok #dataanalytics Powered by @Chartmetric\\n{}\".format(title, hashartist, round(velocity, 2), spot_url)\n",
    "\n",
    "\n",
    "    bot.update_status(message)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parsed_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_artist_popularity = []\n",
    "for artist_id in parsed_data['artist ids']:\n",
    "    popularity_data = get_fan_metrics(api_token, artist_id[0], 'spotify', '2020-10-16','2020-10-16', field='popularity')\n",
    "    if popularity_data['popularity']:\n",
    "        current_artist_popularity.append(popularity_data['popularity'][0]['value'])\n",
    "    else:\n",
    "        current_artist_popularity.append('NaN')\n",
    "        \n",
    "parsed_data['current_artist_popularity'] = pd.Series(current_artist_popularity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = parsed_data[~parsed_data['current_artist_popularity'].isin(['NaN'])]\n",
    "df2 = df1[~df1['before popularity'].isin(['NaN'])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2['popularity change'] = df2['current_artist_popularity'] - df2['before popularity']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "df3 = df2.sort_values('popularity change', ascending=False).reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_most_successful_artist(dataframe):\n",
    "    df3 = dataframe.sort_values('popularity change', ascending=False).reset_index()\n",
    "    return df3['title'][0], df3['artists'][0][0],df3['artist ids'][0][0], df3['before popularity'][0],  df3['current_artist_popularity'][0], df3['popularity change'][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "consumer_key = config['consumer_key']\n",
    "consumer_secret_key = config['consumer_secret_key']\n",
    "access_key = config['access_token']\n",
    "access_token_secret = config['access_token_secret']\n",
    "\n",
    "\n",
    "date = generate_date()\n",
    "\n",
    "data = get_spotify_charts(api_token, date, 'US', 'regional', 'daily')\n",
    "\n",
    "title, artist = parse_data(data)\n",
    "\n",
    "auth = tweepy.OAuthHandler(consumer_key, consumer_secret_key)\n",
    "auth.set_access_token(access_key, access_token_secret)\n",
    "\n",
    "api = tweepy.API(auth)\n",
    "\n",
    "print('One Year Ago: \\nThe #1 song was \"{}\" by {} @spotify #top200 #US'.format(title, artist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = get_tiktok_chart_data(api_token, 'tracks', '2020-10-17', 'weekly')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_bucket = []\n",
    "for track in data:\n",
    "    track_tuple = (track['name'], track['tiktok_artist_names'][0], track['isrc'], track['velocity'], track['cm_track'])\n",
    "    data_bucket.append(track_tuple)\n",
    "    \n",
    "df = pd.DataFrame(data_bucket, columns=['title', 'artist', 'isrc', 'velocity', 'cm_id'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dropna(subset=['isrc'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.sort_values('velocity', ascending=False, inplace=True)\n",
    "df1 = df.reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuesday Tweet - Shazam Insights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_shazam_most_viral_track(api_token,date, country_code='US'):\n",
    "    response = requests.get(url='https://api.chartmetric.com/api/charts/shazam',\n",
    "                            headers={'Authorization' : 'Bearer {}'.format(api_token)}, \n",
    "                            params={'country_code':country_code, 'date':date}\n",
    "                                )\n",
    "    if response.status_code == 200:\n",
    "        data = response.json()\n",
    "        tracks = data['obj']['data']\n",
    "        data_bucket = []\n",
    "        for track in tracks:\n",
    "            if type(track['artist_names']) == type(list):\n",
    "\n",
    "                track_tuple = (track['name'], track['artist_names'][0],track['velocity'], track['cm_artist'][0])\n",
    "                data_bucket.append(track_tuple)\n",
    "            else:\n",
    "                track_tuple = (track['name'], track['artist_names'],track['velocity'], track['cm_artist'])\n",
    "                data_bucket.append(track_tuple)        \n",
    "\n",
    "        df = pd.DataFrame(data_bucket, columns=['title', 'artist','velocity', 'artist id'])\n",
    "        df.sort_values('velocity', ascending=False, inplace=True)\n",
    "        df1 = df.reset_index()\n",
    "        return df1['title'][0], df1['artist'][0][0], df1['velocity'][0], track['cm_artist'][0]\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title, artist, velocity, artist_id = get_shazam_data(api_token,'2020-10-18', country_code='US')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(title)\n",
    "print(artist)\n",
    "print(velocity)\n",
    "print(artist_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_bucket = []\n",
    "for track in data:\n",
    "    if type(track['artist_names']) == type(list):\n",
    "\n",
    "        track_tuple = (track['name'], track['artist_names'][0],track['velocity'], track['cm_artist'][0])\n",
    "        data_bucket.append(track_tuple)\n",
    "    else:\n",
    "        track_tuple = (track['name'], track['artist_names'],track['velocity'], track['cm_artist'])\n",
    "        data_bucket.append(track_tuple)        \n",
    "\n",
    "df = pd.DataFrame(data_bucket, columns=['title', 'artist','velocity', 'artist id'])\n",
    "df.sort_values('velocity', ascending=False, inplace=True)\n",
    "df1 = df.reset_index()\n",
    "print(df1['title'][0] )\n",
    "print(df1['artist'][0][0])\n",
    "print(df1['velocity'][0])\n",
    "print(track['cm_artist'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_spotify_url(api_token, cm_artist_id):\n",
    "    \n",
    "    response = requests.get(url='https://api.chartmetric.com/api/artist/{}/urls'.format(cm_artist_id),\n",
    "                            headers={'Authorization' : 'Bearer {}'.format(api_token)})\n",
    "    if response.status_code == 200:\n",
    "\n",
    "        data = response.json()['obj']\n",
    "        for social in data:\n",
    "            if social['domain'] == 'spotify':\n",
    "                return social['url'][0]\n",
    "    else:\n",
    "        \n",
    "        print(response.status_code)\n",
    "        print(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_spotify_url(api_token, artist_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "popchange = 10\n",
    "original = 62\n",
    "\n",
    "round(popchange/original *100, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Youtube Insights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_youtube_charts(api_token, chart_type, country_code, date):\n",
    "    response = requests.get(url='https://api.chartmetric.com/api/charts/youtube/{}'.format(chart_type),\n",
    "                            headers={'Authorization' : 'Bearer {}'.format(api_token)}, \n",
    "        params={'date':date, 'country_code':country_code}\n",
    "                                )\n",
    "    if response.status_code == 200:\n",
    "        data = response.json()\n",
    "        return data\n",
    "    else:\n",
    "        \n",
    "        print(response.status_code)\n",
    "        print(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_youtube_charts(api_token, 'tracks', 'US', '2020-10-10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parsed_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Biggest Gain in spotify listeners"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tweepy\n",
    "from cm_config import  config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from twitter_bot import *\n",
    "import random\n",
    "import decimal\n",
    "\n",
    "# ################################################\n",
    "# generate api token for chartmetric api access\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "current_date = generate_today_date()\n",
    "\n",
    "before_date = generate_one_week_prior_date()\n",
    "\n",
    "data = get_tiktok_chart_data(api_token, 'tracks', current_date, 'weekly', limit=100)\n",
    "#parse data into dataframe (columns='title', 'artist', 'isrc', 'velocity', 'cm_id')\n",
    "parsed_data = parse_tiktok_data(data)\n",
    "\n",
    "#get artist id for each artist\n",
    "id_bucket = []\n",
    "for artist in parsed_data['artist']:\n",
    "    artist_id = get_artist_id(api_token, artist, 'artists')\n",
    "    id_bucket.append(artist_id)\n",
    "    time.sleep(1.5)\n",
    "    \n",
    "# #create artist ID feature to dataframe\n",
    "parsed_data['cm_artist_id'] = id_bucket\n",
    "\n",
    "# #drop rows with no ID\n",
    "parsed_data2 = parsed_data.dropna(subset=['cm_artist_id'])\n",
    "# # #collect before and after listener values for each artist\n",
    "listener_bucket = []\n",
    "for artist in parsed_data2['cm_artist_id']:\n",
    "    listeners = get_fan_metrics(api_token, artist, 'spotify', before_date, current_date, field='listeners')['listeners']\n",
    "    if len(listeners) > 0:\n",
    "        follow_tuple = (listeners[0]['value'], listeners[-1]['value'])\n",
    "        listener_bucket.append(follow_tuple)\n",
    "        time.sleep(float(decimal.Decimal(random.randrange(100, 200))/100))\n",
    "    else:\n",
    "        follow_tuple = (None, None)\n",
    "        listener_bucket.append(follow_tuple)\n",
    "        time.sleep(1)\n",
    "\n",
    "complete_data = parsed_data2.join(pd.DataFrame(listener_bucket, columns=['before', 'after']))\n",
    "complete_data['listener_diff'] = complete_data['after'] - complete_data['before']\n",
    "\n",
    "complete_data.drop(axis=1, columns=['level_0', 'index'], inplace=True)\n",
    "\n",
    "title, artist, artist_id, before, listener_diff = get_most_listener_gain(complete_data)\n",
    "hashartist = artist.replace(\" \", \"\",)\n",
    "hashtitle = title.replace(\" \", \"\",)\n",
    "\n",
    "#get spotify url for artist\n",
    "spot_url = get_spotify_url(api_token, artist_id)\n",
    "\n",
    "#instantiatiate twitter bot object\n",
    "bot = instantiate_twitter_bot()\n",
    "\n",
    "bot.update_status(\"Out of all the artists trending on this week's top 100 Tiktok tracks,\\n{} had the biggest gain in Spotify listeners\\nUp {}% since last week\\n#{} #{} #DataAnalytics #MusicDiscovery\\nPower by @Chartmetric\\n{}\".format(artist, round(listener_diff/before *100, 2),hashtitle, hashartist,spot_url))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Top 5 Cities for Most Viral Song of The Month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tweepy\n",
    "from cm_config import  config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from twitter_bot import *\n",
    "import random\n",
    "import decimal\n",
    "\n",
    "# ################################################\n",
    "# generate api token for chartmetric api access\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "current_date = generate_today_date()\n",
    "one_month_ago = generate_one_month_ago()\n",
    "\n",
    "date_list = get_date_range(one_month_ago, current_date, 'W')\n",
    "\n",
    "#extract data for all top 100 tracks for dates given\n",
    "data_bucket = []\n",
    "for week in date_list:\n",
    "    data = get_tiktok_chart_data(api_token, 'tracks', week, 'weekly', limit=100)\n",
    "    for track in data:\n",
    "        track_tuple = (track['added_at'], track['name'], track['tiktok_artist_names'][0], track['isrc'], track['velocity'], track['cm_track'],\n",
    "                      track['weekly_posts'])\n",
    "        data_bucket.append(track_tuple)\n",
    "df = pd.DataFrame(data_bucket, columns=['add date', 'title', 'artist', 'isrc', 'velocity', 'cm_id', 'number of posts'])\n",
    "#drop tracks with no isrc code\n",
    "df.dropna(subset=['isrc'], inplace=True)\n",
    "\n",
    "df.sort_values('velocity', ascending=False, inplace=True)\n",
    "\n",
    "# drop duplicate artists except for first occurence\n",
    "df.drop_duplicates(subset=['artist'], keep='first', inplace=True)\n",
    "\n",
    "#get artist id for each artist\n",
    "id_bucket = []\n",
    "for artist in df['artist']:\n",
    "    artist_id = get_artist_id(api_token, artist, 'artists')\n",
    "    id_bucket.append(artist_id)\n",
    "\n",
    "    \n",
    "# #create artist ID feature to dataframe\n",
    "df['cm_artist_id'] = id_bucket\n",
    "\n",
    "\n",
    "#drop rows with no ID\n",
    "df2 = df.dropna(subset=['cm_artist_id'])\n",
    "df2.reset_index(inplace=True)\n",
    "df2 = df2[~df2['cm_artist_id'].isin( ['None'])].reset_index()\n",
    "\n",
    "# # # #collect before and after listener values for each artist\n",
    "listener_bucket = []\n",
    "for artist in df2['cm_artist_id']:\n",
    "    listeners = get_fan_metrics(api_token, artist, 'spotify', one_month_ago, current_date, field='listeners')['listeners']\n",
    "    if len(listeners) > 0:\n",
    "        follow_tuple = (listeners[0]['value'], listeners[-1]['value'])\n",
    "        listener_bucket.append(follow_tuple)\n",
    "\n",
    "    else:\n",
    "        follow_tuple = (None, None)\n",
    "        listener_bucket.append(follow_tuple)\n",
    "\n",
    "complete_data = df2.join(pd.DataFrame(listener_bucket, columns=['before', 'after']))\n",
    "complete_data['listener_diff'] = complete_data['after'] - complete_data['before']\n",
    "\n",
    "#drop unnecessary index columns\n",
    "complete_data.drop(axis=1, columns=['level_0', 'index'], inplace=True)\n",
    "\n",
    "#retreive title, artist, velocity\n",
    "add_date, title, artist, velocity, cm_artist_id = most_viral_tiktoktrack(complete_data)\n",
    "hashartist = artist.replace(\" \", \"\",)\n",
    "hashtitle = title.replace(\" \", \"\",)\n",
    "\n",
    "#get spotify url\n",
    "spot_url = get_spotify_url(api_token, cm_artist_id)\n",
    "\n",
    "#get top cities for artist\n",
    "data_object = monthly_listen(api_token, cm_artist_id, str(add_date)[:10])\n",
    "\n",
    "#save top five cities as variables\n",
    "first, second, third, fourth, fifth = top_5_cities(data_object)\n",
    "\n",
    "#create message\n",
    "message = \"Most Viral Tiktik Song of the Month: #{} by #{}\\nVelocity = {} on {}\\nTop 5 Cities by Spotify Monthly Listeners\\n1. {}\\n2. {}\\n3. {}\\n4. {}\\n5. {}\\n{}\".format(hashtitle,hashartist,round(velocity, 2),add_date,first,second, third, fourth, fifth,spot_url)\n",
    "\n",
    "#instantiate twitter bot\n",
    "bot = instantiate_twitter_bot()\n",
    "\n",
    "#update status with message\n",
    "bot.update_status(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get top cities for artist\n",
    "data_object = monthly_listen(api_token, cm_artist_id, str(add_date)[:10])\n",
    "\n",
    "#save top five cities as variables\n",
    "first, second, third, fourth, fifth = top_5_cities(data_object)\n",
    "\n",
    "#create message\n",
    "message = \"Most Viral Tiktik Song of the Month: #{} by #{}\\nVelocity = {} on {}\\nTop 5 Cities by Spotify Monthly Listeners\\n1. {}\\n2. {}\\n3. {}\\n4. {}\\n5. {}\\n{}\".format(hashtitle,hashartist,round(velocity, 2),add_date,first,second, third, fourth, fifth,spot_url)\n",
    "\n",
    "#instantiate twitter bot\n",
    "bot = instantiate_twitter_bot()\n",
    "\n",
    "#update status with message\n",
    "bot.update_status(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_tiktok_chart_data(api_token, 'tracks', '2020-11-08', 'weekly', limit=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "response = requests.get(url='https://api.chartmetric.com/api/charts/tiktok/{}'.format('tracks'),\n",
    "                            headers={'Authorization' : 'Bearer {}'.format(api_token)}, params={'date': '2020-11-08', 'interval': 'weekly', 'limit': '100'}\n",
    "                                )\n",
    "if response.status_code == 200:\n",
    "    data = response.json()\n",
    "    chart = data['obj']\n",
    "    print(data)\n",
    "    print(chart)\n",
    "    \n",
    "else:\n",
    "    response.status_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def top_5_cities(data_object):\n",
    "    city_list = list(data_object.keys())\n",
    "    return city_list[0],city_list[1],city_list[2],city_list[3], city_list[4]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fifth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm_artist_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_df['listener_diff'].quantile(.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get top spotify monthly cities\n",
    "def monthly_listen(api_token, cm_artist_id, since_date):\n",
    "    response = requests.get(url='https://api.chartmetric.com/api/artist/{}/where-people-listen'.format(cm_artist_id),\n",
    "                           headers={'Authorization' : 'Bearer {}'.format(api_token)},\n",
    "                           params={'since':since_date})\n",
    "    \n",
    "    if response.status_code == 200:\n",
    "        return response.json()['obj']\n",
    "    else:\n",
    "        print(response.status_code)\n",
    "        print(response.text)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cities = monthly_listen(api_token, 110260, '2020-11-15')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cities.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_date = generate_today_date()\n",
    "one_month_ago = generate_one_month_ago()\n",
    "\n",
    "date_list = get_date_range(one_month_ago, current_date, 'W')\n",
    "\n",
    "#extract data for all top 100 tracks for dates given\n",
    "data_bucket = []\n",
    "for week in date_list:\n",
    "    data = get_tiktok_chart_data(api_token, 'tracks', week, 'weekly', limit=100)\n",
    "    for track in data:\n",
    "        track_tuple = (track['added_at'], track['name'], track['tiktok_artist_names'][0], track['isrc'], track['velocity'], track['cm_track'],\n",
    "                      track['weekly_posts'])\n",
    "        data_bucket.append(track_tuple)\n",
    "df = pd.DataFrame(data_bucket, columns=['add date', 'title', 'artist', 'isrc', 'velocity', 'cm_id', 'number of posts'])\n",
    "#drop tracks with no isrc code\n",
    "df.dropna(subset=['isrc'], inplace=True)\n",
    "\n",
    "df.sort_values('velocity', ascending=False, inplace=True)\n",
    "\n",
    "# drop duplicate artists except for first occurence\n",
    "df.drop_duplicates(subset=['artist'], keep='first', inplace=True)\n",
    "\n",
    "#get artist id for each artist\n",
    "id_bucket = []\n",
    "for artist in df['artist']:\n",
    "    artist_id = get_artist_id(api_token, artist, 'artists')\n",
    "    id_bucket.append(artist_id)\n",
    "\n",
    "    \n",
    "# #create artist ID feature to dataframe\n",
    "df['cm_artist_id'] = id_bucket\n",
    "\n",
    "\n",
    "#drop rows with no ID\n",
    "df2 = df.dropna(subset=['cm_artist_id'])\n",
    "df2.reset_index(inplace=True)\n",
    "df2 = df2[~df2['cm_artist_id'].isin( ['None'])].reset_index()\n",
    "\n",
    "# # # #collect before and after listener values for each artist\n",
    "listener_bucket = []\n",
    "for artist in df2:\n",
    "    listeners = get_fan_metrics(api_token, df2['cm_artist_id'], 'spotify', str(df2['add date'][0])[:10], current_date, field='listeners')['listeners']\n",
    "    if len(listeners) > 0:\n",
    "        follow_tuple = (listeners[0]['value'], listeners[-1]['value'])\n",
    "        listener_bucket.append(follow_tuple)\n",
    "    else:\n",
    "        follow_tuple = (None, None)\n",
    "        listener_bucket.append(follow_tuple)\n",
    "\n",
    "complete_data = df2.join(pd.DataFrame(listener_bucket, columns=['before', 'after']))\n",
    "\n",
    "#drop unnecessary index columns\n",
    "complete_data.drop(axis=1, columns=['level_0', 'index'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # # #collect before and after listener values for each artist\n",
    "listener_bucket = []\n",
    "counter = 0\n",
    "for artist in df2['cm_artist_id']:\n",
    "    listeners = get_fan_metrics(api_token, artist, 'spotify', '2020-10-01', current_date, field='listeners')['listeners']\n",
    "    if len(listeners) > 0:\n",
    "        follow_tuple = (listeners[0]['value'], listeners[-1]['value'])\n",
    "        listener_bucket.append(follow_tuple)\n",
    "        counter += 1\n",
    "    else:\n",
    "        follow_tuple = (None, None)\n",
    "        listener_bucket.append(follow_tuple)\n",
    "        counter += 1\n",
    "\n",
    "complete_data = df2.join(pd.DataFrame(listener_bucket, columns=['before', 'after']))\n",
    "\n",
    "#drop unnecessary index columns\n",
    "complete_data.drop(axis=1, columns=['level_0', 'index'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.scatterplot(complete_data['number of posts'], complete_data['after'])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from cm_config import  config\n",
    "from cm_api import *\n",
    "from helper_funct import *\n",
    "from twitter_bot import *\n",
    "\n",
    "\n",
    "#################################################\n",
    "\n",
    "rt = config['refresh_token']\n",
    "api_token = get_api_token(rt)\n",
    "################################################\n",
    "\n",
    "#generate today's date to make api call with\n",
    "date = generate_today_date()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = get_tiktok_chart_data(api_token, 'tracks', date, 'weekly')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title, artist, velocity, cm_id = parse_viral(data)\n",
    "hashartist = artist.replace(\" \", \"\",)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get chartmetric artist id\n",
    "artist_id = get_track_metadata(api_token, cm_id)['artists'][0]['id']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get spotify url for artist\n",
    "spot_url = get_spotify_url(api_token, artist_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#instantiatiate twitter bot object\n",
    "bot = instantiate_twitter_bot()\n",
    "\n",
    "bot.update_status(\"'{}' by #{} has a velocity metric of {},\\nmaking it the most viral song this week on #tiktok #dataanalytics Powered by @Chartmetric\\n{}\".format(title, hashartist, round(velocity, 2), spot_url))"
   ]
  },
  {
   "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "434.844px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}