All_in_One_v1_5_(Beta).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "All in One-v1-5 (Beta).ipynb",
      "provenance": [],
      "collapsed_sections": [
        "uGAJFdQNdUcM",
        "Cqy3vXXOMI06",
        "zRTgBdCpBWMh",
        "cOUZEXihsqCD",
        "bNAroQWy6hL3",
        "Ov6PHWiF4QuO",
        "ercDPZ6CIlVz",
        "SZBgJu8E-W7M",
        "4E-uzYrv5o0B",
        "NkFQ5VDxpteH",
        "JnIOQZ2I-aDT",
        "StT2bKf2WmKj",
        "Ttv0CeCqLX0t",
        "AGVmJ2Y43o_C",
        "7dTNq8TFD6a-",
        "VDInERXVmnm8",
        "PE5J1UDzQXSp",
        "SoxLe8ciEyAc",
        "A0y8bdJSpbmD",
        "WanlireZOjvx",
        "6wktcwkWtHH0",
        "xa8RqAm2wozX",
        "63bRZrGJEZnI",
        "PGMUhd7sVOY9",
        "fJ7W2Z0gcYa5",
        "cHTe9qp2E6f5",
        "yOnMe4O3jtXf",
        "kSvUMUuTPX7r",
        "dySANcIIMdFU",
        "zajDdD9kKNw9",
        "c3cOMk38t8Zm",
        "mtIWnZ60Sczn",
        "jWNiE-RGECHM",
        "MbJ_88vSD-K2",
        "XgMQmTB8EToD",
        "cLQnx323EdqO",
        "yTPpo294F0U8",
        "n3MWoStHEnJx",
        "DYreGU9NvCdk",
        "OSG8fIhSAmZ-",
        "t0eVljW0O0CG",
        "ukxnQC4c0nuR",
        "EFOqhHG6hOVH",
        "FpJXJiRl6-gK",
        "2f-THZmDoOaY",
        "0xI8WiUPji3k",
        "QlsUJhNwyeV3",
        "FVvFaJrZ0bxg",
        "INCWjTDRLye6",
        "4rMlpsk3jv5r",
        "-9RhonZDwNYC"
      ],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/totalleecher/Codemaster/blob/master/All_in_One_v1_5_(Beta).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "uGAJFdQNdUcM"
      },
      "source": [
        "# <center><b>Welcome to My Page</b><h5>You can remote upload and download torrent to your <b>Google Drive</b> Here</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cqy3vXXOMI06",
        "colab_type": "text"
      },
      "source": [
        "# ✦ *Colab Still Alive Console Script:*\n",
        "<p><font size=2px ><font color=\"red\"> Tip - Set a javascript interval to click on the connect button every 60 seconds. Open developer-settings (in your web-browser) with Ctrl+Shift+I then click on console tab and type this on the console prompt. (for mac press Option+Command+I)</font></p><b>Copy script in hidden cell and paste at your browser console !!! DO NOT CLOSE YOUR BROWSER IN ORDER TO STILL RUNNING SCRIPT</b>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Z8cK8h2Avbv",
        "colab_type": "text"
      },
      "source": [
        "function ClickConnect(){\n",
        "    console.log(\"Working\"); \n",
        "    document.querySelector(\"colab-connect-button\").click() \n",
        "}\n",
        "setInterval(ClickConnect,60000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zRTgBdCpBWMh"
      },
      "source": [
        "# ✦ *Quick Useful Scripts:*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cOUZEXihsqCD",
        "colab_type": "text"
      },
      "source": [
        "## ✧ MediaInfo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NTULRguzu0b0",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "path = \"\" #@param {type:\"string\"}\n",
        "save_txt = False #@param {type:\"boolean\"}\n",
        "import os, uuid, re, IPython\n",
        "import ipywidgets as widgets\n",
        "import time\n",
        "\n",
        "from glob import glob\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output, drive\n",
        "\n",
        "def mediainfo():\n",
        "  display(HTML(\"<br>\"))\n",
        "#   print(path.split(\"/\")[::-1][0])\n",
        "  display(HTML(\"<br>\"))\n",
        "#   media = !mediainfo \"$path\"\n",
        "#   media = \"\\n\".join(media).replace(os.path.dirname(path)+\"/\", \"\")\n",
        "  get_ipython().system_raw(\"\"\"mediainfo --LogFile=\"/root/.nfo\" \"$path\" \"\"\")\n",
        "  with open('/root/.nfo', 'r') as file:\n",
        "    media = file.read()\n",
        "    media = media.replace(os.path.dirname(path)+\"/\", \"\")\n",
        "  print(media)\n",
        "  get_ipython().system_raw(\"rm -f '/root/.nfo'\")\n",
        "  \n",
        "  if save_txt:\n",
        "    txt = path.rpartition('.')[0] + \".txt\"\n",
        "    if os.path.exists(txt):\n",
        "      get_ipython().system_raw(\"rm -f '$txt'\")\n",
        "    !curl -s https://pastebin.com/raw/TApKLQfM -o \"$txt\"\n",
        "    with open(txt, 'a+') as file:\n",
        "      file.write(\"\\n\\n\")\n",
        "      file.write(media)\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()\n",
        "    \n",
        "if not os.path.exists(\"/usr/bin/mediainfo\"):\n",
        "  get_ipython().system_raw(\"apt-get install mediainfo\")\n",
        "  \n",
        "mediainfo()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bNAroQWy6hL3",
        "colab_type": "text"
      },
      "source": [
        "## ✧ Generate Streamable Video Links from Google Drive\n",
        "##### *Note: This cell will only work with links that are shared publically*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "W4EXnKHuwmq0",
        "colab": {}
      },
      "source": [
        "import re\n",
        "\n",
        "shared_file_link = \"\" #@param {type:\"string\"}\n",
        "result = re.search(\"[\\w-]{33}\", shared_file_link)\n",
        "your_api_key = \"\" #@param {type:\"string\"}\n",
        "drive_file_id = result.group(0)\n",
        "\n",
        "beg_url = \"https://www.googleapis.com/drive/v3/files/\"\n",
        "end_url = \"/?key=\" + your_api_key + \"&alt=media\"\n",
        "\n",
        "print(beg_url + drive_file_id + end_url)\n",
        "\n",
        "## *This cell will only work with links that are shared publically*"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wZMZjX127rmx",
        "colab_type": "text"
      },
      "source": [
        "## ✧ Crash Colab to clear all RAM"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OH3xVkwWmPYL",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title ← ឵឵ ឵Run this cell to crash your current Runtime if you're low on memory\n",
        "#@markdown <i>After crashing, you'll have access to all the preoccupied storage</i>\n",
        "some_str = ' ' * 5120000000000"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ov6PHWiF4QuO",
        "colab_type": "text"
      },
      "source": [
        "## ✧ Check Your Notebook Spec: Here\n",
        "> The VM used for Colaboratory appears to have 13GB RAM and 2 vCPU when checking using psutil (so a n1-highmem-2 instance)\n",
        "\n",
        "- 2-core Xeon 2.2GHz\n",
        "- 13GB RAM\n",
        "- 33GB HDD\n",
        "\n",
        "maximum lifetime of a VM is 12 hours. Idle VMs time out after 90m"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5GfC8NDx1IOO",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown <h3>⬅️ Click Here to START check your notebook</h3><p>\n",
        "from psutil import *"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xEk87QsflHfP",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Notebook's Internet Speed\n",
        "!sudo apt install speedtest-cli\n",
        "!speedtest-cli"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0BEnwM-W23Y4",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← OS Ver, etc.\n",
        "!cat /proc/version\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "01i75DIjKA5D",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Cpu model\n",
        "!lscpu |grep 'Model name'\n",
        "!cat /proc/cpuinfo"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WPJdbG8K1LZI",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Cpu Count\n",
        "cpu_count()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hJVLg_-4P-Pe",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← no.of sockets i.e available slots for physical processors\n",
        "!lscpu | grep 'Socket(s):'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7yL1tbVeuolJ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← no.of cores each processor is having \n",
        "!lscpu | grep 'Core(s) per socket:'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O09Z1aBpta_e",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← no.of threads each core is having\n",
        "!lscpu | grep 'Thread(s) per core'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7q3wBeTmb4I9",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← L3 cache\n",
        "!lscpu | grep \"L3 cache\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "se9YH4Ps2YAC",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Cpu State\n",
        "cpu_stats()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rYhXUmlNdfFa",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← if it had turbo boost it would've shown Min and Max MHz also but it is only showing current frequency this means it always operates at 2.3GHz\n",
        "!lscpu | grep \"MHz\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ojGuEt8MpJhA",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← use this command to see GPU activity while doing Deep Learning tasks, for this command 'nvidia-smi' and for above one to work, go to 'Runtime > change runtime type > Hardware Accelerator > GPU'\n",
        "!nvidia-smi"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wWkNAM6_OQel",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Click Here to test Notebook's GPU\n",
        "\n",
        "import tensorflow as tf\n",
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gsqXZwauphVV",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← ឵឵GPU count and name\n",
        "!nvidia-smi -L"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GBTdcSKu2VI4",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Gpu test\n",
        "from tensorflow.python.client import device_lib\n",
        "device_lib.list_local_devices()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CjqPaVrihUur",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← memory that we can use\n",
        "!cat /proc/meminfo | grep 'MemAvailable'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YELZKyxU4BiX",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Virtual Memory\n",
        "virtual_memory()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HfLRIyH83che",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← HDD info\n",
        "!df -h"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qvyB0VG4j4zx",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← hard disk that we can use\n",
        "!df -h / | awk '{print $4}'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ercDPZ6CIlVz"
      },
      "source": [
        "# <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/600px-Google_Drive_logo.png\" height=30px>      ___Mount / Unmount Gdrive!___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "U2avD1zRIlWA",
        "colab": {}
      },
      "source": [
        "#@markdown <br><center><img src='https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/600px-Google_Drive_logo.png' height=\"50\" alt=\"Gdrive logo\"/></center>\n",
        "#@markdown <center><h3>Mount Gdrive to /content/drive</h3></center><br>\n",
        "MODE = \"MOUNT\" #@param [\"MOUNT\", \"UNMOUNT\"]\n",
        "#Mount your Gdrive! \n",
        "from google.colab import drive\n",
        "drive.mount._DEBUG = False\n",
        "if MODE == \"MOUNT\":\n",
        "  drive.mount('/content/drive', force_remount=True)\n",
        "elif MODE == \"UNMOUNT\":\n",
        "  try:\n",
        "    drive.flush_and_unmount()\n",
        "  except ValueError:\n",
        "    pass\n",
        "  get_ipython().system_raw(\"rm -rf /root/.config/Google/DriveFS\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "SZBgJu8E-W7M"
      },
      "source": [
        "# <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/600px-Google_Drive_logo.png\" height=30px> ___*Google SDK*___<p>Directly downloaded to your <b>Gdirve</b>. No need to worry about Notebook's space (Beta Ver.)</p>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C6MUykpFnfvO",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Mount Google SDK</h3><p>\n",
        "#@markdown - Only works with deluge <p>\n",
        "#@markdown - Change setting in deluge app ==> uncheck \"Move completed to\"\n",
        "\n",
        "!apt-get install -y -qq software-properties-common python-software-properties module-init-tools\n",
        "!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null\n",
        "!apt-get update -qq 2>&1 > /dev/null\n",
        "!apt-get -y install -qq google-drive-ocamlfuse fuse\n",
        "from google.colab import auth\n",
        "auth.authenticate_user()\n",
        "from oauth2client.client import GoogleCredentials\n",
        "creds = GoogleCredentials.get_application_default()\n",
        "import getpass\n",
        "!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL\n",
        "vcode = getpass.getpass()\n",
        "!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}\n",
        "\n",
        "##\n",
        "!mkdir -p downloads\n",
        "!google-drive-ocamlfuse drive downloads"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4E-uzYrv5o0B",
        "colab_type": "text"
      },
      "source": [
        "# <img src='https://forum.rclone.org/uploads/default/original/2X/d/da6ccb2784ff3fa73d9339300530e0aae4d6cebd.png' height=\"46\" alt=\"rclone\"/><i>         __Mounting with rclone__</i>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iroeLPFdXbif",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>Step 1. </b>Upload your <code>rclone.conf</code> profile</h3>\n",
        "#@markdown <h6>*<i>required to mount your drive!</i></h4>\n",
        "#@markdown \n",
        "Setup_Time_Zone = False \n",
        "\n",
        "import os; from google.colab import files; from IPython.display import HTML, clear_output\n",
        "\n",
        "def upload_conf():\n",
        "  try:\n",
        "    display(HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#446785;\\\">Please upload the config file of rclone (rclone.conf) 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) == True:\n",
        "          os.environ[\"rclone_conf\"] = fn\n",
        "          !mv -f \"$rclone_conf\" /root/.rclone.conf\n",
        "          !chmod 666 /root/.rclone.conf\n",
        "          if Setup_Time_Zone == True:\n",
        "            !sudo dpkg-reconfigure tzdata\n",
        "            clear_output(wait=True)\n",
        "          if os.path.isfile(\"/usr/bin/rclone\") == True:\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#00b24c;\\\">Config has been changed.</h2><br></center>\"))\n",
        "          else:\n",
        "            !rm -rf /content/sample_data/\n",
        "            !curl -s https://rclone.org/install.sh | sudo bash\n",
        "            clear_output(wait=True)\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#446785;\\\">Installation has been successfully completed.</h2><br></center>\"))\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",
        "        os.environ[\"rclone_conf\"] = fn\n",
        "        !rm -f \"$rclone_conf\"\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",
        "\n",
        "upload_conf()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mp6XoynaX4HN",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3><b>Step 2</b>. Mount your Drive with rclone</h3>\n",
        "#@markdown <ul><li><i>Replace values to match the </i><code>rclone.conf</code><i> file you just uploaded</i></li></ul>\n",
        "rclone_config_name = \"GDrive\" #@param {type:\"string\"}\n",
        "local_mount_location = \"/content/udrive/\" #@param {type:\"string\"}\n",
        "# ============================= FORM ============================= #\n",
        "import time\n",
        "import os\n",
        "\n",
        "# clear nohup\n",
        "open(\"nohup.out\", 'w').close()\n",
        "\n",
        "\n",
        "# unmount first\n",
        "\n",
        "!fusermount -u $local_mount_location 2>/dev/null\n",
        "\n",
        "\n",
        "# mount without waiting for the command to complete\n",
        "!mkdir $local_mount_location 2>/dev/null\n",
        "!nohup rclone mount $rclone_config_name: $local_mount_location --buffer-size 96M & \n",
        "  \n",
        "\n",
        "\n",
        "# Show the output that was written to nohup\n",
        "time.sleep(3)\n",
        "f = open(r\"nohup.out\", \"r\")\n",
        "nohupText = f.read()\n",
        "f.close()\n",
        "\n",
        "\n",
        "dirs = os.listdir(local_mount_location)\n",
        "\n",
        "if len(dirs) > 0:\n",
        "  clear_output(wait=True)\n",
        "  print(\"Succeeded. \", str(len(dirs)), \"dirs found at\", local_mount_location)\n",
        "\n",
        "else:\n",
        "  print(\"\\n\\nNot succeeded. No files or directories in mounted location. \\nCheck your config name and content. If the rclone command was not found, run the cell above.\\n\\n\")\n",
        "  print(\"log:\\n\", nohupText)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "NkFQ5VDxpteH"
      },
      "source": [
        "# <center><b>Direct Link, Spotify, You Tube Link, Yandex, Google Drive Downloaders</b><h5>All of hidden cells are direct downloaders</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JnIOQZ2I-aDT",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://upload.wikimedia.org/wikipedia/commons/thumb/2/21/Icons8_flat_upload.svg/800px-Icons8_flat_upload.svg.png' height=\"45\" alt=\"RcloneLab\"/>___Remote Uploading___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tMxyvI91WEgy",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START SERVER</h3>\n",
        "\n",
        "%cd /content/drive/My Drive\n",
        "%mkdir DirectDownload\n",
        "%cd DirectDownload\n",
        "\n",
        "#####################################\n",
        "\n",
        "%pip install wget\n",
        "\n",
        "#####################################\n",
        "import wget\n",
        "url = input(\"Enter Remote Url\")\n",
        "initiateDownload = wget.download(url)\n",
        "initiateDownload\n",
        "\n",
        "##\n",
        "\n",
        "%ls /content/drive/My\\ Drive/DirectDownload\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "StT2bKf2WmKj",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://www.booleanworld.com/wp-content/webp-express/webp-images/doc-root/wp-content/uploads/2018/06/wget-cover-300x256@2x.png.webp' height=\"50\" alt=\"qBitTorrent\"/>   ___Wget___<h6>Direct Download / Remote Upload</h6>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_NiTOoCg-hLp",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title <h3><b>←</b> Run to Download a DDL File\n",
        "#@markdown <h5><i>Example URL:</i> <a src=\"\">https://files.catbox.moe/archive.zip</a>\n",
        "direct_URL = \"\" #@param {type:\"string\"}\n",
        "output_dir = \"/content\" #@param {type:\"string\"}\n",
        "\n",
        "!wget \"$Direct_URL\" \"$output_dir\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ttv0CeCqLX0t",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/src/aria2cli.png' height=\"45\" alt=\"aira2\"/> <font size=1px >___Direct link downloader / Remote Uploading___</font>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ASgRAOtBnVDT"
      },
      "source": [
        "___Auto share link supported : Disk.yandex.com, Gdrive and youtube-dl all extractor...___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "plgToqkpLV5q",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "%cd /content/drive/My Drive\n",
        "%mkdir DirectDownload\n",
        "\n",
        "#\n",
        "\n",
        "URL = \"\" #@param {type:\"string\"}\n",
        "#@markdown <center><h5>Default output path <b>/content/drive/My Drive/DirectDownload</b></h5></center>\n",
        "OUTPUT_PATH = \"\" #@param {type:\"string\"}\n",
        "\n",
        "import pathlib\n",
        "import shutil\n",
        "import hashlib\n",
        "import requests\n",
        "from urllib.parse import urlparse\n",
        "from os import path, mkdir\n",
        "if not path.exists(\"/root/.ipython/ttmg.py\"): \n",
        "    from subprocess import run\n",
        "    from shlex import split\n",
        "\n",
        "    shellCmd = \"wget -qq https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py \\\n",
        "                    -O /root/.ipython/ttmg.py\"\n",
        "    run(split(shellCmd))\n",
        "from ttmg import updateCheck, runSh\n",
        "\n",
        "def youtubedlInstall():\n",
        "  if not path.isfile(\"/usr/local/bin/youtube-dl\"):\n",
        "    cmdC = \"rm -rf /content/sample_data/ && \" \\\n",
        "            \" mkdir -p -m 666 /root/.YouTube-DL/ &&\" \\\n",
        "            \" apt-get install atomicparsley &&\" \\\n",
        "            \" curl -L https://yt-dl.org/downloads/latest/youtube-dl \" \\\n",
        "            \"-o /usr/local/bin/youtube-dl &&\" \\\n",
        "            \" chmod a+rx /usr/local/bin/youtube-dl\"\n",
        "    get_ipython().system_raw(cmdC)\n",
        "\n",
        "def aria2Install():\n",
        "  runSh('apt install -y aria2')\n",
        "\n",
        "def istmd(URL): \n",
        "  link = urlparse(URL)\n",
        "    \n",
        "  #YandexDisk\n",
        "  if link.netloc == \"yadi.sk\":\n",
        "    API_ENDPOINT = 'https://cloud-api.yandex.net/v1/disk/public/resources/' \\\n",
        "                    '?public_key={}&path=/{}&offset={}'\n",
        "    dry = False\n",
        "    def md5sum(file_path):\n",
        "        md5 = hashlib.md5()\n",
        "        with open(file_path, 'rb') as f:\n",
        "            for chunk in iter(lambda: f.read(128 * md5.block_size), b''):\n",
        "                md5.update(chunk)\n",
        "        return md5.hexdigest()\n",
        "\n",
        "\n",
        "    def check_and_download_file(target_path, url, size, checksum):\n",
        "        if path.isfile(target_path):\n",
        "            if size == path.getsize(target_path):\n",
        "                if checksum == md5sum(target_path):\n",
        "                    print('URL {}'.format(url))\n",
        "                    print('skipping correct {}'.format(target_path))\n",
        "                    return\n",
        "        if not dry:\n",
        "            print('URL {}'.format(url))\n",
        "            print('downloading {}'.format(target_path))\n",
        "            runSh(f'aria2c -x 16 -s 16 -k 1M -d {OUTPUT_PATH} {url}', output=True)\n",
        "            # r = requests.get(url, stream=True)\n",
        "            # with open(target_path, 'wb') as f:\n",
        "            #     shutil.copyfileobj(r.raw, f)\n",
        "\n",
        "\n",
        "    def download_path(target_path, public_key, source_path, offset=0):\n",
        "        print('getting \"{}\" at offset {}'.format(source_path, offset))\n",
        "        current_path = path.join(target_path, source_path)\n",
        "        pathlib.Path(current_path).mkdir(parents=True, exist_ok=True)\n",
        "        jsn = requests.get(API_ENDPOINT.format(public_key, source_path, offset)).json()\n",
        "        def try_as_file(j):\n",
        "            if 'file' in j:\n",
        "                file_save_path = path.join(current_path, j['name'])\n",
        "                check_and_download_file(file_save_path, j['file'], j['size'], j['md5'])\n",
        "                return True\n",
        "            return False\n",
        "\n",
        "        # first try to treat the actual json as a single file description\n",
        "        if try_as_file(jsn):\n",
        "            return\n",
        "\n",
        "        # otherwise treat it as a directory\n",
        "        emb = jsn['_embedded']\n",
        "        items = emb['items']\n",
        "        for i in items:\n",
        "            # each item can be a file...\n",
        "            if try_as_file(i):\n",
        "                continue\n",
        "            # ... or a directory\n",
        "            else:\n",
        "                subdir_path = path.join(source_path, i['name'])\n",
        "                download_path(target_path, public_key, subdir_path)\n",
        "\n",
        "        # check if current directory has more items\n",
        "        last = offset + emb['limit']\n",
        "        if last < emb['total']:\n",
        "            download_path(target_path, public_key, source_path, last)\n",
        "    download_path(OUTPUT_PATH, URL, '')\n",
        "    return False  \n",
        "  return URL\n",
        "\n",
        "if not OUTPUT_PATH:\n",
        "  OUTPUT_PATH = \"/content/drive/My Drive/DirectDownload\"\n",
        "  \n",
        "if not URL == \"\":\n",
        "  aria2Install()\n",
        "  youtubedlInstall()\n",
        "  try:\n",
        "    mkdir(\"DirectDownload\")\n",
        "  except FileExistsError:\n",
        "    pass\n",
        "  url = istmd(URL)\n",
        "  if url != False:\n",
        "    print('URL {}'.format(URL))\n",
        "    cmdC = f'youtube-dl -o \"{OUTPUT_PATH}/%(title)s\" {URL} ' \\\n",
        "            '--external-downloader aria2c ' \\\n",
        "            '--external-downloader-args \"-x 16 -s 16 -k 1M\"'\n",
        "    runSh(cmdC, output=True)\n",
        "else:\n",
        "  print(\"Please input url\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AGVmJ2Y43o_C",
        "colab_type": "text"
      },
      "source": [
        "##<left><img src=\"https://ar.toneden.io/13766685/6070f58d-091b-4a80-bd5c-24378e308116\" height=\"50\" alt=\"Zippyshare logo\"/></left> <h6>___Zippyshare Downloader___</h6>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GEcLzHgFArPH",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <center><img src=\"https://ar.toneden.io/13766685/6070f58d-091b-4a80-bd5c-24378e308116\" height=\"100\" alt=\"Zippyshare logo\"/></center>\n",
        "#@markdown <center><h3>Remote upload from Zippyshare to Google drive</h3></center><br>\n",
        "%cd /content\n",
        "!git clone https://github.com/mcrapet/plowshare.git\n",
        "%cd plowshare\n",
        "!make install\n",
        "!plowmod --install\n",
        "!apt-get install nodejs\n",
        "!cd ..\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Gu5xTR0-reg",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START Download</h3>\n",
        "\n",
        "import os\n",
        "direct_URL = \"\" #@param {type:\"string\"}\n",
        "output_dir = \"/content/drive/My Drive\" #@param {type:\"string\"}\n",
        "\n",
        "!plowdown \"$direct_URL\" -o \"$output_dir\"\n",
        "\n",
        "%cd /content/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6WKY3zCQ86ev",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START Batch Download</h3>\n",
        "#@markdown <h5> Make \"download.txt\" file contaning batch links of zippyshare and upload here to down them all.\n",
        "\n",
        "%cd /content/plowshare\n",
        "\n",
        "!rm *.txt\n",
        "\n",
        "from google.colab import files\n",
        "files.upload()\n",
        "\n",
        "import os\n",
        "output_dir = \"/content/drive/My Drive\" #@param {type:\"string\"}\n",
        "\n",
        "!plowdown \"download.txt\" -m -o \"$output_dir\"\n",
        "\n",
        "%cd /content/\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7dTNq8TFD6a-",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_jdownloader.png' height=\"45\" alt=\"JDownloader\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2fQoIcEOD1yu",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute JDownloader\n",
        "# @markdown Example : totalleecher@gmail.com\n",
        "NEW_Account = False  # @param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "from os import path as _p\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run  # nosec\n",
        "\n",
        "    shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                    -O /root/.ipython/rlab_utils.py\"\n",
        "    run(_spl(shellCmd))  # nosec\n",
        "\n",
        "from rlab_utils import handleJDLogin\n",
        "\n",
        "handleJDLogin(NEW_Account)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VDInERXVmnm8",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://github.com/pyload/pyload-webui/raw/master/media/banner.png' height=\"45\" alt=\"JDownloader\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "Ko43eOzYByBf",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://github.com/pyload/pyload-webui/raw/master/media/banner.png' height=\"100\" alt=\"pyLoad\"/></center>\n",
        "#@markdown <center><h3>pyLoad Webinterface<br />The free and open-source Download Manager written in pure Python</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.2.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "#@markdown Default <br>&emsp;username : admin<br>&emsp;password : admin\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs('downloads', exist_ok=True)\n",
        "os.makedirs('tools/pyload', exist_ok=True)\n",
        "\n",
        "# Downloading latest version of pyload\n",
        "if not os.path.exists(\"tools/pyload/pyload-stable\"):\n",
        "  urlF = 'https://github.com/pyload/pyload/archive/stable.zip'\n",
        "  conf = 'https://raw.githubusercontent.com/biplobsd/' \\\n",
        "          'Google-Colab-CloudTorrent/master/res/pyload/pyload.conf'\n",
        "  db = 'https://github.com/biplobsd/Google-Colab-CloudTorrent/raw/master/' \\\n",
        "        'res/pyload/files.db'\n",
        "  urllib.request.urlretrieve(urlF, 'tools/pyload.zip')\n",
        "  urllib.request.urlretrieve(conf, 'tools/pyload/pyload.conf')\n",
        "  urllib.request.urlretrieve(db, 'tools/pyload/files.db')\n",
        "  with zipfile.ZipFile('tools/pyload.zip', 'r') as zip_ref:\n",
        "      zip_ref.extractall('tools/pyload')\n",
        "  try:\n",
        "    pathlib.Path('tools/pyload.zip').unlink()\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "\n",
        "  runSh(\"apt install python-pycurl python-qt4 tesseract-ocr libtesseract-dev\")\n",
        "  runSh(\"pip2 install pycrypto pyOpenSSL Jinja2 tesseract tesseract-ocr\")\n",
        "\n",
        "if not findProcess(\"python2.7\", \"pyLoadCore.py\"):\n",
        "  runCmd = \"python2.7 /content/tools/pyload/pyload-stable/pyLoadCore.py\" \\\n",
        "          \" --configdir=/content/tools/pyload\" \\\n",
        "          \" --no-remote\" \\\n",
        "          \" --daemon\"\n",
        "  runSh(runCmd, shell=True)\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['rcloneConfig', 53682, 'http'], \n",
        "                            ['pyload', 8000, 'http']], 'sa', \n",
        "    [f\"{HOME}/.ngrok2/rclonePyload.yml\", 4074]\n",
        ").start('pyload')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PE5J1UDzQXSp",
        "colab_type": "text"
      },
      "source": [
        "##  <img src='https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/src/spotify-downloader.png' height=\"25\" alt=\"spotify-downloader\" /> spotify-downloader"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v71nnHGOlaSb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/src/spotify-downloader.png' height=\"100\" alt=\"spotify-downloader\"/></center>\n",
        "#@markdown <center><h3>spotify-downloader<br />Download Spotify playlists from YouTube with albumart and meta-tags</h3></center><br>\n",
        "\n",
        "import os, uuid, urllib.parse, re\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",
        "\n",
        "os.makedirs('tools/spotify-downloader/', exist_ok=True)\n",
        "os.makedirs('downloads', exist_ok=True)\n",
        "\n",
        "# # Config files\n",
        "# data = \"\"\"spotify-downloader:\n",
        "#   avconv: false\n",
        "#   download-only-metadata: false\n",
        "#   dry-run: false\n",
        "#   file-format: '{artist} - {track_name}'\n",
        "#   folder: /home/user/Music\n",
        "#   input-ext: .m4a\n",
        "#   log-level: INFO\n",
        "#   manual: false\n",
        "#   music-videos-only: false\n",
        "#   no-fallback-metadata: false\n",
        "#   no-metadata: false\n",
        "#   no-spaces: false\n",
        "#   output-ext: .mp3\n",
        "#   overwrite: prompt\n",
        "#   search-format: '{artist} - {track_name} lyrics'\n",
        "#   skip: null\n",
        "#   spotify_client_id: 4fe3fecfe5334023a1472516cc99d805\n",
        "#   spotify_client_secret: 0f02b7c483c04257984695007a4a8d5c\n",
        "#   trim-silence: false\n",
        "#   write-successful: null\n",
        "#   write-to: null\n",
        "#   youtube-api-key: null\n",
        "# \"\"\"\n",
        "# with open('tools/spotify-downloader/config.yml', 'w') as wnow:\n",
        "#   wnow.write(data)\n",
        "\n",
        "Links = widgets.Textarea(placeholder='''Link list\n",
        "(one link per line)''')\n",
        "\n",
        "fileFormat = widgets.Text(\n",
        "    value='{artist} - {track_name}',\n",
        "    placeholder='File name format',\n",
        "    description=\"\"\"File Name : file format to save the downloaded track with, each\n",
        "                        tag is surrounded by curly braces. Possible formats:\n",
        "                        ['track_name', 'artist', 'album', 'album_artist',\n",
        "                        'genre', 'disc_number', 'duration', 'year',\n",
        "                        'original_date', 'track_number', 'total_tracks',\n",
        "                        'isrc']\"\"\",\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "searchFormat = widgets.Text(\n",
        "    value='{artist} - {track_name} lyrics',\n",
        "    placeholder='Search format',\n",
        "    description=\"\"\"Search Format : search format to search for on YouTube, each tag is\n",
        "                        surrounded by curly braces. Possible formats:\n",
        "                        ['track_name', 'artist', 'album', 'album_artist',\n",
        "                        'genre', 'disc_number', 'duration', 'year',\n",
        "                        'original_date', 'track_number', 'total_tracks',\n",
        "                        'isrc']\"\"\",\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "tab = widgets.Tab()\n",
        "\n",
        "LinksType = widgets.RadioButtons(\n",
        "    options=['Songs', 'Playlist', 'Album', 'Username', 'Artist'],\n",
        "    value='Songs',\n",
        "    layout={'width': 'max-content'},\n",
        "    description='Links type:',\n",
        "    disabled=False,\n",
        ")\n",
        "\n",
        "SavePathYT = widgets.Dropdown(options=[\"/content/downloads\", \"/content\"])\n",
        "\n",
        "Extension = widgets.Select(options=[\"aac\", \"flac\", \"mp3\", \"m4a\", \"opus\", \"vorbis\", \"wav\"], value=\"mp3\")\n",
        "\n",
        "TrimSilence = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Trim silence',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='remove silence from the start of the audio',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "writeM3u = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Write .m3u playlist',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''generate an .m3u playlist file with youtube links\n",
        "               given a text file containing tracks''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "noMeta = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No metadata',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='do not embed metadata in tracks',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "nf = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No fallback metadata',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''do not use YouTube as fallback for metadata if track\n",
        "                        not found on Spotify''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "dryRun = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Dry run',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip=''' show only track title and YouTube URL, and then skip\n",
        "                        to the next track (if any)''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "MusicVidOnly = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Music Videos Only',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''search only for music videos on Youtube (works only\n",
        "                        when YouTube API key is set''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "NoSpaces = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No Spaces',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''replace spaces with underscores in file names''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "manual = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='manually',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''choose the track to download manually from a list of\n",
        "                        matching tracks''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "nr = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Keep original',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''do not remove the original file after conversion''',\n",
        "    icon='check'\n",
        ")\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 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/downloads\", \"/content\"]\n",
        "\n",
        "\n",
        "def ShowYT():\n",
        "  clear_output(wait=True)\n",
        "  RefreshPathYT()\n",
        "  mainTab = widgets.Box([widgets.HBox([widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Link:</b>\"), Links,\n",
        "                                      LinksType, searchFormat, fileFormat, widgets.HBox([TrimSilence, writeM3u, noMeta]), widgets.HBox([nf, dryRun, MusicVidOnly]),widgets.HBox([NoSpaces, manual, nr])]),\n",
        "                        widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extension:</b>\"), Extension,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extra Arguments:</b>\"), ExtraArg])])])\n",
        "  tab.children = [mainTab]\n",
        "  tab.set_title(0, 'spotify-downloader')\n",
        "  display(tab)\n",
        "  display(HTML(\"<h4 style=\\\"color:#888888;\\\">Save Location:</h4>\"), 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",
        "    if writeM3u.value:\n",
        "      M3u = '--write-m3u'\n",
        "    else:\n",
        "      M3u = ''\n",
        "    if TrimSilence.value:\n",
        "      trmS = '--trim-silence'\n",
        "    else:\n",
        "      trmS = ''\n",
        "    if noMeta.value:\n",
        "      noM = '--no-metadata'\n",
        "    else:\n",
        "      noM = ''\n",
        "    if nf.value:\n",
        "      nfv = '--no-fallback-metadata'\n",
        "    else:\n",
        "      nfv = ''\n",
        "    if dryRun.value:\n",
        "      drR = '--dry-run'\n",
        "    else:\n",
        "      drR = ''\n",
        "    if MusicVidOnly.value:\n",
        "      MsV = '--music-videos-only'\n",
        "    else:\n",
        "      MsV = ''\n",
        "    if NoSpaces.value:\n",
        "      NoS = '--no-spaces'\n",
        "    else:\n",
        "      NoS = ''\n",
        "    if manual.value:\n",
        "      mal = '--manual'\n",
        "    else:\n",
        "      mal = ''\n",
        "    if nr.value:\n",
        "      nro = '--no-remove-original' \n",
        "    else:\n",
        "      nro = ''\n",
        "    if not searchFormat.value == '{artist} - {track_name} lyrics':\n",
        "      seFor = f'--search-format \"{searchFormat.value}\"'\n",
        "    else:\n",
        "      seFor = ''\n",
        "    if not fileFormat.value == '{artist} - {track_name}':\n",
        "      fiFor = f'--file-format \"{fileFormat.value}\"'\n",
        "    else:\n",
        "      fiFor = ''\n",
        "    \n",
        "    if not LinksType.value == 'Songs':\n",
        "      with open('tools/spotify-downloader/finish.txt', 'a+') as master:\n",
        "        for Link in Links.value.splitlines():\n",
        "          if LinksType.value == 'Playlist':\n",
        "            outFileName = !spotdl --playlist $Link\n",
        "          elif LinksType.value == 'Album':\n",
        "            outFileName = !spotdl --album $Link\n",
        "          elif LinksType.value == 'Username':\n",
        "            outFileName = !spotdl -u $Link\n",
        "          elif LinksType.value == 'Artist':\n",
        "            outFileName = !spotdl --all-albums $Link\n",
        "          filename = re.search(r\"to\\s(.+\\.txt)\", outFileName[-1]).group(1)\n",
        "          with open(filename, 'r') as r:\n",
        "            master.write(r.read())\n",
        "    else:\n",
        "      for Link in Links.value.splitlines():\n",
        "        with open('tools/spotify-downloader/finish.txt', 'w') as master:\n",
        "          master.write(Link)\n",
        "    # Extra Arguments\n",
        "    \n",
        "    extraargC = ExtraArg.value\n",
        "    cmd = r\"spotdl -l 'tools/spotify-downloader/finish.txt' \" \\\n",
        "      fr\"-f {SavePathYT.value} \" \\\n",
        "      fr\"-o .{Extension.value} \" \\\n",
        "      f\"--overwrite skip \" \\\n",
        "      f\"{seFor} {fiFor} \" \\\n",
        "      f\"{M3u} {trmS} {noM} {nfv} {drR} {MsV} {NoS} {mal} {nro}\" \n",
        "    !$cmd\n",
        "    ShowYT()\n",
        "\n",
        "if not os.path.isfile(\"/usr/local/bin/spotdl\"):\n",
        "  get_ipython().system_raw(\"pip3 install spotdl && apt-get install ffmpeg\")\n",
        "\n",
        "ShowYT()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SoxLe8ciEyAc",
        "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": "2u2LsQC8EtQJ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute YouTube-DL\n",
        "# @markdown 📝 Note: if you want to change an archive file just run this cell again.\n",
        "Archive = False #@param {type:\"boolean\"}\n",
        "# ================================================================ #\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": "A0y8bdJSpbmD"
      },
      "source": [
        "#<center><b>Torrent Downloaders</b><h5>All of hidden cells are torrent downloaders</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WanlireZOjvx",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://colab.research.google.com/img/colab_favicon_256px.png' height=\"50\" alt=\"colab\" />  __Torrent to Gdrive__\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "m6hF0emftx4h",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://colab.research.google.com/img/colab_favicon_256px.png' height=\"100\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>Torrent to Google Drive</h3></center>\n",
        "#@markdown <center><h5>Created by Codemaster</h5></center><br>\n",
        "\n",
        "\n",
        "!apt install python3-libtorrent\n",
        "\n",
        "import libtorrent as lt\n",
        "\n",
        "ses = lt.session()\n",
        "ses.listen_on(6881, 6891)\n",
        "downloads = []\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "0et2A6N3udA0",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to </h3>\n",
        "#@markdown <h3>Upload torrent file</h3>\n",
        "#@markdown <h5>You can run this cell to add more files as many times as you want</h5><br>\n",
        "\n",
        "\n",
        "\n",
        "from google.colab import files\n",
        "\n",
        "source = files.upload()\n",
        "params = {\n",
        "    \"save_path\": \"/content/drive/My Drive/Torrent\",\n",
        "    \"ti\": lt.torrent_info(list(source.keys())[0]),\n",
        "}\n",
        "downloads.append(ses.add_torrent(params))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cwi1GMlxy3te",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to </h3>\n",
        "#@markdown <h3>Add From Magnet Link</h3>\n",
        "#@markdown <h5>You can run this cell to add more files as many times as you want</h5><br>\n",
        "\n",
        "\n",
        "params = {\"save_path\": \"/content/drive/My Drive/Torrent\"}\n",
        "\n",
        "while True:\n",
        "    magnet_link = input(\"Enter Magnet Link Or Type Exit: \")\n",
        "    if magnet_link.lower() == \"exit\":\n",
        "        break\n",
        "    downloads.append(\n",
        "        lt.add_magnet_uri(ses, magnet_link, params)\n",
        "    )\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "DBNoYYoSuDBT",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to Start Download</h3>\n",
        "import time\n",
        "from IPython.display import display\n",
        "import ipywidgets as widgets\n",
        "\n",
        "state_str = [\n",
        "    \"queued\",\n",
        "    \"checking\",\n",
        "    \"downloading metadata\",\n",
        "    \"downloading\",\n",
        "    \"finished\",\n",
        "    \"seeding\",\n",
        "    \"allocating\",\n",
        "    \"checking fastresume\",\n",
        "]\n",
        "\n",
        "layout = widgets.Layout(width=\"auto\")\n",
        "style = {\"description_width\": \"initial\"}\n",
        "download_bars = [\n",
        "    widgets.FloatSlider(\n",
        "        step=0.01, disabled=True, layout=layout, style=style\n",
        "    )\n",
        "    for _ in downloads\n",
        "]\n",
        "display(*download_bars)\n",
        "\n",
        "while downloads:\n",
        "    next_shift = 0\n",
        "    for index, download in enumerate(downloads[:]):\n",
        "        bar = download_bars[index + next_shift]\n",
        "        if not download.is_seed():\n",
        "            s = download.status()\n",
        "\n",
        "            bar.description = \" \".join(\n",
        "                [\n",
        "                    download.name(),\n",
        "                    str(s.download_rate / 1000),\n",
        "                    \"kB/s\",\n",
        "                    state_str[s.state],\n",
        "                ]\n",
        "            )\n",
        "            bar.value = s.progress * 100\n",
        "        else:\n",
        "            next_shift -= 1\n",
        "            ses.remove_torrent(download)\n",
        "            downloads.remove(download)\n",
        "            bar.close() # Seems to be not working in Colab (see https://github.com/googlecolab/colabtools/issues/726#issue-486731758)\n",
        "            download_bars.remove(bar)\n",
        "            print(download.name(), \"complete\")\n",
        "    time.sleep(1)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6wktcwkWtHH0",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://i.imgur.com/DOoxSuO.png' height=\"38\" alt=\"Simple Torrent\" />\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "lrCc585SD2f7",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://i.imgur.com/DOoxSuO.png' height=\"50\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>SimpleTorrent is a a self-hosted remote torrent client.</h3></center><br>\n",
        "#@markdown <center><h5>Auto upload to gdrive after task completed. if gdrive is mounted and if not working tick install_old_version.</h5></center><br>\n",
        "\n",
        "import os\n",
        "import time\n",
        "import pathlib \n",
        "import urllib.request\n",
        "from IPython.display import clear_output\n",
        "\n",
        "# script version\n",
        "Version = '1.2.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "Install_old_version = False  # @param {type:\"boolean\"}\n",
        "Auto_UP_Gdrive = False  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "force_change_version = \"\" # https://github.com/boypt/simple-torrent/releases\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    findProcess,\n",
        "    loadingAn,\n",
        "    updateCheck,\n",
        "    ngrok\n",
        ")\n",
        "# making enviroment for simple-torrent\n",
        "pathlib.Path('downloads').mkdir(mode=0o777, exist_ok=True)\n",
        "pathlib.Path('torrents').mkdir(mode=0o777, exist_ok=True)\n",
        "\n",
        "\n",
        "if Auto_UP_Gdrive:\n",
        "  hCode1 = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "            \"Google-Colab-CloudTorrent/master/res/scripts/doneCMD.sh\"\n",
        "  urllib.request.urlretrieve(hCode1, f'{HOME}/doneCMD.sh')\n",
        "  os.chmod(f'{HOME}/doneCMD.sh', 0o755)\n",
        "else:\n",
        "  try:\n",
        "    os.unlink(f'{HOME}/doneCMD.sh')\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "  \n",
        "configPath = pathlib.Path('cloud-torrent.json')\n",
        "configsdata = r\"\"\"\n",
        "{{\n",
        "  \"AutoStart\": true,\n",
        "  \"EngineDebug\": false,\n",
        "  \"MuteEngineLog\": true,\n",
        "  \"ObfsPreferred\": true,\n",
        "  \"ObfsRequirePreferred\": false,\n",
        "  \"DisableTrackers\": false,\n",
        "  \"DisableIPv6\": false,\n",
        "  \"DownloadDirectory\": \"downloads/\",\n",
        "  \"WatchDirectory\": \"torrents/\",\n",
        "  \"EnableUpload\": true,\n",
        "  \"EnableSeeding\": false,\n",
        "  \"IncomingPort\": 50007,\n",
        "  \"DoneCmd\": \"{}/doneCMD.sh\",\n",
        "  \"SeedRatio\": 1.5,\n",
        "  \"UploadRate\": \"High\",\n",
        "  \"DownloadRate\": \"Unlimited\",\n",
        "  \"TrackerListURL\": \"https://trackerslist.com/best.txt\",\n",
        "  \"AlwaysAddTrackers\": true,\n",
        "  \"ProxyURL\": \"\"\n",
        "}}\n",
        "\"\"\".format(HOME)\n",
        "with open(configPath, \"w+\") as configFile:\n",
        "  configFile.write(configsdata)\n",
        "#####################################\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "\n",
        "# Simple Torrent installing ...\n",
        "loadingAn()\n",
        "if not os.path.isfile(\"/usr/local/bin/cloud-torrent\"):\n",
        "    dcmd = \"wget -qq https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "            \"Google-Colab-CloudTorrent/master/res/scripts/\" \\\n",
        "            \"simpleCloudInstaller.sh -O /root/simpleCloudInstaller.sh\"\n",
        "    runSh(dcmd)\n",
        "    if Install_old_version:\n",
        "        runSh(\"bash /root/simpleCloudInstaller.sh 1.2.3\")\n",
        "    else:\n",
        "        runSh(\"bash /root/simpleCloudInstaller.sh\")\n",
        "\n",
        "if force_change_version:\n",
        "  runSh(\"pkill cloud-torrent\")\n",
        "  runSh(f\"bash /root/simpleCloudInstaller.sh {force_change_version}\")\n",
        "\n",
        "\n",
        "#Opening cloud-torrent in background\n",
        "if not findProcess(\"cloud-torrent\", \"cloud-torrent\"):\n",
        "  PORT = 4444\n",
        "  try:\n",
        "    urllib.request.urlopen(f\"http://localhost:{PORT}\")\n",
        "  except:\n",
        "    cmdC = f'cloud-torrent --port {PORT} ' \\\n",
        "        '-t \"SimpleTorrent\" ' \\\n",
        "        '-c cloud-torrent.json ' \\\n",
        "        '--host 0.0.0.0 --disable-log-time ' \\\n",
        "        '&'\n",
        "    for run in range(10):    \n",
        "      runSh(cmdC, shell=True)\n",
        "      time.sleep(3)\n",
        "      try:\n",
        "        urllib.request.urlopen(f\"http://localhost:{PORT}\")\n",
        "        break\n",
        "      except:\n",
        "        print(\"Error: Simple-Torrent not starting. Retrying ...\")\n",
        "\n",
        "# START_SERVER\n",
        "clear_output()\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['simple-torrent', 4444, 'http'], \n",
        "    ['peerflix-server', 4445, 'http']], 'us', \n",
        "    [f\"{HOME}/.ngrok2/sTpS.yml\", 4040]\n",
        ").start('simple-torrent')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xa8RqAm2wozX",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://camo.githubusercontent.com/95b0ba2a237ee846b3bb8f45954124eb9cba4ebc/68747470733a2f2f63646e2e6a7364656c6976722e6e65742f67682f617361706163682f70656572666c69782d736572766572406d61737465722f6170702f696d616765732f6c6f676f2e737667' height=\"25\" alt=\"Peerflix-server\" /> __PEERFLIX-SERVER__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "0WZEY1EWri78",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://camo.githubusercontent.com/95b0ba2a237ee846b3bb8f45954124eb9cba4ebc/68747470733a2f2f63646e2e6a7364656c6976722e6e65742f67682f617361706163682f70656572666c69782d736572766572406d61737465722f6170702f696d616765732f6c6f676f2e737667' height=\"200\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>PEERFLIX-SERVER<br />Streaming torrent client for node.js with web ui.</h3></center><br>\n",
        "\n",
        "import os\n",
        "import time\n",
        "import pathlib\n",
        "import urllib.request\n",
        "from json import dump\n",
        "from IPython.display import clear_output\n",
        "\n",
        "Version = '1.2.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    findProcess,\n",
        "    ngrok\n",
        ")\n",
        "\n",
        "#####################################\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "pathlib.Path('peerflix').mkdir(mode=0o777, exist_ok=True)\n",
        "loadingAn()\n",
        "\n",
        "#CONFIG\n",
        "if findProcess(\"node\", \"peerflix-server\"):\n",
        "  !pkill -f \"node /tools/node/bin/peerflix-server\"\n",
        "configPath = f\"{HOME}/.config/peerflix-server/config.json\"\n",
        "data = {}  \n",
        "trackers = urllib.request.urlopen(\n",
        "          \"https://trackerslist.com/best.txt\"\n",
        "      ).read().decode().split(\"\\n\\n\")\n",
        "data['connections'] = 500\n",
        "data['path'] = \"peerflix\" \n",
        "data['dht'] = True \n",
        "data['tracker'] = True\n",
        "data['trackers'] = trackers\n",
        "try:\n",
        "  os.mkdir(f'{HOME}/.config/peerflix-server/')\n",
        "except:\n",
        "  pass\n",
        "with open(configPath, \"w+\") as configFile:\n",
        "  dump(data, configFile)\n",
        "\n",
        "if not os.path.isfile(\"/tools/node/bin/peerflix-server\"):\n",
        "  runSh('npm install -g peerflix-server')\n",
        "  \n",
        "#Opening Peerflix-server in background\n",
        "if not findProcess(\"node\", \"peerflix-server\"):\n",
        "  PORT = 4445\n",
        "  cmdC = f'PORT={PORT} peerflix-server &'\n",
        "  for run in range(10):    \n",
        "    runSh(cmdC, shell=True)\n",
        "    time.sleep(3)\n",
        "    try:\n",
        "      urllib.request.urlopen(f\"http://localhost:{PORT}\")\n",
        "      break\n",
        "    except:\n",
        "      print(\"Error: Peerflix-server not starting. Retrying ...\")\n",
        "\n",
        "# START_SERVER\n",
        "clear_output()\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['simple-torrent', 4444, 'http'], \n",
        "    ['peerflix-server', 4445, 'http']], 'us', \n",
        "    [f\"{HOME}/.ngrok2/sTpS.yml\", 4040]\n",
        ").start('peerflix-server', 'r')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "hIk32mGsriDJ",
        "colab": {}
      },
      "source": [
        "\n",
        "#@markdown <br><center><img src='https://i.imgur.com/YWSbyoZ.png' height=\"50\" alt=\"netdata\"/></center>\n",
        "#@markdown <br><center><h1>CLEAN DOWNLODAS FOLDER</center>\n",
        "#@markdown <br><center>PEERFLIX-SERVER don't delete removed torrent task file. So you do this manually after remove torrent task.\n",
        "!touch /content/downloads/errorRemove\n",
        "!cd downloads/ && sudo rm -r *\n",
        "print(\"All Deleted on /content/peerflix\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rGgDHPbtYJBg",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://upload.wikimedia.org/wikipedia/commons/c/c5/Deluge_icon.png' height=\"30\" alt=\"Deluge\" /> __Deluge__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k_z4f8_4U7Ac",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://upload.wikimedia.org/wikipedia/commons/c/c5/Deluge_icon.png' height=\"200\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>Deluge<br />Deluge is a BitTorrent client written in Python.</h3></center><br>\n",
        "#@markdown <center><h5>Auto upload to gdrive after task completed. if gdrive is mounted<br>Default output path /content/downloads/</h5></center><br>\n",
        "import os, urllib.request, pathlib\n",
        "from IPython.display import clear_output\n",
        "\n",
        "Version = '1.2.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = False  # @param {type:\"boolean\"}\n",
        "TOKEN = \"1XZLrMSbzOzbcCeHDeotyfokBhC_4DKdmm3gfVvUrom4g2ghB\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    findProcess,\n",
        "    loadingAn,\n",
        "    ngrok\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "\n",
        "loadingAn()\n",
        "\n",
        "pathlib.Path('downloads').mkdir(exist_ok=True)\n",
        "pathlib.Path(f\"{HOME}/.config/deluge/\").mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "if not (findProcess(\"/usr/bin/python\", \"deluged\") or findProcess(\"/usr/bin/python\", \"deluge-web\")):\n",
        "  runSh('sudo apt install -y deluged deluge-console deluge-webui')\n",
        "  runSh(\n",
        "        f\"wget -qq https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/res/deluge/core.conf \\\n",
        "            -O {HOME}/.config/deluge/core.conf\"\n",
        "    )\n",
        "  runSh(\n",
        "        f\"wget -qq https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/res/deluge/web.conf \\\n",
        "            -O {HOME}/.config/deluge/web.conf\"\n",
        "    )\n",
        "  runSh('deluged &> /dev/null &', shell=True)\n",
        "  runSh('deluge-web --fork', shell=True)\n",
        "  runSh(\"\"\"sed -i 's/if s.hexdigest() == config\\[\"pwd_sha1\"\\]:/if True:/' /usr/lib/python2.7/dist-packages/deluge/ui/web/auth.py\"\"\")\n",
        "  runSh(\"sed -i 's/onShow:function(){this.passwordField.focus(.*)}/onShow:function(){this.onLogin();}/' /usr/lib/python2.7/dist-packages/deluge/ui/web/js/deluge-all.js\")\n",
        "\n",
        "# START_SERVER\n",
        "clear_output()\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['deluge', 8112, 'http'],\n",
        "                            ['utorrent', 5454, 'http']], 'eu', \n",
        "    [f\"{HOME}/.ngrok2/delugeUtorrent.yml\", 4041]\n",
        ").start('deluge')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "63bRZrGJEZnI",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://upload.wikimedia.org/wikipedia/commons/9/9f/UTorrent_%28logo%29.png' height=\"25\" alt=\"µTorrent\" /> ___µTorrent___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "92bz-A8-ZBHM",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://upload.wikimedia.org/wikipedia/commons/9/9f/UTorrent_%28logo%29.png' height=\"200\" alt=\"µTorrent\"/></center>\n",
        "#@markdown <center><h3>µTorrent<br />uTorrent is a proprietary adware BitTorrent client owned and developed by BitTorrent, Inc.</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.2.0'\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "apt-get install python2.7 git python-opensslapt-get install python2.7 git python-opensslapt-get install python2.7 git python-opensslapt-get install python2.7 git python-opensslapt-get install python2.7 git python-opensslapt-get install python2.7 git python-opensslapt-get install python2.7 git python-opensslapt-get install python2.7 git python-opensslapt-get install python2.7 git python-openssl#################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "# OUTPUT_DIR = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "r = get_ipython()\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    findProcess,\n",
        "    displayUrl\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "#uTorrent installing...\n",
        "if not os.path.exists(\"/usr/bin/utserver\"):\n",
        "  os.makedirs(\"downloads\", exist_ok=True)\n",
        "  r.system_raw(\"apt install libssl1.0.0 libssl-dev\")\n",
        "  r.system_raw(r\"wget http://download-new.utorrent.com/endpoint/utserver/os/linux-x64-ubuntu-13-04/track/beta/ -O utserver.tar.gz\")\n",
        "  r.system_raw(r\"tar -zxvf utserver.tar.gz -C /opt/\")\n",
        "  r.system_raw(\"rm -f utserver.tar.gz\")\n",
        "  r.system_raw(\"mv /opt/utorrent-server-* /opt/utorrent\")\n",
        "  os.chmod(\"/opt/utorrent\", 0o777)\n",
        "  r.system_raw(\"ln -s /opt/utorrent/utserver /usr/bin/utserver\")\n",
        "  urllib.request.urlretrieve(\n",
        "      \"https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/res/utorrent/utserver.conf\",\n",
        "      \"/opt/utorrent/utserver.conf\")\n",
        "if not findProcess(\"utserver\", \"-settingspath\"):\n",
        "  cmd = \"utserver -settingspath /opt/utorrent/\" \\\n",
        "        \" -configfile /opt/utorrent/utserver.conf\" \\\n",
        "        \" -daemon\"\n",
        "  runSh(cmd, shell=True)\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['deluge', 8112, 'http'],\n",
        "                            ['utorrent', 5454, 'http']], 'eu', \n",
        "    [f\"{HOME}/.ngrok2/delugeUtorrent.yml\", 4041]\n",
        ").start('utorrent', displayB=False)\n",
        "displayUrl(Server, pNamU='uTorrent : ', \n",
        "           ExUrl=fr\"http://admin:admin@{Server['url'][7:]}/gui\",\n",
        "           btc=\"g\")\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PGMUhd7sVOY9",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_qbittorrent.png' height=\"45\" alt=\"qBittorrent\"/> <font size=1px>_Enhanced Edition_</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0oCsnKJK-VXb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, time, urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    checkAvailable,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    runSh,\n",
        "    displayUrl,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "def addUtils():\n",
        "    if not checkAvailable(\"/usr/local/sessionSettings\"):\n",
        "        runSh(\"mkdir -p -m 777 /usr/local/sessionSettings\")\n",
        "    if not checkAvailable(\"/content/upload.txt\"):\n",
        "        runSh(\"touch /content/upload.txt\")\n",
        "    if not checkAvailable(\"checkAptUpdate.txt\", userPath=True):\n",
        "        runSh(\"apt update -qq -y\")\n",
        "        runSh(\"apt-get install -y iputils-ping\")\n",
        "\n",
        "def configTimezone(auto=True):\n",
        "    if checkAvailable(\"timezone.txt\", userPath=True):\n",
        "        return\n",
        "    if not auto:\n",
        "        runSh(\"sudo dpkg-reconfigure tzdata\")\n",
        "    else:\n",
        "        runSh(\"sudo ln -fs /usr/share/zoneinfo/Asia/Ho_Chi_Minh /etc/localtime\")\n",
        "        runSh(\"sudo dpkg-reconfigure -f noninteractive tzdata\")\n",
        "\n",
        "def uploadQBittorrentConfig():\n",
        "    if checkAvailable(\"updatedQBSettings.txt\", userPath=True):\n",
        "        return\n",
        "    runSh(\n",
        "        \"mkdir -p -m 666 /content/qBittorrent /root/.qBittorrent_temp /root/.config/qBittorrent\"\n",
        "    )\n",
        "    runSh(\n",
        "        \"wget -qq https://raw.githubusercontent.com/biplobsd/RLabClone/master/res/qbittorrent/qBittorrent.conf \\\n",
        "            -O /root/.config/qBittorrent/qBittorrent.conf\"\n",
        "    )\n",
        "\n",
        "\n",
        "def prepareSession():\n",
        "    if checkAvailable(\"ready.txt\", userPath=True):\n",
        "        return\n",
        "    else:\n",
        "        addUtils()\n",
        "        configTimezone()\n",
        "        uploadQBittorrentConfig()\n",
        "\n",
        "def installQBittorrent():\n",
        "    if checkAvailable(\"/usr/bin/qbittorrent-nox\"):\n",
        "        return\n",
        "    else:\n",
        "        try:\n",
        "            runSh(\"add-apt-repository -y ppa:poplite/qbittorrent-enhanced\")\n",
        "            runSh(\"apt-get install qbittorrent-enhanced-nox -qq -y\")\n",
        "        except:\n",
        "            raise Exception('Error installing qbittorrent-enhanced-nox')\n",
        "\n",
        "def startQBService():\n",
        "    prepareSession()\n",
        "    installQBittorrent()\n",
        "    if not findProcess(\"qbittorrent-nox\", \"-d --webui-port\"):\n",
        "        runSh(f\"qbittorrent-nox -d --webui-port={QB_Port}\")\n",
        "        time.sleep(1)\n",
        "\n",
        "QB_Port = 10001\n",
        "loadingAn()\n",
        "startQBService()\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['qbittorrent', QB_Port, 'http']], 'sa', \n",
        "    [f\"{HOME}/.ngrok2/qbittorrent.yml\", 4088]\n",
        ").start('qbittorrent', displayB=False)\n",
        "displayUrl(server, pNamU='QBT_enhanced : ')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fJ7W2Z0gcYa5",
        "colab_type": "text"
      },
      "source": [
        "## <img src='http://pic2.orsoon.com/2017/0719/20170719091439708.png' height=\"60\" alt=\"aria2\" />___aria2___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yN2xLpinUbl6",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='http://pic2.orsoon.com/2017/0719/20170719091439708.png' height=\"200\" alt=\"aria2\"/></center>\n",
        "#@markdown <center><h3>aria2<br />The next generation download utility.</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.2.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "# Aria2 Service\n",
        "Aria2_rpc = True  # @param {type:\"boolean\"}\n",
        "Ariang_WEBUI = True  # @param {type:\"boolean\"}\n",
        "\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "# OUTPUT_DIR = \"\"  # @param {type:\"string\"}\n",
        "PORT = 8221\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    CWD,\n",
        "    displayUrl,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "# Ariang SETUP\n",
        "runSh('sudo apt install -y aria2')\n",
        "pathlib.Path('ariang').mkdir(mode=0o777, exist_ok=True)\n",
        "pathlib.Path('downloads').mkdir(mode=0o777, exist_ok=True)\n",
        "\n",
        "# github latest releases tag define\n",
        "def latestTag(link):\n",
        "  import re\n",
        "  from urllib.request import urlopen\n",
        "  htmlF = urlopen(link+\"/releases/latest\").read().decode('UTF-8')\n",
        "  return re.findall(r'.+\\/tag\\/([.0-9A-Za-z]+)\".+/', htmlF)[0]\n",
        "\n",
        "# Downloading latest version of ariang\n",
        "if not os.path.exists(\"ariang/index.html\"):\n",
        "  BASE_URL = r\"https://github.com/mayswind/AriaNg\"\n",
        "  LATEST_TAG = latestTag(BASE_URL)\n",
        "  urlF = f'{BASE_URL}/releases/download/{LATEST_TAG}/' \\\n",
        "              f'AriaNg-{LATEST_TAG}-AllInOne.zip'\n",
        "  urllib.request.urlretrieve(urlF, 'ariang/new.zip')\n",
        "  with zipfile.ZipFile('ariang/new.zip', 'r') as zip_ref:\n",
        "      zip_ref.extractall('ariang')\n",
        "  try:\n",
        "    pathlib.Path('ariang/new.zip').unlink()\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "\n",
        "# START_ARIANG_WEBUI_AND_ARIA2_RPC\n",
        "try:\n",
        "  if not OUTPUT_DIR:\n",
        "    OUTPUT_DIR = f\"downloads/\"\n",
        "  elif not os.path.exists(OUTPUT_DIR):\n",
        "    clear_output()\n",
        "    print(\"Error: Your set path not found! Create path!\")\n",
        "    exx()\n",
        "except:\n",
        "  OUTPUT_DIR = f\"{CWD}/downloads/\"\n",
        "if Aria2_rpc:\n",
        "  if not findProcess(\"aria2c\", \"--enable-rpc\"):\n",
        "    try:\n",
        "      trackers = urllib.request.urlopen(\n",
        "          \"https://trackerslist.com/best_aria2.txt\"\n",
        "      ).read().decode()\n",
        "      cmdC = r\"aria2c --enable-rpc --rpc-listen-port=6800 -D \" \\\n",
        "            fr\"-d {OUTPUT_DIR} \" \\\n",
        "            r\"-j 20 \" \\\n",
        "            r\"-c \" \\\n",
        "            fr\"--bt-tracker={trackers} \" \\\n",
        "            r\"--bt-request-peer-speed-limit=0 \" \\\n",
        "            r\"--bt-max-peers=0 \" \\\n",
        "            r\"--seed-ratio=0.0 \" \\\n",
        "            r\"--max-connection-per-server=10 \" \\\n",
        "            r\"--min-split-size=10M \" \\\n",
        "            r\"--follow-torrent=mem \" \\\n",
        "            r\" &\"\n",
        "      runSh(\n",
        "          cmdC,\n",
        "          shell=True\n",
        "      )\n",
        "    except:\n",
        "      print(\"aria2 rpc not enabling. Try again later!\")\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['Aria2_rpc', 6800, 'http'], \n",
        "    ['Ariang', 8221, 'http']], 'jp', \n",
        "    [f\"{HOME}/.ngrok2/aria2.yml\", 4042]\n",
        ")\n",
        "if Aria2_rpc:\n",
        "  data = Server.start('Aria2_rpc', displayB=False)\n",
        "  Host, port = {data['url'][7:], \"80\"}\n",
        "  clear_output()\n",
        "if Ariang_WEBUI:\n",
        "  if Aria2_rpc:\n",
        "    filePath = 'ariang/index.html'\n",
        "    with open(filePath, 'r+') as f:\n",
        "      read_data = f.read()\n",
        "      f.seek(0)\n",
        "      f.truncate(0)\n",
        "      read_data = re.sub(r'(rpcHost:\"\\w+.\")|rpcHost:\"\"', \n",
        "                        f'rpcHost:\"{Host}\"', read_data)\n",
        "      read_data = re.sub(r'protocol:\"\\w+.\"', r'protocol:\"ws\"', read_data)\n",
        "      read_data = re.sub(r'rpcPort:\"\\d+.\"', f'rpcPort:\"{port}\"', read_data)\n",
        "      f.write(read_data)\n",
        "  try:\n",
        "    urllib.request.urlopen(f\"http://localhost:{PORT}\")\n",
        "  except:\n",
        "    runSh(f\"python3 -m http.server {PORT} &\", shell=True, cd=\"ariang/\")\n",
        " \n",
        "  data2 = Server.start('Ariang', displayB=False)\n",
        "  displayUrl(data2, pNamU='Ariang : ')\n",
        "\n",
        "if Aria2_rpc:\n",
        "  display(HTML(\"\"\"<style>@import url('https://fonts.googleapis.com/css?family=Source+Code+Pro:200,900');  :root {   --text-color: hsla(210, 50%, 85%, 1);   --shadow-color: hsla(210, 40%, 52%, .4);   --btn-color: hsl(210, 80%, 42%);   --bg-color: #141218; }  * {   box-sizing: border-box; } button { position:relative; padding: 10px 20px;     border: none;   background: none;      font-family: \"Source Code Pro\";   font-weight: 900;font-size: 20px;     color: var(--text-color);      background-color: var(--btn-color);   box-shadow: var(--shadow-color) 2px 2px 22px;   border-radius: 4px;    z-index: 0;overflow: hidden; -webkit-user-select: text;-moz-user-select: text;-ms-user-select: text;user-select: text;}  button:focus {   outline-color: transparent;   box-shadow: var(--btn-color) 2px 2px 22px; }  .right::after, button::after {   content: var(--content);   display: block;   position: absolute;   white-space: nowrap;   padding: 40px 40px;   pointer-events:none; }  button::after{   font-weight: 200;   top: -30px;   left: -20px; }   .right, .left {   position: absolute;   width: 100%;   height: 100%;   top: 0; } .right {   left: 66%; } .left {   right: 66%; } .right::after {   top: -30px;   left: calc(-66% - 20px);      background-color: var(--bg-color);   color:transparent;   transition: transform .4s ease-out;   transform: translate(0, -90%) rotate(0deg) }  button:hover .right::after {   transform: translate(0, -47%) rotate(0deg) }  button .right:hover::after {   transform: translate(0, -50%) rotate(-7deg) }  button .left:hover ~ .right::after {   transform: translate(0, -50%) rotate(7deg) }  /* bubbles */ button::before {   content: '';   pointer-events: none;   opacity: .6;   background:     radial-gradient(circle at 20% 35%,  transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 75% 44%, transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 46% 52%, transparent 0, transparent 4px, var(--text-color) 5px, var(--text-color) 6px, transparent 6px);    width: 100%;   height: 300%;   top: 0;   left: 0;   position: absolute;   animation: bubbles 5s linear infinite both; }  @keyframes bubbles {   from {     transform: translate();   }   to {     transform: translate(0, -66.666%);   } }.zui-table {    border: solid 1px #DDEEEE;    border-collapse: collapse;    border-spacing: 0;    font: normal 13px;}.zui-table thead th {    background-color: #DDEFEF;    border: solid 1px #DDEEEE;    color: #0000009e;    padding: 10px;    text-align: left;}.zui-table tbody td {border: solid 1px #effff97a;color: #ffffffd1;    padding: 10px;}</style><center><button><table class=\"zui-table blueBG\"><p>Aria2 rpc config<p><thead>        <tr>            <th>Protocol</th>            <th>Host</th>            <th>Port</th>        </tr>    </thead>    <tbody>        <tr>            <td>WebSocket</td><td>\"\"\"+Host+\"\"\"</td><td>\"\"\"+port+\"\"\"</td></tr></tbody></table><a target=\"_blank\" style=\"text-decoration: none;color: hsla(210, 50%, 85%, 1);font-size: 10px;\" href=\"http://bit.ly/2qoOw0a\">NB. How to setup this's config. [Click ME]</a></button><center>\"\"\"))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cHTe9qp2E6f5",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://avatars1.githubusercontent.com/u/3368377?s=400&v=4' height=\"60\" alt=\"logo\"/><img src='https://raw.githubusercontent.com/linuxserver/docker-templates/master/linuxserver.io/img/nzbget-banner.png' height=\"52\" alt=\"nzbget\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "Qa0LbpPoaueF",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Click Here to Use NZBget (<i>ngrok</i>)</h3>\n",
        "#@markdown <center>Creat an account and Get Free Token  <a href=\"https://dashboard.ngrok.com/auth\">Here</a>  \n",
        "Ngrok_Token = \"\" #@param {type:\"string\"}\n",
        "\n",
        "import os, psutil, uuid, time, urllib.request, json; from IPython.display import clear_output\n",
        "import ipywidgets as widgets\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",
        "if os.path.isfile(\"/usr/local/bin/ngrok\") == False:\n",
        "  !wget -q -c -nc https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n",
        "  !unzip -qq -n ngrok-stable-linux-amd64.zip\n",
        "  !mv ngrok /usr/local/bin/ngrok\n",
        "  !rm -f /content/ngrok-stable-linux-amd64.zip\n",
        "  print(\"ngrok successfully installed.\")\n",
        "  clear_output(wait=True)\n",
        "else:\n",
        "  print(\"ngrok already installed. Skipping... \")\n",
        "  clear_output(wait=True)\n",
        "  !pkill ngrok\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",
        "try:\n",
        "  try:\n",
        "    Random_NumberNZ\n",
        "  except NameError:\n",
        "    Random_NumberNZ = RandomGenerator()\n",
        "    display(MakeLabel('Installing in Progress', 'warning'))\n",
        "  if os.path.isfile(\"/content/nzbget/nzbget\") == False:\n",
        "    !mkdir /content/nzbget\n",
        "    get_ipython().system_raw(\"rm -rf /content/sample_data/ && wget https://nzbget.net/download/nzbget-latest-bin-linux.run && sh nzbget-latest-bin-linux.run\")\n",
        "  if CheckProcess(\"nzbget\", \"\") != True:\n",
        "    get_ipython().system_raw(\"/content/nzbget/nzbget -s &\")\n",
        "except:\n",
        "  clear_output(wait=True)\n",
        "\n",
        "get_ipython().system_raw('/usr/local/bin/ngrok authtoken $Ngrok_Token && /usr/local/bin/ngrok http 6789 &')\n",
        "time.sleep(10)\n",
        "clear_output(wait=True)\n",
        "with urllib.request.urlopen('http://localhost:4040/api/tunnels') as response:\n",
        "  data = json.loads(response.read().decode())\n",
        "  host = data['tunnels'][0]['public_url'][8:]\n",
        "  print(f'Open this link in new tab http://{host}')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOnMe4O3jtXf",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://forum.rclone.org/uploads/default/original/2X/d/da6ccb2784ff3fa73d9339300530e0aae4d6cebd.png' height=\"45\" alt=\"RcloneLab\"/><h5>Here, rClone is tool to copy/move torrent downloaded file from **Simple torrent/qBittorrent,etc.** to your **google drive**</h5>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9qOSyk-RCTCz",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute rClone\n",
        "\n",
        "%cd /content/drive/My Drive\n",
        "%mkdir rClone\n",
        "\n",
        "# @markdown ##### Quick move (Select and leave all boxes):\n",
        "# @markdown #####{\n",
        "Quick_Move = \"None\"  # @param [\"None\",\"simpleTorrent\", \"Peerflix\", \"qBittorrent\", \"extract\", \"error\"]\n",
        "# @markdown #####}\n",
        "\n",
        "Mode = \"Copy\"  # @param [\"Move\", \"Copy\", \"Sync\", \"Verify\", \"Dedupe\", \"Clean Empty Dirs\", \"Empty Trash\"]\n",
        "Source = \"/content/downloads\"  # @param {type:\"string\"}\n",
        "Destination = \"/content/drive/My Drive/Temp\"  # @param {type:\"string\"}\n",
        "Extra_Arguments = \"\"  # @param {type:\"string\"}\n",
        "COPY_SHARED_FILES = False  # @param{type: \"boolean\"}\n",
        "Compare = \"Size & Checksum\"\n",
        "TRANSFERS, CHECKERS = 20, 20\n",
        "THROTTLE_TPS = True\n",
        "BRIDGE_TRANSFER = False  # @param{type: \"boolean\"}\n",
        "FAST_LIST = True  # @param{type: \"boolean\"}\n",
        "OPTIMIZE_GDRIVE = True\n",
        "SIMPLE_LOG = True\n",
        "RECORD_LOGFILE = False  # @param{type: \"boolean\"}\n",
        "SKIP_NEWER_FILE = False\n",
        "SKIP_EXISTED = False\n",
        "SKIP_UPDATE_MODTIME = False\n",
        "ONE_FILE_SYSTEM = False\n",
        "LOG_LEVEL = \"DEBUG\"\n",
        "SYNC_MODE = \"Delete after transfering\"\n",
        "SYNC_TRACK_RENAME = True\n",
        "DEDUPE_MODE = \"Largest\"\n",
        "USE_TRASH = True\n",
        "DRY_RUN = False  # @param{type: \"boolean\"}\n",
        "# ================================================================ #\n",
        "if Quick_Move == \"None\":\n",
        "  pass\n",
        "elif Quick_Move == \"simpleTorrent\" and Source == \"\" and Destination == \"\":\n",
        "  Mode = \"Move\"\n",
        "  Source = \"/content/downloads\"\n",
        "  Destination = \"/content/drive/My Drive/rCLone\" \n",
        "elif Quick_Move == \"Peerflix\" and Source == \"\" and Destination == \"\":\n",
        "  Mode = \"Move\"\n",
        "  Source = \"/content/peerflix\"\n",
        "  Destination = \"/content/drive/My Drive/rClone\" \n",
        "elif Quick_Move == \"qBittorrent\" and Source == \"\" and Destination == \"\":\n",
        "  Mode = \"Move\"\n",
        "  Source = \"/content/qBittorrent\"\n",
        "  Destination = \"/content/drive/My Drive/rClone\"\n",
        "elif Quick_Move == \"extract\" and Source == \"\" and Destination == \"\":\n",
        "  Mode = \"Move\"\n",
        "  Source = \"/content/extract\"\n",
        "  Destination = \"/content/drive/My Drive/rClone\"\n",
        "elif Quick_Move == \"error\":\n",
        "  raise Exception(\"You are selected Error!\")\n",
        "\n",
        "from os import path as _p\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run\n",
        "\n",
        "    shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                    -O /root/.ipython/rlab_utils.py\"\n",
        "    run(_spl(shellCmd))\n",
        "\n",
        "from datetime import datetime as _dt\n",
        "from rlab_utils import (\n",
        "    displayOutput,\n",
        "    checkAvailable,\n",
        "    runSh,\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        "    accessSettingFile,\n",
        "    memGiB,\n",
        ")\n",
        "\n",
        "\n",
        "def populateActionArg():\n",
        "    if Mode == \"Copy\":\n",
        "        actionArg = \"copy\"\n",
        "    elif Mode == \"Sync\":\n",
        "        actionArg = \"sync\"\n",
        "    elif Mode == \"Verify\":\n",
        "        actionArg = \"check\"\n",
        "    elif Mode == \"Dedupe\":\n",
        "        actionArg = \"dedupe largest\"\n",
        "    elif Mode == \"Clean Empty Dirs\":\n",
        "        actionArg = \"rmdirs\"\n",
        "    elif Mode == \"Empty Trash\":\n",
        "        actionArg = \"delete\"\n",
        "    else:\n",
        "        actionArg = \"move\"\n",
        "\n",
        "    return actionArg\n",
        "\n",
        "\n",
        "def populateCompareArg():\n",
        "    if Compare == \"Mod-Time\":\n",
        "        compareArg = \"--ignore-size\"\n",
        "    elif Compare == \"Size\":\n",
        "        compareArg = \"--size-only\"\n",
        "    elif Compare == \"Checksum\":\n",
        "        compareArg = \"-c --ignore-size\"\n",
        "    else:\n",
        "        compareArg = \"-c\"\n",
        "\n",
        "    return compareArg\n",
        "\n",
        "\n",
        "def populateOptimizeGDriveArg():\n",
        "    return (\n",
        "        \"--buffer-size 256M \\\n",
        "            --drive-chunk-size 256M \\\n",
        "                --drive-upload-cutoff 256M \\\n",
        "                    --drive-acknowledge-abuse \\\n",
        "                        --drive-keep-revision-forever\"\n",
        "        if OPTIMIZE_GDRIVE\n",
        "        else \"--buffer-size 128M\"\n",
        "    )\n",
        "\n",
        "\n",
        "def populateGDriveCopyArg():\n",
        "    if BRIDGE_TRANSFER and memGiB() < 13:\n",
        "        global TRANSFERS, CHECKERS\n",
        "        TRANSFERS, CHECKERS = 10, 80\n",
        "    else:\n",
        "        pass\n",
        "    return \"--disable copy\" if BRIDGE_TRANSFER else \"--drive-server-side-across-configs\"\n",
        "\n",
        "\n",
        "def populateStatsArg():\n",
        "    statsArg = \"--stats-one-line --stats=5s\" if SIMPLE_LOG else \"--stats=5s -P\"\n",
        "    if LOG_LEVEL != \"OFF\":\n",
        "        statsArg += \" -v\" if SIMPLE_LOG else \"-vv\"\n",
        "    elif LOG_LEVEL == \"INFO\":\n",
        "        statsArg += \" --log-level INFO\"\n",
        "    elif LOG_LEVEL == \"ERROR\":\n",
        "        statsArg += \" --log-level ERROR\"\n",
        "    else:\n",
        "        statsArg += \" --log-level DEBUG\"\n",
        "    return statsArg\n",
        "\n",
        "\n",
        "def populateSyncModeArg():\n",
        "    if Mode != \"Sync\":\n",
        "        return \"\"\n",
        "    elif SYNC_MODE == \"Delete before transfering\":\n",
        "        syncModeArg = \"--delete-before\"\n",
        "    elif SYNC_MODE == \"Delete after transfering\":\n",
        "        syncModeArg = \"--delete-after\"\n",
        "    else:\n",
        "        syncModeArg = \"--delete-during\"\n",
        "    if SYNC_TRACK_RENAME:\n",
        "        syncModeArg += \" --track-renames\"\n",
        "    return syncModeArg\n",
        "\n",
        "\n",
        "def populateDedupeModeArg():\n",
        "    if DEDUPE_MODE == \"Interactive\":\n",
        "        dedupeModeArg = \"--dedupe-mode interactive\"\n",
        "    elif DEDUPE_MODE == \"Skip\":\n",
        "        dedupeModeArg = \"--dedupe-mode skip\"\n",
        "    elif DEDUPE_MODE == \"First\":\n",
        "        dedupeModeArg = \"--dedupe-mode first\"\n",
        "    elif DEDUPE_MODE == \"Newest\":\n",
        "        dedupeModeArg = \"--dedupe-mode newest\"\n",
        "    elif DEDUPE_MODE == \"Oldest\":\n",
        "        dedupeModeArg = \"--dedupe-mode oldest\"\n",
        "    elif DEDUPE_MODE == \"Rename\":\n",
        "        dedupeModeArg = \"--dedupe-mode rename\"\n",
        "    else:\n",
        "        dedupeModeArg = \"--dedupe-mode largest\"\n",
        "\n",
        "    return dedupeModeArg\n",
        "\n",
        "\n",
        "def generateCmd():\n",
        "    sharedFilesArgs = (\n",
        "        \"--drive-shared-with-me --files-from /content/upload.txt --no-traverse\"\n",
        "        if COPY_SHARED_FILES\n",
        "        else \"\"\n",
        "    )\n",
        "\n",
        "    logFileArg = f\"--log-file /content/rclone_log.txt -vv -P\"\n",
        "\n",
        "    args = [\n",
        "        \"rclone\",\n",
        "        f\"--config {PATH_RClone_Config}/rclone.conf\",\n",
        "        '--user-agent \"Mozilla\"',\n",
        "        populateActionArg(),\n",
        "        f'\"{Source}\"',\n",
        "        f'\"{Destination}\"' if Mode in (\"Move\", \"Copy\", \"Sync\") else \"\",\n",
        "        f\"--transfers {str(TRANSFERS)}\",\n",
        "        f\"--checkers {str(CHECKERS)}\",\n",
        "    ]\n",
        "\n",
        "    if Mode == \"Verify\":\n",
        "        args.append(\"--one-way\")\n",
        "    elif Mode == \"Empty Trash\":\n",
        "        args.append(\"--drive-trashed-only --drive-use-trash=false\")\n",
        "    else:\n",
        "        args.extend(\n",
        "            [\n",
        "                populateGDriveCopyArg(),\n",
        "                populateSyncModeArg(),\n",
        "                populateCompareArg(),\n",
        "                populateOptimizeGDriveArg(),\n",
        "                \"-u\" if SKIP_NEWER_FILE else \"\",\n",
        "                \"--ignore-existing\" if SKIP_EXISTED else \"\",\n",
        "                \"--no-update-modtime\" if SKIP_UPDATE_MODTIME else \"\",\n",
        "                \"--one-file-system\" if ONE_FILE_SYSTEM else \"\",\n",
        "                \"--tpslimit 95 --tpslimit-burst 40\" if THROTTLE_TPS else \"\",\n",
        "                \"--fast-list\" if FAST_LIST else \"\",\n",
        "                \"--delete-empty-src-dirs\" if Mode == \"Move\" else \"\",\n",
        "            ]\n",
        "        )\n",
        "    args.extend(\n",
        "        [\n",
        "            \"-n\" if DRY_RUN else \"\",\n",
        "            populateStatsArg() if not RECORD_LOGFILE else logFileArg,\n",
        "            sharedFilesArgs,\n",
        "            Extra_Arguments,\n",
        "        ]\n",
        "    )\n",
        "\n",
        "    return args\n",
        "\n",
        "\n",
        "def executeRclone():\n",
        "    prepareSession()\n",
        "    if Source.strip() == \"\":\n",
        "        displayOutput(\"❌ The Source field is empty.\")\n",
        "        return\n",
        "    if checkAvailable(\"/content/rclone_log.txt\"):\n",
        "        if not checkAvailable(\"/content/logfiles\"):\n",
        "            runSh(\"mkdir -p -m 666 /content/logfiles\")\n",
        "        job = accessSettingFile(\"job.txt\")\n",
        "        runSh(\n",
        "            f'mv /content/rclone_log.txt /content/logfiles/{job[\"title\"]}_{job[\"status\"]}_logfile.txt'\n",
        "        )\n",
        "\n",
        "    onGoingJob = {\n",
        "        \"title\": f'{Mode}_{Source}_{Destination}_{_dt.now().strftime(\"%a-%H-%M-%S\")}',\n",
        "        \"status\": \"ongoing\",\n",
        "    }\n",
        "    accessSettingFile(\"job.txt\", onGoingJob)\n",
        "\n",
        "    cmd = \" \".join(generateCmd())\n",
        "    runSh(cmd, output=True)\n",
        "    displayOutput(Mode, \"success\")\n",
        "\n",
        "    onGoingJob[\"status\"] = \"finished\"\n",
        "    accessSettingFile(\"job.txt\", onGoingJob)\n",
        "\n",
        "executeRclone()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GUqn6vGlfZ_x",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h3>Rclone MOUNT / UNMOUNT</h3></center><br>\n",
        "import os\n",
        "import random\n",
        "import string\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "import time\n",
        "import uuid\n",
        "import ipywidgets as widgets\n",
        "from google.colab import output\n",
        "import re\n",
        "#####################################\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "runW = get_ipython()\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "  from shlex import split as _spl\n",
        "  from subprocess import run\n",
        "\n",
        "  shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                  -O /root/.ipython/rlab_utils.py\"\n",
        "  run(_spl(shellCmd))\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    displayUrl,\n",
        "    findProcess,\n",
        "    CWD,\n",
        "    textAn,\n",
        "    checkAvailable\n",
        ")\n",
        "from rlab_utils import (\n",
        "    displayOutput,\n",
        "    checkAvailable,\n",
        "    runSh,\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        "    accessSettingFile,\n",
        "    memGiB,\n",
        ")\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 ShowAC():\n",
        "  clear_output(wait=True)\n",
        "  display(\n",
        "      widgets.HBox(\n",
        "          [widgets.VBox(\n",
        "              [widgets.HTML(\n",
        "                  '''\n",
        "                  <h3 style=\"font-family:Trebuchet MS;color:#4f8bd6;\">\n",
        "                  Rclone available config...</h3>\n",
        "                  '''\n",
        "                  ),\n",
        "               mountNam]\n",
        "               )\n",
        "          ]\n",
        "          )\n",
        "      )\n",
        "  \n",
        "  display(HTML(\"<br>\"), MakeButton(\"Mount\", MountCMD, \"primary\"),\n",
        "          MakeButton(\"Unmount\", unmountCMD, \"danger\"))\n",
        "\n",
        "prepareSession()\n",
        "content = open(f\"{PATH_RClone_Config}/rclone.conf\").read()\n",
        "avCon = re.findall(r\"^\\[(.+)\\]$\", content, re.M)\n",
        "mountNam = widgets.Dropdown(options=avCon)\n",
        "\n",
        "def MountCMD():\n",
        "    mPoint = f\"/content/drives/{mountNam.value}\"\n",
        "    os.makedirs(mPoint, exist_ok=True)\n",
        "    cmd = rf\"rclone mount {mountNam.value}: {mPoint}\" \\\n",
        "      rf\" --config {PATH_RClone_Config}/rclone.conf\" \\\n",
        "      ' --user-agent \"Mozilla\" &'\n",
        "    runSh(cmd, shell=True)\n",
        "    print(f\"Mount success! - \\t{mPoint}\")\n",
        "\n",
        "def unmountCMD():\n",
        "  mPoint = f\"/content/drives/{mountNam.value}\"\n",
        "  runSh(f\"fusermount -u {mPoint}\")\n",
        "  runSh(f\"rm -rf {mPoint}\")\n",
        "  print(f\"Unmounted success! - \\t{mPoint}\")\n",
        "\n",
        "\n",
        "ShowAC()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "whyei9P7GIsM",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h3>Rclone webui</h3></center><br>\n",
        "import os, signal\n",
        "import random\n",
        "import string\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "import time\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "#@markdown Default <br>&emsp;username : user<br>&emsp;password : pass\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "runW = get_ipython()\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "  from shlex import split as _spl\n",
        "  from subprocess import run\n",
        "\n",
        "  shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                  -O /root/.ipython/rlab_utils.py\"\n",
        "  run(_spl(shellCmd))\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    displayUrl,\n",
        "    findProcess,\n",
        "    CWD,\n",
        "    textAn,\n",
        "    checkAvailable\n",
        ")\n",
        "from rlab_utils import (\n",
        "    displayOutput,\n",
        "    checkAvailable,\n",
        "    runSh,\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        "    accessSettingFile,\n",
        "    memGiB,\n",
        ")\n",
        "\n",
        "loadingAn()\n",
        "prepareSession()\n",
        "pid = findProcess(\"rclone\", \"rcd\", isPid=True)\n",
        "try:\n",
        "  os.kill(int(pid), signal.SIGTERM)\n",
        "except TypeError:\n",
        "  pass\n",
        "cmd = \"rclone rcd --rc-web-gui --rc-addr :5572\" \\\n",
        "      \" --rc-serve\" \\\n",
        "      \" --rc-user=user --rc-pass=pass\" \\\n",
        "      \" --rc-no-auth\" \\\n",
        "      rf\" --config {PATH_RClone_Config}/rclone.conf\" \\\n",
        "      ' --user-agent \"Mozilla\"' \\\n",
        "      \" &\"\n",
        "runSh(cmd, shell=True)\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['rclone', 5572, 'http'],\n",
        "                            ['filebrowser', 4000, 'http']], 'ap', \n",
        "    [f\"{HOME}/.ngrok2/filebrowserRclone.yml\", 4099]\n",
        ").start('rclone', displayB=False)\n",
        "# output\n",
        "clear_output()\n",
        "displayUrl(Server, pNamU='Rclone webUI : ', \n",
        "           ExUrl=fr\"http://user:pass@{Server['url'][7:]}\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-BeHgvH1aNIJ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h3>Create Rclone config</h3>Create a new remote with name, type and options.<br><font size=1px>After created your config file download that. Next time just upload and you are done!</font></center>\n",
        "import os, urllib.request\n",
        "from IPython.display import HTML\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "runW = get_ipython()\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "#####################################\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "  from shlex import split as _spl\n",
        "  from subprocess import run\n",
        "\n",
        "  shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                  -O /root/.ipython/rlab_utils.py\"\n",
        "  run(_spl(shellCmd))\n",
        "\n",
        "from rlab_utils import (\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        "    runSh\n",
        ")\n",
        "from ttmg import (\n",
        "    ngrok\n",
        ")\n",
        "\n",
        "###################################\n",
        "import codecs\n",
        "import contextlib\n",
        "import locale\n",
        "import os\n",
        "import pty\n",
        "import select\n",
        "import signal\n",
        "import subprocess\n",
        "import sys\n",
        "import termios\n",
        "import time\n",
        "\n",
        "\n",
        "from IPython.utils import text\n",
        "import six\n",
        "from google.colab import _ipython\n",
        "from google.colab import _message\n",
        "from google.colab.output import _tags\n",
        "\n",
        "# Linux read(2) limits to 0x7ffff000 so stay under that for clarity.\n",
        "_PTY_READ_MAX_BYTES_FOR_TEST = 2**20  # 1MB\n",
        "\n",
        "_ENCODING = 'UTF-8'\n",
        "\n",
        "class ShellResult(object):\n",
        "  \"\"\"Result of an invocation of the shell magic.\n",
        "\n",
        "  Note: This is intended to mimic subprocess.CompletedProcess, but has slightly\n",
        "  different characteristics, including:\n",
        "    * CompletedProcess has separate stdout/stderr properties. A ShellResult\n",
        "      has a single property containing the merged stdout/stderr stream,\n",
        "      providing compatibility with the existing \"!\" shell magic (which this is\n",
        "      intended to provide an alternative to).\n",
        "    * A custom __repr__ method that returns output. When the magic is invoked as\n",
        "      the only statement in the cell, Python prints the string representation by\n",
        "      default. The existing \"!\" shell magic also returns output.\n",
        "  \"\"\"\n",
        "\n",
        "  def __init__(self, args, returncode, command_output):\n",
        "    self.args = args\n",
        "    self.returncode = returncode\n",
        "    self.output = command_output\n",
        "\n",
        "  def check_returncode(self):\n",
        "    if self.returncode:\n",
        "      raise subprocess.CalledProcessError(\n",
        "          returncode=self.returncode, cmd=self.args, output=self.output)\n",
        "\n",
        "  def _repr_pretty_(self, p, cycle):  # pylint:disable=unused-argument\n",
        "    # Note: When invoking the magic and not assigning the result\n",
        "    # (e.g. %shell echo \"foo\"), Python's default semantics will be used and\n",
        "    # print the string representation of the object. By default, this will\n",
        "    # display the __repr__ of ShellResult. Suppress this representation since\n",
        "    # the output of the command has already been displayed to the output window.\n",
        "    if cycle:\n",
        "      raise NotImplementedError\n",
        "\n",
        "\n",
        "def _configure_term_settings(pty_fd):\n",
        "  term_settings = termios.tcgetattr(pty_fd)\n",
        "  # ONLCR transforms NL to CR-NL, which is undesirable. Ensure this is disabled.\n",
        "  # http://man7.org/linux/man-pages/man3/termios.3.html\n",
        "  term_settings[1] &= ~termios.ONLCR\n",
        "\n",
        "  # ECHOCTL echoes control characters, which is undesirable.\n",
        "  term_settings[3] &= ~termios.ECHOCTL\n",
        "\n",
        "  termios.tcsetattr(pty_fd, termios.TCSANOW, term_settings)\n",
        "\n",
        "\n",
        "def _run_command(cmd, clear_streamed_output):\n",
        "  \"\"\"Calls the shell command, forwarding input received on the stdin_socket.\"\"\"\n",
        "  locale_encoding = locale.getpreferredencoding()\n",
        "  if locale_encoding != _ENCODING:\n",
        "    raise NotImplementedError(\n",
        "        'A UTF-8 locale is required. Got {}'.format(locale_encoding))\n",
        "\n",
        "  parent_pty, child_pty = pty.openpty()\n",
        "  _configure_term_settings(child_pty)\n",
        "\n",
        "  epoll = select.epoll()\n",
        "  epoll.register(\n",
        "      parent_pty,\n",
        "      (select.EPOLLIN | select.EPOLLOUT | select.EPOLLHUP | select.EPOLLERR))\n",
        "\n",
        "  try:\n",
        "    temporary_clearer = _tags.temporary if clear_streamed_output else _no_op\n",
        "\n",
        "    with temporary_clearer(), _display_stdin_widget(\n",
        "        delay_millis=500) as update_stdin_widget:\n",
        "      # TODO(b/115531839): Ensure that subprocesses are terminated upon\n",
        "      # interrupt.\n",
        "      p = subprocess.Popen(\n",
        "          cmd,\n",
        "          shell=True,\n",
        "          executable='/bin/bash',\n",
        "          stdout=child_pty,\n",
        "          stdin=child_pty,\n",
        "          stderr=child_pty,\n",
        "          close_fds=True)\n",
        "      # The child PTY is only needed by the spawned process.\n",
        "      os.close(child_pty)\n",
        "\n",
        "      return _monitor_process(parent_pty, epoll, p, cmd, update_stdin_widget)\n",
        "  finally:\n",
        "    epoll.close()\n",
        "    os.close(parent_pty)\n",
        "\n",
        "\n",
        "class _MonitorProcessState(object):\n",
        "\n",
        "  def __init__(self):\n",
        "    self.process_output = six.StringIO()\n",
        "    self.is_pty_still_connected = True\n",
        "\n",
        "\n",
        "def _monitor_process(parent_pty, epoll, p, cmd, update_stdin_widget):\n",
        "  \"\"\"Monitors the given subprocess until it terminates.\"\"\"\n",
        "  state = _MonitorProcessState()\n",
        "\n",
        "  # A single UTF-8 character can span multiple bytes. os.read returns bytes and\n",
        "  # could return a partial byte sequence for a UTF-8 character. Using an\n",
        "  # incremental decoder is incrementally fed input bytes and emits UTF-8\n",
        "  # characters.\n",
        "  decoder = codecs.getincrementaldecoder(_ENCODING)()\n",
        "\n",
        "  num_interrupts = 0\n",
        "  echo_status = None\n",
        "  while True:\n",
        "    try:\n",
        "      result = _poll_process(parent_pty, epoll, p, cmd, decoder, state)\n",
        "      if result is not None:\n",
        "        return result\n",
        "      term_settings = termios.tcgetattr(parent_pty)\n",
        "      new_echo_status = bool(term_settings[3] & termios.ECHO)\n",
        "      if echo_status != new_echo_status:\n",
        "        update_stdin_widget(new_echo_status)\n",
        "        echo_status = new_echo_status\n",
        "    except KeyboardInterrupt:\n",
        "      try:\n",
        "        num_interrupts += 1\n",
        "        if num_interrupts == 1:\n",
        "          p.send_signal(signal.SIGINT)\n",
        "        elif num_interrupts == 2:\n",
        "          # Process isn't responding to SIGINT and user requested another\n",
        "          # interrupt. Attempt to send SIGTERM followed by a SIGKILL if the\n",
        "          # process doesn't respond.\n",
        "          p.send_signal(signal.SIGTERM)\n",
        "          time.sleep(0.5)\n",
        "          if p.poll() is None:\n",
        "            p.send_signal(signal.SIGKILL)\n",
        "      except KeyboardInterrupt:\n",
        "        # Any interrupts that occur during shutdown should not propagate.\n",
        "        pass\n",
        "\n",
        "      if num_interrupts > 2:\n",
        "        # In practice, this shouldn't be possible since\n",
        "        # SIGKILL is quite effective.\n",
        "        raise\n",
        "\n",
        "\n",
        "def _poll_process(parent_pty, epoll, p, cmd, decoder, state):\n",
        "  \"\"\"Polls the process and captures / forwards input and output.\"\"\"\n",
        "\n",
        "  terminated = p.poll() is not None\n",
        "  if terminated:\n",
        "    termios.tcdrain(parent_pty)\n",
        "    # We're no longer interested in write events and only want to consume any\n",
        "    # remaining output from the terminated process. Continuing to watch write\n",
        "    # events may cause early termination of the loop if no output was\n",
        "    # available but the pty was ready for writing.\n",
        "    epoll.modify(parent_pty,\n",
        "                 (select.EPOLLIN | select.EPOLLHUP | select.EPOLLERR))\n",
        "\n",
        "  output_available = False\n",
        "\n",
        "  events = epoll.poll()\n",
        "  input_events = []\n",
        "  for _, event in events:\n",
        "    if event & select.EPOLLIN:\n",
        "      output_available = True\n",
        "      raw_contents = os.read(parent_pty, _PTY_READ_MAX_BYTES_FOR_TEST)\n",
        "      import re\n",
        "      decoded_contents = re.sub(r\"http:\\/\\/127.0.0.1:53682\", Server[\"url\"], \n",
        "                                decoder.decode(raw_contents))\n",
        "      sys.stdout.write(decoded_contents)\n",
        "      state.process_output.write(decoded_contents)\n",
        "\n",
        "    if event & select.EPOLLOUT:\n",
        "      # Queue polling for inputs behind processing output events.\n",
        "      input_events.append(event)\n",
        "\n",
        "    # PTY was disconnected or encountered a connection error. In either case,\n",
        "    # no new output should be made available.\n",
        "    if (event & select.EPOLLHUP) or (event & select.EPOLLERR):\n",
        "      state.is_pty_still_connected = False\n",
        "\n",
        "  for event in input_events:\n",
        "    # Check to see if there is any input on the stdin socket.\n",
        "    # pylint: disable=protected-access\n",
        "    input_line = _message._read_stdin_message()\n",
        "    # pylint: enable=protected-access\n",
        "    if input_line is not None:\n",
        "      # If a very large input or sequence of inputs is available, it's\n",
        "      # possible that the PTY buffer could be filled and this write call\n",
        "      # would block. To work around this, non-blocking writes and keeping\n",
        "      # a list of to-be-written inputs could be used. Empirically, the\n",
        "      # buffer limit is ~12K, which shouldn't be a problem in most\n",
        "      # scenarios. As such, optimizing for simplicity.\n",
        "      input_bytes = bytes(input_line.encode(_ENCODING))\n",
        "      os.write(parent_pty, input_bytes)\n",
        "\n",
        "  # Once the process is terminated, there still may be output to be read from\n",
        "  # the PTY. Wait until the PTY has been disconnected and no more data is\n",
        "  # available for read. Simply waiting for disconnect may be insufficient if\n",
        "  # there is more data made available on the PTY than we consume in a single\n",
        "  # read call.\n",
        "  if terminated and not state.is_pty_still_connected and not output_available:\n",
        "    sys.stdout.flush()\n",
        "    command_output = state.process_output.getvalue()\n",
        "    return ShellResult(cmd, p.returncode, command_output)\n",
        "\n",
        "  if not output_available:\n",
        "    # The PTY is almost continuously available for reading input to provide\n",
        "    # to the underlying subprocess. This means that the polling loop could\n",
        "    # effectively become a tight loop and use a large amount of CPU. Add a\n",
        "    # slight delay to give resources back to the system while monitoring the\n",
        "    # process.\n",
        "    # Skip this delay if we read output in the previous loop so that a partial\n",
        "    # read doesn't unnecessarily sleep before reading more output.\n",
        "    # TODO(b/115527726): Rather than sleep, poll for incoming messages from\n",
        "    # the frontend in the same poll as for the output.\n",
        "    time.sleep(0.1)\n",
        "\n",
        "\n",
        "@contextlib.contextmanager\n",
        "def _display_stdin_widget(delay_millis=0):\n",
        "  \"\"\"Context manager that displays a stdin UI widget and hides it upon exit.\n",
        "\n",
        "  Args:\n",
        "    delay_millis: Duration (in milliseconds) to delay showing the widget within\n",
        "      the UI.\n",
        "\n",
        "  Yields:\n",
        "    A callback that can be invoked with a single argument indicating whether\n",
        "    echo is enabled.\n",
        "  \"\"\"\n",
        "  shell = _ipython.get_ipython()\n",
        "  display_args = ['cell_display_stdin', {'delayMillis': delay_millis}]\n",
        "  _message.blocking_request(*display_args, parent=shell.parent_header)\n",
        "\n",
        "  def echo_updater(new_echo_status):\n",
        "    # Note: Updating the echo status uses colab_request / colab_reply on the\n",
        "    # stdin socket. Input provided by the user also sends messages on this\n",
        "    # socket. If user input is provided while the blocking_request call is still\n",
        "    # waiting for a colab_reply, the input will be dropped per\n",
        "    # https://github.com/googlecolab/colabtools/blob/56e4dbec7c4fa09fad51b60feb5c786c69d688c6/google/colab/_message.py#L100.\n",
        "    update_args = ['cell_update_stdin', {'echo': new_echo_status}]\n",
        "    _message.blocking_request(*update_args, parent=shell.parent_header)\n",
        "\n",
        "  yield echo_updater\n",
        "\n",
        "  hide_args = ['cell_remove_stdin', {}]\n",
        "  _message.blocking_request(*hide_args, parent=shell.parent_header)\n",
        "\n",
        "\n",
        "@contextlib.contextmanager\n",
        "def _no_op():\n",
        "  yield\n",
        "\n",
        "###################################\n",
        "prepareSession()\n",
        "\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['rcloneConfig', 53682, 'http'], \n",
        "                            ['pyload', 8000, 'http']], 'sa', \n",
        "    [f\"{HOME}/.ngrok2/rclonePyload.yml\", 4074]\n",
        ").start('rcloneConfig', displayB=False, v=False)\n",
        "\n",
        "printData = \"\"\"Copy this URL,\n",
        "  It's needed for authentication purposes.\n",
        "  After completing your account select, you redirect to a website, after back\n",
        "  you need to change http://127.0.0.0:53682 to {}\"\"\".format(Server['url'])\n",
        "print(printData)\n",
        "display(HTML('&emsp;&emsp;<a href=\"https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/src/rclone_config_create.gif\" target=\"_blank\">See how</a><br><br>'))\n",
        "print(f\"{Server['url']}\", end=\"\\n\\n\")\n",
        "_run_command(f\"rclone config --config {PATH_RClone_Config}/rclone.conf\", False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uB-vkVstVpVs",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute Upload Local File\n",
        "MODE = \"RCONFIG\"  # @param ['UTILS', 'RCONFIG', 'RCONFIG_append', \"GENERATELIST\"]\n",
        "REMOTE = \"\"  # @param {type:\"string\"}\n",
        "QUERY_PATTERN = \"\"  # @param {type:\"string\"}\n",
        "# @markdown #### <font size=1px>For not able to upload local file : https://stackoverflow.com/a/58661947</font>\n",
        "# ================================================================ #\n",
        "\n",
        "from os import path as _p\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run  # nosec\n",
        "\n",
        "    shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                    -O /root/.ipython/rlab_utils.py\"\n",
        "    run(_spl(shellCmd))  # nosec\n",
        "\n",
        "import importlib, rlab_utils\n",
        "from google.colab import files  # pylint: disable=import-error #nosec\n",
        "from rlab_utils import checkAvailable, runSh, PATH_RClone_Config, prepareSession\n",
        "\n",
        "\n",
        "def generateUploadList():\n",
        "    prepareSession()\n",
        "    if checkAvailable(\"/content/upload.txt\"):\n",
        "        runSh(\"rm -f upload.txt\")\n",
        "    runSh(\n",
        "        f\"rclone --config {PATH_RClone_Config}/rclone.conf lsf {REMOTE}: --include '{QUERY_PATTERN}' --drive-shared-with-me --files-only --max-depth 1 > /content/upload.txt\",\n",
        "        shell=True,  # nosec\n",
        "    )\n",
        "\n",
        "\n",
        "def uploadLocalFiles():\n",
        "    if MODE == \"UTILS\":\n",
        "        filePath = \"/root/.ipython/rlab_utils.py\"\n",
        "    elif MODE in (\"RCONFIG\", \"RCONFIG_append\"):\n",
        "        filePath = f\"{PATH_RClone_Config}/rclone.conf\"\n",
        "    else:\n",
        "        pass\n",
        "\n",
        "    try:\n",
        "      if checkAvailable(filePath):\n",
        "        runSh(f\"rm -f {filePath}\")\n",
        "      print(\"Select file from your computer.\\n\")\n",
        "      uploadedFile = files.upload()\n",
        "      fileNameDictKeys = uploadedFile.keys()\n",
        "      fileNo = len(fileNameDictKeys)\n",
        "      if fileNo > 1:\n",
        "          for fn in fileNameDictKeys:\n",
        "              runSh(f'rm -f \"/content/{fn}\"')\n",
        "          return print(\"\\nPlease only upload a single config file.\")\n",
        "      elif fileNo == 0:\n",
        "          return print(\"\\nFile upload cancelled.\")\n",
        "      elif fileNo == 1:\n",
        "          for fn in fileNameDictKeys:\n",
        "              if checkAvailable(f\"/content/{fn}\"):\n",
        "                  if MODE == \"RCONFIG_append\":\n",
        "                    import urllib\n",
        "                    urllib.request.urlretrieve(\"https://biplobsd.github.io/RLabClone/res/rclonelab/rclone.conf\",\n",
        "                                               \"/usr/local/sessionSettings/rclone.conf\")\n",
        "                    with open(f\"/content/{fn}\", 'r+') as r:\n",
        "                      new_data = r.read()\n",
        "                      runSh(f'rm -f \"/content/{fn}\"')\n",
        "                    with open(filePath, 'r+') as f:\n",
        "                      old_data = f.read()\n",
        "                      f.seek(0)\n",
        "                      f.truncate(0)\n",
        "                      f.write(old_data + new_data)\n",
        "                    print(\"\\nUpdate completed.\")\n",
        "                  else:\n",
        "                    runSh(f'mv -f \"/content/{fn}\" {filePath}')\n",
        "                    runSh(f\"chmod 666 {filePath}\")\n",
        "                    runSh(f'rm -f \"/content/{fn}\"')\n",
        "                    importlib.reload(rlab_utils)\n",
        "                    print(\"\\nUpload completed.\")\n",
        "              return\n",
        "      else:\n",
        "          print(\"\\nNo file\")\n",
        "          return\n",
        "    except:\n",
        "      return print(\"\\nUpload process Error.\")\n",
        "\n",
        "\n",
        "if MODE == \"GENERATELIST\":\n",
        "    generateUploadList()\n",
        "else:\n",
        "    uploadLocalFiles()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RG2o5dgK5P4j",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Download config file.\n",
        "MODE = \"RCONFIG\"  # @param ['UTILS', 'RCONFIG']\n",
        "# ================================================================ #\n",
        "from google.colab import files\n",
        "\n",
        "def downloadFile():\n",
        "  if MODE == \"UTILS\":\n",
        "      filePath = \"/root/.ipython/rlab_utils.py\"\n",
        "  elif MODE == \"RCONFIG\":\n",
        "      filePath = f\"{PATH_RClone_Config}/rclone.conf\"\n",
        "  else:\n",
        "      pass\n",
        "  try:\n",
        "    files.download(filePath)\n",
        "  except FileNotFoundError:\n",
        "    print(\"File not found!\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "  downloadFile()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bRurZqpoVtT6",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ SYNC Backups\n",
        "FAST_LIST = True\n",
        "# ================================================================ #\n",
        "\n",
        "from os import path as _p\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run  # nosec\n",
        "\n",
        "    shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                    -O /root/.ipython/rlab_utils.py\"\n",
        "    run(_spl(shellCmd))  # nosec\n",
        "\n",
        "from rlab_utils import (\n",
        "    runSh,\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        ")\n",
        "\n",
        "\n",
        "def generateCmd(src, dst):\n",
        "    block=f\"{'':=<117}\"\n",
        "    title=f\"\"\"+{f'Now Synchronizing... \"{src}\" > \"{dst}\" Fast List : {\"ON\" if FAST_LIST else \"OFF\"}':^{len(block)-2}}+\"\"\"\n",
        "    print(f\"{block}\\n{title}\\n{block}\")\n",
        "    cmd = f'rclone sync \"{src}\" \"{dst}\" --config {PATH_RClone_Config}/rclone.conf {\"--fast-list\" if FAST_LIST else \"\"} --user-agent \"Mozilla\" --transfers 20 --checkers 20 --drive-server-side-across-configs -c --buffer-size 256M --drive-chunk-size 256M --drive-upload-cutoff 256M --drive-acknowledge-abuse --drive-keep-revision-forever --tpslimit 95 --tpslimit-burst 40 --stats-one-line --stats=5s -v'\n",
        "    return cmd\n",
        "\n",
        "\n",
        "def executeSync():\n",
        "    prepareSession()\n",
        "    runSh(generateCmd(\"tdTdnMov:Movies\",\"tdMovRa4:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnTvs:TV Shows\",\"tdTvsRa5:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnRa6:Games\",\"tdGamRa7:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnRa8:Software\",\"tdSofRa9:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnR11:Tutorials\",\"tdTutR12:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnR13:Anime\",\"tdAniR14:\"), output=True)\n",
        "    # runSh(generateCmd(\"tdTdn14:Music\",\"tdMusR15:\"), output=True)\n",
        "\n",
        "\n",
        "executeSync()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZCAy1fhuU4_",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Check VM's Status\n",
        "Check_IP = True \n",
        "Loop_Check = False  #@param {type:\"boolean\"}\n",
        "Loop_Interval = 3600 \n",
        "# ================================================================ #\n",
        "\n",
        "import time, requests\n",
        "from IPython.display import clear_output\n",
        "\n",
        "Loop = True\n",
        "try:\n",
        "    while Loop == True:\n",
        "        clear_output(wait=True)\n",
        "        !top -bcn1 -w512\n",
        "        sessionIP = f\"\\nYour Public IP: {requests.get('http://ip.42.pl/raw').text}:12121\"\n",
        "        if Check_IP: \n",
        "            print(sessionIP)             \n",
        "        print(\"====\")\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": "kSvUMUuTPX7r",
        "colab_type": "text"
      },
      "source": [
        "## ![alt text](https://mega.nz/favicon.ico?v=3) __TRANSFERE to MEGA__\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q3uC2Lo5R6N9",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown <center><h2>INPUT YOUR MEGA ID</h2></center><br>\n",
        "from functools import wraps\n",
        "import errno\n",
        "import os\n",
        "import signal\n",
        "import subprocess\n",
        "import shlex\n",
        "\n",
        "\n",
        "class TimeoutError(Exception):\n",
        "    pass\n",
        "\n",
        "\n",
        "def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):\n",
        "    def decorator(func):\n",
        "        def _handle_timeout(signum, frame):\n",
        "            raise TimeoutError(error_message)\n",
        "\n",
        "        def wrapper(*args, **kwargs):\n",
        "            signal.signal(signal.SIGALRM, _handle_timeout)\n",
        "            signal.alarm(seconds)\n",
        "            try:\n",
        "                result = func(*args, **kwargs)\n",
        "            finally:\n",
        "                signal.alarm(0)\n",
        "            return result\n",
        "\n",
        "        return wraps(func)(wrapper)\n",
        "\n",
        "    return decorator\n",
        "\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/ttmg.py\"):\n",
        "    from subprocess import run\n",
        "    from shlex import split\n",
        "\n",
        "    shellCmd = \"wget -qq https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/res/ttmg.py \\\n",
        "                    -O /root/.ipython/ttmg.py\"\n",
        "    run(split(shellCmd))\n",
        "from ttmg import runSh\n",
        "\n",
        "@timeout(10)\n",
        "def runShT(args):\n",
        "    return runSh(args, output=True)\n",
        "\n",
        "\n",
        "# MEGAcmd installing\n",
        "if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "    print(\"Installing MEGA ...\")\n",
        "    runSh('sudo apt-get -y update')\n",
        "    runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "    runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "    runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "    print(\"MEGA is installed.\")\n",
        "else:\n",
        "    !pkill mega-cmd\n",
        "\n",
        "# INPUT YOUR MEGA ID\n",
        "\n",
        "USERNAME = \"\"  # @param {type:\"string\"}\n",
        "PASSWORD = \"\"  # @param {type:\"string\"}\n",
        "if not (USERNAME == \"\" or PASSWORD == \"\"):\n",
        "    try:\n",
        "        runShT(f\"mega-login {USERNAME} {PASSWORD}\")\n",
        "    except TimeoutError:\n",
        "        runSh('mega-whoami', output=True)\n",
        "else:\n",
        "    print(\"Please Input your Mega IDs.\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E3N6hyM2I6hk",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown ##### Quick move (check and leave all boxs):\n",
        "# @markdown #####{\n",
        "import time\n",
        "import subprocess\n",
        "import contextlib\n",
        "from IPython.display import clear_output\n",
        "Simple_torrent = False  # @param{type: \"boolean\"}\n",
        "Peerflix = False  # @param{type: \"boolean\"}\n",
        "# @markdown ##### }\n",
        "# @markdown <br><center><img src='https://www.impactcomputing.co.uk/uploads/files/services/managed-office-365.svg' height=\"100\" alt=\"netdata\"/></center>\n",
        "# @markdown <center><h2>TRANSFERE NOW</h2></center><br>\n",
        "# TRANSFERE NOW\n",
        "\n",
        "PATH_TO_FILE = \"\"  # @param {type:\"string\"}\n",
        "# Unix, Windows and old Macintosh end-of-line\n",
        "newlines = ['\\n', '\\r\\n', '\\r']\n",
        "\n",
        "\n",
        "def unbuffered(proc, stream='stdout'):\n",
        "    stream = getattr(proc, stream)\n",
        "    with contextlib.closing(stream):\n",
        "        while True:\n",
        "            out = []\n",
        "            last = stream.read(1)\n",
        "            # Don't loop forever\n",
        "            if last == '' and proc.poll() is not None:\n",
        "                break\n",
        "            while last not in newlines:\n",
        "                # Don't loop forever\n",
        "                if last == '' and proc.poll() is not None:\n",
        "                    break\n",
        "                out.append(last)\n",
        "                last = stream.read(1)\n",
        "            out = ''.join(out)\n",
        "            yield out\n",
        "\n",
        "\n",
        "def transfare():\n",
        "    cmd = \"\"\n",
        "    if Simple_torrent:\n",
        "        cmd = ['mega-put', 'downloads', '/colab']\n",
        "    elif Peerflix:\n",
        "        cmd = ['mega-put', 'peerflix', '/colab']\n",
        "    else:\n",
        "        cmd = ['mega-put', PATH_TO_FILE, '/colab']\n",
        "    proc = subprocess.Popen(\n",
        "        cmd,\n",
        "        stdout=subprocess.PIPE,\n",
        "        stderr=subprocess.STDOUT,\n",
        "        # Make all end-of-lines '\\n'\n",
        "        universal_newlines=True,\n",
        "    )\n",
        "    for line in unbuffered(proc):\n",
        "        clear_output(wait=True)\n",
        "        print(line)\n",
        "\n",
        "try:\n",
        "    transfare()\n",
        "except FileNotFoundError:\n",
        "    print(\"Login your account!\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XlDyLy_JZJ03",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "import os\n",
        "from IPython.display import clear_output\n",
        "#@title MEGA public link download\n",
        "URL = \"\" #@param {type:\"string\"}\n",
        "path_to_folder = \"\" #@param {type:\"string\"}\n",
        "if not path_to_folder:\n",
        "  os.makedirs(\"downloads\", exist_ok=True)\n",
        "  path_to_folder = \"downloads\"\n",
        "# MEGAcmd installing\n",
        "if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "    print(\"Installing MEGA ...\")\n",
        "    runSh('sudo apt-get -y update')\n",
        "    runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "    runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "    runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "    print(\"MEGA is installed.\")\n",
        "    clear_output()\n",
        "\n",
        "!mega-get $URL $path_to_folder "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "dySANcIIMdFU"
      },
      "source": [
        "# <center><b>Special Features</b><h5>Zipping, Encoding, Cloning, Free Vps</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zajDdD9kKNw9"
      },
      "source": [
        "##<img src='https://yuju.pw/y/qUkg.png' height=\"65\" alt=\"7zip\"><i>__7-Zip + UNRAR__</i>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "3fMs7cVkKNxA",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> <i>Required:</i> Install 7-Zip + UNRAR\n",
        "!sudo apt update\n",
        "!sudo apt install p7zip-full p7zip-rar unrar rar"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "BYmG1ZmqKNxM",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>» Run to change current working directory\n",
        "import os\n",
        "new_dir = \"\" #@param {type:\"string\"}\n",
        "\n",
        "%cd \"$new_dir\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "zuaySeQuKNxV",
        "colab": {}
      },
      "source": [
        "#@title » Extract Archive (<i>.zip, .rar, .7z, etc.</i>)\n",
        "import os, sys, re\n",
        "\n",
        "archive_file_path = \"\" #@param {type:\"string\"}\n",
        "os.environ['inputFile'] = archive_file_path\n",
        "\n",
        "!7z e \"$inputFile\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "EJKWr_UwKNxj",
        "colab": {}
      },
      "source": [
        "#@title » Create .zip from Folder\n",
        "import os, sys, re\n",
        "\n",
        "folder_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", folder_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", folder_path)\n",
        "folder_name = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "\n",
        "os.environ['inputDir'] = folder_path\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "os.environ['folderName'] = folder_name\n",
        "\n",
        "!7z a -tzip \"$outputPath\"/\"$folderName\".zip \"$inputDir\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c3cOMk38t8Zm",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/biplobsd/Google-Colab-CloudTorrent/master/src/zip.png' height=\"30\" alt=\"netdata\"> __Extracte/Archive Zip/Tar/Rar__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aK-ly9_92Chr",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Extract Files\n",
        "MODE = \"UNZIP\"  # @param [\"UNZIP\", \"UNTAR\", \"UNRAR\", \"7Z\"]\n",
        "PATH_TO_FILE = \"\"  # @param {type:\"string\"}\n",
        "extractPath = \"\"  # @param {type:\"string\"}\n",
        "ARCHIVE_PASSWORD = \"\" #@param {type:\"string\"}\n",
        "\n",
        "# ================================================================ #\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    checkAvailable,\n",
        ")\n",
        "\n",
        "def extractFiles():\n",
        "    global extractPath\n",
        "    if ARCHIVE_PASSWORD:\n",
        "      passADD = f'-P {ARCHIVE_PASSWORD}'\n",
        "    else:\n",
        "      passADD = ''\n",
        "    if not extractPath:\n",
        "      extractPath = \"/content/extract\"\n",
        "    os.makedirs(extractPath, exist_ok=True)\n",
        "    if MODE == \"UNZIP\":\n",
        "        runSh('unzip '+passADD+f' \"{PATH_TO_FILE}\" -d \"{extractPath}\"', output=True)\n",
        "    elif MODE == \"UNRAR\":\n",
        "        runSh(f'unrar x \"{PATH_TO_FILE}\" \"{extractPath}\" '+passADD+' -o+', output=True)\n",
        "    elif MODE == \"UNTAR\":\n",
        "        runSh(f'tar -C \"{extractPath}\" -xvf \"{PATH_TO_FILE}\"', output=True)\n",
        "    else:\n",
        "        runSh(f'7z x \"{PATH_TO_FILE}\" -o{extractPath} '+passADD, output=True)\n",
        "\n",
        "\n",
        "extractFiles()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OyIeKHClum9J",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Archive Files\n",
        "MODE = \"ZIP\" #@param [\"ZIP\", \"TAR\", \"7Z\"]\n",
        "FILENAME = \"\"  # @param {type:\"string\"}\n",
        "PATH_TO_FILE = \"\"  # @param {type:\"string\"}\n",
        "ARCHIVE_PASSWORD = \"\" #@param {type:\"string\"}\n",
        "\n",
        "# ================================================================ #\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    checkAvailable,\n",
        ")\n",
        "\n",
        "def extractFiles():\n",
        "    global FILENAME\n",
        "    if MODE == \"ZIP\":\n",
        "        if not FILENAME:\n",
        "          FILENAME = \"/content/NEW_FILE.ZIP\"\n",
        "        if ARCHIVE_PASSWORD:\n",
        "          passADD = f'--password \"{ARCHIVE_PASSWORD}\"'\n",
        "        else:\n",
        "          passADD = ''\n",
        "        runSh(f'zip {passADD} -r \"{FILENAME}\" \"{PATH_TO_FILE}\"', output=True)\n",
        "    elif MODE == \"TAR\":\n",
        "        if not FILENAME:\n",
        "          FILENAME = \"NEW_FILE\"\n",
        "        runSh(f'tar -zcvf \"{FILENAME}.tar.gz\" {PATH_TO_FILE}', output=True)\n",
        "    else:\n",
        "        if not FILENAME:\n",
        "            FILENAME = \"NEW_FILE\"\n",
        "        runSh(f'7z a \"{FILENAME}.7z\" {PATH_TO_FILE}', output=True)\n",
        "\n",
        "\n",
        "extractFiles()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mtIWnZ60Sczn",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://yuju.pw/y/q6fc.png' height=\"60\" alt=\"qBitTorrent\"/><i>__folderclone__</i>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jWNiE-RGECHM",
        "colab_type": "text"
      },
      "source": [
        "### **Step 1.** Installing Required modules"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "12dTZfUQEN8b",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run this cell to install all required modules</h3>\n",
        "!python -m pip install --upgrade pip\n",
        "!pip install oauth2client\n",
        "!pip install google-api-python-client\n",
        "!pip install progress\n",
        "!pip install progressbar2\n",
        "!pip install httplib2shim"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MbJ_88vSD-K2",
        "colab_type": "text"
      },
      "source": [
        "### **Step 2.** Pulling your repo from GitHub\n",
        "- *Remove* \"<code>https://</code>\" *from Repo link*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h5kQ5bxsDNiX",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Click here download your private repo</h3>\n",
        "import os\n",
        "userID = \"\" #@param {type:\"string\"}\n",
        "Password = \"\"#@param {type:\"string\"}\n",
        "Repolink = \"github.com/MissSarahh/MFCBPDEMO\"#@param {type:\"string\"}\n",
        "!git clone https://\"$userID\":\"$Password\"@\"$Repolink\".git"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XgMQmTB8EToD",
        "colab_type": "text"
      },
      "source": [
        "### **Step 3.** Changing current working directory to *your folderclone*\n",
        "- *You should see a new folder in the file directory titled* folderclone"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MbaXfAt6Eb3V",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run this cell to change default directory</h3>\n",
        "import os\n",
        "PATH = \"/content/drive/My Drive/\" #@param {type:\"string\"}\n",
        "\n",
        "%cd \"$PATH\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cLQnx323EdqO",
        "colab_type": "text"
      },
      "source": [
        "### **Step 4.** Check Current Directory"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X04yZvEwEkyr",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run this cell to check the working directory</h3>\n",
        "import os\n",
        "os.getcwd()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yTPpo294F0U8",
        "colab_type": "text"
      },
      "source": [
        "### **Step 5.** Adding All SAs to TD\n",
        "- In the  field below put the Team Drive ID that you want to add all SAs to\n",
        "* You'll only need to do this step ***once***, your progress is saved on GitHub\n",
        "\n",
        "<h4><b><i>Important:</b></i></h4>\n",
        "<h5> ✧  ឵After completing this step, you can <b>skip</b> it in the future!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N_TmVIzfFyRQ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run this cell to add all SAs to a Team Drive</h3>\n",
        "#@markdown <h5><i>This may take some time. Be patient!</i></h5>\n",
        "import os\n",
        "TDid = \"\" #@param {type:\"string\"}\n",
        "!python masshare.py -d \"$TDid\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n3MWoStHEnJx",
        "colab_type": "text"
      },
      "source": [
        "### **Final Step -** Running folderclone\n",
        "- Add the Source Folder ID and then the Destination Folder ID\n",
        "- Note: ***Your source*** *(*`src`*)* ***folder must be publically accessible***\n",
        "\n",
        "##### Folder IDs are found at the end of the URL:\n",
        "![](https://yuju.pw/y/qNvy.png)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qHQzhGLUEy2J",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title <h3><b>←</b> Run to clone all folders + files from <code>src</code> to <code>dest</code>\n",
        "#@markdown <i>Paste only the Folder IDs for these values</i>:\n",
        "src = \"\" #@param {type:\"string\"}\n",
        "dest = \"\" #@param {type:\"string\"}\n",
        "\n",
        "!python multifolderclone.py -s \"$src\" -d \"$dest\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DYreGU9NvCdk",
        "colab_type": "text"
      },
      "source": [
        "## ***Extra***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSG8fIhSAmZ-",
        "colab_type": "text"
      },
      "source": [
        "### **Bonus 1:** Removing SAs from TD \n",
        "#### ✧ Note: This is ***not required***\n",
        "- Add the Team Drive ID from which you want to remove all SAs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iWjIU7lwDWef",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run this cell to remove all SAs to a TD</h3>\n",
        "import os\n",
        "TDid = \"\" #@param {type:\"string\"}\n",
        "\n",
        "!python remove.py \"$TDid\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t0eVljW0O0CG",
        "colab_type": "text"
      },
      "source": [
        "### **Bonus 2:** Deleting a Directory *(if needed, just in case)*\n",
        "#### ✧ Note: This is ***not required***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LgG4fBSgO9Ev",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title <h3><b>←</b> Run This Cell to Delete a Directory\n",
        "import os, shutil\n",
        "path = \"\" #@param {type:\"string\"}\n",
        "shutil.rmtree(path)\n",
        "print(\"Successfully deleted 👍\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ukxnQC4c0nuR",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://www.vozidea.com/wp-content/uploads/2018/05/ffmpeg-logo-grande.png ' height=\"57\" alt=\"RcloneLab\"/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EFOqhHG6hOVH",
        "colab_type": "text"
      },
      "source": [
        "## ***Required to use Scripts:*** Install FFmpeg"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hFeE-qPuhTiK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!apt install ffmpeg"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KgNPvGccgwd8",
        "colab_type": "text"
      },
      "source": [
        "## FFmpeg Scripts *(Convert, Edit, Trim + more)*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RDHuIkoi6l9a",
        "colab_type": "text"
      },
      "source": [
        "###» Display Media File Codecs + Metadata"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X4yIG_nqYAoH",
        "colab_type": "text"
      },
      "source": [
        "> *You can ignore the \"At least one output file must be specified\" error after running this.*\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sv8au_RO6WUs",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "import os, sys, re\n",
        "\n",
        "media_file_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "os.environ['inputFile'] = media_file_path\n",
        "\n",
        "!ffmpeg -i \"$inputFile\" -hide_banner"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NQ0TxfKeghR8",
        "colab_type": "text"
      },
      "source": [
        "###» Convert *.mkv* ➔ *.mp4* (Lossless)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ls4O5VLwief-",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputFile'] = filename_raw\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -c copy -strict experimental \"$outputPath\"\"$outputFile\".mp4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FpJXJiRl6-gK",
        "colab_type": "text"
      },
      "source": [
        "###» Trim Video File (Lossless)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iFBUeQhn7QTc",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "start_time = \"00:00:00.000\" #@param {type:\"string\"}\n",
        "end_time = \"00:01:00.000\" #@param {type:\"string\"}\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "file_extension = re.search(\".{3}$\", filename)\n",
        "file_extension_raw = file_extension.group(0)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "os.environ['startTime'] = start_time\n",
        "os.environ['endTime'] = end_time\n",
        "os.environ['fileName'] = filename_raw\n",
        "os.environ['fileExtension'] = file_extension_raw\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -ss \"$startTime\" -to \"$endTime\" -c copy \"$outputPath\"/\"$fileName\"-TRIM.\"$fileExtension\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "2f-THZmDoOaY"
      },
      "source": [
        "###» Extract Audio from Video File (Lossless)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nSeO98YQoTJe",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "output_file_extension = 'm4a' #@param [\"m4a\", \"mp3\", \"opus\", \"flac\", \"wav\"]\n",
        "\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputPath'] = output_file_path.group(0)\n",
        "os.environ['fileName'] = filename_raw\n",
        "os.environ['fileType'] = output_file_extension\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -vn -c:a copy \"$outputPath\"/\"$fileName\"-audio.\"$fileType\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MSUasbRUDP3B",
        "colab_type": "text"
      },
      "source": [
        "###» Re-encode a Video to a Different Resolution"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nd2LvSRZCxRe",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "import os, sys, re\n",
        "\n",
        "video_file_path = '' #@param {type:\"string\"}\n",
        "resolution = '360p' #@param [\"1080p\", \"720p\", \"480p\", \"360p\", \"240p\"]\n",
        "file_type = 'mkv' #@param [\"mkv\", \"mp4\"]\n",
        "\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "testsplit = video_file_path.split(\"/\")\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "resolution_raw = re.search(\"[^p]{3,4}\", resolution)\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputPath'] = output_file_path.group(0)\n",
        "os.environ['fileName'] = filename_raw\n",
        "os.environ['fileType'] = file_type\n",
        "os.environ['resolutionHeight'] = resolution_raw.group(0)\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -vf \"scale=-1:\"$resolutionHeight\"\" -c:a copy -strict experimental \"$outputPath\"/\"$fileName\"-\"$resolutionHeight\"p.\"$fileType\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0xI8WiUPji3k",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://yuju.pw/y/qVwA.png' height=\"50\" alt=\"RcloneLab\"/> ___SSH Access___\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fsceu1YCkoes",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run to enable SSH acccess\n",
        "#@markdown <h5><i>This will ask for your ngrok token from:</i> <a href=\"https://dashboard.ngrok.com/auth\">https://dashboard.ngrok.com/auth</a></h5>\n",
        "#Generate root password\n",
        "import random, string\n",
        "password = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(20))\n",
        "#Download ngrok\n",
        "! wget -q -c -nc https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n",
        "! unzip -qq -n ngrok-stable-linux-amd64.zip\n",
        "#Setup sshd\n",
        "! apt-get install -qq -o=Dpkg::Use-Pty=0 openssh-server pwgen > /dev/null\n",
        "#Set root password\n",
        "! echo root:$password | chpasswd\n",
        "! mkdir -p /var/run/sshd\n",
        "! echo \"PermitRootLogin yes\" >> /etc/ssh/sshd_config\n",
        "! echo \"PasswordAuthentication yes\" >> /etc/ssh/sshd_config\n",
        "! echo \"LD_LIBRARY_PATH=/usr/lib64-nvidia\" >> /root/.bashrc\n",
        "! echo \"export LD_LIBRARY_PATH\" >> /root/.bashrc\n",
        "#Run sshd\n",
        "get_ipython().system_raw('/usr/sbin/sshd -D &')\n",
        "#Ask token\n",
        "print(\"Copy authtoken from https://dashboard.ngrok.com/auth\")\n",
        "import getpass\n",
        "authtoken = getpass.getpass()\n",
        "#Create tunnel\n",
        "get_ipython().system_raw('./ngrok authtoken $authtoken && ./ngrok tcp 22 &')\n",
        "#Print root password\n",
        "print(\"Root password: {}\".format(password))\n",
        "#Get public address\n",
        "! curl -s http://localhost:4040/api/tunnels | python3 -c \\\n",
        "\"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QlsUJhNwyeV3",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://szyha.github.io/RcloneLabArchive/img/title_rclonelab.png' height=\"56\" alt=\"RcloneLab\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_RezFPjUJ9Yq",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Click Here Before Using RcloneLab</h3>\n",
        "#@markdown <h5><i>Note: This cell will ask for your</i> <code>rclone.conf</code> <i>file</i></h5>\n",
        "Setup_Time_Zone = False #@param {type:\"boolean\"}\n",
        "\n",
        "import os; from google.colab import files; from IPython.display import HTML, clear_output\n",
        "\n",
        "def upload_conf():\n",
        "  try:\n",
        "    display(HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Please upload the config file of rclone (rclone.conf) from your computer.</h2><br>\"))\n",
        "    UploadConfig = files.upload().keys()\n",
        "    clear_output()\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) == True:\n",
        "          get_ipython().system_raw(\"mv -f \" + \"\\\"\" + fn + \"\\\" /root/.rclone.conf && chmod 666 /root/.rclone.conf\")\n",
        "          if Setup_Time_Zone == True:\n",
        "            !sudo dpkg-reconfigure tzdata\n",
        "            clear_output()\n",
        "          if os.path.isfile(\"/usr/bin/rclone\") == True:\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#00b24c;\\\">Config has been changed.</h2><br></center>\"))\n",
        "          else:\n",
        "            get_ipython().system_raw(\"rm -rf /content/sample_data/ && curl -s https://rclone.org/install.sh | sudo bash\")\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Installation has been successfully completed.</h2><br></center>\"))\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()\n",
        "    return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Error occurred during upload file.</h2><br></center>\"))\n",
        "\n",
        "upload_conf()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RIr3CXMAGNdy",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Run This Cell to Use RcloneLab</h3>\n",
        "# ============================= FORM ============================= #\n",
        "Mode = \"Config\" #@param [\"Config\", \"Copy\", \"Move\", \"Mount\", \"Sync\", \"Checker\", \"Deduplicate\", \"Remove Empty Directories\", \"Empty Trash\", \"qBittorrent\"]\n",
        "Compare = \"Size & Mod-Time\" #@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 #@param {type:\"slider\", min:1, max:20, step:1}\n",
        "Checkers = 20 #@param {type:\"slider\", min:1, max:20, step:1}\n",
        "#@markdown ---\n",
        "\n",
        "#@markdown <center><h3><font color=\"#3399ff\"><b>⚙️ Global Configuration ⚙️</b></font></h3></center>\n",
        "Simple_Ouput = True #@param {type:\"boolean\"}\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 = False #@param {type:\"boolean\"}\n",
        "Google_Drive_server_side_copy = False #@param {type:\"boolean\"}\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 128M\"\n",
        "else:\n",
        "  bufferC = \"--buffer-size 192M\"\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 128M --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 128M --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://raw.githubusercontent.com/Sparoney/RcloneLab/master/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": "markdown",
      "metadata": {
        "id": "FVvFaJrZ0bxg",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://szyha.github.io/RcloneLabArchive/img/title_netdata.png' height=\"45\" alt=\"netdata\"/>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H0Q1ERYX0Vrb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <br><center><img src='https://szyha.github.io/RcloneLabArchive/img/title_netdata.png' height=\"100\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>Real-time Server Monitoring</h3></center><br>\n",
        "# ============================= FORM ============================= #\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "# ============================= FORM ============================= #\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, subprocess, shlex\n",
        "from IPython.display import HTML, clear_output\n",
        "import time\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    shellCmd = \"wget -qq https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\" \\\n",
        "                f\" -O {HOME}/.ipython/ttmg.py\"\n",
        "    subprocess.run(shlex.split(shellCmd))\n",
        "\n",
        "from ttmg import (\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    runSh,\n",
        "    textAn\n",
        ")\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 Start_ServerMT():\n",
        "  if CheckProcess(\"netdata\", \"\") != True:\n",
        "    runSh('/usr/sbin/netdata', shell=True)\n",
        "\n",
        "loadingAn()      \n",
        "\n",
        "if not os.path.isfile(\"/usr/sbin/netdata\"):\n",
        "  clear_output(wait=True)\n",
        "  textAn(\"[Installing] Wait for almost 2 minutes...\")\n",
        "  #start = time.time()\n",
        "  get_ipython().system_raw(\"bash <(curl -Ss https://my-netdata.io/kickstart.sh) --dont-wait --dont-start-it\")\n",
        "  #end = time.time()\n",
        "  clear_output(wait=True)\n",
        "Start_ServerMT()\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['netdata', 19999, 'http'], \n",
        "                            ['cloudcmd', 7007, 'http']], 'au', \n",
        "    [f\"{HOME}/.ngrok2/netdataCloudcmd.yml\", 4044]\n",
        ").start('netdata', 'g')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "INCWjTDRLye6",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_cloud_commander.png' height=\"45\" alt=\"cloudCommander\"/>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SX9z-_6PLpb8",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@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",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "import os, psutil, time, urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        ")\n",
        "\n",
        "loadingAn()\n",
        "if os.path.isfile(\"/tools/node/bin/cloudcmd\") == False:\n",
        "  get_ipython().system_raw(\"npm cache clean -f && npm install -g n && n stable && npm i cloudcmd -g --force\")\n",
        "\n",
        "try:\n",
        "  urllib.request.urlopen('http://localhost:7007')\n",
        "except urllib.error.URLError:\n",
        "  !nohup cloudcmd --online --no-auth --show-config --show-file-name \\\n",
        "        --editor 'deepword' --packer 'tar' --port 7007 \\\n",
        "        --no-confirm-copy --confirm-move --name 'File Manager' \\\n",
        "        --keys-panel --no-contact --console --sync-console-path \\\n",
        "        --no-terminal --no-vim --columns 'name-size-date' --no-log &\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['netdata', 19999, 'http'], \n",
        "                            ['cloudcmd', 7007, 'http']], 'au', \n",
        "    [f\"{HOME}/.ngrok2/netdataCloudcmd.yml\", 4044]\n",
        ").start('cloudcmd')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4rMlpsk3jv5r",
        "colab_type": "text"
      },
      "source": [
        "## <img src='http://icons.iconarchive.com/icons/blackvariant/button-ui-system-apps/1024/Terminal-icon.png' height=\"25\" alt=\"ssh\" />___SSH and noVNC___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E4mhEMnmj5-s",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to create ssh tunnel</h3>\n",
        "#@markdown <br><center><img src='http://icons.iconarchive.com/icons/blackvariant/button-ui-system-apps/1024/Terminal-icon.png' height=\"200\" alt=\"ssh\"/></center>\n",
        "#@markdown <center><h3>Forward ssh now</h3></center><br>\n",
        "import os\n",
        "import random\n",
        "import string\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "import time\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "CREATE_VNC = True # @param {type:\"boolean\"}\n",
        "CREATE_SSH = True # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "runW = get_ipython()\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    displayUrl,\n",
        "    findProcess,\n",
        "    CWD,\n",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn()\n",
        "\n",
        "# password ganarate\n",
        "try:\n",
        "  print(f\"Found old password! : {password}\")\n",
        "except:\n",
        "  password = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(20))\n",
        "\n",
        "#Set root password\n",
        "if CREATE_SSH  and os.path.exists('/var/run/sshd') == False:\n",
        "  #Setup sshd\n",
        "  runSh('apt install -qq -o=Dpkg::Use-Pty=0 openssh-server pwgen')\n",
        "  runW.system_raw(\"echo root:$password | chpasswd\")\n",
        "  os.makedirs(\"/var/run/sshd\", exist_ok=True)\n",
        "  runW.system_raw('echo \"PermitRootLogin yes\" >> /etc/ssh/sshd_config')\n",
        "  runW.system_raw('echo \"PasswordAuthentication yes\" >> /etc/ssh/sshd_config')\n",
        "  runW.system_raw('echo \"LD_LIBRARY_PATH=/usr/lib64-nvidia\" >> /root/.bashrc')\n",
        "  runW.system_raw('echo \"export LD_LIBRARY_PATH\" >> /root/.bashrc')\n",
        "\n",
        "  #Run sshd\n",
        "  if not findProcess(\"/usr/sbin/sshd\", command=\"-D\"):\n",
        "    runSh('/usr/sbin/sshd -D &', shell=True)\n",
        "\n",
        "if CREATE_VNC:\n",
        "  clear_output()\n",
        "  #start = time.time()\n",
        "  textAn(\"Wait for almost 2 minutes. It's doing for VNC ready...\")\n",
        "  os.makedirs(f'{HOME}/.vnc', exist_ok=True)\n",
        "  runW.system_raw('add-apt-repository -y ppa:apt-fast/stable < /dev/null')\n",
        "  runW.system_raw('echo debconf apt-fast/maxdownloads string 16 | debconf-set-selections')\n",
        "  runW.system_raw('echo debconf apt-fast/dlflag boolean true | debconf-set-selections')\n",
        "  runW.system_raw('echo debconf apt-fast/aptmanager string apt-get | debconf-set-selections')\n",
        "  runW.system_raw('apt install -y apt-fast')\n",
        "  runW.system_raw('apt-fast install -y xfce4 xfce4-goodies firefox tightvncserver')\n",
        "  runW.system_raw(rf'echo \"{password}\" | vncpasswd -f > ~/.vnc/passwd')\n",
        "  data = \"\"\"\n",
        "#!/bin/bash\n",
        "xrdb $HOME/.Xresources\n",
        "startxfce4 &\n",
        "\"\"\"\n",
        "  with open(f'{HOME}/.vnc/xstartup', 'w+') as wNow:\n",
        "    wNow.write(data)\n",
        "  os.chmod(f'{HOME}/.vnc/xstartup', 0o755)\n",
        "  os.chmod(f'{HOME}/.vnc/passwd', 0o400)\n",
        "  runSh('sudo vncserver &', shell=True)\n",
        "  runSh(f'git clone https://github.com/novnc/noVNC.git {CWD}/noVNC')\n",
        "  runSh(\"bash noVNC/utils/launch.sh --listen 6080 --vnc localhost:5901 &\",\n",
        "        shell=True)\n",
        "  #end = time.time()\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "Server = ngrok(TOKEN, USE_FREE_TOKEN, [['ssh', 22, 'tcp'], \n",
        "               ['vnc', 6080, 'http']], 'in', \n",
        "               [f\"{HOME}/.ngrok2/sshVnc.yml\", 4045])\n",
        "data = Server.start('ssh', displayB=False)\n",
        "# output\n",
        "Host,port = data['url'][7:].split(':')\n",
        "data2 = Server.start('vnc', displayB=False)\n",
        "clear_output()\n",
        "if CREATE_VNC:\n",
        "  displayUrl(data2, pNamU='noVnc : ',\n",
        "            EcUrl=f'/vnc.html?autoconnect=true&password={password}')\n",
        "if CREATE_SSH:\n",
        "  display(HTML(\"\"\"<style>@import url('https://fonts.googleapis.com/css?family=Source+Code+Pro:200,900');  :root {   --text-color: hsla(210, 50%, 85%, 1);   --shadow-color: hsla(210, 40%, 52%, .4);   --btn-color: hsl(210, 80%, 42%);   --bg-color: #141218; }  * {   box-sizing: border-box; } button { position:relative; padding: 10px 20px;     border: none;   background: none;      font-family: \"Source Code Pro\";   font-weight: 900;font-size: 20px;     color: var(--text-color);      background-color: var(--btn-color);   box-shadow: var(--shadow-color) 2px 2px 22px;   border-radius: 4px;    z-index: 0;overflow: hidden; -webkit-user-select: text;-moz-user-select: text;-ms-user-select: text;user-select: text;}  button:focus {   outline-color: transparent;   box-shadow: var(--btn-color) 2px 2px 22px; }  .right::after, button::after {   content: var(--content);   display: block;   position: absolute;   white-space: nowrap;   padding: 40px 40px;   pointer-events:none; }  button::after{   font-weight: 200;   top: -30px;   left: -20px; }   .right, .left {   position: absolute;   width: 100%;   height: 100%;   top: 0; } .right {   left: 66%; } .left {   right: 66%; } .right::after {   top: -30px;   left: calc(-66% - 20px);      background-color: var(--bg-color);   color:transparent;   transition: transform .4s ease-out;   transform: translate(0, -90%) rotate(0deg) }  button:hover .right::after {   transform: translate(0, -47%) rotate(0deg) }  button .right:hover::after {   transform: translate(0, -50%) rotate(-7deg) }  button .left:hover ~ .right::after {   transform: translate(0, -50%) rotate(7deg) }  /* bubbles */ button::before {   content: '';   pointer-events: none;   opacity: .6;   background:     radial-gradient(circle at 20% 35%,  transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 75% 44%, transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 46% 52%, transparent 0, transparent 4px, var(--text-color) 5px, var(--text-color) 6px, transparent 6px);    width: 100%;   height: 300%;   top: 0;   left: 0;   position: absolute;   animation: bubbles 5s linear infinite both; }  @keyframes bubbles {   from {     transform: translate();   }   to {     transform: translate(0, -66.666%);   } }.zui-table {    border: solid 1px #DDEEEE;    border-collapse: collapse;    border-spacing: 0;    font: normal 13px;}.zui-table thead th {    background-color: #DDEFEF;    border: solid 1px #DDEEEE;    color: #0000009e;    padding: 10px;    text-align: left;}.zui-table tbody td {border: solid 1px #effff97a;color: #ffffffd1;    padding: 10px;}</style><center><button><table class=\"zui-table blueBG\"><p>Ssh config<p><thead>        <tr>        <th>Host</th>            <th>Port</th>        <th>Password</th> </tr>    </thead>    <tbody>        <tr><td>\"\"\"+Host+\"\"\"</td><td>\"\"\"+port+\"\"\"</td><td>\"\"\"+password+\"\"\"</td></tr></tbody></table><center><br><table class=\"zui-table blueBG\"><thead>        <tr>        <th>Simple ssh command</th></tr>    </thead>    <tbody>        <tr><td>ssh root@\"\"\"+Host+\"\"\" -p \"\"\"+port+\"\"\"</td></tr></tbody></table></center><a target=\"_blank\" style=\"text-decoration: none;color: hsla(210, 50%, 85%, 1);font-size: 10px;\" href=\"http://bit.ly/2RDhV0c\">NB. How to setup this's config. [Click ME]</a></button><center>\"\"\"))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "-9RhonZDwNYC"
      },
      "source": [
        "## <img src='https://blobscdn.gitbook.com/v0/b/gitbook-28427.appspot.com/o/spaces%2F-LV-MXWFGfo4YU_ahhaj%2Favatar.png?generation=1546194591038935&alt=media' height=\"25\" alt=\"filebrowser\" /> ___filebrowser___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oieqNETPNVny",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://blobscdn.gitbook.com/v0/b/gitbook-28427.appspot.com/o/spaces%2F-LV-MXWFGfo4YU_ahhaj%2Favatar.png?generation=1546194591038935&alt=media' height=\"200\" alt=\"filebrowser\"/></center>\n",
        "#@markdown <center><h3>filebrowser<br />📂 Web File Browser which can be used as a middleware or standalone app</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.2.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "# OUTPUT_DIR = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "get_ipython().system_raw(r\"curl -fsSL https://filebrowser.xyz/get.sh | bash\")\n",
        "if not findProcess(\"filebrowser\", \"--noauth\"):\n",
        "  runSh(\"filebrowser --noauth -r /content/ -p 4000 &\", shell=True)\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['rclone', 5572, 'http'],\n",
        "                            ['filebrowser', 4000, 'http']], 'ap', \n",
        "    [f\"{HOME}/.ngrok2/filebrowserRclone.yml\", 4099]\n",
        ").start('filebrowser')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ixPzmxtjwNYa"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "WB9BQ7tJbN_j"
      },
      "source": [
        "# <center><h3>Copyright © 2020. All right reserved.</h3><h5>Source Code - <b>biplobsd, blackpearl</b>. Modified by <b>Codemaster@BSSG</b><h5>All in one downloader ver 1.5</h5></center></h5>\n"
      ]
    }
  ]
}