Master-Colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Master Colab Notebook - Working & Updated (March 2020)",
      "provenance": [],
      "collapsed_sections": [
        "zRTgBdCpBWMh",
        "cOUZEXihsqCD",
        "bNAroQWy6hL3",
        "wZMZjX127rmx",
        "4E-uzYrv5o0B",
        "ZVIyGBSmjlOY",
        "AAOkoLYa1nQb",
        "smfdosUWghxD",
        "Nx9ud5luiyJY",
        "8YFON0D4mVdr",
        "StT2bKf2WmKj",
        "mtIWnZ60Sczn",
        "jWNiE-RGECHM",
        "MbJ_88vSD-K2",
        "yTPpo294F0U8",
        "n3MWoStHEnJx",
        "DYreGU9NvCdk",
        "t0eVljW0O0CG",
        "ukxnQC4c0nuR",
        "EFOqhHG6hOVH",
        "KgNPvGccgwd8",
        "RDHuIkoi6l9a",
        "NQ0TxfKeghR8",
        "FpJXJiRl6-gK",
        "2f-THZmDoOaY",
        "MSUasbRUDP3B",
        "0xI8WiUPji3k",
        "Nl4RbJbX0-a4",
        "QlsUJhNwyeV3",
        "cHTe9qp2E6f5",
        "kAdRu4gm5k8v"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/yunooooo/Master-Colab/blob/master/Master-Colab.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": "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 = \"https://drive.google.com/open?id=\" #@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": "4E-uzYrv5o0B",
        "colab_type": "text"
      },
      "source": [
        "# **0.** Mounting with rclone\n",
        "# <img src='https://forum.rclone.org/uploads/default/original/2X/d/da6ccb2784ff3fa73d9339300530e0aae4d6cebd.png' height=\"46\" alt=\"rclone\"/>"
      ]
    },
    {
      "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": {
        "id": "ZVIyGBSmjlOY",
        "colab_type": "text"
      },
      "source": [
        "# **1**. Mounting Google Drive\n",
        "# <img src='https://i.ibb.co/nD9NnTc/drive.png' height=\"50\" alt=\"GDrive\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6DzJx4rdjvUQ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h2><b>←</b> ឵឵Click Here to Mount your Google Drive</h2>\n",
        "#@markdown <h5><i>(Provided by Google)</i></h5>\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IsQPA4qZD4hK",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h4><b>←</b> ឵឵Click Here to <b>Force Remount</b> your Google Drive</h4>\n",
        "#@markdown <h5><i>(Only use if needed)</i></h5>\n",
        "drive.mount(\"/content/drive\", force_remount=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AAOkoLYa1nQb",
        "colab_type": "text"
      },
      "source": [
        "# **2**. qBitTorrent\n",
        "# <img src='https://yuju.pw/y/8Axp.png' height=\"60\" alt=\"qBitTorrent\"/><img src='https://yuju.pw/y/qs5U.png' height=\"38\" alt=\"+\"/><img src='https://yuju.pw/y/qjCK.png' height='48' alt=\"ngrok\"/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "smfdosUWghxD",
        "colab_type": "text"
      },
      "source": [
        "## **A**. <img src='https://yuju.pw/y/3yVA.png' height=\"35\" alt=\"ngrok\"/>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0jctMTc3-rPt",
        "colab_type": "text"
      },
      "source": [
        "* You'll need your own ngrok Auth Token to use this cell. After logging in, you can find it [here](https://dashboard.ngrok.com/auth).\n",
        " * [Screenshot](https://yuju.pw/y/8Z3S.png) locating your ngrok Auth Token."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "dmAyXqzfL9yK",
        "colab": {}
      },
      "source": [
        "#@title ← ឵឵ Run This Cell for ***qBitTorrent*** *v4.1.7 Web UI*\n",
        "Ngrok_Token = \"\" #@param {type:\"string\"}\n",
        "import os, time, urllib.request, json; from IPython.display import clear_output\n",
        "if os.path.isfile(\"/usr/bin/qbittorrent-nox\") == False:\n",
        "    get_ipython().system_raw(\"apt update -qq -y && yes \"\" | add-apt-repository ppa:qbittorrent-team/qbittorrent-stable\")\n",
        "    get_ipython().system_raw(\"apt install qbittorrent-nox\")\n",
        "    get_ipython().system_raw(\"mkdir -p -m 666 /{content/qBittorrent,root/{.qBittorrent_temp,.config/qBittorrent}} && curl -s https://pastebin.com/raw/XbthBkJU -o /root/.config/qBittorrent/qBittorrent.conf\")\n",
        "    print(\"qBittorrent successfully installed.\")\n",
        "    clear_output(wait=True)\n",
        "else:\n",
        "    print(\"qBittorrent already installed. Skipping...\")\n",
        "    clear_output(wait=True)\n",
        "    !pkill qbittorrent-nox\n",
        "    \n",
        "!qbittorrent-nox -d --webui-port=4444\n",
        "print(\"qBittorrent started \")\n",
        "clear_output(wait=True)\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",
        "if os.path.isfile(\"/usr/bin/rclone\") == False:\n",
        "    get_ipython().system_raw('curl https://rclone.org/install.sh | sudo bash &')\n",
        "    print(\"Rclone successfully installed\")\n",
        "    clear_output(wait=True)\n",
        "else:\n",
        "    print(\"Rclone already installed. Skipping...\")\n",
        "    clear_output(wait=True)\n",
        "\n",
        "get_ipython().system_raw('/usr/local/bin/ngrok authtoken $Ngrok_Token && /usr/local/bin/ngrok http 4444 &')\n",
        "print(\"Hold on...\")\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": {
        "colab_type": "text",
        "id": "Nx9ud5luiyJY"
      },
      "source": [
        "## **B**. <img src='https://yuju.pw/y/3dLR.png' height=\"43\" alt=\"ngrok\"/>\n",
        "#### (***Not Recommended***)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aO74zstqkSsh",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title ← ឵឵ Run This Cell for ***qBitTorrent*** *v4.1.7 Web UI* \n",
        "#@markdown <h5>- Don't use the mounted Google Drive as a save path for torrent; data corruption will most likely occur.</h5>\n",
        "Old_Version = False #@param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, IPython, uuid, time\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    template = \"\"\"<button class=\"p-Widget jupyter-widgets jupyter-button widget-button mod-info\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RandomGenerator():\n",
        "  return time.strftime(\"%S\") + str(time.time()).split(\".\")[-1]\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "  \n",
        "def AutoSSH(name,port):\n",
        "  get_ipython().system_raw(\"autossh -l \" + name + \" -M 0 -fNT -o 'StrictHostKeyChecking=no' -o 'ServerAliveInterval 300' -o 'ServerAliveCountMax 30' -R 80:localhost:\" + port + \" ssh.localhost.run &\")\n",
        "  get_ipython().system_raw(\"autossh -M 0 -fNT -o 'StrictHostKeyChecking=no' -o 'ServerAliveInterval 300' -o 'ServerAliveCountMax 30' -R \" + name + \":80:localhost:\" + port + \" serveo.net &\")\n",
        "\n",
        "def Start_Server():\n",
        "  if CheckProcess(\"qbittorrent-nox\", \"\") != True:\n",
        "    get_ipython().system_raw(\"qbittorrent-nox -d --webui-port=6006\")\n",
        "  if CheckProcess(\"autossh\", \"qb\" + Random_Number) != True:\n",
        "      AutoSSH(\"qb\" + Random_Number, \"6006\")\n",
        "\n",
        "try:\n",
        "  try:\n",
        "    Random_Number\n",
        "  except NameError:\n",
        "    display(MakeLabel(\"Installing in Progress\", \"warning\"))\n",
        "    Random_Number = RandomGenerator()\n",
        "    get_ipython().system_raw(\"rm -rf /content/sample_data/ &\")\n",
        "  if os.path.isfile(\"/usr/bin/qbittorrent-nox\") == False:\n",
        "    get_ipython().system_raw(\"apt update -qq -y && yes \"\" | add-apt-repository ppa:qbittorrent-team/qbittorrent-stable\")\n",
        "    if Old_Version == True:\n",
        "      get_ipython().system_raw(\"apt install qbittorrent-nox=4.0.3-1 -qq -y\")\n",
        "    else:\n",
        "      get_ipython().system_raw(\"apt install qbittorrent-nox -qq -y\")\n",
        "    get_ipython().system_raw(\"mkdir -p -m 666 /{content/qBittorrent,root/{.qBittorrent_temp,.config/qBittorrent}} && wget -q https://minormole.github.io/RcloneLab/res/qbittorrent/qBittorrent.conf -O /root/.config/qBittorrent/qBittorrent.conf\")\n",
        "  if os.path.isfile(\"/usr/bin/autossh\") == False:\n",
        "    get_ipython().system_raw(\"apt install autossh -qq -y\")\n",
        "  Start_Server()\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"✔ Successfully\", \"success\"), MakeButton(\"Recheck\", Start_Server), HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">qBittorrent</h2><h4 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">\" \\\n",
        "                    \"<a style=\\\"font-family:Trebuchet MS;color:#356ebf;\\\" href=\\\"http://qb\" + Random_Number + \".serveo.net\\\" target=\\\"_blank\\\">Website</a><br>\" \\\n",
        "                    \"<a style=\\\"font-family:Trebuchet MS;color:#356ebf;\\\" href=\\\"http://qb\" + Random_Number + \".localhost.run\\\" target=\\\"_blank\\\">Website (Backup)</a></h4>\"))\n",
        "except:\n",
        "  clear_output(wait=True)\n",
        "  display(MakeLabel(\"✘ Unsuccessfully\", \"danger\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8YFON0D4mVdr",
        "colab_type": "text"
      },
      "source": [
        "# **3**. JDownloader\n",
        "# <img src='https://szyha.github.io/RcloneLabArchive/img/title_jdownloader.png' height=\"56\" alt=\"JDownloader\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eyTydVIrm2Ms",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown ← ឵឵ Click Here to Install JDownloader\n",
        "\n",
        "import os, uuid, re, IPython\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from glob import glob\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output\n",
        "\n",
        "Email = widgets.Text(placeholder=\"*Required\", description=\"Email:\")\n",
        "Password = widgets.Text(placeholder=\"*Required\", description=\"Password:\")\n",
        "Device = widgets.Text(placeholder=\"Optional\", description=\"Name:\")\n",
        "SavePath = widgets.Dropdown(value=\"/content\", options=[\"/content\", \"/content/Downloads\"], description=\"Save Path:\")\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback, style):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "    self._style = style\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    if self._style != \"\":\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "    else:\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "    template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RefreshPath():\n",
        "  if os.path.exists(\"/content/drive/\"):\n",
        "    if os.path.exists(\"/content/drive/Shared drives/\"):\n",
        "      SavePath.options = [\"/content\", \"/content/Downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/Shared drives/*\")\n",
        "    else:\n",
        "      SavePath.options = [\"/content\", \"/content/Downloads\", \"/content/drive/My Drive\"]\n",
        "  else:\n",
        "    SavePath.options = [\"/content\", \"/content/Downloads\"]\n",
        "\n",
        "def LoginForm():\n",
        "  clear_output()\n",
        "  Email.value = \"\"\n",
        "  Password.value = \"\"\n",
        "  Device.value = \"\"\n",
        "  RefreshPath()\n",
        "  display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">If you don't have an account yet, please register <a href=\\\"https://my.jdownloader.org/login.html#register\\\" target=\\\"_blank\\\">here</a>.</h3>\"), HTML(\"<br>\"), Email, Password, Device, SavePath)\n",
        "  if not os.path.exists(\"/content/drive/\"):\n",
        "    display(HTML(\"*If you want to save in Google Drive please run the cell below.\"))\n",
        "  display(HTML(\"<br>\"), MakeButton(\"Login\", CheckLogin, \"info\"))\n",
        "  if os.path.isfile(\"/root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\"):\n",
        "    display(MakeButton(\"Cancel\", Show, \"danger\"))\n",
        "  \n",
        "def RestartForm():\n",
        "  clear_output()\n",
        "  display(MakeLabel(\"Restart Confirm?\", \"\"), MakeButton(\"Confirm\", Restart, \"danger\"), MakeButton(\"Cancel\", Show, \"warning\"))\n",
        "  \n",
        "def ExitForm():\n",
        "  clear_output()\n",
        "  display(MakeLabel(\"Exit Confirm?\", \"\"), MakeButton(\"Confirm\", Exit, \"danger\"), MakeButton(\"Cancel\", Show, \"warning\"))\n",
        "\n",
        "def CheckLogin():\n",
        "  try:\n",
        "    if not Email.value.strip():\n",
        "      ERROR = \"Email field is empty.\"\n",
        "      THROW_ERROR\n",
        "    if not \"@\" in Email.value and not \".\" in Email.value:\n",
        "      ERROR = \"Email is an incorrect format.\"\n",
        "      THROW_ERROR\n",
        "    if not Password.value.strip():\n",
        "      ERROR = \"Password field is empty.\"\n",
        "      THROW_ERROR\n",
        "    if not bool(re.match(\"^[a-zA-Z0-9]+$\", Device.value)) and Device.value.strip():\n",
        "      ERROR = \"Only alphanumeric are allowed for the device name.\"\n",
        "      THROW_ERROR\n",
        "    Login()\n",
        "  except:\n",
        "    print(ERROR)\n",
        "\n",
        "def Login():\n",
        "  clear_output()\n",
        "  if SavePath.value == \"/content\":\n",
        "    get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"/content\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "  elif SavePath.value == \"/content/Downloads\":\n",
        "    get_ipython().system_raw(\"mkdir -p -m 666 /content/Downloads\")\n",
        "    get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"/content/Downloads\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "  else:\n",
        "    get_ipython().system_raw(\"echo '{\\\"defaultdownloadfolder\\\" : \\\"\" + SavePath.value + \"\\\"}' > /root/.JDownloader/cfg/org.jdownloader.settings.GeneralSettings.json\")\n",
        "  if Device.value.strip() == \"\":\n",
        "    Device.value = Email.value\n",
        "  get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "  get_ipython().system_raw(\"echo '{\\\"email\\\" : \\\"'\" + Email.value + \"'\\\", \\\"password\\\" : \\\"'\" + Password.value + \"'\\\", \\\"devicename\\\" : \\\"'\" + Device.value + \"'\\\", \\\"directconnectmode\\\" : \\\"LAN\\\"}' > /root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\")\n",
        "  get_ipython().system_raw(\"java -jar /root/.JDownloader/JDownloader.jar -norestart -noerr -r &\")\n",
        "  Show()\n",
        "\n",
        "def Restart():\n",
        "  get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "  get_ipython().system_raw(\"java -jar /root/.JDownloader/JDownloader.jar -norestart -noerr -r &\")\n",
        "  Show()\n",
        "  \n",
        "def Exit():\n",
        "  get_ipython().system_raw(\"pkill -9 -e -f java\")\n",
        "  clear_output()\n",
        "  display(MakeButton(\"Start\", Restart, \"info\"))\n",
        "  \n",
        "def Show():\n",
        "  clear_output()\n",
        "  display(MakeLabel(\"Control Panel\", \"\"), HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">You can login to the WebUI by clicking <a href=\\\"https://my.jdownloader.org/\\\" target=\\\"_blank\\\">here</a>.</h3>\"), HTML(\"<h4 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">If the server didn't showup in 30 sec. please re-login.</h4>\"), HTML(\"<br>\"), MakeButton(\"Re-Login\", LoginForm, \"info\"), MakeButton(\"Restart\", RestartForm, \"warning\"), MakeButton(\"Exit\", ExitForm, \"danger\"))\n",
        "  \n",
        "    \n",
        "if not os.path.isfile(\"/root/.JDownloader/JDownloader.jar\"):\n",
        "  clear_output()\n",
        "  display(MakeLabel(\"Installing in Progress\", \"warning\"))\n",
        "  get_ipython().system_raw(\"rm -rf /content/sample_data/ && apt install openjdk-8-jre-headless -qq -y && mkdir -p -m 666 /root/.JDownloader && wget -q http://installer.jdownloader.org/JDownloader.jar -O /root/.JDownloader/JDownloader.jar && java -jar /root/.JDownloader/JDownloader.jar -norestart -h\")\n",
        "  LoginForm()\n",
        "elif not os.path.isfile(\"/root/.JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json\"):\n",
        "  LoginForm()\n",
        "else:  \n",
        "  Show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "StT2bKf2WmKj",
        "colab_type": "text"
      },
      "source": [
        "# **4**. wget\n",
        "# <img src='https://yuju.pw/y/q4aq.png' height=\"54\" alt=\"qBitTorrent\"/>\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": "mtIWnZ60Sczn",
        "colab_type": "text"
      },
      "source": [
        "# **5**. folderclone\n",
        "\n",
        "# <img src='https://yuju.pw/y/q6fc.png' height=\"60\" alt=\"qBitTorrent\"/>\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",
        "!pip3 install folderclone"
      ],
      "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",
        "username = \"\" #@param {type:\"string\"}\n",
        "Password = \"\"#@param {type:\"string\"}\n",
        "Repolink = \"github.com/Sarah/MFCBPDEMO\"#@param {type:\"string\"}\n",
        "!git clone https://\"$username\":\"$Password\"@\"$Repolink\".git"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yTPpo294F0U8",
        "colab_type": "text"
      },
      "source": [
        "### **Step 3.** Adding All SAs to Google Group"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m2b0lgo8Pc8C",
        "colab_type": "text"
      },
      "source": [
        "- Add your service accounts emails to one collective Google Group (limit 100 per day)\n",
        "- Share your `@googlegroups.com` email with the Source TD, and the Destination TD\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": "markdown",
      "metadata": {
        "id": "n3MWoStHEnJx",
        "colab_type": "text"
      },
      "source": [
        "### **Step 4.** Running folderclone\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "nLyWJmQXO4vr",
        "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",
        "accountspath = \"/content/folderclone/accounts\"#@param {type:\"string\"}\n",
        "!multifolderclone -s \"$src\" -d \"$dest\" --path \"$accountspath\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "505daA1YPSdW",
        "colab_type": "text"
      },
      "source": [
        "- 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": "markdown",
      "metadata": {
        "id": "DYreGU9NvCdk",
        "colab_type": "text"
      },
      "source": [
        "## ***Extra***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t0eVljW0O0CG",
        "colab_type": "text"
      },
      "source": [
        "### **Bonus 1:** 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": [
        "# **6.** FFmpeg\n",
        "# <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 = '1080p' #@param [\"1080p\", \"720p\", \"480p\", \"360p\", \"240p\"]\n",
        "file_type = 'mp4' #@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": [
        "# **7.** SSH Access\n",
        "# <img src='https://yuju.pw/y/qVwA.png' height=\"56\" alt=\"RcloneLab\"/>\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": "Nl4RbJbX0-a4",
        "colab_type": "text"
      },
      "source": [
        "# **8.** youtube-dl\n",
        "# <img src='https://yuju.pw/y/3wRy.png' height=\"52\" alt=\"RcloneLab\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dCK-puiMnHYj",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Click Here to use youtube-dl</h3>\n",
        "\n",
        "import os, uuid, urllib.parse\n",
        "import ipywidgets as widgets\n",
        "Archive = False\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": {
        "id": "QlsUJhNwyeV3",
        "colab_type": "text"
      },
      "source": [
        "# **9**. rcloneLab\n",
        "# <img src='https://szyha.github.io/RcloneLabArchive/img/title_rclonelab.png' height=\"56\" alt=\"RcloneLab\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9qOSyk-RCTCz",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown ####<b>←</b> Execute rClone\n",
        "# @markdown ---\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 = \"Move\"  # @param [\"Move\", \"Copy\", \"Sync\", \"Verify\", \"Dedupe\", \"Clean Empty Dirs\", \"Empty Trash\"]\n",
        "Source = \"\"  # @param {type:\"string\"}\n",
        "Destination = \"\"  # @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 = False  # @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\" \n",
        "elif Quick_Move == \"Peerflix\" and Source == \"\" and Destination == \"\":\n",
        "  Mode = \"Move\"\n",
        "  Source = \"/content/peerflix\"\n",
        "  Destination = \"/content/drive/My Drive\" \n",
        "elif Quick_Move == \"qBittorrent\" and Source == \"\" and Destination == \"\":\n",
        "  Mode = \"Move\"\n",
        "  Source = \"/content/qBittorrent\"\n",
        "  Destination = \"/content/drive/My Drive\"\n",
        "elif Quick_Move == \"extract\" and Source == \"\" and Destination == \"\":\n",
        "  Mode = \"Move\"\n",
        "  Source = \"/content/extract\"\n",
        "  Destination = \"/content/drive/My Drive\"\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": "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",
        "    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",
        "      ' --transfers 16' \\\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/Edit 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 #### <b>←</b>  Execute Upload Local File\n",
        "MODE = \"RCONFIG\"  # @param ['UTILS', 'RCONFIG', 'RCONFIG_append', \"GENERATELIST\"]\n",
        "REMOTE = \"mnc\"  # @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",
        "    prepareSession()\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 #### <b>←</b>  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": "markdown",
      "metadata": {
        "id": "cHTe9qp2E6f5",
        "colab_type": "text"
      },
      "source": [
        "# **10**. NZBget\n",
        "# <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": "kAdRu4gm5k8v",
        "colab_type": "text"
      },
      "source": [
        "# **11**. 7-Zip + UNRAR\n",
        "<img src='https://yuju.pw/y/qUkg.png' height=\"65\" alt=\"7zip\">"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MXv72l138scn",
        "colab_type": "code",
        "cellView": "form",
        "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": "VjDJz38G9fqo",
        "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": {
        "id": "QTmQKpsm8fFQ",
        "colab_type": "code",
        "cellView": "form",
        "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": "pWKlqyFP_qkX",
        "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": []
    }
  ]
}