{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import base64\n", "import concurrent.futures\n", "import os\n", "import time\n", "\n", "import matplotlib.pyplot as plt\n", "import mysql.connector\n", "import requests\n", "\n", "%matplotlib inline " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "%load_ext dotenv\n", "%dotenv" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "%reload_ext dotenv" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "mydb = mysql.connector.connect(\n", " host=os.environ['ar_host'],\n", " user=os.environ['ar_user'],\n", " passwd=os.environ['ar_password'],\n", " database=os.environ['ar_database'],\n", ")" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "mycursor = mydb.cursor()\n", "\n", "mycursor.execute(\n", " \"\"\"select distinct name\n", " from artist_info\n", " order by artist_id desc\n", " limit %(limit)s;\n", " \"\"\", {'limit': 10000}\n", ")\n", "result = mycursor.fetchall()\n", "\n", "artists = [x[0] for x in result]" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def _to_base64(s):\n", " \"\"\"Encode string to base64 and return result as string.\n", " Args:\n", " s (str): string which needs to be encoded.\n", " Returns:\n", " str: result of encoding.\n", " \"\"\"\n", " return base64.b64encode(s.encode()).decode()\n", "\n", "\n", "def _obtain_access_token():\n", " \"\"\"Obtain access token for further Spotify API calls.\n", " Returns:\n", " str: access token.\n", " \"\"\"\n", " auth_token = _to_base64('{}:{}'.format(\n", " os.environ['SPOTIFY_CLIENT_ID'], os.environ['SPOTIFY_SECRET_ID']))\n", " resp = requests.post(\n", " 'https://accounts.spotify.com/api/token',\n", " data={'grant_type': 'client_credentials'},\n", " headers={\n", " 'Authorization': 'Basic {}'.format(auth_token)}).json()\n", "\n", " return resp['access_token']\n", "\n", "\n", "def _auth_headers(access_token):\n", " \"\"\"Form Spotify API headers.\n", " Args:\n", " access_token (str): access token for Spotify API calls.\n", " Returns:\n", " dict: headers dictionary.\n", " \"\"\"\n", " return {'Authorization': 'Bearer {}'.format(access_token)}\n", "\n", "access_token = _obtain_access_token()\n", "headers = _auth_headers(access_token)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def search_artist(artist):\n", " try:\n", " params = {'q': artist, 'type': 'artist'}\n", " start_time = time.time()\n", " response = requests.get(\n", " 'https://api.spotify.com/v1/search', params,\n", " headers=headers)\n", " data = response.json()\n", " error_code = data.get('error', {}).get('status')\n", " except Exception as e:\n", " print(e)\n", " error_code = -1\n", " return {\n", " 'time': time.time() - start_time,\n", " 'error_code': error_code\n", " }\n", "\n", "\n", "def measure_api(workers, artists):\n", " start = time.time()\n", " results = []\n", " with concurrent.futures.ThreadPoolExecutor(workers) as executor:\n", " future_to_url = [\n", " executor.submit(search_artist, artist)\n", " for artist in artists\n", " ]\n", "\n", " for future in concurrent.futures.as_completed(future_to_url):\n", " res = future.result()\n", " if res is not None:\n", " results.append(res)\n", " end = time.time()\n", " return results, end - start" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "tests = [\n", " {'workers': 5},\n", " {'workers': 10},\n", " {'workers': 20},\n", " {'workers': 30},\n", " {'workers': 40},\n", "]" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Hallstein+Sandvin%2C+Veskehund&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "10\n", "20\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Christopher+Glynn&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Al+Dubin&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Lee+Hyla&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=DooWop&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "30\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=TAEMIN&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Mikayla+Braun&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Atif+Ali+Khan&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Jiras&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Carmen+Lombardo&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Dyablo%2C+Lalo+KV&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Kamlesh+Haripuri&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Grup+Kardelen&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=E%C5%9Fref+Ziya&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Paul+Mares&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=TimTim&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=USSR+Ministry+of+Culture+Symphony+Orchestra&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Ghazal&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=ESPARZA+JIMENEZ&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Pandora+Bras%C3%A3o&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "40\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Denise+Renne+Caplock&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Steve+Farmer&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Warren&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Rory+Marsden&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Thanasis+Alevras&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Darrel+Beasant&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Cimlli+%C4%B0bo&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=2Lightyears&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Mihail+Plopschi&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=LUME&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n", "HTTPSConnectionPool(host='api.spotify.com', port=443): Max retries exceeded with url: /v1/search?q=Reellsoul&type=artist (Caused by NewConnectionError(': Failed to establish a new connection: [Errno 8] nodename nor servname provided, or not known'))\n" ] } ], "source": [ "for test in tests:\n", " print(test['workers'])\n", " test['results'], test['total_time'] = measure_api(test['workers'], artists)\n", " test['success'] = sum(1 if not r['error_code'] else 0 for r in test['results'])\n", " test['failed'] = len(test['results']) - test['success']\n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "timings = []\n", "for test in tests:\n", " timing = []\n", " timings.append(timing)\n", " for result in test['results']:\n", " timing.append(result['time'])\n", "fig, ax = plt.subplots(figsize=(20, 6))\n", "ax.boxplot(timings, vert=False)\n", "ax.set_title('Spotify API response time', fontsize=20)\n", "plt.xlabel('seconds', fontsize=12)\n", "plt.ylabel('test number', fontsize=12)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdAAAAEbCAYAAABqctV3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3debwcVZn/8c+XHSGAQNiR4ILDIpthRwMICIIERVAQhriAC47gMKKgskzUYcRBFJefDJAAAw4oICIgmxAmEsCEBFkCghAxIZEAQhK2kJvn98c5TTqd6nu7K/em7u37fb9e/eruqlNVTy1dT51TSysiMDMzs/YsV3UAZmZmA5ETqJmZWQlOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJAzaBSholKSSNanO4kHRnQfcNJF0iabqkrlxurd6K1zqTpP0l3S3pxbzN/HopxlW4bZrZsiNpmqRprZRtKYFKWl7ScZLGSXpB0huSnpX0J0kXSjpkqSLuRe3MfIOxwDHAOODbwFnAa70X2eIkfSPvMEPSu7spN6quXO31uqSnJI2VtFWT8mP7KnZLJA0DrgM2By4mbTP/W2FIZrYMrdBTAUnLA78FDgBeBG4ApgMrAVsDRwH/BPym78IsdC1wDzCzzeG2BF6p7yBpJWA/4LaI+GTvhNecJAGfBQIQcBzwbz0M9gBQq92sCewFHAscIWmfiLinb6K1buwLrAKcHBFXVB2MmS1bPSZQ4EhS8nwAGBERL9X3lPQWYJc+iK1bOY6Xeiy45HCPFnTegFQbf2Zp42rR/sAwUq33AOBYSadFxPxuhpkSEWfWvuQkPIaURP8D2LuvgrWmNsrvy2q7MbP+JCK6fQE/JdWUTuqpbN0wo/Iwo4CDgLuBl4F/AL8C3tVkuA2BnwDTgPnAbOAa4L3dTSN/3yt/L3qNrRsugDvrvk9rNgzwufz5jCbxbgC8ATzY6rLJw/0qj3d34Pv588d7WJZjC/rtnPu93Er5buI5BLidVJt/nZQQxgFfbCg3DZjWZBxn5unuVdDvn0hNnNPy+J8F/g/4Qi+UHQv8LW8vfweuAN5dUHb9vKwfy9vii/nzWODtdeVEOii5O29/r+Xx31xbRz1sa3uVXVaN22YP62xY3Xa6BXBlXlYL68cLrE06wJoKvEo66Lwd2L9gnCsBXwbuJ/1WX8nzcR2wb1GspIOIy/K0XwUmAUc1iXk54PPAH4F5eT38EfgCsFxB+do01gUuYNH2+TDwqYLyPa67hvKbAD8GnszjfZ7UkrZTQdkhwLeAh4A5wFzgL3m5L7F/ajL/d+Z5Wpl0muipPN2/AGcAKzUZrp3tfGyextuBfwH+lNdLj9sVsC3wCxb99mbnbeE8YMWGsisAXyS1As7J28pk4EtF67Juf3UlMCOPfyZwC3BEQdkjgLvy9voq8CBwKrByQdlp+bUacA7wdB7/E8DXADXZVr6Ut6XXckw/JrXuTaPJb7fx1UoN9Pn8vkULZRt9FDiQ1Nx6J7A9cBiwt6TdI+KxWkFJmwPjST/I35NW5KbA4cBBkg6LiN92M61ppHNQJ+Xv59X1m9LNcOeRdkYnsngz6RTgNuB7wGckfTsiuhqG/TRpQ/p5N+NfjKT1SQnrzxFxt6Q5wMnA8aSNqx3K76UfaCzpeFL8s4DrgeeA9Ug/pk+RDqBKk3QQ8EvSTuN3pPW6FrAdcArws5JlDyAdXK2Y436CtEP8KGl72Tsi7s9l3wL8AXgHcGsuL2AzYCTpgObJPOrvkH6oTwFXkX7AGwI7kbbFK1m0re0FjAAuyd2oe19W3gHcC/wZuBxYlbRDQ9JmpN/dMNJByO9IO5mDgd9J+lxE/HfduMaSWpweAi4l7bg2AvYktZTc1jDtt5KS1Yuk1pC1SDu+yyVtHBHnNJS/jHTK52/AhaTt9iOkbWxPoOj0yVqkdTeftJ5WJq2HiyUtjIhL6sq2su7Iy2ZH0s57bVKCvYaUqA8Fxkv6SETcmMsqL7vdgQk59gWk7W3vvGwnFcTezFU5pl+RDsBHkg6qhks6JPIePk+75e28wQ+B95FOud0INO67FiNpW9J2FKSDiKeANYB3khLlN3OsSKrF8kHSQegVpCS0N3A+qUXymIbxH0f6/Xbl8T9O2s8Mz+O/qq7sd0nr8bk87nmkPPJd4IOS9o8lW+tWJK3HjYCbSOvnUOBs0mmWsxrKn0c6WJxJOjirrYddSAeS3bUGLtLCUckOeWQLST+AjwKb9TDMKBYdkR/c0O/E3P32hu435+7faOi+e14YzwOrF0xjVNHRSDexLXGUT93RfEH5HzeZD5F2ui8Da7ZytJKH+3oe36l13Sbm5fvObpbl2ILpX9K4LJuV7yaeSaSjtfUK+q3b6rKloFZF2iG9lLefEQXDbFKy7FtJNaTngK0aym1D+sHdX9ftwzm2HxSMdyVgSN3350nn+N/SwvJYYp7LLqtm22Y36622zQbw3SZl7szb1Scauq9FOkB8FVg/d1szl50ILF8wrnUKYg3Sjm+5uu6bAy/k9Vhfsz8yl7+fxX/Hq+VpBg0117ppXFgfE7AVaZ/wSEP5ltYd6aD3CdJOf0RDuY1ItZGZ5NoO8J4cx7UF410OeGuL6+zOPJ4/1w9D2sFPyP2OKbud5+5j83hmAJu3Elce7r/ycCML+r21YR3Xtt/zG9bL8sBFjePJ6+uNvF1sXTD++t/2bnn4p4ENGtbZ9bnfaQW/tSAdKKxa13090sHdi9TVoEk5JfI2sHaT9VD4210i9hYX7hF5g4q61/OkmuWHC8qPoiBJ1i3kJ3L/zWoLMH//Kw1NBbn/Zbn/PxdMY1TBwmw687SfQLfO/a5v6P7B3P3iNjZS5XnvAjau6/6lPK7/7GZZTskb7pnAD0jNJUFqOtm1oPwS89Ikpkmkg4AedwLdLVuKE+jJudsPWxh3O2VrB2EnNOn/g9x/q/y9lkALE03DsM+Tjr6XaCpqZZ7LLqtm22Y3065ts7OKYiXV2gP4ZZPhR+b+X8zf18jf/0BBk1fB8EFKYkvspOvm74y6brfmbkVNxx/I/X5fMI2XgTUKhhmX+9cn45bWXd28n9PD9vWh/L2WQK9oZd10M907aUiSdf32yv3uKLud525jc7cT24ytlkCXWD8N5ZbLy3kmsEJB/7VIB2JX1XU7P4/7Ky3E8d+57PEF/bYg7TufbOg+LQ9TVAGpVTK2KZhG0WmA2noo/O02vlppwiUirpJ0LamKviepVronqYp8qKRLSYksGgYdVzCuLknjSU1PO5CS5g659/9FxBsFIfweODqXu7SVmHtLRDws6S7gQEmbRsTfcq/j8/v/a2N0+5Dm++aImFHX/QrSBjxK0jebLIPt8gvS0dxM0oHF2RHxSBsxNLo8T/sRSf9LWmd/iIjZSzHOml3z+029XHa3/L6dpDML+tdON2wJPEKapxnA13PT3Y2kRDEllmyWv5x07ugRSVflYSdEw8Vz/cgDEfF6QffaMlqzyTIamt+3BIiIOZKuJx1sTJF0Nalp8t6IeKVgeICnI+Kpgu53ks7p7VDXbUfSjvXOgvLjSDvGHQr6PR4Rcwq6136HbyXVxKD1dVdbNps1WTbvyu9bkraVR0gHsEfmZvHrSKebJkb3F/41s8R+MY+vcRm0u53Xu6/NmK4kJexfS/oVqbn+DxHxl4Jprk1qgv1mat1ewqs5ppp2fts75vffN/aIiD9Lmg5sLmnNhvX6UkQ8UTC++u2kcRrdrYeWtJRAAfJO/Zb8qt3echjpgo9/JtVGG28i/3uT0c3K72s2vDe7JaXWvaoHG/wUeD/p1pMzJG1AOo85JSLa2VBrSXdsfceIeCHvvA5j0Tm5RpdExKg24+5RRJwr6TnSeYgvk84hh6RxwFcjYuJSjL62vmZ0W6r9suvk9+N6KLc6vJkcdiWdBzmE1HoA8JyknwLfrjto+Qqpaf5TpOb2rwMLJN1Iul2l6EdapVlNuteW0X751czqdZ8/Trro4igWnTN6Le9Q/y0iGn/Prf6+a59fKEo4EbEgb4PrFYzrxSbTWJDfl6/r1uq6qy2bw5uMu6a2/XRJ2gc4HfgY8J+5/1xJl5BOx8xrMo4iSyy3Jsugre28QbPtolBE3CfpfcA3SPN4DICkx4CzIuIXDTG9i3SQ1EpM7fy2W8kFb8vjrE+g7WwntWl0tx5aUvpJRBHRFRFXkZoRINWuGq3fZPAN8vtLDe8bFJSFdCFAfbll7RrSwv5MPnAoc/HQUFKNHeAXjQ9HICVPWJRkl5mIuDQidiX9OA4incd4P3BzjrtmIc0PuooObmob9cYthNFO2dp2sF1EqJvXmxeYRMT0iPgMaQe1Delg4XnSTvH0unJdEXFeRGxH2n4PIx0cHkK68GblFuKD9pdVWY2tPjW1ZXRiD8voU2+OKOLViDgzIrYg7aSOJh2RH03xQV2rv+/a57XzBSiLkbQC6Rx4UU2zZW2su1pcI3tYNmfVjfsfEfGViNiUlDw+CzxKOv3y5sVtLVpiuTVZBm1v5/WLo82YiIgJEXEwqba2BzA6x3qFpH0bYrq2h5g2rxt1md92X+aC2rDdrYeW9Maj/ObWpl3Qb0Rjh5yA9sxfJze875lnoFHtHseiq80adbH40cZSy7WTC0kbwIdJP555pCajVh1LumBlEilBFb1mA/vmK5KXuYh4MSJujIjjSLXktUmJtOYfwPpFO0HS1XSNag93OLCFyZcp+74Wyi4mkocj4nwW1cwObVL22Yi4JiKOIDUpvYOUfFvR7rLqbaWXEUBE/C0iLifV1p8g/TbXaSj2tvw0pkZ75ffJdd0mk/Y371+idOq2PK39vlvSw7pb2mXzRERcRNq/zSO1GrVjif0iaZ+4PIsvs6WKs6yIeD0i7o6I00kHmrBoHh8lJcRdm2zbRdr5bdfmf6/GHpLeSbpe5qmIaFbjbEVtO+tuPbQmej6peyRpR1N0n9YGpLbwAA6v6z6Knq/Cbbxg4Jbc/d8auu9Cqoa/wOJXS9amMaqh/H2kq+tWbTI/bV1EVFfmbTmO6bnsz3tadg3DP5aH27mbMqNzme8UzGfT2BrG0W75vSm+T6p2xduBdd1+RsEJ/ob1vVdd9/ora99fMI1mV+H2VHYdUoJ6tmh5knbU9XFsTb7atKHc8Bzzvfn7ysAeBeVWZNFFW1vWdT+zcZ7LLqtm22Y3662VbfYu0gHlp5v0fw/56mvSOdH3FJQZQmo2e4PFf3+1ebiS4qtw3wDeUdf9qFz+PuqukgXekrsF8MlWlweLLpYZ1u66y92eIF2A96Em49+tFmeep7cXlNkob69/b3Gd3UnPV+HWXyjZ1nZetFxafZGuTF1in0l6QlpQd4Ej8O+528+aDLMhi1/YVH8V7lYF5TdpiCNIF4MNreu+POkUYbDknRrTaO/ixj3opatwWzkHugsp6c3KF//ULhrYnNTctyrppHpRE8/1wLX5AqQnSPeBHpgX5Bcbyn6edGHHOZL2J13aXrsPdCHpiqm59Ox20j1Wv8sX/7xOutDi+haGbSoinpZ0A6k5CNprvt2LdPL9wej+nOlFpHMQn5J0RkQs6KZsb7kWmCfpHtKGKNIR706k2nL9vX/nk84v/UzSB0gn6Lcn7Wx+S7q/8E0R8Zyko0jbxh2SbiLd2L0G6T7TTUnbUbtln5f0sRz7PZJuJ90QHbncbqSdzyo5lP1I29UE0s7rWdKR7EjStlW7X3FV0j2AT+R5/2sex36kiyJ+ExFTW1yubS2rPnIUqfZ1kaQvk+7ze5E079uSamS7kZbHxsBkSQ+SlvvfSMv+YNKB8o8Kfn9/Iu0fJkm6hUX3ga4FnBJ1F6BExBWSRub+Dys9dD9Itf/NgSsj1XjLanndRcQbkj5KunXuBkl3ky4SeoW0/exEehDBhrnbdsA1kv5IeiDFM6QDjpGkZFw7J9qqqaRlUH8f6DtI92xeVitUYjtfGqcA+0j6P9I+fh7pwPNAUhK/oK7saNIy+TzwYUm/J53fXI/UvL0HaT/2SJ6PRyR9kXTB5WRJ15EqXuuQlvUccitjpHvjv5fjeSgvo5dzHNuQTik03l/cloj4g6TzSRecPdSwHv5BO4+HbeHIZFPgBNJKfCzP7Pw8kRtJ50eWaxhmFLl2SPoBTmDR01+uBrZoMq2NSUc1f83TeI501FH0ZJA3p9HQfbU8jumkGuNiR+mUrIHmcrXL3//Y5tHd5Xm4L7dQtlYT/0jDfHYbW8FyabX85/O6fZK0s3iBdMR+CnU1jrrye5JqNq/kbeEG0s74TJrXxrYmXT09g0VPUhlH8aXq7ZQdRrpP93FSq8McUhPTZcChdeW2BM4lHZTNJh1UTSMl693ryq2Y5/sm0n1or+Xy9+TltFLD9JvOc5llVbRtdrPeWt1mhwCnkZLKPNIVkk/lWI4HVsvl1iKdC67tDGtPirmT1AqlolhJtbD/ISXh10jNY909ieiLeT28kl+TSPuXpk8iajKusSxeA21r3eVh1iPdaP9QjmVe3pZ+RdqvrZDLbUK6if8PpItzXiftX26iroWmhXV2Z4658UlET5IuyCm8/YYWt/Oi5dJGbPuTHobxCKkl6GXS/v5HFNz3TzrQPoZUYand9zuDlOBOAzYtGGY30v7/2Vz+GdIDKj5WUPYTeVxz8zw/TErKqxSUnUb7t4zVnkQ0lUVPX/sJbT6JSHlkvUrpL8bGkGqNY3t9AhXJl5KfAXw20jkQs0EpX/g2LiL2qjqWgULpr+pGREThvR828AzY/wNd1iQNIR3JvkB6xJyZmQ1iLd8HOljl57PuSLr6dn3SRU7Nbiw3M7NBwgm0Z4eTbkH5O+lfLX7QfXEzMxsM+uQcqJmZWadzDRRYd911Y9iwYVWHYWY2YEyaNOm5iBjac8nO5QQKDBs2jIkTl+aRr2Zmg4ukv1YdQ9V8Fa6ZmVkJTqBmZmYlOIGamZmV4ARqZmZWghOomZlZCU6gZmZmJTiBmpmZleAEamZmVoITqJmZWQlOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJTqBmZmYlOIGamZmV4ARqZmZWghOomZlZCQM2gUraVNIdkh6R9LCkExv6nywpJK1bVYxmZta5Vqg6gKWwADg5Iu6XNASYJOnWiHhE0qbA/sDT1YZoZmadasDWQCNiZkTcnz/PBaYCG+fePwBOAaKi8MzMrMMN2ARaT9IwYAfgXkkjgRkR8UAPwxwvaaKkibNnz14GUZqZWScZ8AlU0urA1cBJpGbd04DTexouIi6IiOERMXzo0KF9HKWZmXWaAZ1AJa1ISp6XR8Q1wDuAzYEHJE0DNgHul7RBdVGamVknGrAXEUkScBEwNSLOBYiIB4H16spMA4ZHxHOVBGlmZh1rINdA9wCOAfaRNCW/PlR1UGZmNjgM2BpoRIwH1EOZYcsmGjMzG2wGcg3UzMysMk6gZmZmJTiBmpmZleAEamZmVoITqJmZWQlOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJTqBmZmYlOIGamZmV4ARqZmZWghOomZlZCU6gZmZmJTiBmpmZleAEamZmVoITqJmZWQlOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJTqBmZmYlOIGamZmV4ARqZmZWghOomZlZCU6gZmZmJTiBmpmZleAEamZmVoITqJmZWQlOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJTqA2YM2cO5MRY0cwa96sqkOxErz+bKAbsAlU0qaS7pD0iKSHJZ2Yu58j6VFJf5J0raS1qo7V+sbou0Yz/unxjB43uupQrASvPxvoBmwCBRYAJ0fEVsCuwAmStgJuBbaJiG2BPwOnVhij9ZGZc2cyZsoYFsZCxkwZ41rMAOP1Z51gwCbQiJgZEffnz3OBqcDGEXFLRCzIxe4BNqkqRus7o+8azcJYCEBXdLkWM8B4/VknGLAJtJ6kYcAOwL0NvT4N3LSs47G+Vau9zO+aD8D8rvmuxQwgXn/WKSpNoJKWk7T7Uo5jdeBq4KSImFPX/RukZt7Lmwx3vKSJkibOnj17aUKwZay+9lLjWszA4fVnnaLSBBoRC4GflB1e0oqk5Hl5RFxT130UcDDwyYiIJtO+ICKGR8TwoUOHlg3BKjBh+oQ3ay8187vmc/f0uyuKyNrh9WedYoWqAwBul3QYcE2zZFdEkoCLgKkRcW5d9wOAU4AREfFKr0drlZv8uclVh2BLwevPOkV/SKCfA/4V6JL0KiAgImKNHobbAzgGeFDSlNztNOBHwMrArSnHck9EfL5PIjczs0Gr8gQaEUNKDjeelGwb3bh0EZmZmfWs8qtwlRwt6Vv5+6aSdq46LjMzs+5UnkCBnwK7AUfl7/NYiguLzMzMloXKm3CBXSJiR0mTASLiH5JWqjooMzOz7vSHGugbkpYHAkDSUGBh94OYmZlVqz8k0B8B1wLrS/oOMB74brUhmZmZda/yJtyIuFzSJOADudOhETG1ypjMzMx6UnkCzd4C1JpxV604FjMzsx5V3oQr6XTgEmBtYF1gjKRvVhuVmZlZ9/pDDfSTwHYR8RqApLOBKcC3K43KzMysG5XXQIFngFXqvq8MzKgoFjMzs5ZUVgOVdD7pnOdLwMOSbs3f9wPuqyouMzOzVlTZhDsxv08i3cZSc+eyD8XMrHfNnDuTT1z9Ca782JVssPoGVYdjfaCyBBoRl1Q1bTOzvjb6rtGMf3o8o8eN5icH+emknajyc6CSDpY0WdILkuZImitpTtVxmZmVNXPuTMZMGcPCWMiYKWOYNW9W1SFZH6g8gQLnAccC60TEGhExpIX/AjUz67dG3zWahZGeSNoVXYweN7riiKwv9IcE+jfgoYiIqgMxM1tatdrn/K75AMzvmu9aaIfqDwn0FOBGSadK+tfaq+qgzMzKqK991rgW2pn6w4MUvkP6D9BVAP+NmZkNaBOmT3iz9lkzv2s+d0+/u6KIrK/0hwS6UURsU3UQZma9YfLnJlcdgi0j/aEJ90ZJ+1cdhJmZWTv6QwL9AvA7Sa/6NhYzMxsoKm/CjYghVcdgZmbWrsproJLeX/SqOi6zqs2cO5MRY0f49gezfqryGijw1brPqwA7k56Pu0814Zj1D34UnFn/VnkNNCI+XPfaD9gG+EfVcZlVyY+CM+v/Kk+gBaYDW1YdhFmV/Cg4s/6v8ibcuv8FhZTQtwfury4is2o1exTct0Z8y3+LZdaP9Ica6ETSOc9JwATgaxFxdLUhmVXHj4IzGxgqr4H6f0HNFudHwZkNDJUnUEl7AGcCm5HiERAR8fYq4zKrih8FZzYwVJ5AgYuAr5CacLsqjsXMzKwl/SGBvhQRN1UdhJmZWTv6QwK9Q9I5wDXA67WOEeErcc3MrN/qDwl0l/w+vK5b4CcRmZlZP1Z5Ao2IvauOwczMrF394T7QUiRtKukOSY9IeljSibn72pJulfR4fn9r1bGamVnnGbAJFFgAnBwRWwG7AidI2gr4OnB7RLwLuD1/NzMz61UDNoFGxMzahUYRMReYCmwMjARqD2e4BDi0mgjNzKyTVZ5AJR0uaUj+/E1J10jasc1xDAN2AO4F1o+ImbnXLGD9JsMcL2mipImzZ88uHb+ZmQ1OlSdQ4FsRMVfSnsC+pAcr/KzVgSWtDlwNnBQRc+r7RUSw6EH1NPS7ICKGR8TwoUOHlo/ezMwGpf6QQGtPHzoIuCAibgBWamVASSuSkuflEXFN7vx3SRvm/hsCz/ZyvGZmZv0igc6Q9HPg48CNklamhbgkiVRbnRoR59b1+g1wbP58LHBdL8drZmbWLxLoEcDNwAcj4kVgbeCrLQy3B3AMsI+kKfn1IeBsYD9Jj5OahM/uo7jNzGwQq/xBCsDPI+KY2peImCnpe8At3Q0UEeNJ/9xS5AO9GJ+ZmdkS+kMNdOv6L5KWB95bUSxmZmYtqSyBSjpV0lxgW0lz8msu6aIfn7c0M7N+rbIEGhH/ERFDgHMiYo38GhIR60TEqVXFZWZm1or+0IT7W0mrAUg6WtK5kjarOigzM7Pu9IcE+jPgFUnbAScDfwEurTYkMzOz7vWHBLogPzFoJPDjiPgJMKTimMzMzLrVH25jmSvpVNI9ne+TtBywYsUxmZmZdas/1EA/DrwOfDoiZgGbAOdUG5KZmVn3Kk+gOWleDaycOz0HXFtdRGZmZj2rPIFKOg74FfDz3Glj4NfVRWRmZtazyhMocALpubZzACLicWC9SiMyMzPrQX9IoK9HxPzaF0kr0OQ/PK09M+fOZMTYEcyaN6vqUMzMOk5/SKDjJJ0GrCppP+CXwPUVx9QRRt81mvFPj2f0uNFVh2Jm1nH6QwL9OjAbeBD4HHAj8M1KI+oAM+fOZMyUMSyMhYyZMsa1UDOzXlZ5Ao2IhRHx3xFxeER8LH92E+5SGn3XaBbGQgC6osu1UDOzXlZ5ApX0lKQnG19VxzWQ1Wqf87vSqeX5XfNdCzUz62WVJ1BgOLBTfr0P+BHwP5VGNMDV1z5rXAs1M+tdlSfQiHi+7jUjIs4DDqo6roFswvQJb9Y+a+Z3zefu6XdXFJGZWeep/Fm4knas+7ocqUZaeVwD2eTPTa46BDOzjtcfEtV/1X1eAEwDjqgmFDMzs9ZUnkAjYu+qYzAzM2tX5QlU0r921z8izl1WsZiZmbWq8gTKoqtwf5O/fxi4D3i8sojMzMx60B8S6CbAjhExF0DSmcANEXF0pVGZmZl1o/LbWID1gfp7LubnbmZmZv1Wf6iBXgrcJ6n2J9qHApdUGI+ZmVmPKk+gEfEdSTeRnkIE8KmI8I2MZmbWr/WHJlyAtwBzIuKHwHRJm1cdkJmZWXcqT6CSzgC+BpyaO62In4VrZmb9XOUJFPgIcAjwMkBEPAMMqTQiMzOzHvSHBDo///9nAEhareJ4zMzMetQfEuhVkn4OrCXpOOA24MKKYzIzM+tWf7gK9/uS9gPmAO8GTo+IWysOy8zMrFuVJ1CAnDBvBZC0nKRPRsTlFYdlZmbWVGVNuJLWkHSqpB9L2l/Jl4AnaeHvzCRdLOlZSQ/Vddte0j2SpkiaKGnnvpwHMzMbvKo8B3oZqcn2QeCzwB3A4cChETGyheHHAgc0dPsecFZEbA+cnr+bmcZqYEoAAAivSURBVJn1uiqbcN8eEe8BkHQhMBN4W0S81srAEXGXpGGNnYE18uc1gWd6J1QzM7PFVZlA36h9iIguSdNbTZ7dOAm4WdL3SbXr3ZdyfGZmZoWqbMLdTtKc/JoLbFv7LGlOyXF+AfhKRGwKfAW4qFlBScfn86QTZ8+eXXJyZmY2WCk9w2Bgyk24v42IbfL3l4C1IiIkCXgpItboZhQADB8+PCZOnNinsZqZdRJJkyJieNVxVKk/PEihNz0DjMif9wEerzAWMzPrYP3iPtAyJP0C2AtYV9J04AzgOOCHklYAXgOOry5CMzPrZAM2gUbEkU16vXeZBmJmZoNSpzXhmpmZLRNOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJTqBmZmYlOIGamZmV4ARqZmZWghOomZlZCU6gZmZmJTiBmpmZleAEamZmVoITqJmZWQlOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJTqBmZmYlOIGamZmV4ARqZmZWghOomZlZCU6gZmZmJTiBmpmZleAEamZmVoITqJmZWQlOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJTqBmZmYlOIGamZmV4ARqZmZWghOomZlZCU6gZmZmJTiBmpmZlTBgE6ikiyU9K+mhhu7/IulRSQ9L+l5V8ZmZWWcbsAkUGAscUN9B0t7ASGC7iNga+H4FcZmZ2SAwYBNoRNwFvNDQ+QvA2RHxei7z7DIPzMzMBoUBm0Cb2AJ4n6R7JY2TtFOzgpKOlzRR0sTZs2cvwxDNzKwTdFoCXQFYG9gV+CpwlSQVFYyICyJieEQMHzp06LKM0czMOkCnJdDpwDWR3AcsBNatOCYzM+tAnZZAfw3sDSBpC2Al4LlKIzIzs460QtUBlCXpF8BewLqSpgNnABcDF+dbW+YDx0ZEVBelmZl1qgGbQCPiyCa9jl6mgZiZ2aDUaU24ZmZmy4QTqJmZWQlOoGZmZiU4gZqZmZXgBGpmZlaCE6iZmVkJTqBmZmYlOIGamZmV4ARqZmZWghOomZlZCU6gZmZmJTiBmpmZleAEamZmVoITqJmZWQlOoGZmZiU4gZqZmZWgiKg6hspJmgs8VnUcfWRd4Lmqg+hDnr+BzfM3cL07IoZUHUSVVqg6gH7isYgYXnUQfUHSxE6dN/D8DXSev4FL0sSqY6iam3DNzMxKcAI1MzMrwQk0uaDqAPpQJ88beP4GOs/fwNXJ89YSX0RkZmZWgmugZmZmJTiBmpmZleAECkg6XNLDkhZK6phLziUdIOkxSU9I+nrV8fQmSRdLelbSQ1XH0hckbSrpDkmP5G3zxKpj6i2SVpF0n6QH8rydVXVMfUHS8pImS/pt1bH0NknTJD0oacpgvp3FCTR5CPgocFfVgfQWScsDPwEOBLYCjpS0VbVR9aqxwAFVB9GHFgAnR8RWwK7ACR20/l4H9omI7YDtgQMk7VpxTH3hRGBq1UH0ob0jYvtOvc+1FU6gQERMjYhOexLRzsATEfFkRMwH/hcYWXFMvSYi7gJeqDqOvhIRMyPi/vx5LmlHvHG1UfWOSOblryvmV0ddzShpE+Ag4MKqY7G+4wTauTYG/lb3fTodsgMebCQNA3YA7q02kt6TmzenAM8Ct0ZEx8xbdh5wCrCw6kD6SAC3SJok6fiqg6nKoHmUn6TbgA0Ken0jIq5b1vGYtULS6sDVwEkRMafqeHpLRHQB20taC7hW0jYR0RHnsyUdDDwbEZMk7VV1PH1kz4iYIWk94FZJj+ZWoUFl0CTQiNi36hiWsRnApnXfN8ndbICQtCIpeV4eEddUHU9fiIgXJd1BOp/dEQkU2AM4RNKHgFWANST9T0QcXXFcvSYiZuT3ZyVdSzplNOgSqJtwO9cfgXdJ2lzSSsAngN9UHJO1SJKAi4CpEXFu1fH0JklDc80TSasC+wGPVhtV74mIUyNik4gYRvrd/b6Tkqek1SQNqX0G9qdzDn7a4gQKSPqIpOnAbsANkm6uOqalFRELgC8BN5MuQLkqIh6uNqreI+kXwATg3ZKmS/pM1TH1sj2AY4B98q0CU3KNphNsCNwh6U+kA71bI6LjbvXoYOsD4yU9ANwH3BARv6s4pkr4UX5mZmYluAZqZmZWghOomZlZCU6gZmZmJTiBmpmZleAEamZmVoITqFk3JK1TdxvJLEkz6r6v1MZ4Pi2p6ElYfUbSZyWdtyynaTaYDJonEZmVERHPk/4xBElnAvMi4vslRvVp4H5gVu9F17ckLZ8fuWdmBVwDNStJ0rH5fy2nSPqppOUkrSDpsvxfiQ9J+rKkj5OS8JVFNVdJ4yWdncf1mKTdc/fFapCSfidpzzyNFyWdm/9P82ZJu0gaJ+nJhgcubJa7Py7pmy3E/qKk8/JDDnbu2yVoNrA5gZqVIGkb4CPA7hGxPak15xPAe4F1I+I9EbENcGlEXAlMAT6e/z9xftEoI2Jn4KvA6S2EsCZwU0RsDcwHzgQ+ABwO/HtduZ2BQ0kJ/ChJ23cTe228d0XEthExodXlYTYYuQnXrJx9gZ2AiemxtaxK+vu4m0mPF/wRcANwS4vjqz0sfhIwrIXyr0bErfnzg8BLEbFA0oMNw98cEf8AkPRrYE/S774odkjJ+NoWYzYb1JxAzcoRcHFEfGuJHtK2wIHACcBhQCv/l/h6fu9i0e9yAYu3Eq1S97m+FruwbviFLP67bnxWZzSLXdIKpMTs53uatcBNuGbl3AYcIWldePNq3bdJGkpqjv0lqSl2x1x+LjCkzWlMA3ZQMozUPNyu/SWtJektwEjgD81iLzFus0HNNVCzEiLiQUlnAbdJWg54A/g8qQZ5Uf47sgC+lgcZA1wo6VVg5ybnQRuNI/2H61TgYdJ51Hb9EbgO2Ai4JCKmADSJ/ZkS4zcbtPxvLGZmZiW4CdfMzKwEJ1AzM7MSnEDNzMxKcAI1MzMrwQnUzMysBCdQMzOzEpxAzczMSvj/Ot+9H/GPbI4AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "success_resposnes = [test['success'] / test['total_time'] for test in tests if test['success']]\n", "plt.plot(success_resposnes, 'g^')\n", "plt.axis([-1, 5, 15, 25])\n", "plt.title('Spoitify API successful responses per second', fontsize=20)\n", "plt.xlabel('Test number')\n", "plt.ylabel('Requests number')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "all_respones = [len(test['results']) / test['total_time'] for test in tests if test['success']]\n", "plt.plot(all_respones, 'bs')\n", "plt.axis([-1, 5, 50, 150])\n", "plt.title('Total number of Spoitify API responses per second', fontsize=20)\n", "plt.ylabel('requests number')\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.1" } }, "nbformat": 4, "nbformat_minor": 2 }