RcloneLab_bak.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "RLabClone 02/09",
      "version": "0.3.2",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [
        "6I2huqscJEPn",
        "fkaNFMaxHDWz",
        "8uUbyNZHi8a5",
        "X_o8umGH27Ke",
        "_lxNNpMCqYT4",
        "5-5ksQslqmYy"
      ],
      "toc_visible": true,
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HGctdySsIGFS",
        "colab_type": "text"
      },
      "source": [
        "#### 📚 Use [Chrome](https://www.google.com/chrome/) for the best experience; if you face any issues with other browsers, it's the browser problem, not us. For more information please visit our [GitHub](https://github.com/MinorMole/RcloneLab/). This is a [Geart Fork](https://github.com/biplobsd/RcloneLab/tree/biplobsd-patch-1), [Lastest version](https://colab.research.google.com/github/biplobsd/RLabClone/blob/master/RcloneLab.ipynb)!\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6I2huqscJEPn",
        "colab_type": "text"
      },
      "source": [
        "# <img src='https://biplobsd.github.io/RLabClone/img/title_rclonelab.svg' height=\"45\" alt=\"RcloneLab\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iroeLPFdXbif",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Install rClone</h3>\n",
        "Upload_From_Computer = False #@param {type:\"boolean\"}\n",
        "Beta = True \n",
        "Setup_Time_Zone = False\n",
        "\n",
        "import os, subprocess; from google.colab import files; from IPython.display import HTML, clear_output\n",
        "\n",
        "def printOutput(text):\n",
        "  clear_output(wait=True)\n",
        "  display(HTML(f\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#3399ff;\\\">{text}</h2><br></center>\"))\n",
        "\n",
        "def installRclone():\n",
        "  if os.path.isfile(\"/content/sample_data\"):\n",
        "    get_ipython().system_raw(\"rm -rf /content/sample_data\")\n",
        "\n",
        "  if Setup_Time_Zone:\n",
        "    !sudo dpkg-reconfigure tzdata\n",
        "  elif subprocess.Popen('cat /etc/timezone', shell=True, stdout=subprocess.PIPE, ).communicate()[0].decode().strip() != \"Asia/Ho_Chi_Minh\":\n",
        "    get_ipython().system_raw(\"sudo ln -fs /usr/share/zoneinfo/Asia/Ho_Chi_Minh /etc/localtime && sudo dpkg-reconfigure -f noninteractive tzdata\")\n",
        "  \n",
        "  if Upload_From_Computer:\n",
        "    try:\n",
        "      printOutput(\"Please upload the config file of rclone (rclone.conf) from your computer.\")\n",
        "      UploadConfig = files.upload().keys()\n",
        "      if len(UploadConfig) == 0:\n",
        "        return printOutput(\"File upload has been cancelled during upload file.\")\n",
        "      elif len(UploadConfig) == 1:\n",
        "        for fn in UploadConfig:\n",
        "          if os.path.isfile(\"/content/\" + fn):\n",
        "            get_ipython().system_raw(\"mv -f \" + \"\\\"\" + fn + \"\\\" /root/.rclone.conf && chmod 666 /root/.rclone.conf\")   \n",
        "          else:\n",
        "            return printOutput(\"File upload has been failed during upload file.\")\n",
        "      else:\n",
        "        for fn in UploadConfig:\n",
        "          get_ipython().system_raw(\"rm -f \" + \"\\\"\" + fn + \"\\\"\")\n",
        "        return printOutput(\"Please uploading only one file at a time.\")\n",
        "    except:\n",
        "      return printOutput(\"Error occurred during upload file.\")\n",
        "  else:\n",
        "    get_ipython().system_raw(\"wget -q https://biplobsd.github.io/RLabClone/res/rclonelab/rclone.conf -O /root/.rclone.conf\")\n",
        "\n",
        "  if os.path.isfile(\"/usr/bin/rclone\"):\n",
        "    return printOutput(\"Config file updated.\")\n",
        "  else:\n",
        "    if Beta:\n",
        "      get_ipython().system_raw(\"curl -s https://rclone.org/install.sh | sudo bash -s beta\")\n",
        "    else:\n",
        "      get_ipython().system_raw(\"curl -s https://rclone.org/install.sh | sudo bash\")\n",
        "    return printOutput(\"Installation has been successfully completed.\")\n",
        "\n",
        "installRclone()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RIr3CXMAGNdy",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Execute rClone</h3>\n",
        "# ============================= FORM ============================= #\n",
        "Mode = \"Move\" #@param [\"Config\", \"Copy\", \"Move\", \"Mount\", \"Sync\", \"Checker\", \"Deduplicate\", \"Remove Empty Directories\", \"Empty Trash\", \"qBittorrent\"]\n",
        "Compare = \"Size & Checksum\" #@param [\"Size & Mod-Time\", \"Size & Checksum\", \"Only Mod-Time\", \"Only Size\", \"Only Checksum\"]\n",
        "Source = \"\" #@param {type:\"string\"}\n",
        "Destination = \"\" #@param {type:\"string\"}\n",
        "Transfers = 20\n",
        "Checkers = 20\n",
        "#@markdown ---\n",
        "\n",
        "#@markdown <center><h3><font color=\"#3399ff\"><b>⚙️ Global Configuration ⚙️</b></font></h3></center>\n",
        "Simple_Ouput = True \n",
        "Skip_files_that_are_newer_on_the_destination = False #@param {type:\"boolean\"}\n",
        "Skip_all_files_that_exist = False #@param {type:\"boolean\"}\n",
        "Do_not_cross_filesystem_boundaries = False\n",
        "Do_not_update_modtime_if_files_are_identical = False #@param {type:\"boolean\"}\n",
        "Large_amount_of_files_optimization = False\n",
        "Google_Drive_optimization = True \n",
        "Google_Drive_server_side_copy = True \n",
        "Dry_Run = False #@param {type:\"boolean\"}\n",
        "Output_Log_File = \"OFF\" #@param [\"OFF\", \"NOTICE\", \"INFO\", \"ERROR\", \"DEBUG\"]\n",
        "Extra_Arguments = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown <center><h3><font color=\"#3399ff\"><b>↪️ Sync Configuration ↩️</b></font></h3></center>\n",
        "Sync_Mode = \"Delete during transfer\" #@param [\"Delete during transfer\", \"Delete before transfering\", \"Delete after transfering\"]\n",
        "Track_Renames = False #@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown <center><h3><font color=\"#3399ff\"><b>💞 Deduplicate Configuration 💞</b></font></h3></center>\n",
        "Deduplicate_Mode = \"Interactive\" #@param [\"Interactive\", \"Skip\", \"First\", \"Newest\", \"Oldest\", \"Largest\", \"Rename\"]\n",
        "Deduplicate_Use_Trash = True #@param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil; from IPython.display import HTML, clear_output; from IPython.utils.io import ask_yes_no\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "\n",
        "### Variable Declaration\n",
        "\n",
        "# Optimized for Google Colaboratory\n",
        "if Google_Drive_optimization:\n",
        "  bufferC = \"--buffer-size 256M\"\n",
        "else:\n",
        "  bufferC = \"--buffer-size 128M\"\n",
        "\n",
        "if Compare == \"Size & Checksum\":\n",
        "  compareC = \"-c\"\n",
        "elif Compare == \"Only Mod-Time\":\n",
        "  compareC = \"--ignore-size\"\n",
        "elif Compare == \"Only Size\":\n",
        "  compareC = \"--size-only\"\n",
        "elif Compare == \"Only Checksum\":\n",
        "  compareC = \"-c --ignore-size\"\n",
        "else:\n",
        "  compareC = \"\"\n",
        "\n",
        "transfersC = \"--transfers \"+str(Transfers)\n",
        "checkersC = \"--checkers \"+str(Checkers)\n",
        "\n",
        "if Skip_files_that_are_newer_on_the_destination:\n",
        "  skipnewC = \"-u\"\n",
        "else:\n",
        "  skipnewC = \"\"\n",
        "  \n",
        "if Skip_all_files_that_exist:\n",
        "  skipexistC = \"--ignore-existing\"\n",
        "else:\n",
        "  skipexistC = \"\"\n",
        "  \n",
        "if Do_not_cross_filesystem_boundaries:\n",
        "  nocrossfilesystemC = \"--one-file-system\"\n",
        "else:\n",
        "  nocrossfilesystemC = \"\"\n",
        "  \n",
        "if Do_not_update_modtime_if_files_are_identical:\n",
        "  noupdatemodtimeC = \"--no-update-modtime\"\n",
        "else:\n",
        "  noupdatemodtimeC = \"\"\n",
        "\n",
        "if Large_amount_of_files_optimization:\n",
        "  filesoptimizeC = \"--fast-list\"\n",
        "else:\n",
        "  filesoptimizeC = \"\"\n",
        "  \n",
        "if Google_Drive_optimization:\n",
        "  driveoptimizeC = \"--drive-chunk-size 256M --drive-acknowledge-abuse --drive-keep-revision-forever\"\n",
        "else:\n",
        "  driveoptimizeC = \"\"\n",
        "\n",
        "if Google_Drive_server_side_copy:\n",
        "  drivecopyC = \"--drive-server-side-across-configs=true\"\n",
        "elif Google_Drive_optimization:\n",
        "  drivecopyC = \"--disable copy\"\n",
        "\n",
        "if Dry_Run:\n",
        "  dryrunC = \"-n\"\n",
        "else:\n",
        "  dryrunC = \"\"\n",
        "  \n",
        "if Output_Log_File != \"OFF\":\n",
        "  statsC = \"--log-file=/root/.rclone_log/rclone_log.txt\"\n",
        "else:\n",
        "  if Simple_Ouput:\n",
        "    statsC = \"-v --stats-one-line --stats=5s\"\n",
        "  else:\n",
        "    statsC = \"-v --stats=5s\"\n",
        "  \n",
        "if Output_Log_File == \"INFO\":\n",
        "  loglevelC = \"--log-level INFO\"\n",
        "elif Output_Log_File == \"ERROR\":\n",
        "  loglevelC = \"--log-level ERROR\"\n",
        "elif Output_Log_File == \"DEBUG\":\n",
        "  loglevelC = \"--log-level DEBUG\"\n",
        "else:\n",
        "  loglevelC = \"\"\n",
        "\n",
        "if Sync_Mode == \"Delete during transfer\":\n",
        "  syncmodeC = \"--delete-during\"\n",
        "elif Sync_Mode == \"Delete before transfering\":\n",
        "  syncmodeC = \"--delete-before\"\n",
        "elif Sync_Mode == \"Delete after transfering\":\n",
        "  syncmodeC = \"--delete-after\"\n",
        "  \n",
        "if Track_Renames:\n",
        "  trackrenamesC = \"--track-renames\"\n",
        "else:\n",
        "  trackrenamesC = \"\"\n",
        "  \n",
        "if Deduplicate_Mode == \"Interactive\":\n",
        "  deduplicateC = \"interactive\"\n",
        "elif Deduplicate_Mode == \"Skip\":\n",
        "  deduplicateC = \"skip\"\n",
        "elif Deduplicate_Mode == \"First\":\n",
        "  deduplicateC = \"first\"\n",
        "elif Deduplicate_Mode == \"Newest\":\n",
        "  deduplicateC = \"newest\"\n",
        "elif Deduplicate_Mode == \"Oldest\":\n",
        "  deduplicateC = \"oldest\"\n",
        "elif Deduplicate_Mode == \"Largest\":\n",
        "  deduplicateC = \"largest\"\n",
        "elif Deduplicate_Mode == \"Rename\":\n",
        "  deduplicateC = \"rename\"\n",
        "  \n",
        "if Deduplicate_Use_Trash:\n",
        "  deduplicatetrashC = \"\"\n",
        "else:\n",
        "  deduplicatetrashC = \"--drive-use-trash=false\"\n",
        "  \n",
        "### rclone Execution\n",
        "\n",
        "if Output_Log_File != \"OFF\" and Mode != \"Config\":\n",
        "  get_ipython().system_raw(\"mkdir -p -m 666 /root/.rclone_log/\")\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Logging enables, rclone will not output log through the terminal, please wait until finished.</h2><br></center>\"))\n",
        "\n",
        "if Mode == \"Config\":\n",
        "  !rclone --config=/root/.rclone.conf config\n",
        "elif Mode == \"Copy\":\n",
        "  !rclone --config=/root/.rclone.conf copy \"$Source\" \"$Destination\" $transfersC $checkersC $statsC $loglevelC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Move\":\n",
        "  !rclone --config=/root/.rclone.conf move \"$Source\" \"$Destination\" $transfersC $checkersC $statsC $loglevelC --delete-empty-src-dirs $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Mount\":\n",
        "  try:\n",
        "    if not CheckProcess(\"rclone\", \"/content/\" + Source.split(\":\")[0] + \"/\"):\n",
        "      if not os.path.exists(\"/content/\" + Source.split(\":\")[0] + \"/\"):\n",
        "        get_ipython().system_raw(\"mkdir -p -m 666 '/content/\" + Source.split(\":\")[0] + \"/'\")\n",
        "      get_ipython().system_raw(\"rclone --config=/root/.rclone.conf mount '$Source' '/content/\" + Source.split(\":\")[0] + \"/' $loglevelC $noupdatemodtimeC $bufferC $filesoptimizeC --drive-chunk-size 256M --drive-acknowledge-abuse --drive-keep-revision-forever $Extra_Arguments &\")\n",
        "  except:\n",
        "    pass\n",
        "elif Mode == \"Sync\":\n",
        "  !rclone --config=/root/.rclone.conf sync \"$Source\" \"$Destination\" $transfersC $checkersC $statsC $loglevelC $syncmodeC $trackrenamesC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Checker\":\n",
        "  !rclone --config=/root/.rclone.conf check \"$Source\" \"$Destination\" $checkersC $statsC $loglevelC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Deduplicate\":\n",
        "  !rclone --config=/root/.rclone.conf dedupe \"$Source\" $checkersC $statsC $loglevelC --dedupe-mode $deduplicateC $deduplicatetrashC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Remove Empty Directories\":\n",
        "  !rclone --config=/root/.rclone.conf rmdirs \"$Source\" $statsC $loglevelC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Empty Trash\":\n",
        "  !rclone --config=/root/.rclone.conf cleanup \"$Source\" $statsC $loglevelC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"qBittorrent\":\n",
        "  if Source == \"\":\n",
        "    !chmod -R 666 /content/qBittorrent/ && rclone --config=/root/.rclone.conf move \"/content/qBittorrent/\" \"$Destination\" $transfersC $checkersC $statsC $loglevelC --delete-empty-src-dirs --exclude **/.unwanted/ $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "\n",
        "### Log Output\n",
        "  \n",
        "if Output_Log_File != \"OFF\" and Mode != \"Config\" and os.path.isfile(\"/root/.rclone_log/rclone_log.txt\"):\n",
        "  ### Rename log file and output settings.\n",
        "  get_ipython().system_raw(\"mv /root/.rclone_log/rclone_log.txt /root/.rclone_log/rclone_log_$(date +%Y-%m-%d_%H.%M.%S).txt\")\n",
        "  with open(\"/root/.rclone_log/\" + Mode + \"_settings.txt\", \"w\") as f:\n",
        "    f.write(\"Mode: \" + Mode + \\\n",
        "            \"\\nCompare: \" + Compare + \\\n",
        "            \"\\nSource: \\\"\" + Source + \\\n",
        "            \"\\\"\\nDestination: \\\"\" + Destination + \\\n",
        "            \"\\\"\\nTransfers: \" + str(Transfers) + \\\n",
        "            \"\\nCheckers: \" + str(Checkers) + \\\n",
        "            \"\\nSkip files that are newer on the destination: \" + str(Skip_files_that_are_newer_on_the_destination) + \\\n",
        "            \"\\nSkip all files that exist: \" + str(Skip_all_files_that_exist) + \\\n",
        "            \"\\nDo not cross filesystem boundaries: \" + str(Do_not_cross_filesystem_boundaries) + \\\n",
        "            \"\\nDo not update modtime if files are identical: \" + str(Do_not_update_modtime_if_files_are_identical) + \\\n",
        "            \"\\nDry-Run: \" + str(Dry_Run) + \\\n",
        "            \"\\nOutput Log Level: \" + Output_Log_File + \\\n",
        "            \"\\nExtra Arguments: \\\"\" + Extra_Arguments + \\\n",
        "            \"\\\"\\nSync Moden: \" + Sync_Mode + \\\n",
        "            \"\\nTrack Renames: \" + str(Track_Renames) + \\\n",
        "            \"\\nDeduplicate Mode: \" + Deduplicate_Mode + \\\n",
        "            \"\\nDeduplicate Use Trash: \" + str(Deduplicate_Use_Trash))\n",
        "  ### Compressing log file.\n",
        "  get_ipython().system_raw(\"rm -f /root/rclone_log.zip && zip -r -q -j -9 /root/rclone_log.zip /root/.rclone_log/ && rm -rf /root/.rclone_log/ && mkdir -p -m 666 /root/.rclone_log/\")\n",
        "  ### Send Log\n",
        "  if os.path.isfile(\"/root/rclone_log.zip\"):\n",
        "    try:\n",
        "      files.download(\"/root/rclone_log.zip\")\n",
        "      get_ipython().system_raw(\"rm -f /root/rclone_log.zip\")\n",
        "      display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Sending log to your browser...</h2><br></center>\"))\n",
        "    except:\n",
        "      get_ipython().system_raw(\"mv /root/rclone_log.zip /content/rclone_log_$(date +%Y-%m-%d_%H.%M.%S).zip\")\n",
        "      display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">You can use file explorer to download the log file.</h2><br><img src=\\\"https://biplobsd.github.io/RLabClone/res/rclonelab/01.png\\\"><br></center>\"))\n",
        "  else:\n",
        "    clear_output(wait=True)\n",
        "    display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">There is no log file.</h2><br></center>\"))\n",
        "\n",
        "### Operation has been successfully completed.\n",
        "if os.path.isfile(\"/usr/bin/rclone\") == False:\n",
        "  clear_output(wait=True)\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ Please run the installation cell above first.</h2><br></center>\"))\n",
        "elif Mode == \"qBittorrent\" and Source.strip() != \"\":\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ Please empty the Source field in qBittorrent mode.</h2><br></center>\"))\n",
        "elif Mode == \"Mount\" and Source.strip() == \"\":\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ The Source field is empty.</h2><br></center>\"))\n",
        "elif Mode != \"Config\":\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#00b24c;\\\">✅ Operation has been successfully completed.</h2><br></center>\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KlzC4F8bR7p3",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3>⬅️ Check VM's Status</h3>\n",
        "Check_IP = True \n",
        "Loop_Check = False \n",
        "Loop_Interval = 15 \n",
        "# ================================================================ #\n",
        "\n",
        "import time, requests\n",
        "from IPython.display import clear_output\n",
        "Loop = True\n",
        "\n",
        "try:\n",
        "  while Loop == True:\n",
        "    clear_output(wait=True)\n",
        "    if Check_IP: print(\"\\nYour Public IP: \" + requests.get('http://ip.42.pl/raw').text)\n",
        "    print(\"====\")\n",
        "    !du -sh /content /root/.qBittorrent_temp/\n",
        "    print(\"====\")\n",
        "    !top -bcn1 -w512\n",
        "    if Loop_Check == False:\n",
        "      Loop = False\n",
        "    else:\n",
        "      time.sleep(Loop_Interval)\n",
        "except:\n",
        "  clear_output()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fkaNFMaxHDWz",
        "colab_type": "text"
      },
      "source": [
        "# <img src='https://biplobsd.github.io/RLabClone/img/title_qbittorrent.png' height=\"45\" alt=\"qBittorrent\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IT8biycBSlw4",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title ⬅️ Install qBittorrent on Ngrok.io\n",
        "API = 'api001' #@param {type:\"string\"}\n",
        "tokens = {\n",
        "    'ddn' : '6qGnEsrCL4GqZ7hMfqpyz_7ejAThUCjVnU9gD5pbP5u',\n",
        "    'tdn' : '1Q4i7F6isO7zZRrrjBKZzZhwsMu_74yJqoEs1HrJh1zYyxNo1',\n",
        "    'api001' : '1Q3zMbZhIunjp92RvrZpnyuJxZL_3V3JUziX5Dp1sQbTMAPrr',\n",
        "    'api002' : '1Q45NXgsx6oyusN3GiNAYvkNJPS_AveYUDBcPHsvRvf21WZv',\n",
        "    'api003' : '1Q6smHt4Bzz9VEXTwj3a7p5Gdx2_5mp6ivT6N6nB3YmRHUEM3'\n",
        "  }\n",
        "import os, time, requests, json, uuid, random, psutil\n",
        "from IPython.display import clear_output, HTML\n",
        "from google.colab import output\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    template = \"\"\"<button class=\"p-Widget jupyter-widgets jupyter-button widget-button mod-info\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id)\n",
        "    return html\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "\n",
        "def selectApi(api):\n",
        "  try:\n",
        "    return tokens[api]\n",
        "  except:\n",
        "    return \"Invalid Token\"\n",
        "\n",
        "def checkToken():\n",
        "  return Ngrok_Token == \"Invalid Token\"\n",
        "\n",
        "def randGen():\n",
        "  # return random.randint(10000,15111)\n",
        "  return 10001\n",
        "\n",
        "def printUrl(data):\n",
        "  clear_output(wait=True)\n",
        "  print(f'Web UI: {data[\"url\"]} : {data[\"port\"]}')\n",
        "  if 'surl' in data.keys():\n",
        "    print(f'Web UI (S): {data[\"surl\"]} : {data[\"port\"]}')\n",
        "  display(MakeButton(\"Reset\", Reset_Host))\n",
        "\n",
        "def handleOutput():\n",
        "  if checkToken():\n",
        "    clear_output(wait=True)\n",
        "    print(Ngrok_Token)\n",
        "  else:\n",
        "    time.sleep(10)\n",
        "    try:\n",
        "      host = json.loads(requests.get(\"http://localhost:4040/api/tunnels\").text)['tunnels'][0]['public_url'][8:]\n",
        "      data = {'url' : f'http://{host}', 'surl' : f'https://{host}', 'port': Port_QB, 'token': Ngrok_Token}\n",
        "      printUrl(data)\n",
        "      with open('/usr/local/bin/url.txt', 'w') as outfile:\n",
        "        json.dump(data, outfile)\n",
        "    except:\n",
        "      print('ngrok Token in used!')\n",
        "\n",
        "def handleStartService():\n",
        "  get_ipython().system_raw('ngrok authtoken $Ngrok_Token && ngrok http -inspect=false $Port_QB &')\n",
        "  if CheckProcess(\"qbittorrent-nox\", \"\") != True:\n",
        "    get_ipython().system_raw(\"qbittorrent-nox -d --webui-port=$Port_QB\")\n",
        "\n",
        "def Reset_Host():\n",
        "  # global Port_QB\n",
        "  global Ngrok_Token\n",
        "  # Port_QB = randGen()\n",
        "  Ngrok_Token = selectApi(API)\n",
        "  !pkill ngrok\n",
        "  handleStartService()\n",
        "  handleOutput()\n",
        "\n",
        "Port_QB = randGen()\n",
        "Ngrok_Token = selectApi(API)\n",
        "\n",
        "if os.path.isfile(\"/usr/local/bin/url.txt\") == True:\n",
        "  with open('/usr/local/bin/url.txt') as jsonObj:\n",
        "    data = json.load(jsonObj)\n",
        "    printUrl(data)\n",
        "else:\n",
        "  if checkToken():\n",
        "    clear_output(wait=True)\n",
        "    print(Ngrok_Token)\n",
        "  else:\n",
        "    if os.path.isfile(\"/usr/bin/qbittorrent-nox\") == False:\n",
        "      get_ipython().system_raw(\"apt update -qq -y && yes \"\" | add-apt-repository ppa:qbittorrent-team/qbittorrent-stable && apt install qbittorrent-nox -qq -y\")\n",
        "      get_ipython().system_raw(\"mkdir -p -m 666 /{content/qBittorrent,root/{.qBittorrent_temp,.config/qBittorrent}} && wget -q https://biplobsd.github.io/RLabClone/res/qbittorrent/qBittorrent.conf -O /root/.config/qBittorrent/qBittorrent.conf\")\n",
        "    if os.path.isfile(\"/usr/local/bin/ngrok\") == False:\n",
        "      !pkill -1 -f ngrok\n",
        "      get_ipython().system_raw(\"wget -q -c -nc https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip && unzip -qq -n ngrok-stable-linux-amd64.zip && mv ngrok /usr/local/bin/ngrok\")\n",
        "      get_ipython().system_raw(\"rm -f /content/ngrok-stable-linux-amd64.zip && rm -rf /content/sample_data\")\n",
        "    handleStartService()\n",
        "    handleOutput()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CmzYd3QGHB7d",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3>⬅️ Alternative qBittorrent</h3>\n",
        "Old_Version = False #@param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, IPython, uuid, time\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    template = \"\"\"<button class=\"p-Widget jupyter-widgets jupyter-button widget-button mod-info\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RandomGenerator():\n",
        "  return time.strftime(\"%S\") + str(time.time()).split(\".\")[-1]\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "  \n",
        "def AutoSSH(name,port):\n",
        "  get_ipython().system_raw(\"autossh -M 0 -fNT -o 'StrictHostKeyChecking=no' -o 'ServerAliveInterval 300' -o 'ServerAliveCountMax 30' -R \" + name + \":80:localhost:\" + port + \" serveo.net &\")\n",
        "\n",
        "def Start_AutoSSH_QB():\n",
        "  if CheckProcess(\"qbittorrent-nox\", \"\") != True:\n",
        "    get_ipython().system_raw(\"qbittorrent-nox -d --webui-port=$Port_QB\")\n",
        "  if CheckProcess(\"autossh\", Random_URL_QB) != True:\n",
        "      AutoSSH(Random_URL_QB, Port_QB)\n",
        "\n",
        "def Start_Localhost_QB():\n",
        "  try:\n",
        "    clear_output(wait=True)\n",
        "    !autossh -l $Random_URL_QB -M 0 -o 'StrictHostKeyChecking=no' -o 'ServerAliveInterval 300' -o 'ServerAliveCountMax 30' -R 80:localhost:$Port_QB ssh.localhost.run\n",
        "  except:\n",
        "    Control_Panel_QB()\n",
        "  Control_Panel_QB()\n",
        "\n",
        "def Control_Panel_QB():\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"✔ Successfully\", \"success\"), MakeButton(\"Recheck\", Start_AutoSSH_QB), MakeButton(\"Backup Website\", Start_Localhost_QB), HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">qBittorrent</h2><h4 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">\" \\\n",
        "                    \"<a style=\\\"font-family:Trebuchet MS;color:#356ebf;\\\" href=\\\"http://\" + Random_URL_QB + \".serveo.net\\\" target=\\\"_blank\\\">Website</a></h4>\"))\n",
        "\n",
        "try:\n",
        "  try:\n",
        "    Random_URL_QB\n",
        "  except NameError:\n",
        "    Random_URL_QB = \"qb\" + RandomGenerator()\n",
        "    Port_QB = \"6006\"\n",
        "    display(MakeLabel(\"Installing in Progress\", \"warning\"))\n",
        "    get_ipython().system_raw(\"rm -rf /content/sample_data/ &\")\n",
        "  if os.path.isfile(\"/usr/bin/autossh\") == False:\n",
        "    get_ipython().system_raw(\"apt update -qq -y && apt install autossh -qq -y\")\n",
        "  if os.path.isfile(\"/usr/bin/qbittorrent-nox\") == False:\n",
        "    if Old_Version:\n",
        "      get_ipython().system_raw(\"apt install libtorrent-rasterbar9 -qq -y && wget -q https://launchpad.net/~qbittorrent-team/+archive/ubuntu/qbittorrent-stable/+build/17345008/+files/qbittorrent-nox_4.1.6.99~201907311051-6714-9c2a114~ubuntu18.04.1_amd64.deb -O /root/.qbittorrent-nox_4.1.6.deb && dpkg -i /root/.qbittorrent-nox_4.1.6.deb\")\n",
        "      # get_ipython().system_raw(\"apt install qbittorrent-nox=4.0.3-1 -qq -y\")\n",
        "    else:\n",
        "      get_ipython().system_raw(\"yes \"\" | add-apt-repository ppa:qbittorrent-team/qbittorrent-stable && apt install qbittorrent-nox -qq -y\")\n",
        "    get_ipython().system_raw(\"mkdir -p -m 666 /{content/qBittorrent,root/{.qBittorrent_temp,.config/qBittorrent}} && wget -q https://biplobsd.github.io/RLabClone/res/qbittorrent/qBittorrent.conf -O /root/.config/qBittorrent/qBittorrent.conf\")\n",
        "  Start_AutoSSH_QB()\n",
        "  Control_Panel_QB()\n",
        "except:\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"✘ Unsuccessfully\", \"danger\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8uUbyNZHi8a5",
        "colab_type": "text"
      },
      "source": [
        "# <img src='https://biplobsd.github.io/RLabClone/img/title_jdownloader.png' height=\"45\" alt=\"JDownloader\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mfg4A3KRjESb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Install JDownloader</h3>\n",
        "Login_Account = False #@param {type:\"boolean\"}\n",
        "import os, uuid, re, IPython\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from glob import glob\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output\n",
        "\n",
        "Email = widgets.Text(placeholder=\"*Required\", description=\"Email:\")\n",
        "Password = widgets.Text(placeholder=\"*Required\", description=\"Password:\")\n",
        "Device = widgets.Text(placeholder=\"Optional\", description=\"Name:\")\n",
        "SavePath = widgets.Dropdown(value=\"/content/Downloads\", options=[\"/content\", \"/content/Downloads\"], description=\"Save Path:\")\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback, style):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "    self._style = style\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    if self._style != \"\":\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "    else:\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "    template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RefreshPath():\n",
        "  if os.path.exists(\"/content/drive/\"):\n",
        "    if os.path.exists(\"/content/drive/Shared drives/\"):\n",
        "      SavePath.options = [\"/content\", \"/content/Downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\") + glob(\"/content/drive/Shared drives/*/\")\n",
        "    else:\n",
        "      SavePath.options = [\"/content\", \"/content/Downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\")\n",
        "  else:\n",
        "    SavePath.options = [\"/content\", \"/content/Downloads\"]\n",
        "\n",
        "def LoginForm():\n",
        "  clear_output(wait=True)\n",
        "  Email.value = \"daniel.dungngo@gmail.com\"\n",
        "  Password.value = \"ZjPNiqjL4e6ckwM\"\n",
        "  Device.value = \"\"\n",
        "  RefreshPath()\n",
        "  display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">If you don't have an account yet, please register <a href=\\\"https://my.jdownloader.org/login.html#register\\\" target=\\\"_blank\\\">here</a>.</h3>\"), HTML(\"<br>\"), Email, Password, Device, SavePath, MakeButton(\"Refresh\", RefreshPath, \"\"))\n",
        "  if not os.path.exists(\"/content/drive/\"):\n",
        "    display(HTML(\"*If you want to save in Google Drive please run the cell below.\"))\n",
        "  display(HTML(\"<br>\"), MakeButton(\"Login\", CheckLogin, \"info\"))\n",
        "  if os.path.isfile(\"/root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\"):\n",
        "    display(MakeButton(\"Cancel\", Show, \"danger\"))\n",
        "  \n",
        "def RestartForm():\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"Restart Confirm?\", \"\"), MakeButton(\"Confirm\", Restart, \"danger\"), MakeButton(\"Cancel\", Show, \"warning\"))\n",
        "  \n",
        "def ExitForm():\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"Exit Confirm?\", \"\"), MakeButton(\"Confirm\", Exit, \"danger\"), MakeButton(\"Cancel\", Show, \"warning\"))\n",
        "\n",
        "def CheckLogin():\n",
        "  try:\n",
        "    if not Email.value.strip():\n",
        "      ERROR = \"Email field is empty.\"\n",
        "      THROW_ERROR\n",
        "    if not \"@\" in Email.value and not \".\" in Email.value:\n",
        "      ERROR = \"Email is an incorrect format.\"\n",
        "      THROW_ERROR\n",
        "    if not Password.value.strip():\n",
        "      ERROR = \"Password field is empty.\"\n",
        "      THROW_ERROR\n",
        "    if not bool(re.match(\"^[a-zA-Z0-9]+$\", Device.value)) and Device.value.strip():\n",
        "      ERROR = \"Only alphanumeric are allowed for the device name.\"\n",
        "      THROW_ERROR\n",
        "    Login()\n",
        "  except:\n",
        "    print(ERROR)\n",
        "\n",
        "def Login():\n",
        "  clear_output(wait=True)\n",
        "  if SavePath.value == \"/content\":\n",
        "    get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"/content\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "  elif SavePath.value == \"/content/Downloads\":\n",
        "    get_ipython().system_raw(\"mkdir -p -m 666 /content/Downloads\")\n",
        "    get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"/content/Downloads\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "  else:\n",
        "    get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"\" + SavePath.value + \"\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "  if Device.value.strip() == \"\":\n",
        "    Device.value = Email.value\n",
        "  get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "  get_ipython().system_raw(\"echo '{\\\"email\\\" : \\\"'\" + Email.value + \"'\\\", \\\"password\\\" : \\\"'\" + Password.value + \"'\\\", \\\"devicename\\\" : \\\"'\" + Device.value + \"'\\\", \\\"directconnectmode\\\" : \\\"LAN\\\"}' > /root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\")\n",
        "  get_ipython().system_raw(\"java -jar /root/.JDownloader/JDownloader.jar -norestart -noerr -r &\")\n",
        "  Show()\n",
        "\n",
        "def Restart():\n",
        "  get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "  get_ipython().system_raw(\"java -jar /root/.JDownloader/JDownloader.jar -norestart -noerr -r &\")\n",
        "  Show()\n",
        "  \n",
        "def Exit():\n",
        "  get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "  clear_output(wait=True)\n",
        "  display(MakeButton(\"Start\", Restart, \"info\"))\n",
        "  \n",
        "def Show():\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"Control Panel\", \"\"), HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">You can login to the WebUI by clicking <a href=\\\"https://my.jdownloader.org/\\\" target=\\\"_blank\\\">here</a>.</h3>\"), HTML(\"<h4 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">If the server didn't showup in 30 sec. please re-login.</h4>\"), HTML(\"<br>\"), MakeButton(\"Re-Login\", LoginForm, \"info\"), MakeButton(\"Restart\", RestartForm, \"warning\"), MakeButton(\"Exit\", ExitForm, \"danger\"))\n",
        "\n",
        "def handleLogin():\n",
        "  if Login_Account:\n",
        "    LoginForm()\n",
        "  else:\n",
        "    get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "    get_ipython().system_raw(\"echo '{\\\"email\\\" : \\\"daniel.dungngo@gmail.com\\\", \\\"password\\\" : \\\"ZjPNiqjL4e6ckwM\\\", \\\"devicename\\\" : \\\"daniel.dungngo@gmail.com\\\", \\\"directconnectmode\\\" : \\\"LAN\\\"}' > /root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\")\n",
        "    get_ipython().system_raw(\"java -jar /root/.JDownloader/JDownloader.jar -norestart -noerr -r &\")\n",
        "    Show()\n",
        "\n",
        "if not os.path.isfile(\"/root/.JDownloader/JDownloader.jar\"):\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"Installing in Progress\", \"warning\"))\n",
        "  get_ipython().system_raw(\"rm -rf /content/sample_data/ && apt install openjdk-8-jre-headless -qq -y && mkdir -p -m 666 /root/.JDownloader/libs && wget -q http://installer.jdownloader.org/JDownloader.jar -O /root/.JDownloader/JDownloader.jar && java -jar /root/.JDownloader/JDownloader.jar -norestart -h && wget -q https://biplobsd.github.io/RLabClone/res/jdownloader/sevenzipjbinding1509.jar -O /root/.JDownloader/libs/sevenzipjbinding1509.jar && wget -q https://biplobsd.github.io/RLabClone/res/jdownloader/sevenzipjbinding1509Linux.jar -O /root/.JDownloader/libs/sevenzipjbinding1509Linux.jar\")\n",
        "  handleLogin()\n",
        "elif not os.path.isfile(\"/root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\"):\n",
        "  handleLogin()\n",
        "else:  \n",
        "  Show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X_o8umGH27Ke",
        "colab_type": "text"
      },
      "source": [
        "# <img src='https://biplobsd.github.io/RLabClone/img/title_youtube-dl.png' height=\"45\" alt=\"Youtube-DL\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v_bqZeo83e-S",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Use YouTube-DL</h3>\n",
        "#@markdown <h4>📝 Note: if you want to change an archive file just run this cell again.</h4>\n",
        "Archive = False #@param {type:\"boolean\"}\n",
        "\n",
        "import os, uuid, urllib.parse\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from glob import glob\n",
        "from urllib.parse import urlparse, parse_qs\n",
        "from IPython.display import HTML, clear_output, YouTubeVideo\n",
        "from IPython.utils.io import ask_yes_no\n",
        "from google.colab import output, files\n",
        "\n",
        "Links = widgets.Textarea(placeholder='''Video/Playlist Link\n",
        "(one link per line)''')\n",
        "\n",
        "VideoQ = widgets.Dropdown(options=[\"Best Quality (VP9 upto 4K)\", \"Best Compatibility (H.264 upto 1080p)\"])\n",
        "\n",
        "AudioQ = widgets.Dropdown(options=[\"Best Quality (Opus)\", \"Best Compatibility (M4A)\"])\n",
        "\n",
        "Subtitle = widgets.ToggleButton(value=True, description=\"Subtitle\", button_style=\"info\", tooltip=\"Subtitle\")\n",
        "\n",
        "SavePathYT = widgets.Dropdown(options=[\"/content\", \"/content/Downloads\"])\n",
        "\n",
        "AudioOnly = widgets.ToggleButton(value=False, description=\"Audio Only\", button_style=\"\", tooltip=\"Audio Only\")\n",
        "\n",
        "Resolution = widgets.Select(options=[\"Highest\", \"4K\", \"1440p\", \"1080p\", \"720p\", \"480p\", \"360p\", \"240p\", \"144p\"], value=\"Highest\")\n",
        "\n",
        "Extension = widgets.Select(options=[\"mkv\", \"webm\"], value=\"mkv\")\n",
        "\n",
        "UsernameYT = widgets.Text(placeholder=\"Username\")\n",
        "\n",
        "PasswordYT = widgets.Text(placeholder=\"Password\")\n",
        "\n",
        "SecAuth = widgets.Text(placeholder=\"2nd Factor Authentication\")\n",
        "\n",
        "VideoPW = widgets.Text(placeholder=\"Video Password\")\n",
        "\n",
        "GEOBypass = widgets.Dropdown(options=[\"Disable\", \"Hide\", \"AD\", \"AE\", \"AF\", \"AG\", \"AI\", \"AL\", \"AM\", \"AO\", \"AQ\", \"AR\", \"AS\", \"AT\", \"AU\", \"AW\", \"AX\", \"AZ\", \"BA\", \"BB\", \"BD\", \"BE\", \"BF\", \"BG\", \"BH\", \"BI\", \"BJ\", \"BL\", \"BM\", \"BN\", \"BO\", \"BQ\", \"BR\", \"BS\", \"BT\", \"BV\", \"BW\", \"BY\", \"BZ\", \"CA\", \"CC\", \"CD\", \"CF\", \"CG\", \"CH\", \"CI\", \"CK\", \"CL\", \"CM\", \"CN\", \"CO\", \"CR\", \"CU\", \"CV\", \"CW\", \"CX\", \"CY\", \"CZ\", \"DE\", \"DJ\", \"DK\", \"DM\", \"DO\", \"DZ\", \"EC\", \"EE\", \"EG\", \"EH\", \"ER\", \"ES\", \"ET\", \"FI\", \"FJ\", \"FK\", \"FM\", \"FO\", \"FR\", \"GA\", \"GB\", \"GD\", \"GE\", \"GF\", \"GG\", \"GH\", \"GI\", \"GL\", \"GM\", \"GN\", \"GP\", \"GQ\", \"GR\", \"GS\", \"GT\", \"GU\", \"GW\", \"GY\", \"HK\", \"HM\", \"HN\", \"HR\", \"HT\", \"HU\", \"ID\", \"IE\", \"IL\", \"IM\", \"IN\", \"IO\", \"IQ\", \"IR\", \"IS\", \"IT\", \"JE\", \"JM\", \"JO\", \"JP\", \"KE\", \"KG\", \"KH\", \"KI\", \"KM\", \"KN\", \"KP\", \"KR\", \"KW\", \"KY\", \"KZ\", \"LA\", \"LB\", \"LC\", \"LI\", \"LK\", \"LR\", \"LS\", \"LT\", \"LU\", \"LV\", \"LY\", \"MA\", \"MC\", \"MD\", \"ME\", \"MF\", \"MG\", \"MH\", \"MK\", \"ML\", \"MM\", \"MN\", \"MO\", \"MP\", \"MQ\", \"MR\", \"MS\", \"MT\", \"MU\", \"MV\", \"MW\", \"MX\", \"MY\", \"MZ\", \"NA\", \"NC\", \"NE\", \"NF\", \"NG\", \"NI\", \"NL\", \"NO\", \"NP\", \"NR\", \"NU\", \"NZ\", \"OM\", \"PA\", \"PE\", \"PF\", \"PG\", \"PH\", \"PK\", \"PL\", \"PM\", \"PN\", \"PR\", \"PS\", \"PT\", \"PW\", \"PY\", \"QA\", \"RE\", \"RO\", \"RS\", \"RU\", \"RW\", \"SA\", \"SB\", \"SC\", \"SD\", \"SE\", \"SG\", \"SH\", \"SI\", \"SJ\", \"SK\", \"SL\", \"SM\", \"SN\", \"SO\", \"SR\", \"SS\", \"ST\", \"SV\", \"SX\", \"SY\", \"SZ\", \"TC\", \"TD\", \"TF\", \"TG\", \"TH\", \"TJ\", \"TK\", \"TL\", \"TM\", \"TN\", \"TO\", \"TR\", \"TT\", \"TV\", \"TW\", \"TZ\", \"UA\", \"UG\", \"UM\", \"US\", \"UY\", \"UZ\", \"VA\", \"VC\", \"VE\", \"VG\", \"VI\", \"VN\", \"VU\", \"WF\", \"WS\", \"YE\", \"YT\", \"ZA\", \"ZM\", \"ZW\"])\n",
        "\n",
        "ProxyYT = widgets.Text(placeholder=\"Proxy URL\")\n",
        "\n",
        "MinSleep = widgets.BoundedIntText(value=0, min=0, max=300, step=1, description=\"Min:\")\n",
        "\n",
        "MaxSleep = widgets.BoundedIntText(value=0, min=0, max=300, step=1, description=\"Max:\")\n",
        "\n",
        "ExtraArg = widgets.Text(placeholder=\"Extra Arguments\")\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback, style):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "    self._style = style\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    if self._style != \"\":\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "    else:\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "    template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def upload_archive():\n",
        "  if ask_yes_no(\"Do you already have an archive file? (y/n)\", default=\"\", interrupt=\"\"):\n",
        "    try:\n",
        "      display(HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Please upload an archive from your computer.</h2><br>\"))\n",
        "      UploadConfig = files.upload().keys()\n",
        "      clear_output(wait=True)\n",
        "      if len(UploadConfig) == 0:\n",
        "        return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">File upload has been cancelled during upload file.</h2><br></center>\"))\n",
        "      elif len(UploadConfig) == 1:\n",
        "        for fn in UploadConfig:\n",
        "          if os.path.isfile(\"/content/\" + fn):\n",
        "            get_ipython().system_raw(\"mv -f \" + \"\\\"\" + fn + \"\\\" /root/.youtube-dl.txt && chmod 666 /root/.youtube-dl.txt\")\n",
        "            AudioOnly.observe(AudioOnlyChange)\n",
        "            Subtitle.observe(SubtitleChange)\n",
        "            AudioQ.observe(AudioQChange)\n",
        "            ShowYT()\n",
        "          else:\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">File upload has been failed during upload file.</h2><br></center>\"))\n",
        "      else:\n",
        "        for fn in UploadConfig:\n",
        "          get_ipython().system_raw(\"rm -f \" + \"\\\"\" + fn + \"\\\"\")\n",
        "        return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Please uploading only one file at a time.</h2><br></center>\"))\n",
        "    except:\n",
        "      clear_output(wait=True)\n",
        "      return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Error occurred during upload file.</h2><br></center>\"))\n",
        "  else:\n",
        "    get_ipython().system_raw(\"touch '/root/.youtube-dl.txt'\")\n",
        "    AudioOnly.observe(AudioOnlyChange)\n",
        "    Subtitle.observe(SubtitleChange)\n",
        "    AudioQ.observe(AudioQChange)\n",
        "    ShowYT()\n",
        "\n",
        "def RefreshPathYT():\n",
        "  if os.path.exists(\"/content/drive/\"):\n",
        "    if os.path.exists(\"/content/drive/Shared drives/\"):\n",
        "      SavePathYT.options = [\"/content\", \"/content/Downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\") + glob(\"/content/drive/Shared drives/*/\")\n",
        "    else:\n",
        "      SavePathYT.options = [\"/content\", \"/content/Downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\")\n",
        "  else:\n",
        "    SavePathYT.options = [\"/content\", \"/content/Downloads\"]\n",
        "\n",
        "def AudioOnlyChange(change):\n",
        "  if change[\"type\"] == \"change\" and change[\"new\"]:\n",
        "    VideoQ.disabled = True\n",
        "    Subtitle.disabled = True\n",
        "    if Subtitle.value:\n",
        "      Subtitle.button_style = \"info\"\n",
        "    else:\n",
        "      Subtitle.button_style = \"\"\n",
        "    Resolution.disabled = True\n",
        "    Extension.options = [\"best\", \"aac\", \"flac\", \"mp3\", \"m4a\", \"opus\", \"vorbis\", \"wav\"]\n",
        "    Extension.value = \"best\"\n",
        "    AudioOnly.button_style = \"info\"\n",
        "  elif change[\"type\"] == \"change\" and change[\"new\"] == False:\n",
        "    VideoQ.disabled = False\n",
        "    Subtitle.disabled = False\n",
        "    if Subtitle.value:\n",
        "      Subtitle.button_style = \"info\"\n",
        "    else:\n",
        "      Subtitle.button_style = \"\"\n",
        "    Resolution.disabled = False\n",
        "    if AudioQ.value == \"Best Quality (Opus)\":\n",
        "      Extension.options = [\"mkv\", \"webm\"]\n",
        "    else:\n",
        "      Extension.options = [\"mkv\", \"mp4\", \"webm\"]\n",
        "    Extension.value = \"mkv\"\n",
        "    AudioOnly.button_style = \"\"\n",
        "\n",
        "def SubtitleChange(change):\n",
        "  if change[\"type\"] == \"change\" and change[\"new\"]:\n",
        "    Subtitle.button_style = \"info\"\n",
        "  elif change[\"type\"] == \"change\" and change[\"new\"] == False:\n",
        "    Subtitle.button_style = \"\"\n",
        "\n",
        "def AudioQChange(change):\n",
        "  if change[\"type\"] == \"change\" and change[\"new\"] == \"Best Quality (Opus)\":\n",
        "    Extension.options = [\"mkv\", \"webm\"]\n",
        "    Extension.value = \"mkv\"\n",
        "  elif change[\"type\"] == \"change\" and change[\"new\"] == \"Best Compatibility (M4A)\":\n",
        "    Extension.options = [\"mkv\", \"mp4\", \"webm\"]\n",
        "    Extension.value = \"mkv\"\n",
        "\n",
        "def ShowYT():\n",
        "  clear_output(wait=True)\n",
        "  RefreshPathYT()\n",
        "  display(widgets.HBox([widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Link:</b>\"), Links,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">For website that require an account:</b>\"), UsernameYT, PasswordYT, SecAuth, VideoPW,\n",
        "                                      widgets.HTML(\"<b><a href=\\\"https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements\\\" target=\\\"_blank\\\">GEO Bypass Country:</a></b>\"), GEOBypass,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Proxy:</b>\"), ProxyYT,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Sleep Interval (second):</b>\"), MinSleep, MaxSleep]),\n",
        "                        widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Video Quality:</b>\"), VideoQ, widgets.HTML(\"<b style=\\\"color:#888888;\\\">Resolution:</b>\"), Resolution,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Audio Quality:</b>\"), AudioQ, widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extension:</b>\"), Extension,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extra Options:</b>\"), widgets.HBox([Subtitle, AudioOnly]),\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extra Arguments:</b>\"), ExtraArg])]), HTML(\"<h4 style=\\\"color:#888888;\\\">Save Location:</h4>\"),\n",
        "          SavePathYT, MakeButton(\"Refresh\", RefreshPathYT, \"\"))\n",
        "  if not os.path.exists(\"/content/drive/\"):\n",
        "    display(HTML(\"*If you want to save in Google Drive please run the cell below.\"))\n",
        "  display(HTML(\"<br>\"), MakeButton(\"Download\", DownloadYT, \"info\"))\n",
        "\n",
        "def DownloadYT():\n",
        "  if Links.value.strip():\n",
        "    Count = 0\n",
        "    Total = str(len(Links.value.splitlines()))\n",
        "    # Account Check\n",
        "    if UsernameYT.value.strip() and PasswordYT.value.strip():\n",
        "      accountC = \"--username \\\"\" + UsernameYT.value + \"\\\" --password \\\"\" + PasswordYT.value + \"\\\"\"\n",
        "    else:\n",
        "      accountC = \"\"\n",
        "    if SecAuth.value.strip():\n",
        "      secauthC = \"-2 \" + SecAuth.value\n",
        "    else:\n",
        "      secauthC = \"\"\n",
        "    if VideoPW.value.strip():\n",
        "      videopwC = \"--video-password \" + VideoPW.value\n",
        "    else:\n",
        "      videopwC = \"\"\n",
        "    # Proxy\n",
        "    if ProxyYT.value.strip():\n",
        "      proxyytC = \"--proxy \" + ProxyYT.value\n",
        "    else:\n",
        "      proxyytC = \"\"\n",
        "    # GEO Bypass\n",
        "    if GEOBypass.value == \"Disable\":\n",
        "      geobypass = \"\"\n",
        "    elif GEOBypass.value == \"Hide\":\n",
        "      geobypass = \"--geo-bypass\"\n",
        "    else:\n",
        "      geobypass = \"--geo-bypass-country \" + GEOBypass.value\n",
        "    # Video Quality\n",
        "    if VideoQ.value == \"Best Quality (VP9 upto 4K)\":\n",
        "      videoqC = \"webm\"\n",
        "    else:\n",
        "      videoqC = \"mp4\"\n",
        "    # Audio Quality\n",
        "    if AudioQ.value == \"Best Quality (Opus)\":\n",
        "      audioqC = \"webm\"\n",
        "    else:\n",
        "      audioqC = \"m4a\"\n",
        "    # Audio Only Check\n",
        "    if AudioOnly.value:\n",
        "      subtitleC = \"\"\n",
        "      thumbnailC = \"\"\n",
        "      extC = \"-x --audio-quality 0 --audio-format \" + Extension.value\n",
        "      codecC = \"bestaudio[ext=\" + audioqC + \"]/bestaudio/best\"\n",
        "    else:\n",
        "      if Subtitle.value:\n",
        "        subtitleC = \"--all-subs --convert-subs srt --embed-subs\"\n",
        "      else:\n",
        "        subtitleC = \"\"\n",
        "      if Extension.value == \"mp4\":\n",
        "        thumbnailC = \"--embed-thumbnail\"\n",
        "      else:\n",
        "        thumbnailC = \"\"\n",
        "      extC = \"--merge-output-format \" + Extension.value\n",
        "      if Resolution.value == \"Highest\":\n",
        "        codecC = \"bestvideo[ext=\" + videoqC + \"]+bestaudio[ext=\" + audioqC + \"]/bestvideo+bestaudio/best\"\n",
        "      else:\n",
        "        codecC = \"bestvideo[ext=\" + videoqC + \",height<=\" + Resolution.value.replace(\"4K\", \"2160\").replace(\"p\", \"\") + \"]+bestaudio[ext=\" + audioqC + \"]/bestvideo[height<=\" + Resolution.value.replace(\"4K\", \"2160\").replace(\"p\", \"\") + \"]+bestaudio/bestvideo+bestaudio/best\"\n",
        "    # Archive\n",
        "    if os.path.isfile(\"/root/.youtube-dl.txt\"):\n",
        "      archiveC = \"--download-archive \\\"/root/.youtube-dl.txt\\\"\"\n",
        "    else:\n",
        "      archiveC = \"\"\n",
        "    # Sleep Interval\n",
        "    if MinSleep.value > 0 and MaxSleep.value > 0:\n",
        "      minsleepC = \"--min-sleep-interval \" + MinSleep.value\n",
        "      maxsleepC = \"--max-sleep-interval \" + MaxSleep.value\n",
        "    else:\n",
        "      minsleepC = \"\"\n",
        "      maxsleepC = \"\"\n",
        "    # Extra Arguments\n",
        "    extraargC = ExtraArg.value\n",
        "    for Link in Links.value.splitlines():\n",
        "      clear_output(wait=True)\n",
        "      Count += 1\n",
        "      display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Processing link \" + str(Count) + \" out of \" + Total + \"</h3>\"))\n",
        "      if \"youtube.com\" in Link or \"youtu.be\" in Link:\n",
        "        display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Currently downloading...</h3><br>\"), YouTubeVideo(Link, width=640, height=360), HTML(\"<br>\"))\n",
        "      else:\n",
        "        display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Currently downloading <a href=\\\"\" + Link + \"\\\">\" + Link + \"</a></h3><br>\"))\n",
        "      if (\"youtube.com\" in Link or \"youtu.be\" in Link) and \"list=\" in Link:\n",
        "        !youtube-dl -i --no-warnings --yes-playlist --add-metadata $accountC $secauthC $videopwC $minsleepC $maxsleepC $geobypass $proxyytC $extC $thumbnailC $subtitleC $archiveC $extraargC -f \"$codecC\" -o \"/root/.YouTube-DL/%(playlist)s/%(playlist_index)s - %(title)s.%(ext)s\" \"$Link\"\n",
        "      else:\n",
        "        !youtube-dl -i --no-warnings --yes-playlist --add-metadata $accountC $secauthC $videopwC $minsleepC $maxsleepC $geobypass $proxyytC $extC $thumbnailC $subtitleC $archiveC $extraargC -f \"$codecC\" -o \"/root/.YouTube-DL/%(title)s.%(ext)s\" \"$Link\"\n",
        "      if not os.path.exists(SavePathYT.value):\n",
        "        get_ipython().system_raw(\"mkdir -p -m 666 \" + SavePathYT.value)\n",
        "      get_ipython().system_raw(\"mv /root/.YouTube-DL/* '\" + SavePathYT.value + \"/'\")\n",
        "    # Archive Download\n",
        "    if os.path.isfile(\"/root/.youtube-dl.txt\"):\n",
        "      files.download(\"/root/.youtube-dl.txt\")\n",
        "    ShowYT()\n",
        "\n",
        "if not os.path.isfile(\"/usr/local/bin/youtube-dl\"):\n",
        "  get_ipython().system_raw(\"rm -rf /content/sample_data/ && mkdir -p -m 666 /root/.YouTube-DL/ && apt-get install atomicparsley && curl -L https://yt-dl.org/downloads/latest/youtube-dl -o /usr/local/bin/youtube-dl && chmod a+rx /usr/local/bin/youtube-dl\")\n",
        "if Archive:\n",
        "  upload_archive()\n",
        "else:\n",
        "  AudioOnly.observe(AudioOnlyChange)\n",
        "  Subtitle.observe(SubtitleChange)\n",
        "  AudioQ.observe(AudioQChange)\n",
        "  ShowYT()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "5-5ksQslqmYy"
      },
      "source": [
        "# <img src='https://biplobsd.github.io/RLabClone/img/title_utility.png' height=\"45\" alt=\"Utility\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y2-AxI9xJOFC",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Mount Google Drive</h3>\n",
        "import os, uuid; import ipywidgets as widgets\n",
        "from IPython.display import clear_output\n",
        "from google.colab import drive, output\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback, style):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "    self._style = style\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    if self._style != \"\":\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "    else:\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "    template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "    \n",
        "def DemountForm():\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"Demount Confirm?\", \"\"), MakeButton(\"Confirm\", Demount, \"danger\"), MakeButton(\"Cancel\", ShowGD, \"warning\"))\n",
        "    \n",
        "def Demount():\n",
        "  clear_output(wait=True)\n",
        "  get_ipython().system_raw(\"pkill -9 -e -f drive\")\n",
        "  !rm -rf /root/.config/Google/DriveFS/\n",
        "  !echo \"If you want to mount Google Drive run this cell again.\"\n",
        "  \n",
        "def ShowGD():\n",
        "  try:\n",
        "    RefreshPath()\n",
        "  except:\n",
        "    clear_output(wait=True)\n",
        "  display(MakeLabel(\"Control Panel\", \"\"), MakeButton(\"Demount\", DemountForm, \"danger\"))\n",
        "\n",
        "while not os.path.exists(\"/content/drive\"):\n",
        "  try:\n",
        "    drive.mount(\"/content/drive\")\n",
        "    clear_output(wait=True)\n",
        "  except:\n",
        "    clear_output(wait=True)\n",
        "    \n",
        "ShowGD()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "okRRPq_htqmR",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3>⬅️ Install netdata (Real-time Server Monitoring)</h3>\n",
        "#@markdown <br><center><img src='https://biplobsd.github.io/RLabClone/img/title_netdata.png' height=\"60\" alt=\"netdata\"/></center>\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, IPython, uuid, time\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    template = \"\"\"<button class=\"p-Widget jupyter-widgets jupyter-button widget-button mod-info\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id)\n",
        "    return html\n",
        "\n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RandomGenerator():\n",
        "  return time.strftime(\"%S\") + str(time.time()).split(\".\")[-1]\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "\n",
        "def AutoSSH(name,port):\n",
        "  get_ipython().system_raw(\"autossh -M 0 -fNT -o 'StrictHostKeyChecking=no' -o 'ServerAliveInterval 300' -o 'ServerAliveCountMax 30' -R \" + name + \":80:localhost:\" + port + \" serveo.net &\")\n",
        "\n",
        "def Start_AutoSSH_ND():\n",
        "  if CheckProcess(\"netdata\", \"\") != True:\n",
        "    get_ipython().system_raw(\"/usr/sbin/netdata\")\n",
        "  if CheckProcess(\"autossh\", Random_URL_ND) != True:\n",
        "      AutoSSH(Random_URL_ND, Port_ND)\n",
        "\n",
        "def Start_Localhost_ND():\n",
        "  try:\n",
        "    clear_output(wait=True)\n",
        "    !autossh -l $Random_URL_ND -M 0 -o 'StrictHostKeyChecking=no' -o 'ServerAliveInterval 300' -o 'ServerAliveCountMax 30' -R 80:localhost:$Port_ND ssh.localhost.run\n",
        "  except:\n",
        "    Control_Panel_CC()\n",
        "  Control_Panel_CC()\n",
        "\n",
        "def Control_Panel_ND():\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"✔ Successfully\", \"success\"), MakeButton(\"Recheck\", Start_AutoSSH_ND), MakeButton(\"Backup Website\", Start_Localhost_ND), HTML(\"<h4 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">\" \\\n",
        "                    \"<a style=\\\"font-family:Trebuchet MS;color:#356ebf;\\\" href=\\\"https://\" + Random_URL_ND + \".serveo.net/#theme=slate;update_always=true\\\" target=\\\"_blank\\\">Website</a></h4>\"))\n",
        "\n",
        "try:\n",
        "  try:\n",
        "    Random_URL_ND\n",
        "  except NameError:\n",
        "    Random_URL_ND = \"nd\" + RandomGenerator()\n",
        "    Port_ND = \"19999\"\n",
        "    display(MakeLabel(\"Installing in Progress\", \"warning\"))\n",
        "  if os.path.isfile(\"/usr/bin/autossh\") == False:\n",
        "    get_ipython().system_raw(\"apt update -qq -y && apt install autossh -qq -y\")\n",
        "  if os.path.isfile(\"/usr/sbin/netdata\") == False:\n",
        "    get_ipython().system_raw(\"bash <(curl -Ss https://my-netdata.io/kickstart.sh) --dont-wait --dont-start-it\")\n",
        "  Start_AutoSSH_ND()\n",
        "  Control_Panel_ND()\n",
        "except:\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"✘ Unsuccessfully\", \"danger\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cz4yU58HwTgb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Install Cloud Commander (file manager)</h3>\n",
        "#@markdown <br><center><img src='https://biplobsd.github.io/RLabClone/img/title_cloud_commander.png' height=\"60\" alt=\"netdata\"/></center>\n",
        "\n",
        "import os, psutil, IPython, uuid, time\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    template = \"\"\"<button class=\"p-Widget jupyter-widgets jupyter-button widget-button mod-info\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RandomGenerator():\n",
        "  return time.strftime(\"%S\") + str(time.time()).split(\".\")[-1]\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "  \n",
        "def AutoSSH(name,port):\n",
        "  get_ipython().system_raw(\"autossh -M 0 -fNT -o 'StrictHostKeyChecking=no' -o 'ServerAliveInterval 300' -o 'ServerAliveCountMax 30' -R \" + name + \":80:localhost:\" + port + \" serveo.net &\")\n",
        "\n",
        "def Start_AutoSSH_CC():\n",
        "  if CheckProcess(\"cloudcmd\", \"\") != True:\n",
        "    get_ipython().system_raw(\"cloudcmd --online --no-auth --show-config --show-file-name --editor 'deepword' --packer 'tar' --port $Port_CC --progress --no-confirm-copy --confirm-move --name 'RcloneLab File Manager' --keys-panel --no-contact --console --sync-console-path --no-terminal --no-vim --columns 'name-size-date' --no-log &\")\n",
        "  if CheckProcess(\"autossh\", Random_URL_CC) != True:\n",
        "    AutoSSH(Random_URL_CC, Port_CC)\n",
        "\n",
        "def Start_Localhost_CC():\n",
        "  try:\n",
        "    clear_output(wait=True)\n",
        "    !pkill autossh\n",
        "    !autossh -l $Random_URL_CC -M 0 -o 'StrictHostKeyChecking=no' -o 'ServerAliveInterval 300' -o 'ServerAliveCountMax 30' -R 80:localhost:$Port_CC ssh.localhost.run\n",
        "  except:\n",
        "    Control_Panel_CC()\n",
        "  Control_Panel_CC()\n",
        "\n",
        "def Control_Panel_CC():\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"✔ Successfully\", \"success\"), MakeButton(\"Recheck\", Start_AutoSSH_CC), MakeButton(\"Backup Website\", Start_Localhost_CC), HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">File Manager</h2><h4 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">\" \\\n",
        "                    \"<a style=\\\"font-family:Trebuchet MS;color:#356ebf;\\\" href=\\\"https://\" + Random_URL_CC + \".serveo.net/fs/content/\\\" target=\\\"_blank\\\">Website</a></h3>\"))\n",
        "\n",
        "try:\n",
        "  try:\n",
        "    Random_URL_CC\n",
        "  except NameError:\n",
        "    Random_URL_CC = \"cc\" + RandomGenerator()\n",
        "    Port_CC = \"7007\"\n",
        "    display(MakeLabel('Installing in Progress', 'warning'))\n",
        "  if os.path.isfile(\"/tools/node/bin/cloudcmd\") == False:\n",
        "    get_ipython().system_raw(\"rm -rf /content/sample_data/ && npm i -g npm && npm i cloudcmd -g\")\n",
        "  if os.path.isfile(\"/usr/bin/autossh\") == False:\n",
        "    get_ipython().system_raw(\"apt update -qq -y && apt install autossh -qq -y\")\n",
        "  Start_AutoSSH_CC()\n",
        "  Control_Panel_CC()\n",
        "except:\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"✘ Unsuccessfully\", \"danger\")) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "O-jIeNjdbkOQ",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3>⬅️ Check VM's Status</h3>\n",
        "Check_IP = True #@param {type:\"boolean\"}\n",
        "Loop_Check = False #@param {type:\"boolean\"}\n",
        "Loop_Interval = 15 #@param {type:\"slider\", min:1, max:15, step:1}\n",
        "# ================================================================ #\n",
        "\n",
        "import time, requests\n",
        "from IPython.display import clear_output\n",
        "Loop = True\n",
        "\n",
        "try:\n",
        "  while Loop == True:\n",
        "    clear_output(wait=True)\n",
        "    if Check_IP: print(\"\\nYour Public IP: \" + requests.get('http://ip.42.pl/raw').text)\n",
        "    print(\"====\")\n",
        "    !du -sh /content /root/.qBittorrent_temp/\n",
        "    print(\"====\")\n",
        "    !top -bcn1 -w512\n",
        "    if Loop_Check == False:\n",
        "      Loop = False\n",
        "    else:\n",
        "      time.sleep(Loop_Interval)\n",
        "except:\n",
        "  clear_output()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M4tD3PEMEOH9",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3>⬅️ Get VM's Specification</h3>\n",
        "Output_Format = \"TEXT\" #@param [\"TEXT\", \"HTML\", \"XML\", \"JSON\"]\n",
        "Short_Output = True #@param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os\n",
        "from google.colab import files\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "try:\n",
        "  Output_Format_Ext\n",
        "except NameError:\n",
        "  get_ipython().system_raw(\"apt install lshw -qq -y\")\n",
        "\n",
        "if Short_Output:\n",
        "  Output_Format = \"txt\"\n",
        "  Output_Format2 = \"-short\"\n",
        "  Output_Format_Ext = \"txt\"\n",
        "elif Output_Format == \"TEXT\":\n",
        "  Output_Format = \"txt\"\n",
        "  Output_Format2 = \"\"\n",
        "  Output_Format_Ext = \"txt\"\n",
        "else:\n",
        "  Output_Format = Output_Format.lower()\n",
        "  Output_Format2 = \"-\"+Output_Format.lower()\n",
        "  Output_Format_Ext = Output_Format.lower()\n",
        "\n",
        "get_ipython().system_raw(\"lshw \" + Output_Format2 + \" > Specification.\" + Output_Format)\n",
        "files.download(\"/content/Specification.\" + Output_Format_Ext)\n",
        "get_ipython().system_raw(\"rm -f /content/Specification.$outputformatC\")\n",
        "display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Sending log to your browser...</h2><br></center>\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bwrd7yzxR3dX",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Speedtest</h3>\n",
        "#@markdown <h4>📝 Note: Rerun this cell to test.</h4>\n",
        "import os\n",
        "import re\n",
        "import csv\n",
        "import sys\n",
        "import math\n",
        "import errno\n",
        "import signal\n",
        "import socket\n",
        "import timeit\n",
        "import datetime\n",
        "import platform\n",
        "import threading\n",
        "import xml.parsers.expat\n",
        "\n",
        "try:\n",
        "    import gzip\n",
        "    GZIP_BASE = gzip.GzipFile\n",
        "except ImportError:\n",
        "    gzip = None\n",
        "    GZIP_BASE = object\n",
        "\n",
        "__version__ = '2.1.1'\n",
        "\n",
        "\n",
        "class FakeShutdownEvent(object):\n",
        "    \"\"\"Class to fake a threading.Event.isSet so that users of this module\n",
        "    are not required to register their own threading.Event()\n",
        "    \"\"\"\n",
        "\n",
        "    @staticmethod\n",
        "    def isSet():\n",
        "        \"Dummy method to always return false\"\"\"\n",
        "        return False\n",
        "\n",
        "\n",
        "# Some global variables we use\n",
        "DEBUG = False\n",
        "_GLOBAL_DEFAULT_TIMEOUT = object()\n",
        "\n",
        "# Begin import game to handle Python 2 and Python 3\n",
        "try:\n",
        "    import json\n",
        "except ImportError:\n",
        "    try:\n",
        "        import simplejson as json\n",
        "    except ImportError:\n",
        "        json = None\n",
        "\n",
        "try:\n",
        "    import xml.etree.cElementTree as ET\n",
        "except ImportError:\n",
        "    try:\n",
        "        import xml.etree.ElementTree as ET\n",
        "    except ImportError:\n",
        "        from xml.dom import minidom as DOM\n",
        "        from xml.parsers.expat import ExpatError\n",
        "        ET = None\n",
        "\n",
        "try:\n",
        "    from urllib2 import (urlopen, Request, HTTPError, URLError,\n",
        "                         AbstractHTTPHandler, ProxyHandler,\n",
        "                         HTTPDefaultErrorHandler, HTTPRedirectHandler,\n",
        "                         HTTPErrorProcessor, OpenerDirector)\n",
        "except ImportError:\n",
        "    from urllib.request import (urlopen, Request, HTTPError, URLError,\n",
        "                                AbstractHTTPHandler, ProxyHandler,\n",
        "                                HTTPDefaultErrorHandler, HTTPRedirectHandler,\n",
        "                                HTTPErrorProcessor, OpenerDirector)\n",
        "\n",
        "try:\n",
        "    from httplib import HTTPConnection, BadStatusLine\n",
        "except ImportError:\n",
        "    from http.client import HTTPConnection, BadStatusLine\n",
        "\n",
        "try:\n",
        "    from httplib import HTTPSConnection\n",
        "except ImportError:\n",
        "    try:\n",
        "        from http.client import HTTPSConnection\n",
        "    except ImportError:\n",
        "        HTTPSConnection = None\n",
        "\n",
        "try:\n",
        "    from httplib import FakeSocket\n",
        "except ImportError:\n",
        "    FakeSocket = None\n",
        "\n",
        "try:\n",
        "    from Queue import Queue\n",
        "except ImportError:\n",
        "    from queue import Queue\n",
        "\n",
        "try:\n",
        "    from urlparse import urlparse\n",
        "except ImportError:\n",
        "    from urllib.parse import urlparse\n",
        "\n",
        "try:\n",
        "    from urlparse import parse_qs\n",
        "except ImportError:\n",
        "    try:\n",
        "        from urllib.parse import parse_qs\n",
        "    except ImportError:\n",
        "        from cgi import parse_qs\n",
        "\n",
        "try:\n",
        "    from hashlib import md5\n",
        "except ImportError:\n",
        "    from md5 import md5\n",
        "\n",
        "try:\n",
        "    from argparse import ArgumentParser as ArgParser\n",
        "    from argparse import SUPPRESS as ARG_SUPPRESS\n",
        "    PARSER_TYPE_INT = int\n",
        "    PARSER_TYPE_STR = str\n",
        "    PARSER_TYPE_FLOAT = float\n",
        "except ImportError:\n",
        "    from optparse import OptionParser as ArgParser\n",
        "    from optparse import SUPPRESS_HELP as ARG_SUPPRESS\n",
        "    PARSER_TYPE_INT = 'int'\n",
        "    PARSER_TYPE_STR = 'string'\n",
        "    PARSER_TYPE_FLOAT = 'float'\n",
        "\n",
        "try:\n",
        "    from cStringIO import StringIO\n",
        "    BytesIO = None\n",
        "except ImportError:\n",
        "    try:\n",
        "        from StringIO import StringIO\n",
        "        BytesIO = None\n",
        "    except ImportError:\n",
        "        from io import StringIO, BytesIO\n",
        "\n",
        "try:\n",
        "    import __builtin__\n",
        "except ImportError:\n",
        "    import builtins\n",
        "    from io import TextIOWrapper, FileIO\n",
        "\n",
        "    class _Py3Utf8Output(TextIOWrapper):\n",
        "        \"\"\"UTF-8 encoded wrapper around stdout for py3, to override\n",
        "        ASCII stdout\n",
        "        \"\"\"\n",
        "        def __init__(self, f, **kwargs):\n",
        "            buf = FileIO(f.fileno(), 'w')\n",
        "            super(_Py3Utf8Output, self).__init__(\n",
        "                buf,\n",
        "                encoding='utf8',\n",
        "                errors='strict'\n",
        "            )\n",
        "\n",
        "        def write(self, s):\n",
        "            super(_Py3Utf8Output, self).write(s)\n",
        "            self.flush()\n",
        "\n",
        "    _py3_print = getattr(builtins, 'print')\n",
        "    try:\n",
        "        _py3_utf8_stdout = _Py3Utf8Output(sys.stdout)\n",
        "        _py3_utf8_stderr = _Py3Utf8Output(sys.stderr)\n",
        "    except OSError:\n",
        "        # sys.stdout/sys.stderr is not a compatible stdout/stderr object\n",
        "        # just use it and hope things go ok\n",
        "        _py3_utf8_stdout = sys.stdout\n",
        "        _py3_utf8_stderr = sys.stderr\n",
        "\n",
        "    def to_utf8(v):\n",
        "        \"\"\"No-op encode to utf-8 for py3\"\"\"\n",
        "        return v\n",
        "\n",
        "    def print_(*args, **kwargs):\n",
        "        \"\"\"Wrapper function for py3 to print, with a utf-8 encoded stdout\"\"\"\n",
        "        if kwargs.get('file') == sys.stderr:\n",
        "            kwargs['file'] = _py3_utf8_stderr\n",
        "        else:\n",
        "            kwargs['file'] = kwargs.get('file', _py3_utf8_stdout)\n",
        "        _py3_print(*args, **kwargs)\n",
        "else:\n",
        "    del __builtin__\n",
        "\n",
        "    def to_utf8(v):\n",
        "        \"\"\"Encode value to utf-8 if possible for py2\"\"\"\n",
        "        try:\n",
        "            return v.encode('utf8', 'strict')\n",
        "        except AttributeError:\n",
        "            return v\n",
        "\n",
        "    def print_(*args, **kwargs):\n",
        "        \"\"\"The new-style print function for Python 2.4 and 2.5.\n",
        "        Taken from https://pypi.python.org/pypi/six/\n",
        "        Modified to set encoding to UTF-8 always, and to flush after write\n",
        "        \"\"\"\n",
        "        fp = kwargs.pop(\"file\", sys.stdout)\n",
        "        if fp is None:\n",
        "            return\n",
        "\n",
        "        def write(data):\n",
        "            if not isinstance(data, basestring):\n",
        "                data = str(data)\n",
        "            # If the file has an encoding, encode unicode with it.\n",
        "            encoding = 'utf8'  # Always trust UTF-8 for output\n",
        "            if (isinstance(fp, file) and\n",
        "                    isinstance(data, unicode) and\n",
        "                    encoding is not None):\n",
        "                errors = getattr(fp, \"errors\", None)\n",
        "                if errors is None:\n",
        "                    errors = \"strict\"\n",
        "                data = data.encode(encoding, errors)\n",
        "            fp.write(data)\n",
        "            fp.flush()\n",
        "        want_unicode = False\n",
        "        sep = kwargs.pop(\"sep\", None)\n",
        "        if sep is not None:\n",
        "            if isinstance(sep, unicode):\n",
        "                want_unicode = True\n",
        "            elif not isinstance(sep, str):\n",
        "                raise TypeError(\"sep must be None or a string\")\n",
        "        end = kwargs.pop(\"end\", None)\n",
        "        if end is not None:\n",
        "            if isinstance(end, unicode):\n",
        "                want_unicode = True\n",
        "            elif not isinstance(end, str):\n",
        "                raise TypeError(\"end must be None or a string\")\n",
        "        if kwargs:\n",
        "            raise TypeError(\"invalid keyword arguments to print()\")\n",
        "        if not want_unicode:\n",
        "            for arg in args:\n",
        "                if isinstance(arg, unicode):\n",
        "                    want_unicode = True\n",
        "                    break\n",
        "        if want_unicode:\n",
        "            newline = unicode(\"\\n\")\n",
        "            space = unicode(\" \")\n",
        "        else:\n",
        "            newline = \"\\n\"\n",
        "            space = \" \"\n",
        "        if sep is None:\n",
        "            sep = space\n",
        "        if end is None:\n",
        "            end = newline\n",
        "        for i, arg in enumerate(args):\n",
        "            if i:\n",
        "                write(sep)\n",
        "            write(arg)\n",
        "        write(end)\n",
        "\n",
        "\n",
        "# Exception \"constants\" to support Python 2 through Python 3\n",
        "try:\n",
        "    import ssl\n",
        "    try:\n",
        "        CERT_ERROR = (ssl.CertificateError,)\n",
        "    except AttributeError:\n",
        "        CERT_ERROR = tuple()\n",
        "\n",
        "    HTTP_ERRORS = (\n",
        "        (HTTPError, URLError, socket.error, ssl.SSLError, BadStatusLine) +\n",
        "        CERT_ERROR\n",
        "    )\n",
        "except ImportError:\n",
        "    ssl = None\n",
        "    HTTP_ERRORS = (HTTPError, URLError, socket.error, BadStatusLine)\n",
        "\n",
        "\n",
        "class SpeedtestException(Exception):\n",
        "    \"\"\"Base exception for this module\"\"\"\n",
        "\n",
        "\n",
        "class SpeedtestCLIError(SpeedtestException):\n",
        "    \"\"\"Generic exception for raising errors during CLI operation\"\"\"\n",
        "\n",
        "\n",
        "class SpeedtestHTTPError(SpeedtestException):\n",
        "    \"\"\"Base HTTP exception for this module\"\"\"\n",
        "\n",
        "\n",
        "class SpeedtestConfigError(SpeedtestException):\n",
        "    \"\"\"Configuration XML is invalid\"\"\"\n",
        "\n",
        "\n",
        "class SpeedtestServersError(SpeedtestException):\n",
        "    \"\"\"Servers XML is invalid\"\"\"\n",
        "\n",
        "\n",
        "class ConfigRetrievalError(SpeedtestHTTPError):\n",
        "    \"\"\"Could not retrieve config.php\"\"\"\n",
        "\n",
        "\n",
        "class ServersRetrievalError(SpeedtestHTTPError):\n",
        "    \"\"\"Could not retrieve speedtest-servers.php\"\"\"\n",
        "\n",
        "\n",
        "class InvalidServerIDType(SpeedtestException):\n",
        "    \"\"\"Server ID used for filtering was not an integer\"\"\"\n",
        "\n",
        "\n",
        "class NoMatchedServers(SpeedtestException):\n",
        "    \"\"\"No servers matched when filtering\"\"\"\n",
        "\n",
        "\n",
        "class SpeedtestMiniConnectFailure(SpeedtestException):\n",
        "    \"\"\"Could not connect to the provided speedtest mini server\"\"\"\n",
        "\n",
        "\n",
        "class InvalidSpeedtestMiniServer(SpeedtestException):\n",
        "    \"\"\"Server provided as a speedtest mini server does not actually appear\n",
        "    to be a speedtest mini server\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "class ShareResultsConnectFailure(SpeedtestException):\n",
        "    \"\"\"Could not connect to speedtest.net API to POST results\"\"\"\n",
        "\n",
        "\n",
        "class ShareResultsSubmitFailure(SpeedtestException):\n",
        "    \"\"\"Unable to successfully POST results to speedtest.net API after\n",
        "    connection\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "class SpeedtestUploadTimeout(SpeedtestException):\n",
        "    \"\"\"testlength configuration reached during upload\n",
        "    Used to ensure the upload halts when no additional data should be sent\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "class SpeedtestBestServerFailure(SpeedtestException):\n",
        "    \"\"\"Unable to determine best server\"\"\"\n",
        "\n",
        "\n",
        "class SpeedtestMissingBestServer(SpeedtestException):\n",
        "    \"\"\"get_best_server not called or not able to determine best server\"\"\"\n",
        "\n",
        "\n",
        "def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,\n",
        "                      source_address=None):\n",
        "    \"\"\"Connect to *address* and return the socket object.\n",
        "    Convenience function.  Connect to *address* (a 2-tuple ``(host,\n",
        "    port)``) and return the socket object.  Passing the optional\n",
        "    *timeout* parameter will set the timeout on the socket instance\n",
        "    before attempting to connect.  If no *timeout* is supplied, the\n",
        "    global default timeout setting returned by :func:`getdefaulttimeout`\n",
        "    is used.  If *source_address* is set it must be a tuple of (host, port)\n",
        "    for the socket to bind as a source address before making the connection.\n",
        "    An host of '' or port 0 tells the OS to use the default.\n",
        "    Largely vendored from Python 2.7, modified to work with Python 2.4\n",
        "    \"\"\"\n",
        "\n",
        "    host, port = address\n",
        "    err = None\n",
        "    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):\n",
        "        af, socktype, proto, canonname, sa = res\n",
        "        sock = None\n",
        "        try:\n",
        "            sock = socket.socket(af, socktype, proto)\n",
        "            if timeout is not _GLOBAL_DEFAULT_TIMEOUT:\n",
        "                sock.settimeout(float(timeout))\n",
        "            if source_address:\n",
        "                sock.bind(source_address)\n",
        "            sock.connect(sa)\n",
        "            return sock\n",
        "\n",
        "        except socket.error:\n",
        "            err = get_exception()\n",
        "            if sock is not None:\n",
        "                sock.close()\n",
        "\n",
        "    if err is not None:\n",
        "        raise err\n",
        "    else:\n",
        "        raise socket.error(\"getaddrinfo returns an empty list\")\n",
        "\n",
        "\n",
        "class SpeedtestHTTPConnection(HTTPConnection):\n",
        "    \"\"\"Custom HTTPConnection to support source_address across\n",
        "    Python 2.4 - Python 3\n",
        "    \"\"\"\n",
        "    def __init__(self, *args, **kwargs):\n",
        "        source_address = kwargs.pop('source_address', None)\n",
        "        timeout = kwargs.pop('timeout', 10)\n",
        "\n",
        "        HTTPConnection.__init__(self, *args, **kwargs)\n",
        "\n",
        "        self.source_address = source_address\n",
        "        self.timeout = timeout\n",
        "\n",
        "    def connect(self):\n",
        "        \"\"\"Connect to the host and port specified in __init__.\"\"\"\n",
        "        try:\n",
        "            self.sock = socket.create_connection(\n",
        "                (self.host, self.port),\n",
        "                self.timeout,\n",
        "                self.source_address\n",
        "            )\n",
        "        except (AttributeError, TypeError):\n",
        "            self.sock = create_connection(\n",
        "                (self.host, self.port),\n",
        "                self.timeout,\n",
        "                self.source_address\n",
        "            )\n",
        "\n",
        "\n",
        "if HTTPSConnection:\n",
        "    class SpeedtestHTTPSConnection(HTTPSConnection,\n",
        "                                   SpeedtestHTTPConnection):\n",
        "        \"\"\"Custom HTTPSConnection to support source_address across\n",
        "        Python 2.4 - Python 3\n",
        "        \"\"\"\n",
        "        def __init__(self, *args, **kwargs):\n",
        "            source_address = kwargs.pop('source_address', None)\n",
        "            timeout = kwargs.pop('timeout', 10)\n",
        "\n",
        "            HTTPSConnection.__init__(self, *args, **kwargs)\n",
        "\n",
        "            self.timeout = timeout\n",
        "            self.source_address = source_address\n",
        "\n",
        "        def connect(self):\n",
        "            \"Connect to a host on a given (SSL) port.\"\n",
        "\n",
        "            SpeedtestHTTPConnection.connect(self)\n",
        "\n",
        "            if ssl:\n",
        "                try:\n",
        "                    kwargs = {}\n",
        "                    if hasattr(ssl, 'SSLContext'):\n",
        "                        kwargs['server_hostname'] = self.host\n",
        "                    self.sock = self._context.wrap_socket(self.sock, **kwargs)\n",
        "                except AttributeError:\n",
        "                    self.sock = ssl.wrap_socket(self.sock)\n",
        "                    try:\n",
        "                        self.sock.server_hostname = self.host\n",
        "                    except AttributeError:\n",
        "                        pass\n",
        "            elif FakeSocket:\n",
        "                # Python 2.4/2.5 support\n",
        "                try:\n",
        "                    self.sock = FakeSocket(self.sock, socket.ssl(self.sock))\n",
        "                except AttributeError:\n",
        "                    raise SpeedtestException(\n",
        "                        'This version of Python does not support HTTPS/SSL '\n",
        "                        'functionality'\n",
        "                    )\n",
        "            else:\n",
        "                raise SpeedtestException(\n",
        "                    'This version of Python does not support HTTPS/SSL '\n",
        "                    'functionality'\n",
        "                )\n",
        "\n",
        "\n",
        "def _build_connection(connection, source_address, timeout, context=None):\n",
        "    \"\"\"Cross Python 2.4 - Python 3 callable to build an ``HTTPConnection`` or\n",
        "    ``HTTPSConnection`` with the args we need\n",
        "    Called from ``http(s)_open`` methods of ``SpeedtestHTTPHandler`` or\n",
        "    ``SpeedtestHTTPSHandler``\n",
        "    \"\"\"\n",
        "    def inner(host, **kwargs):\n",
        "        kwargs.update({\n",
        "            'source_address': source_address,\n",
        "            'timeout': timeout\n",
        "        })\n",
        "        if context:\n",
        "            kwargs['context'] = context\n",
        "        return connection(host, **kwargs)\n",
        "    return inner\n",
        "\n",
        "\n",
        "class SpeedtestHTTPHandler(AbstractHTTPHandler):\n",
        "    \"\"\"Custom ``HTTPHandler`` that can build a ``HTTPConnection`` with the\n",
        "    args we need for ``source_address`` and ``timeout``\n",
        "    \"\"\"\n",
        "    def __init__(self, debuglevel=0, source_address=None, timeout=10):\n",
        "        AbstractHTTPHandler.__init__(self, debuglevel)\n",
        "        self.source_address = source_address\n",
        "        self.timeout = timeout\n",
        "\n",
        "    def http_open(self, req):\n",
        "        return self.do_open(\n",
        "            _build_connection(\n",
        "                SpeedtestHTTPConnection,\n",
        "                self.source_address,\n",
        "                self.timeout\n",
        "            ),\n",
        "            req\n",
        "        )\n",
        "\n",
        "    http_request = AbstractHTTPHandler.do_request_\n",
        "\n",
        "\n",
        "class SpeedtestHTTPSHandler(AbstractHTTPHandler):\n",
        "    \"\"\"Custom ``HTTPSHandler`` that can build a ``HTTPSConnection`` with the\n",
        "    args we need for ``source_address`` and ``timeout``\n",
        "    \"\"\"\n",
        "    def __init__(self, debuglevel=0, context=None, source_address=None,\n",
        "                 timeout=10):\n",
        "        AbstractHTTPHandler.__init__(self, debuglevel)\n",
        "        self._context = context\n",
        "        self.source_address = source_address\n",
        "        self.timeout = timeout\n",
        "\n",
        "    def https_open(self, req):\n",
        "        return self.do_open(\n",
        "            _build_connection(\n",
        "                SpeedtestHTTPSConnection,\n",
        "                self.source_address,\n",
        "                self.timeout,\n",
        "                context=self._context,\n",
        "            ),\n",
        "            req\n",
        "        )\n",
        "\n",
        "    https_request = AbstractHTTPHandler.do_request_\n",
        "\n",
        "\n",
        "def build_opener(source_address=None, timeout=10):\n",
        "    \"\"\"Function similar to ``urllib2.build_opener`` that will build\n",
        "    an ``OpenerDirector`` with the explicit handlers we want,\n",
        "    ``source_address`` for binding, ``timeout`` and our custom\n",
        "    `User-Agent`\n",
        "    \"\"\"\n",
        "\n",
        "    printer('Timeout set to %d' % timeout, debug=True)\n",
        "\n",
        "    if source_address:\n",
        "        source_address_tuple = (source_address, 0)\n",
        "        printer('Binding to source address: %r' % (source_address_tuple,),\n",
        "                debug=True)\n",
        "    else:\n",
        "        source_address_tuple = None\n",
        "\n",
        "    handlers = [\n",
        "        ProxyHandler(),\n",
        "        SpeedtestHTTPHandler(source_address=source_address_tuple,\n",
        "                             timeout=timeout),\n",
        "        SpeedtestHTTPSHandler(source_address=source_address_tuple,\n",
        "                              timeout=timeout),\n",
        "        HTTPDefaultErrorHandler(),\n",
        "        HTTPRedirectHandler(),\n",
        "        HTTPErrorProcessor()\n",
        "    ]\n",
        "\n",
        "    opener = OpenerDirector()\n",
        "    opener.addheaders = [('User-agent', build_user_agent())]\n",
        "\n",
        "    for handler in handlers:\n",
        "        opener.add_handler(handler)\n",
        "\n",
        "    return opener\n",
        "\n",
        "\n",
        "class GzipDecodedResponse(GZIP_BASE):\n",
        "    \"\"\"A file-like object to decode a response encoded with the gzip\n",
        "    method, as described in RFC 1952.\n",
        "    Largely copied from ``xmlrpclib``/``xmlrpc.client`` and modified\n",
        "    to work for py2.4-py3\n",
        "    \"\"\"\n",
        "    def __init__(self, response):\n",
        "        # response doesn't support tell() and read(), required by\n",
        "        # GzipFile\n",
        "        if not gzip:\n",
        "            raise SpeedtestHTTPError('HTTP response body is gzip encoded, '\n",
        "                                     'but gzip support is not available')\n",
        "        IO = BytesIO or StringIO\n",
        "        self.io = IO()\n",
        "        while 1:\n",
        "            chunk = response.read(1024)\n",
        "            if len(chunk) == 0:\n",
        "                break\n",
        "            self.io.write(chunk)\n",
        "        self.io.seek(0)\n",
        "        gzip.GzipFile.__init__(self, mode='rb', fileobj=self.io)\n",
        "\n",
        "    def close(self):\n",
        "        try:\n",
        "            gzip.GzipFile.close(self)\n",
        "        finally:\n",
        "            self.io.close()\n",
        "\n",
        "\n",
        "def get_exception():\n",
        "    \"\"\"Helper function to work with py2.4-py3 for getting the current\n",
        "    exception in a try/except block\n",
        "    \"\"\"\n",
        "    return sys.exc_info()[1]\n",
        "\n",
        "\n",
        "def distance(origin, destination):\n",
        "    \"\"\"Determine distance between 2 sets of [lat,lon] in km\"\"\"\n",
        "\n",
        "    lat1, lon1 = origin\n",
        "    lat2, lon2 = destination\n",
        "    radius = 6371  # km\n",
        "\n",
        "    dlat = math.radians(lat2 - lat1)\n",
        "    dlon = math.radians(lon2 - lon1)\n",
        "    a = (math.sin(dlat / 2) * math.sin(dlat / 2) +\n",
        "         math.cos(math.radians(lat1)) *\n",
        "         math.cos(math.radians(lat2)) * math.sin(dlon / 2) *\n",
        "         math.sin(dlon / 2))\n",
        "    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))\n",
        "    d = radius * c\n",
        "\n",
        "    return d\n",
        "\n",
        "\n",
        "def build_user_agent():\n",
        "    \"\"\"Build a Mozilla/5.0 compatible User-Agent string\"\"\"\n",
        "\n",
        "    ua_tuple = (\n",
        "        'Mozilla/5.0',\n",
        "        '(%s; U; %s; en-us)' % (platform.platform(),\n",
        "                                platform.architecture()[0]),\n",
        "        'Python/%s' % platform.python_version(),\n",
        "        '(KHTML, like Gecko)',\n",
        "        'speedtest-cli/%s' % __version__\n",
        "    )\n",
        "    user_agent = ' '.join(ua_tuple)\n",
        "    printer('User-Agent: %s' % user_agent, debug=True)\n",
        "    return user_agent\n",
        "\n",
        "\n",
        "def build_request(url, data=None, headers=None, bump='0', secure=False):\n",
        "    \"\"\"Build a urllib2 request object\n",
        "    This function automatically adds a User-Agent header to all requests\n",
        "    \"\"\"\n",
        "\n",
        "    if not headers:\n",
        "        headers = {}\n",
        "\n",
        "    if url[0] == ':':\n",
        "        scheme = ('http', 'https')[bool(secure)]\n",
        "        schemed_url = '%s%s' % (scheme, url)\n",
        "    else:\n",
        "        schemed_url = url\n",
        "\n",
        "    if '?' in url:\n",
        "        delim = '&'\n",
        "    else:\n",
        "        delim = '?'\n",
        "\n",
        "    # WHO YOU GONNA CALL? CACHE BUSTERS!\n",
        "    final_url = '%s%sx=%s.%s' % (schemed_url, delim,\n",
        "                                 int(timeit.time.time() * 1000),\n",
        "                                 bump)\n",
        "\n",
        "    headers.update({\n",
        "        'Cache-Control': 'no-cache',\n",
        "    })\n",
        "\n",
        "    printer('%s %s' % (('GET', 'POST')[bool(data)], final_url),\n",
        "            debug=True)\n",
        "\n",
        "    return Request(final_url, data=data, headers=headers)\n",
        "\n",
        "\n",
        "def catch_request(request, opener=None):\n",
        "    \"\"\"Helper function to catch common exceptions encountered when\n",
        "    establishing a connection with a HTTP/HTTPS request\n",
        "    \"\"\"\n",
        "\n",
        "    if opener:\n",
        "        _open = opener.open\n",
        "    else:\n",
        "        _open = urlopen\n",
        "\n",
        "    try:\n",
        "        uh = _open(request)\n",
        "        if request.get_full_url() != uh.geturl():\n",
        "            printer('Redirected to %s' % uh.geturl(), debug=True)\n",
        "        return uh, False\n",
        "    except HTTP_ERRORS:\n",
        "        e = get_exception()\n",
        "        return None, e\n",
        "\n",
        "\n",
        "def get_response_stream(response):\n",
        "    \"\"\"Helper function to return either a Gzip reader if\n",
        "    ``Content-Encoding`` is ``gzip`` otherwise the response itself\n",
        "    \"\"\"\n",
        "\n",
        "    try:\n",
        "        getheader = response.headers.getheader\n",
        "    except AttributeError:\n",
        "        getheader = response.getheader\n",
        "\n",
        "    if getheader('content-encoding') == 'gzip':\n",
        "        return GzipDecodedResponse(response)\n",
        "\n",
        "    return response\n",
        "\n",
        "\n",
        "def get_attributes_by_tag_name(dom, tag_name):\n",
        "    \"\"\"Retrieve an attribute from an XML document and return it in a\n",
        "    consistent format\n",
        "    Only used with xml.dom.minidom, which is likely only to be used\n",
        "    with python versions older than 2.5\n",
        "    \"\"\"\n",
        "    elem = dom.getElementsByTagName(tag_name)[0]\n",
        "    return dict(list(elem.attributes.items()))\n",
        "\n",
        "\n",
        "def print_dots(shutdown_event):\n",
        "    \"\"\"Built in callback function used by Thread classes for printing\n",
        "    status\n",
        "    \"\"\"\n",
        "    def inner(current, total, start=False, end=False):\n",
        "        if shutdown_event.isSet():\n",
        "            return\n",
        "\n",
        "        sys.stdout.write('.')\n",
        "        if current + 1 == total and end is True:\n",
        "            sys.stdout.write('\\n')\n",
        "        sys.stdout.flush()\n",
        "    return inner\n",
        "\n",
        "\n",
        "def do_nothing(*args, **kwargs):\n",
        "    pass\n",
        "\n",
        "\n",
        "class HTTPDownloader(threading.Thread):\n",
        "    \"\"\"Thread class for retrieving a URL\"\"\"\n",
        "\n",
        "    def __init__(self, i, request, start, timeout, opener=None,\n",
        "                 shutdown_event=None):\n",
        "        threading.Thread.__init__(self)\n",
        "        self.request = request\n",
        "        self.result = [0]\n",
        "        self.starttime = start\n",
        "        self.timeout = timeout\n",
        "        self.i = i\n",
        "        if opener:\n",
        "            self._opener = opener.open\n",
        "        else:\n",
        "            self._opener = urlopen\n",
        "\n",
        "        if shutdown_event:\n",
        "            self._shutdown_event = shutdown_event\n",
        "        else:\n",
        "            self._shutdown_event = FakeShutdownEvent()\n",
        "\n",
        "    def run(self):\n",
        "        try:\n",
        "            if (timeit.default_timer() - self.starttime) <= self.timeout:\n",
        "                f = self._opener(self.request)\n",
        "                while (not self._shutdown_event.isSet() and\n",
        "                        (timeit.default_timer() - self.starttime) <=\n",
        "                        self.timeout):\n",
        "                    self.result.append(len(f.read(10240)))\n",
        "                    if self.result[-1] == 0:\n",
        "                        break\n",
        "                f.close()\n",
        "        except IOError:\n",
        "            pass\n",
        "\n",
        "\n",
        "class HTTPUploaderData(object):\n",
        "    \"\"\"File like object to improve cutting off the upload once the timeout\n",
        "    has been reached\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, length, start, timeout, shutdown_event=None):\n",
        "        self.length = length\n",
        "        self.start = start\n",
        "        self.timeout = timeout\n",
        "\n",
        "        if shutdown_event:\n",
        "            self._shutdown_event = shutdown_event\n",
        "        else:\n",
        "            self._shutdown_event = FakeShutdownEvent()\n",
        "\n",
        "        self._data = None\n",
        "\n",
        "        self.total = [0]\n",
        "\n",
        "    def pre_allocate(self):\n",
        "        chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
        "        multiplier = int(round(int(self.length) / 36.0))\n",
        "        IO = BytesIO or StringIO\n",
        "        try:\n",
        "            self._data = IO(\n",
        "                ('content1=%s' %\n",
        "                 (chars * multiplier)[0:int(self.length) - 9]\n",
        "                 ).encode()\n",
        "            )\n",
        "        except MemoryError:\n",
        "            raise SpeedtestCLIError(\n",
        "                'Insufficient memory to pre-allocate upload data. Please '\n",
        "                'use --no-pre-allocate'\n",
        "            )\n",
        "\n",
        "    @property\n",
        "    def data(self):\n",
        "        if not self._data:\n",
        "            self.pre_allocate()\n",
        "        return self._data\n",
        "\n",
        "    def read(self, n=10240):\n",
        "        if ((timeit.default_timer() - self.start) <= self.timeout and\n",
        "                not self._shutdown_event.isSet()):\n",
        "            chunk = self.data.read(n)\n",
        "            self.total.append(len(chunk))\n",
        "            return chunk\n",
        "        else:\n",
        "            raise SpeedtestUploadTimeout()\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.length\n",
        "\n",
        "\n",
        "class HTTPUploader(threading.Thread):\n",
        "    \"\"\"Thread class for putting a URL\"\"\"\n",
        "\n",
        "    def __init__(self, i, request, start, size, timeout, opener=None,\n",
        "                 shutdown_event=None):\n",
        "        threading.Thread.__init__(self)\n",
        "        self.request = request\n",
        "        self.request.data.start = self.starttime = start\n",
        "        self.size = size\n",
        "        self.result = None\n",
        "        self.timeout = timeout\n",
        "        self.i = i\n",
        "\n",
        "        if opener:\n",
        "            self._opener = opener.open\n",
        "        else:\n",
        "            self._opener = urlopen\n",
        "\n",
        "        if shutdown_event:\n",
        "            self._shutdown_event = shutdown_event\n",
        "        else:\n",
        "            self._shutdown_event = FakeShutdownEvent()\n",
        "\n",
        "    def run(self):\n",
        "        request = self.request\n",
        "        try:\n",
        "            if ((timeit.default_timer() - self.starttime) <= self.timeout and\n",
        "                    not self._shutdown_event.isSet()):\n",
        "                try:\n",
        "                    f = self._opener(request)\n",
        "                except TypeError:\n",
        "                    # PY24 expects a string or buffer\n",
        "                    # This also causes issues with Ctrl-C, but we will concede\n",
        "                    # for the moment that Ctrl-C on PY24 isn't immediate\n",
        "                    request = build_request(self.request.get_full_url(),\n",
        "                                            data=request.data.read(self.size))\n",
        "                    f = self._opener(request)\n",
        "                f.read(11)\n",
        "                f.close()\n",
        "                self.result = sum(self.request.data.total)\n",
        "            else:\n",
        "                self.result = 0\n",
        "        except (IOError, SpeedtestUploadTimeout):\n",
        "            self.result = sum(self.request.data.total)\n",
        "\n",
        "\n",
        "class SpeedtestResults(object):\n",
        "    \"\"\"Class for holding the results of a speedtest, including:\n",
        "    Download speed\n",
        "    Upload speed\n",
        "    Ping/Latency to test server\n",
        "    Data about server that the test was run against\n",
        "    Additionally this class can return a result data as a dictionary or CSV,\n",
        "    as well as submit a POST of the result data to the speedtest.net API\n",
        "    to get a share results image link.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, download=0, upload=0, ping=0, server=None, client=None,\n",
        "                 opener=None, secure=False):\n",
        "        self.download = download\n",
        "        self.upload = upload\n",
        "        self.ping = ping\n",
        "        if server is None:\n",
        "            self.server = {}\n",
        "        else:\n",
        "            self.server = server\n",
        "        self.client = client or {}\n",
        "\n",
        "        self._share = None\n",
        "        self.timestamp = '%sZ' % datetime.datetime.utcnow().isoformat()\n",
        "        self.bytes_received = 0\n",
        "        self.bytes_sent = 0\n",
        "\n",
        "        if opener:\n",
        "            self._opener = opener\n",
        "        else:\n",
        "            self._opener = build_opener()\n",
        "\n",
        "        self._secure = secure\n",
        "\n",
        "    def __repr__(self):\n",
        "        return repr(self.dict())\n",
        "\n",
        "    def share(self):\n",
        "        \"\"\"POST data to the speedtest.net API to obtain a share results\n",
        "        link\n",
        "        \"\"\"\n",
        "\n",
        "        if self._share:\n",
        "            return self._share\n",
        "\n",
        "        download = int(round(self.download / 1000.0, 0))\n",
        "        ping = int(round(self.ping, 0))\n",
        "        upload = int(round(self.upload / 1000.0, 0))\n",
        "\n",
        "        # Build the request to send results back to speedtest.net\n",
        "        # We use a list instead of a dict because the API expects parameters\n",
        "        # in a certain order\n",
        "        api_data = [\n",
        "            'recommendedserverid=%s' % self.server['id'],\n",
        "            'ping=%s' % ping,\n",
        "            'screenresolution=',\n",
        "            'promo=',\n",
        "            'download=%s' % download,\n",
        "            'screendpi=',\n",
        "            'upload=%s' % upload,\n",
        "            'testmethod=http',\n",
        "            'hash=%s' % md5(('%s-%s-%s-%s' %\n",
        "                             (ping, upload, download, '297aae72'))\n",
        "                            .encode()).hexdigest(),\n",
        "            'touchscreen=none',\n",
        "            'startmode=pingselect',\n",
        "            'accuracy=1',\n",
        "            'bytesreceived=%s' % self.bytes_received,\n",
        "            'bytessent=%s' % self.bytes_sent,\n",
        "            'serverid=%s' % self.server['id'],\n",
        "        ]\n",
        "\n",
        "        headers = {'Referer': 'http://c.speedtest.net/flash/speedtest.swf'}\n",
        "        request = build_request('://www.speedtest.net/api/api.php',\n",
        "                                data='&'.join(api_data).encode(),\n",
        "                                headers=headers, secure=self._secure)\n",
        "        f, e = catch_request(request, opener=self._opener)\n",
        "        if e:\n",
        "            raise ShareResultsConnectFailure(e)\n",
        "\n",
        "        response = f.read()\n",
        "        code = f.code\n",
        "        f.close()\n",
        "\n",
        "        if int(code) != 200:\n",
        "            raise ShareResultsSubmitFailure('Could not submit results to '\n",
        "                                            'speedtest.net')\n",
        "\n",
        "        qsargs = parse_qs(response.decode())\n",
        "        resultid = qsargs.get('resultid')\n",
        "        if not resultid or len(resultid) != 1:\n",
        "            raise ShareResultsSubmitFailure('Could not submit results to '\n",
        "                                            'speedtest.net')\n",
        "\n",
        "        self._share = 'http://www.speedtest.net/result/%s.png' % resultid[0]\n",
        "\n",
        "        return self._share\n",
        "\n",
        "    def dict(self):\n",
        "        \"\"\"Return dictionary of result data\"\"\"\n",
        "\n",
        "        return {\n",
        "            'download': self.download,\n",
        "            'upload': self.upload,\n",
        "            'ping': self.ping,\n",
        "            'server': self.server,\n",
        "            'timestamp': self.timestamp,\n",
        "            'bytes_sent': self.bytes_sent,\n",
        "            'bytes_received': self.bytes_received,\n",
        "            'share': self._share,\n",
        "            'client': self.client,\n",
        "        }\n",
        "\n",
        "    @staticmethod\n",
        "    def csv_header(delimiter=','):\n",
        "        \"\"\"Return CSV Headers\"\"\"\n",
        "\n",
        "        row = ['Server ID', 'Sponsor', 'Server Name', 'Timestamp', 'Distance',\n",
        "               'Ping', 'Download', 'Upload', 'Share', 'IP Address']\n",
        "        out = StringIO()\n",
        "        writer = csv.writer(out, delimiter=delimiter, lineterminator='')\n",
        "        writer.writerow([to_utf8(v) for v in row])\n",
        "        return out.getvalue()\n",
        "\n",
        "    def csv(self, delimiter=','):\n",
        "        \"\"\"Return data in CSV format\"\"\"\n",
        "\n",
        "        data = self.dict()\n",
        "        out = StringIO()\n",
        "        writer = csv.writer(out, delimiter=delimiter, lineterminator='')\n",
        "        row = [data['server']['id'], data['server']['sponsor'],\n",
        "               data['server']['name'], data['timestamp'],\n",
        "               data['server']['d'], data['ping'], data['download'],\n",
        "               data['upload'], self._share or '', self.client['ip']]\n",
        "        writer.writerow([to_utf8(v) for v in row])\n",
        "        return out.getvalue()\n",
        "\n",
        "    def json(self, pretty=False):\n",
        "        \"\"\"Return data in JSON format\"\"\"\n",
        "\n",
        "        kwargs = {}\n",
        "        if pretty:\n",
        "            kwargs.update({\n",
        "                'indent': 4,\n",
        "                'sort_keys': True\n",
        "            })\n",
        "        return json.dumps(self.dict(), **kwargs)\n",
        "\n",
        "\n",
        "class Speedtest(object):\n",
        "    \"\"\"Class for performing standard speedtest.net testing operations\"\"\"\n",
        "\n",
        "    def __init__(self, config=None, source_address=None, timeout=10,\n",
        "                 secure=False, shutdown_event=None):\n",
        "        self.config = {}\n",
        "\n",
        "        self._source_address = source_address\n",
        "        self._timeout = timeout\n",
        "        self._opener = build_opener(source_address, timeout)\n",
        "\n",
        "        self._secure = secure\n",
        "\n",
        "        if shutdown_event:\n",
        "            self._shutdown_event = shutdown_event\n",
        "        else:\n",
        "            self._shutdown_event = FakeShutdownEvent()\n",
        "\n",
        "        self.get_config()\n",
        "        if config is not None:\n",
        "            self.config.update(config)\n",
        "\n",
        "        self.servers = {}\n",
        "        self.closest = []\n",
        "        self._best = {}\n",
        "\n",
        "        self.results = SpeedtestResults(\n",
        "            client=self.config['client'],\n",
        "            opener=self._opener,\n",
        "            secure=secure,\n",
        "        )\n",
        "\n",
        "    @property\n",
        "    def best(self):\n",
        "        if not self._best:\n",
        "            self.get_best_server()\n",
        "        return self._best\n",
        "\n",
        "    def get_config(self):\n",
        "        \"\"\"Download the speedtest.net configuration and return only the data\n",
        "        we are interested in\n",
        "        \"\"\"\n",
        "\n",
        "        headers = {}\n",
        "        if gzip:\n",
        "            headers['Accept-Encoding'] = 'gzip'\n",
        "        request = build_request('://www.speedtest.net/speedtest-config.php',\n",
        "                                headers=headers, secure=self._secure)\n",
        "        uh, e = catch_request(request, opener=self._opener)\n",
        "        if e:\n",
        "            raise ConfigRetrievalError(e)\n",
        "        configxml_list = []\n",
        "\n",
        "        stream = get_response_stream(uh)\n",
        "\n",
        "        while 1:\n",
        "            try:\n",
        "                configxml_list.append(stream.read(1024))\n",
        "            except (OSError, EOFError):\n",
        "                raise ConfigRetrievalError(get_exception())\n",
        "            if len(configxml_list[-1]) == 0:\n",
        "                break\n",
        "        stream.close()\n",
        "        uh.close()\n",
        "\n",
        "        if int(uh.code) != 200:\n",
        "            return None\n",
        "\n",
        "        configxml = ''.encode().join(configxml_list)\n",
        "\n",
        "        printer('Config XML:\\n%s' % configxml, debug=True)\n",
        "\n",
        "        try:\n",
        "            try:\n",
        "                root = ET.fromstring(configxml)\n",
        "            except ET.ParseError:\n",
        "                e = get_exception()\n",
        "                raise SpeedtestConfigError(\n",
        "                    'Malformed speedtest.net configuration: %s' % e\n",
        "                )\n",
        "            server_config = root.find('server-config').attrib\n",
        "            download = root.find('download').attrib\n",
        "            upload = root.find('upload').attrib\n",
        "            # times = root.find('times').attrib\n",
        "            client = root.find('client').attrib\n",
        "\n",
        "        except AttributeError:\n",
        "            try:\n",
        "                root = DOM.parseString(configxml)\n",
        "            except ExpatError:\n",
        "                e = get_exception()\n",
        "                raise SpeedtestConfigError(\n",
        "                    'Malformed speedtest.net configuration: %s' % e\n",
        "                )\n",
        "            server_config = get_attributes_by_tag_name(root, 'server-config')\n",
        "            download = get_attributes_by_tag_name(root, 'download')\n",
        "            upload = get_attributes_by_tag_name(root, 'upload')\n",
        "            # times = get_attributes_by_tag_name(root, 'times')\n",
        "            client = get_attributes_by_tag_name(root, 'client')\n",
        "\n",
        "        ignore_servers = list(\n",
        "            map(int, server_config['ignoreids'].split(','))\n",
        "        )\n",
        "\n",
        "        ratio = int(upload['ratio'])\n",
        "        upload_max = int(upload['maxchunkcount'])\n",
        "        up_sizes = [32768, 65536, 131072, 262144, 524288, 1048576, 7340032]\n",
        "        sizes = {\n",
        "            'upload': up_sizes[ratio - 1:],\n",
        "            'download': [350, 500, 750, 1000, 1500, 2000, 2500,\n",
        "                         3000, 3500, 4000]\n",
        "        }\n",
        "\n",
        "        size_count = len(sizes['upload'])\n",
        "\n",
        "        upload_count = int(math.ceil(upload_max / size_count))\n",
        "\n",
        "        counts = {\n",
        "            'upload': upload_count,\n",
        "            'download': int(download['threadsperurl'])\n",
        "        }\n",
        "\n",
        "        threads = {\n",
        "            'upload': int(upload['threads']),\n",
        "            'download': int(server_config['threadcount']) * 2\n",
        "        }\n",
        "\n",
        "        length = {\n",
        "            'upload': int(upload['testlength']),\n",
        "            'download': int(download['testlength'])\n",
        "        }\n",
        "\n",
        "        self.config.update({\n",
        "            'client': client,\n",
        "            'ignore_servers': ignore_servers,\n",
        "            'sizes': sizes,\n",
        "            'counts': counts,\n",
        "            'threads': threads,\n",
        "            'length': length,\n",
        "            'upload_max': upload_count * size_count\n",
        "        })\n",
        "\n",
        "        try:\n",
        "            self.lat_lon = (float(client['lat']), float(client['lon']))\n",
        "        except ValueError:\n",
        "            raise SpeedtestConfigError(\n",
        "                'Unknown location: lat=%r lon=%r' %\n",
        "                (client.get('lat'), client.get('lon'))\n",
        "            )\n",
        "\n",
        "        printer('Config:\\n%r' % self.config, debug=True)\n",
        "\n",
        "        return self.config\n",
        "\n",
        "    def get_servers(self, servers=None, exclude=None):\n",
        "        \"\"\"Retrieve a the list of speedtest.net servers, optionally filtered\n",
        "        to servers matching those specified in the ``servers`` argument\n",
        "        \"\"\"\n",
        "        if servers is None:\n",
        "            servers = []\n",
        "\n",
        "        if exclude is None:\n",
        "            exclude = []\n",
        "\n",
        "        self.servers.clear()\n",
        "\n",
        "        for server_list in (servers, exclude):\n",
        "            for i, s in enumerate(server_list):\n",
        "                try:\n",
        "                    server_list[i] = int(s)\n",
        "                except ValueError:\n",
        "                    raise InvalidServerIDType(\n",
        "                        '%s is an invalid server type, must be int' % s\n",
        "                    )\n",
        "\n",
        "        urls = [\n",
        "            '://www.speedtest.net/speedtest-servers-static.php',\n",
        "            'http://c.speedtest.net/speedtest-servers-static.php',\n",
        "            '://www.speedtest.net/speedtest-servers.php',\n",
        "            'http://c.speedtest.net/speedtest-servers.php',\n",
        "        ]\n",
        "\n",
        "        headers = {}\n",
        "        if gzip:\n",
        "            headers['Accept-Encoding'] = 'gzip'\n",
        "\n",
        "        errors = []\n",
        "        for url in urls:\n",
        "            try:\n",
        "                request = build_request(\n",
        "                    '%s?threads=%s' % (url,\n",
        "                                       self.config['threads']['download']),\n",
        "                    headers=headers,\n",
        "                    secure=self._secure\n",
        "                )\n",
        "                uh, e = catch_request(request, opener=self._opener)\n",
        "                if e:\n",
        "                    errors.append('%s' % e)\n",
        "                    raise ServersRetrievalError()\n",
        "\n",
        "                stream = get_response_stream(uh)\n",
        "\n",
        "                serversxml_list = []\n",
        "                while 1:\n",
        "                    try:\n",
        "                        serversxml_list.append(stream.read(1024))\n",
        "                    except (OSError, EOFError):\n",
        "                        raise ServersRetrievalError(get_exception())\n",
        "                    if len(serversxml_list[-1]) == 0:\n",
        "                        break\n",
        "\n",
        "                stream.close()\n",
        "                uh.close()\n",
        "\n",
        "                if int(uh.code) != 200:\n",
        "                    raise ServersRetrievalError()\n",
        "\n",
        "                serversxml = ''.encode().join(serversxml_list)\n",
        "\n",
        "                printer('Servers XML:\\n%s' % serversxml, debug=True)\n",
        "\n",
        "                try:\n",
        "                    try:\n",
        "                        try:\n",
        "                            root = ET.fromstring(serversxml)\n",
        "                        except ET.ParseError:\n",
        "                            e = get_exception()\n",
        "                            raise SpeedtestServersError(\n",
        "                                'Malformed speedtest.net server list: %s' % e\n",
        "                            )\n",
        "                        elements = root.getiterator('server')\n",
        "                    except AttributeError:\n",
        "                        try:\n",
        "                            root = DOM.parseString(serversxml)\n",
        "                        except ExpatError:\n",
        "                            e = get_exception()\n",
        "                            raise SpeedtestServersError(\n",
        "                                'Malformed speedtest.net server list: %s' % e\n",
        "                            )\n",
        "                        elements = root.getElementsByTagName('server')\n",
        "                except (SyntaxError, xml.parsers.expat.ExpatError):\n",
        "                    raise ServersRetrievalError()\n",
        "\n",
        "                for server in elements:\n",
        "                    try:\n",
        "                        attrib = server.attrib\n",
        "                    except AttributeError:\n",
        "                        attrib = dict(list(server.attributes.items()))\n",
        "\n",
        "                    if servers and int(attrib.get('id')) not in servers:\n",
        "                        continue\n",
        "\n",
        "                    if (int(attrib.get('id')) in self.config['ignore_servers']\n",
        "                            or int(attrib.get('id')) in exclude):\n",
        "                        continue\n",
        "\n",
        "                    try:\n",
        "                        d = distance(self.lat_lon,\n",
        "                                     (float(attrib.get('lat')),\n",
        "                                      float(attrib.get('lon'))))\n",
        "                    except Exception:\n",
        "                        continue\n",
        "\n",
        "                    attrib['d'] = d\n",
        "\n",
        "                    try:\n",
        "                        self.servers[d].append(attrib)\n",
        "                    except KeyError:\n",
        "                        self.servers[d] = [attrib]\n",
        "\n",
        "                break\n",
        "\n",
        "            except ServersRetrievalError:\n",
        "                continue\n",
        "\n",
        "        if (servers or exclude) and not self.servers:\n",
        "            raise NoMatchedServers()\n",
        "\n",
        "        return self.servers\n",
        "\n",
        "    def set_mini_server(self, server):\n",
        "        \"\"\"Instead of querying for a list of servers, set a link to a\n",
        "        speedtest mini server\n",
        "        \"\"\"\n",
        "\n",
        "        urlparts = urlparse(server)\n",
        "\n",
        "        name, ext = os.path.splitext(urlparts[2])\n",
        "        if ext:\n",
        "            url = os.path.dirname(server)\n",
        "        else:\n",
        "            url = server\n",
        "\n",
        "        request = build_request(url)\n",
        "        uh, e = catch_request(request, opener=self._opener)\n",
        "        if e:\n",
        "            raise SpeedtestMiniConnectFailure('Failed to connect to %s' %\n",
        "                                              server)\n",
        "        else:\n",
        "            text = uh.read()\n",
        "            uh.close()\n",
        "\n",
        "        extension = re.findall('upload_?[Ee]xtension: \"([^\"]+)\"',\n",
        "                               text.decode())\n",
        "        if not extension:\n",
        "            for ext in ['php', 'asp', 'aspx', 'jsp']:\n",
        "                try:\n",
        "                    f = self._opener.open(\n",
        "                        '%s/speedtest/upload.%s' % (url, ext)\n",
        "                    )\n",
        "                except Exception:\n",
        "                    pass\n",
        "                else:\n",
        "                    data = f.read().strip().decode()\n",
        "                    if (f.code == 200 and\n",
        "                            len(data.splitlines()) == 1 and\n",
        "                            re.match('size=[0-9]', data)):\n",
        "                        extension = [ext]\n",
        "                        break\n",
        "        if not urlparts or not extension:\n",
        "            raise InvalidSpeedtestMiniServer('Invalid Speedtest Mini Server: '\n",
        "                                             '%s' % server)\n",
        "\n",
        "        self.servers = [{\n",
        "            'sponsor': 'Speedtest Mini',\n",
        "            'name': urlparts[1],\n",
        "            'd': 0,\n",
        "            'url': '%s/speedtest/upload.%s' % (url.rstrip('/'), extension[0]),\n",
        "            'latency': 0,\n",
        "            'id': 0\n",
        "        }]\n",
        "\n",
        "        return self.servers\n",
        "\n",
        "    def get_closest_servers(self, limit=5):\n",
        "        \"\"\"Limit servers to the closest speedtest.net servers based on\n",
        "        geographic distance\n",
        "        \"\"\"\n",
        "\n",
        "        if not self.servers:\n",
        "            self.get_servers()\n",
        "\n",
        "        for d in sorted(self.servers.keys()):\n",
        "            for s in self.servers[d]:\n",
        "                self.closest.append(s)\n",
        "                if len(self.closest) == limit:\n",
        "                    break\n",
        "            else:\n",
        "                continue\n",
        "            break\n",
        "\n",
        "        printer('Closest Servers:\\n%r' % self.closest, debug=True)\n",
        "        return self.closest\n",
        "\n",
        "    def get_best_server(self, servers=None):\n",
        "        \"\"\"Perform a speedtest.net \"ping\" to determine which speedtest.net\n",
        "        server has the lowest latency\n",
        "        \"\"\"\n",
        "\n",
        "        if not servers:\n",
        "            if not self.closest:\n",
        "                servers = self.get_closest_servers()\n",
        "            servers = self.closest\n",
        "\n",
        "        if self._source_address:\n",
        "            source_address_tuple = (self._source_address, 0)\n",
        "        else:\n",
        "            source_address_tuple = None\n",
        "\n",
        "        user_agent = build_user_agent()\n",
        "\n",
        "        results = {}\n",
        "        for server in servers:\n",
        "            cum = []\n",
        "            url = os.path.dirname(server['url'])\n",
        "            stamp = int(timeit.time.time() * 1000)\n",
        "            latency_url = '%s/latency.txt?x=%s' % (url, stamp)\n",
        "            for i in range(0, 3):\n",
        "                this_latency_url = '%s.%s' % (latency_url, i)\n",
        "                printer('%s %s' % ('GET', this_latency_url),\n",
        "                        debug=True)\n",
        "                urlparts = urlparse(latency_url)\n",
        "                try:\n",
        "                    if urlparts[0] == 'https':\n",
        "                        h = SpeedtestHTTPSConnection(\n",
        "                            urlparts[1],\n",
        "                            source_address=source_address_tuple\n",
        "                        )\n",
        "                    else:\n",
        "                        h = SpeedtestHTTPConnection(\n",
        "                            urlparts[1],\n",
        "                            source_address=source_address_tuple\n",
        "                        )\n",
        "                    headers = {'User-Agent': user_agent}\n",
        "                    path = '%s?%s' % (urlparts[2], urlparts[4])\n",
        "                    start = timeit.default_timer()\n",
        "                    h.request(\"GET\", path, headers=headers)\n",
        "                    r = h.getresponse()\n",
        "                    total = (timeit.default_timer() - start)\n",
        "                except HTTP_ERRORS:\n",
        "                    e = get_exception()\n",
        "                    printer('ERROR: %r' % e, debug=True)\n",
        "                    cum.append(3600)\n",
        "                    continue\n",
        "\n",
        "                text = r.read(9)\n",
        "                if int(r.status) == 200 and text == 'test=test'.encode():\n",
        "                    cum.append(total)\n",
        "                else:\n",
        "                    cum.append(3600)\n",
        "                h.close()\n",
        "\n",
        "            avg = round((sum(cum) / 6) * 1000.0, 3)\n",
        "            results[avg] = server\n",
        "\n",
        "        try:\n",
        "            fastest = sorted(results.keys())[0]\n",
        "        except IndexError:\n",
        "            raise SpeedtestBestServerFailure('Unable to connect to servers to '\n",
        "                                             'test latency.')\n",
        "        best = results[fastest]\n",
        "        best['latency'] = fastest\n",
        "\n",
        "        self.results.ping = fastest\n",
        "        self.results.server = best\n",
        "\n",
        "        self._best.update(best)\n",
        "        printer('Best Server:\\n%r' % best, debug=True)\n",
        "        return best\n",
        "\n",
        "    def download(self, callback=do_nothing, threads=None):\n",
        "        \"\"\"Test download speed against speedtest.net\n",
        "        A ``threads`` value of ``None`` will fall back to those dictated\n",
        "        by the speedtest.net configuration\n",
        "        \"\"\"\n",
        "\n",
        "        urls = []\n",
        "        for size in self.config['sizes']['download']:\n",
        "            for _ in range(0, self.config['counts']['download']):\n",
        "                urls.append('%s/random%sx%s.jpg' %\n",
        "                            (os.path.dirname(self.best['url']), size, size))\n",
        "\n",
        "        request_count = len(urls)\n",
        "        requests = []\n",
        "        for i, url in enumerate(urls):\n",
        "            requests.append(\n",
        "                build_request(url, bump=i, secure=self._secure)\n",
        "            )\n",
        "\n",
        "        def producer(q, requests, request_count):\n",
        "            for i, request in enumerate(requests):\n",
        "                thread = HTTPDownloader(\n",
        "                    i,\n",
        "                    request,\n",
        "                    start,\n",
        "                    self.config['length']['download'],\n",
        "                    opener=self._opener,\n",
        "                    shutdown_event=self._shutdown_event\n",
        "                )\n",
        "                thread.start()\n",
        "                q.put(thread, True)\n",
        "                callback(i, request_count, start=True)\n",
        "\n",
        "        finished = []\n",
        "\n",
        "        def consumer(q, request_count):\n",
        "            while len(finished) < request_count:\n",
        "                thread = q.get(True)\n",
        "                while thread.isAlive():\n",
        "                    thread.join(timeout=0.1)\n",
        "                finished.append(sum(thread.result))\n",
        "                callback(thread.i, request_count, end=True)\n",
        "\n",
        "        q = Queue(threads or self.config['threads']['download'])\n",
        "        prod_thread = threading.Thread(target=producer,\n",
        "                                       args=(q, requests, request_count))\n",
        "        cons_thread = threading.Thread(target=consumer,\n",
        "                                       args=(q, request_count))\n",
        "        start = timeit.default_timer()\n",
        "        prod_thread.start()\n",
        "        cons_thread.start()\n",
        "        while prod_thread.isAlive():\n",
        "            prod_thread.join(timeout=0.1)\n",
        "        while cons_thread.isAlive():\n",
        "            cons_thread.join(timeout=0.1)\n",
        "\n",
        "        stop = timeit.default_timer()\n",
        "        self.results.bytes_received = sum(finished)\n",
        "        self.results.download = (\n",
        "            (self.results.bytes_received / (stop - start)) * 8.0\n",
        "        )\n",
        "        if self.results.download > 100000:\n",
        "            self.config['threads']['upload'] = 8\n",
        "        return self.results.download\n",
        "\n",
        "    def upload(self, callback=do_nothing, pre_allocate=True, threads=None):\n",
        "        \"\"\"Test upload speed against speedtest.net\n",
        "        A ``threads`` value of ``None`` will fall back to those dictated\n",
        "        by the speedtest.net configuration\n",
        "        \"\"\"\n",
        "\n",
        "        sizes = []\n",
        "\n",
        "        for size in self.config['sizes']['upload']:\n",
        "            for _ in range(0, self.config['counts']['upload']):\n",
        "                sizes.append(size)\n",
        "\n",
        "        # request_count = len(sizes)\n",
        "        request_count = self.config['upload_max']\n",
        "\n",
        "        requests = []\n",
        "        for i, size in enumerate(sizes):\n",
        "            # We set ``0`` for ``start`` and handle setting the actual\n",
        "            # ``start`` in ``HTTPUploader`` to get better measurements\n",
        "            data = HTTPUploaderData(\n",
        "                size,\n",
        "                0,\n",
        "                self.config['length']['upload'],\n",
        "                shutdown_event=self._shutdown_event\n",
        "            )\n",
        "            if pre_allocate:\n",
        "                data.pre_allocate()\n",
        "\n",
        "            headers = {'Content-length': size}\n",
        "            requests.append(\n",
        "                (\n",
        "                    build_request(self.best['url'], data, secure=self._secure,\n",
        "                                  headers=headers),\n",
        "                    size\n",
        "                )\n",
        "            )\n",
        "\n",
        "        def producer(q, requests, request_count):\n",
        "            for i, request in enumerate(requests[:request_count]):\n",
        "                thread = HTTPUploader(\n",
        "                    i,\n",
        "                    request[0],\n",
        "                    start,\n",
        "                    request[1],\n",
        "                    self.config['length']['upload'],\n",
        "                    opener=self._opener,\n",
        "                    shutdown_event=self._shutdown_event\n",
        "                )\n",
        "                thread.start()\n",
        "                q.put(thread, True)\n",
        "                callback(i, request_count, start=True)\n",
        "\n",
        "        finished = []\n",
        "\n",
        "        def consumer(q, request_count):\n",
        "            while len(finished) < request_count:\n",
        "                thread = q.get(True)\n",
        "                while thread.isAlive():\n",
        "                    thread.join(timeout=0.1)\n",
        "                finished.append(thread.result)\n",
        "                callback(thread.i, request_count, end=True)\n",
        "\n",
        "        q = Queue(threads or self.config['threads']['upload'])\n",
        "        prod_thread = threading.Thread(target=producer,\n",
        "                                       args=(q, requests, request_count))\n",
        "        cons_thread = threading.Thread(target=consumer,\n",
        "                                       args=(q, request_count))\n",
        "        start = timeit.default_timer()\n",
        "        prod_thread.start()\n",
        "        cons_thread.start()\n",
        "        while prod_thread.isAlive():\n",
        "            prod_thread.join(timeout=0.1)\n",
        "        while cons_thread.isAlive():\n",
        "            cons_thread.join(timeout=0.1)\n",
        "\n",
        "        stop = timeit.default_timer()\n",
        "        self.results.bytes_sent = sum(finished)\n",
        "        self.results.upload = (\n",
        "            (self.results.bytes_sent / (stop - start)) * 8.0\n",
        "        )\n",
        "        return self.results.upload\n",
        "\n",
        "\n",
        "def ctrl_c(shutdown_event):\n",
        "    \"\"\"Catch Ctrl-C key sequence and set a SHUTDOWN_EVENT for our threaded\n",
        "    operations\n",
        "    \"\"\"\n",
        "    def inner(signum, frame):\n",
        "        shutdown_event.set()\n",
        "        printer('\\nCancelling...', error=True)\n",
        "        sys.exit(0)\n",
        "    return inner\n",
        "\n",
        "\n",
        "def version():\n",
        "    \"\"\"Print the version\"\"\"\n",
        "\n",
        "    printer('speedtest-cli %s' % __version__)\n",
        "    printer('Python %s' % sys.version.replace('\\n', ''))\n",
        "    sys.exit(0)\n",
        "\n",
        "\n",
        "def csv_header(delimiter=','):\n",
        "    \"\"\"Print the CSV Headers\"\"\"\n",
        "\n",
        "    printer(SpeedtestResults.csv_header(delimiter=delimiter))\n",
        "    sys.exit(0)\n",
        "\n",
        "\n",
        "def parse_args():\n",
        "    \"\"\"Function to handle building and parsing of command line arguments\"\"\"\n",
        "    description = (\n",
        "        'Command line interface for testing internet bandwidth using '\n",
        "        'speedtest.net.\\n'\n",
        "        '------------------------------------------------------------'\n",
        "        '--------------\\n'\n",
        "        'https://github.com/sivel/speedtest-cli')\n",
        "\n",
        "    parser = ArgParser(description=description)\n",
        "    # Give optparse.OptionParser an `add_argument` method for\n",
        "    # compatibility with argparse.ArgumentParser\n",
        "    try:\n",
        "        parser.add_argument = parser.add_option\n",
        "    except AttributeError:\n",
        "        pass\n",
        "    parser.add_argument('--no-download', dest='download', default=True,\n",
        "                        action='store_const', const=False,\n",
        "                        help='Do not perform download test')\n",
        "    parser.add_argument('--no-upload', dest='upload', default=True,\n",
        "                        action='store_const', const=False,\n",
        "                        help='Do not perform upload test')\n",
        "    parser.add_argument('--single', default=False, action='store_true',\n",
        "                        help='Only use a single connection instead of '\n",
        "                             'multiple. This simulates a typical file '\n",
        "                             'transfer.')\n",
        "    parser.add_argument('--bytes', dest='units', action='store_const',\n",
        "                        const=('byte', 8), default=('bit', 1),\n",
        "                        help='Display values in bytes instead of bits. Does '\n",
        "                             'not affect the image generated by --share, nor '\n",
        "                             'output from --json or --csv')\n",
        "    parser.add_argument('--share', action='store_true',\n",
        "                        help='Generate and provide a URL to the speedtest.net '\n",
        "                             'share results image, not displayed with --csv')\n",
        "    parser.add_argument('--simple', action='store_true', default=False,\n",
        "                        help='Suppress verbose output, only show basic '\n",
        "                             'information')\n",
        "    parser.add_argument('--csv', action='store_true', default=False,\n",
        "                        help='Suppress verbose output, only show basic '\n",
        "                             'information in CSV format. Speeds listed in '\n",
        "                             'bit/s and not affected by --bytes')\n",
        "    parser.add_argument('--csv-delimiter', default=',', type=PARSER_TYPE_STR,\n",
        "                        help='Single character delimiter to use in CSV '\n",
        "                             'output. Default \",\"')\n",
        "    parser.add_argument('--csv-header', action='store_true', default=False,\n",
        "                        help='Print CSV headers')\n",
        "    parser.add_argument('--json', action='store_true', default=False,\n",
        "                        help='Suppress verbose output, only show basic '\n",
        "                             'information in JSON format. Speeds listed in '\n",
        "                             'bit/s and not affected by --bytes')\n",
        "    parser.add_argument('--list', action='store_true',\n",
        "                        help='Display a list of speedtest.net servers '\n",
        "                             'sorted by distance')\n",
        "    parser.add_argument('--server', type=PARSER_TYPE_INT, action='append',\n",
        "                        help='Specify a server ID to test against. Can be '\n",
        "                             'supplied multiple times')\n",
        "    parser.add_argument('--exclude', type=PARSER_TYPE_INT, action='append',\n",
        "                        help='Exclude a server from selection. Can be '\n",
        "                             'supplied multiple times')\n",
        "    parser.add_argument('--mini', help='URL of the Speedtest Mini server')\n",
        "    parser.add_argument('--source', help='Source IP address to bind to')\n",
        "    parser.add_argument('--timeout', default=10, type=PARSER_TYPE_FLOAT,\n",
        "                        help='HTTP timeout in seconds. Default 10')\n",
        "    parser.add_argument('--secure', action='store_true',\n",
        "                        help='Use HTTPS instead of HTTP when communicating '\n",
        "                             'with speedtest.net operated servers')\n",
        "    parser.add_argument('--no-pre-allocate', dest='pre_allocate',\n",
        "                        action='store_const', default=True, const=False,\n",
        "                        help='Do not pre allocate upload data. Pre allocation '\n",
        "                             'is enabled by default to improve upload '\n",
        "                             'performance. To support systems with '\n",
        "                             'insufficient memory, use this option to avoid a '\n",
        "                             'MemoryError')\n",
        "    parser.add_argument('--version', action='store_true',\n",
        "                        help='Show the version number and exit')\n",
        "    parser.add_argument('--debug', action='store_true',\n",
        "                        help=ARG_SUPPRESS, default=ARG_SUPPRESS)\n",
        "\n",
        "    options = parser.parse_args(args=[])\n",
        "    if isinstance(options, tuple):\n",
        "        args = options[0]\n",
        "    else:\n",
        "        args = options\n",
        "    return args\n",
        "\n",
        "\n",
        "def validate_optional_args(args):\n",
        "    \"\"\"Check if an argument was provided that depends on a module that may\n",
        "    not be part of the Python standard library.\n",
        "    If such an argument is supplied, and the module does not exist, exit\n",
        "    with an error stating which module is missing.\n",
        "    \"\"\"\n",
        "    optional_args = {\n",
        "        'json': ('json/simplejson python module', json),\n",
        "        'secure': ('SSL support', HTTPSConnection),\n",
        "    }\n",
        "\n",
        "    for arg, info in optional_args.items():\n",
        "        if getattr(args, arg, False) and info[1] is None:\n",
        "            raise SystemExit('%s is not installed. --%s is '\n",
        "                             'unavailable' % (info[0], arg))\n",
        "\n",
        "\n",
        "def printer(string, quiet=False, debug=False, error=False, **kwargs):\n",
        "    \"\"\"Helper function print a string with various features\"\"\"\n",
        "\n",
        "    if debug and not DEBUG:\n",
        "        return\n",
        "\n",
        "    if debug:\n",
        "        if sys.stdout.isatty():\n",
        "            out = '\\033[1;30mDEBUG: %s\\033[0m' % string\n",
        "        else:\n",
        "            out = 'DEBUG: %s' % string\n",
        "    else:\n",
        "        out = string\n",
        "\n",
        "    if error:\n",
        "        kwargs['file'] = sys.stderr\n",
        "\n",
        "    if not quiet:\n",
        "        print_(out, **kwargs)\n",
        "\n",
        "\n",
        "def shell():\n",
        "    \"\"\"Run the full speedtest.net test\"\"\"\n",
        "\n",
        "    global DEBUG\n",
        "    shutdown_event = threading.Event()\n",
        "\n",
        "    signal.signal(signal.SIGINT, ctrl_c(shutdown_event))\n",
        "\n",
        "    args = parse_args()\n",
        "\n",
        "    # Print the version and exit\n",
        "    if args.version:\n",
        "        version()\n",
        "\n",
        "    if not args.download and not args.upload:\n",
        "        raise SpeedtestCLIError('Cannot supply both --no-download and '\n",
        "                                '--no-upload')\n",
        "\n",
        "    if len(args.csv_delimiter) != 1:\n",
        "        raise SpeedtestCLIError('--csv-delimiter must be a single character')\n",
        "\n",
        "    if args.csv_header:\n",
        "        csv_header(args.csv_delimiter)\n",
        "\n",
        "    validate_optional_args(args)\n",
        "\n",
        "    debug = getattr(args, 'debug', False)\n",
        "    if debug == 'SUPPRESSHELP':\n",
        "        debug = False\n",
        "    if debug:\n",
        "        DEBUG = True\n",
        "\n",
        "    if args.simple or args.csv or args.json:\n",
        "        quiet = True\n",
        "    else:\n",
        "        quiet = False\n",
        "\n",
        "    if args.csv or args.json:\n",
        "        machine_format = True\n",
        "    else:\n",
        "        machine_format = False\n",
        "\n",
        "    # Don't set a callback if we are running quietly\n",
        "    if quiet or debug:\n",
        "        callback = do_nothing\n",
        "    else:\n",
        "        callback = print_dots(shutdown_event)\n",
        "\n",
        "    printer('Retrieving speedtest.net configuration...', quiet)\n",
        "    try:\n",
        "        speedtest = Speedtest(\n",
        "            source_address=args.source,\n",
        "            timeout=args.timeout,\n",
        "            secure=args.secure\n",
        "        )\n",
        "    except (ConfigRetrievalError,) + HTTP_ERRORS:\n",
        "        printer('Cannot retrieve speedtest configuration', error=True)\n",
        "        raise SpeedtestCLIError(get_exception())\n",
        "\n",
        "    if args.list:\n",
        "        try:\n",
        "            speedtest.get_servers()\n",
        "        except (ServersRetrievalError,) + HTTP_ERRORS:\n",
        "            printer('Cannot retrieve speedtest server list', error=True)\n",
        "            raise SpeedtestCLIError(get_exception())\n",
        "\n",
        "        for _, servers in sorted(speedtest.servers.items()):\n",
        "            for server in servers:\n",
        "                line = ('%(id)5s) %(sponsor)s (%(name)s, %(country)s) '\n",
        "                        '[%(d)0.2f km]' % server)\n",
        "                try:\n",
        "                    printer(line)\n",
        "                except IOError:\n",
        "                    e = get_exception()\n",
        "                    if e.errno != errno.EPIPE:\n",
        "                        raise\n",
        "        sys.exit(0)\n",
        "\n",
        "    printer('Testing from %(isp)s (%(ip)s)...' % speedtest.config['client'],\n",
        "            quiet)\n",
        "\n",
        "    if not args.mini:\n",
        "        printer('Retrieving speedtest.net server list...', quiet)\n",
        "        try:\n",
        "            speedtest.get_servers(servers=args.server, exclude=args.exclude)\n",
        "        except NoMatchedServers:\n",
        "            raise SpeedtestCLIError(\n",
        "                'No matched servers: %s' %\n",
        "                ', '.join('%s' % s for s in args.server)\n",
        "            )\n",
        "        except (ServersRetrievalError,) + HTTP_ERRORS:\n",
        "            printer('Cannot retrieve speedtest server list', error=True)\n",
        "            raise SpeedtestCLIError(get_exception())\n",
        "        except InvalidServerIDType:\n",
        "            raise SpeedtestCLIError(\n",
        "                '%s is an invalid server type, must '\n",
        "                'be an int' % ', '.join('%s' % s for s in args.server)\n",
        "            )\n",
        "\n",
        "        if args.server and len(args.server) == 1:\n",
        "            printer('Retrieving information for the selected server...', quiet)\n",
        "        else:\n",
        "            printer('Selecting best server based on ping...', quiet)\n",
        "        speedtest.get_best_server()\n",
        "    elif args.mini:\n",
        "        speedtest.get_best_server(speedtest.set_mini_server(args.mini))\n",
        "\n",
        "    results = speedtest.results\n",
        "\n",
        "    printer('Hosted by %(sponsor)s (%(name)s) [%(d)0.2f km]: '\n",
        "            '%(latency)s ms' % results.server, quiet)\n",
        "\n",
        "    if args.download:\n",
        "        printer('Testing download speed', quiet,\n",
        "                end=('', '\\n')[bool(debug)])\n",
        "        speedtest.download(\n",
        "            callback=callback,\n",
        "            threads=(None, 1)[args.single]\n",
        "        )\n",
        "        printer('Download: %0.2f M%s/s' %\n",
        "                ((results.download / 1000.0 / 1000.0) / args.units[1],\n",
        "                 args.units[0]),\n",
        "                quiet)\n",
        "    else:\n",
        "        printer('Skipping download test', quiet)\n",
        "\n",
        "    if args.upload:\n",
        "        printer('Testing upload speed', quiet,\n",
        "                end=('', '\\n')[bool(debug)])\n",
        "        speedtest.upload(\n",
        "            callback=callback,\n",
        "            pre_allocate=args.pre_allocate,\n",
        "            threads=(None, 1)[args.single]\n",
        "        )\n",
        "        printer('Upload: %0.2f M%s/s' %\n",
        "                ((results.upload / 1000.0 / 1000.0) / args.units[1],\n",
        "                 args.units[0]),\n",
        "                quiet)\n",
        "    else:\n",
        "        printer('Skipping upload test', quiet)\n",
        "\n",
        "    printer('Results:\\n%r' % results.dict(), debug=True)\n",
        "\n",
        "    if not args.simple and args.share:\n",
        "        results.share()\n",
        "\n",
        "    if args.simple:\n",
        "        printer('Ping: %s ms\\nDownload: %0.2f M%s/s\\nUpload: %0.2f M%s/s' %\n",
        "                (results.ping,\n",
        "                 (results.download / 1000.0 / 1000.0) / args.units[1],\n",
        "                 args.units[0],\n",
        "                 (results.upload / 1000.0 / 1000.0) / args.units[1],\n",
        "                 args.units[0]))\n",
        "    elif args.csv:\n",
        "        printer(results.csv(delimiter=args.csv_delimiter))\n",
        "    elif args.json:\n",
        "        printer(results.json())\n",
        "\n",
        "    if args.share and not machine_format:\n",
        "        printer('Share results: %s' % results.share())\n",
        "\n",
        "\n",
        "def main():\n",
        "    try:\n",
        "        shell()\n",
        "    except KeyboardInterrupt:\n",
        "        printer('\\nCancelling...', error=True)\n",
        "    except (SpeedtestException, SystemExit):\n",
        "        e = get_exception()\n",
        "        # Ignore a successful exit, or argparse exit\n",
        "        if getattr(e, 'code', 1) not in (0, 2):\n",
        "            msg = '%s' % e\n",
        "            if not msg:\n",
        "                msg = '%r' % e\n",
        "            raise SystemExit('ERROR: %s' % msg)\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    main()"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}