torrentTOmega_gdrive.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "torrentTOmega_gdrive.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "QRKdKW2SRc23",
        "FhSimpi68qbV",
        "6wktcwkWtHH0",
        "xa8RqAm2wozX",
        "rGgDHPbtYJBg",
        "PGMUhd7sVOY9",
        "63bRZrGJEZnI",
        "aknJQM1dqDqk",
        "3di4eNDqStBp",
        "C2--6Vt2uBIj",
        "9KIWnL2jCRB-",
        "kSvUMUuTPX7r",
        "yOnMe4O3jtXf",
        "NuyWhC0U_Dzv",
        "znqEQoWfTjGx",
        "AOrO7nJ_7wjh",
        "VDInERXVmnm8",
        "PE5J1UDzQXSp",
        "fJ7W2Z0gcYa5",
        "Ttv0CeCqLX0t",
        "7dTNq8TFD6a-",
        "SoxLe8ciEyAc",
        "c3cOMk38t8Zm",
        "7U8mMA7ZBRMl",
        "wZMZjX127rmx",
        "i5K4z5KBuGEx",
        "4rMlpsk3jv5r",
        "FVvFaJrZ0bxg",
        "qtAvLGCMBx1L",
        "gz_8S4IOni_1",
        "INCWjTDRLye6",
        "fhhDx-Svhrp3",
        "HsvEZZy0hrp6",
        "Z1YQc9zZ45wW",
        "yL1BRPGVwfbt",
        "1EP1o4UDLS6f",
        "bOOBrzjbEGo_"
      ],
      "toc_visible": true,
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QRKdKW2SRc23",
        "colab_type": "text"
      },
      "source": [
        "# <center><a href=\"https://t.me/torrentToGM\"><img src='https://i.imgur.com/CLg6blO.png' height=\"70\" alt=\"Telegram Group\"/></a><a href=\"https://github.com/biplobsd/Google-Colab-CloudTorrent\"><img src='https://upload.wikimedia.org/wikipedia/commons/thumb/e/eb/Ei-sc-github.svg/768px-Ei-sc-github.svg.png' height=\"80\" alt=\"Github\"/></a><img src=\"https://hitcounter.pythonanywhere.com/count/tag.svg?url=https%3A%2F%2Fgithub.com%2Fbiplobsd%2FGoogle-Colab-CloudTorrent\" alt=\"Hits\" align=\"right\"></center>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o2wFxTv8czNX",
        "colab_type": "text"
      },
      "source": [
        "___Preview___ <img src=\"https://media.giphy.com/media/3kIHVWVw2rDIfJyiN1/giphy.gif\" height=15px>\n",
        "![preview](https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/preview.gif)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rnFLGfbepLQz",
        "colab_type": "text"
      },
      "source": [
        "___aria2 Rpc Config Setup___ <img src=\"https://media.giphy.com/media/3kIHVWVw2rDIfJyiN1/giphy.gif\" height=15px>\n",
        "![preview](https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/aria2RpcConfigSetup.gif)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lb45olSEmSNl",
        "colab_type": "text"
      },
      "source": [
        "___SSH Preview___ <img src=\"https://media.giphy.com/media/3kIHVWVw2rDIfJyiN1/giphy.gif\" height=15px>\n",
        "![preview](https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/sshPreview.gif)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sGFA1R3iYIqK",
        "colab_type": "text"
      },
      "source": [
        "___Rclone config create___ <img src=\"https://media.giphy.com/media/3kIHVWVw2rDIfJyiN1/giphy.gif\" height=15px>\n",
        "![preview](https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/rclone_config_create.gif)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EkjL0r6ouLD4",
        "colab_type": "text"
      },
      "source": [
        "___L3MON DEMO___ <img src=\"https://media.giphy.com/media/3kIHVWVw2rDIfJyiN1/giphy.gif\" height=15px>\n",
        "![preview](https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/L3MON_DEMO.gif)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yvcQmeGIfXGI",
        "colab_type": "text"
      },
      "source": [
        "#`mountUmount(`<font size=\"3px\" color=\"#01c968\">`Gdrive`</font>`)`\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tPuLCnbGFmxo",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <br><center><img src='https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/600px-Google_Drive_logo.png' height=\"50\" alt=\"Gdrive-logo\"/></center>\n",
        "#@markdown <center><h3>Mount Gdrive to /content/drive</h3></center><br>\n",
        "MODE = \"MOUNT\" #@param [\"MOUNT\", \"UNMOUNT\"]\n",
        "#Mount your Gdrive! \n",
        "from google.colab import drive\n",
        "drive.mount._DEBUG = False\n",
        "if MODE == \"MOUNT\":\n",
        "  drive.mount('/content/drive', force_remount=True)\n",
        "elif MODE == \"UNMOUNT\":\n",
        "  try:\n",
        "    drive.flush_and_unmount()\n",
        "  except ValueError:\n",
        "    pass\n",
        "  get_ipython().system_raw(\"rm -rf /root/.config/Google/DriveFS\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FhSimpi68qbV",
        "colab_type": "text"
      },
      "source": [
        "#`torrentClients(`<font size=\"3px\" color=\"#4d90fe\">`SimpleTorrent` </font>,<font size=\"3px\" color=\"#f05832\"> `Peerflix-Server` </font>, <font size=\"3px\" color=\"#4f6a91\">`Deluge` </font>, <font size=\"3px\" color=\"#67a8ec\">`qBittorrent` </font>, <font size=\"3px\" color=\"#84be52\">`µTorrent`</font> , <font size=\"3px\" color=\"#3d3de5\">`rTorrent`</font> , <font size=\"3px\" color=\"#c70000\">`Transmission-Web-Control`</font> , <font size=\"3px\" color=\"#045c98\">`Vuze`</font>`)`\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6wktcwkWtHH0",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://i.imgur.com/DOoxSuO.png' height=\"38\" alt=\"Simple Torrent\" />\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "lrCc585SD2f7",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://i.imgur.com/DOoxSuO.png' height=\"50\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>SimpleTorrent is a a self-hosted remote torrent client.</h3></center><br>\n",
        "#@markdown <center><h5>Auto upload to gdrive after task completed. if gdrive is mounted and if not working tick install_old_version.</h5></center><br>\n",
        "\n",
        "import os\n",
        "import time\n",
        "import pathlib \n",
        "import urllib.request\n",
        "from IPython.display import clear_output\n",
        "\n",
        "# script version\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "Install_old_version = False  # @param {type:\"boolean\"}\n",
        "Auto_UP_Gdrive = False  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "AUTO_MOVE_PATH = \"/content/drive/My Drive\"  # @param {type:\"string\"}\n",
        "force_change_version = \"\" # https://github.com/boypt/simple-torrent/releases\n",
        "rclone_DestinationPath = \"\" # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    findProcess,\n",
        "    loadingAn,\n",
        "    updateCheck,\n",
        "    PortForward_wrapper\n",
        ")\n",
        "# making enviroment for simple-torrent\n",
        "pathlib.Path('downloads').mkdir(mode=0o777, exist_ok=True)\n",
        "pathlib.Path('torrents').mkdir(mode=0o777, exist_ok=True)\n",
        "\n",
        "def generateCmd(src, dst):\n",
        "  FAST_LIST = True\n",
        "  PATH_RClone_Config = \"/usr/local/sessionSettings\"\n",
        "  cmd = f'rclone move \"{src}\" \"{dst}\" ' \\\n",
        "    f'--config {PATH_RClone_Config}/rclone.conf ' \\\n",
        "    f'{\"--fast-list\" if FAST_LIST else \"\"} --user-agent \"Mozilla\" ' \\\n",
        "    '--transfers 20 --checkers 20 --drive-server-side-across-configs ' \\\n",
        "    '-c --buffer-size 256M --drive-chunk-size 256M ' \\\n",
        "    '--drive-upload-cutoff 256M --drive-acknowledge-abuse ' \\\n",
        "    '--drive-keep-revision-forever --tpslimit 95 --tpslimit-burst 40 ' \\\n",
        "    '--stats-one-line --stats=5s -v'\n",
        "  return cmd\n",
        "\n",
        "\n",
        "if Auto_UP_Gdrive:\n",
        "  # hCode1 = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "  #           \"Google-Colab-CloudTorrent/master/res/scripts/doneCMD.sh\"\n",
        "  # urllib.request.urlretrieve(hCode1, f'{HOME}/doneCMD.sh')\n",
        "  data = \"\"\"#!/bin/bash\n",
        "\n",
        "dir=${CLD_DIR}\n",
        "path=${CLD_PATH}\n",
        "abp=\"${dir}/${path}\"\n",
        "type=${CLD_TYPE}\n",
        "\n",
        "if [[ ${type} == \"torrent\" ]]; then\n",
        "\"\"\"\n",
        "  nUpload = \"\"\"    \n",
        "    \n",
        "    #Upload to Gdrive\n",
        "    #mkdir -p \"%s/$(dirname \"${path}\")\"\n",
        "    mv \"${abp}\" \"%s/${path}\"\n",
        "\n",
        "    \"\"\" % (AUTO_MOVE_PATH, AUTO_MOVE_PATH)\n",
        "  \n",
        "  rcloneUpload = \"\"\"\n",
        "    #You can also use rcone move file to remote\n",
        "    %s\n",
        "    \"\"\" % generateCmd(r\"${abp}\", rclone_DestinationPath)\n",
        "  \n",
        "  end = \"\"\"\n",
        "fi\n",
        "\"\"\"\n",
        "  data = data + (rcloneUpload if rclone_DestinationPath else nUpload) + end\n",
        "  with open(pathDoneCMD, 'w') as w:\n",
        "    w.write(data)\n",
        "  os.chmod(pathDoneCMD, 0o755)\n",
        "else:\n",
        "  try:\n",
        "    os.unlink(pathDoneCMD)\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "  \n",
        "configPath = pathlib.Path('cloud-torrent.json')\n",
        "configsdata = r\"\"\"\n",
        "{{\n",
        "  \"AutoStart\": true,\n",
        "  \"EngineDebug\": false,\n",
        "  \"MuteEngineLog\": true,\n",
        "  \"ObfsPreferred\": true,\n",
        "  \"ObfsRequirePreferred\": false,\n",
        "  \"DisableTrackers\": false,\n",
        "  \"DisableIPv6\": false,\n",
        "  \"DownloadDirectory\": \"downloads/\",\n",
        "  \"WatchDirectory\": \"torrents/\",\n",
        "  \"EnableUpload\": true,\n",
        "  \"EnableSeeding\": false,\n",
        "  \"IncomingPort\": 50007,\n",
        "  \"DoneCmd\": \"{}/doneCMD.sh\",\n",
        "  \"SeedRatio\": 1.5,\n",
        "  \"UploadRate\": \"High\",\n",
        "  \"DownloadRate\": \"Unlimited\",\n",
        "  \"TrackerListURL\": \"https://trackerslist.com/best.txt\",\n",
        "  \"AlwaysAddTrackers\": true,\n",
        "  \"ProxyURL\": \"\"\n",
        "}}\n",
        "\"\"\".format(HOME)\n",
        "with open(configPath, \"w+\") as configFile:\n",
        "  configFile.write(configsdata)\n",
        "#####################################\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "\n",
        "# Simple Torrent installing ...\n",
        "loadingAn()\n",
        "if not os.path.isfile(\"/usr/local/bin/cloud-torrent\"):\n",
        "    dcmd = \"wget -qq https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "            \"Google-Colab-CloudTorrent/master/res/scripts/\" \\\n",
        "            \"simpleCloudInstaller.sh -O /root/simpleCloudInstaller.sh\"\n",
        "    runSh(dcmd)\n",
        "    if Install_old_version:\n",
        "        runSh(\"bash /root/simpleCloudInstaller.sh 1.2.3\")\n",
        "    else:\n",
        "        runSh(\"bash /root/simpleCloudInstaller.sh\")\n",
        "\n",
        "if force_change_version:\n",
        "  runSh(\"pkill cloud-torrent\")\n",
        "  runSh(f\"bash /root/simpleCloudInstaller.sh {force_change_version}\")\n",
        "\n",
        "\n",
        "#Opening cloud-torrent in background\n",
        "if not findProcess(\"cloud-torrent\", \"cloud-torrent\"):\n",
        "  PORT = 4444\n",
        "  try:\n",
        "    urllib.request.urlopen(f\"http://localhost:{PORT}\")\n",
        "  except:\n",
        "    cmdC = f'cloud-torrent --port {PORT} ' \\\n",
        "        '-t \"SimpleTorrent\" ' \\\n",
        "        '-c cloud-torrent.json ' \\\n",
        "        '--host 0.0.0.0 --disable-log-time ' \\\n",
        "        '&'\n",
        "    for run in range(10):    \n",
        "      runSh(cmdC, shell=True)\n",
        "      time.sleep(3)\n",
        "      try:\n",
        "        urllib.request.urlopen(f\"http://localhost:{PORT}\")\n",
        "        break\n",
        "      except:\n",
        "        print(\"Error: Simple-Torrent not starting. Retrying ...\")\n",
        "\n",
        "# START_SERVER\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['simple-torrent', 4444, 'http'], \n",
        "    ['peerflix-server', 4445, 'http']], 'us', \n",
        "    [f\"{HOME}/.ngrok2/sTpS.yml\", 4040]\n",
        ").start('simple-torrent')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xa8RqAm2wozX",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://camo.githubusercontent.com/95b0ba2a237ee846b3bb8f45954124eb9cba4ebc/68747470733a2f2f63646e2e6a7364656c6976722e6e65742f67682f617361706163682f70656572666c69782d736572766572406d61737465722f6170702f696d616765732f6c6f676f2e737667' height=\"25\" alt=\"Peerflix-server\" /> __PEERFLIX-SERVER__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "0WZEY1EWri78",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://camo.githubusercontent.com/95b0ba2a237ee846b3bb8f45954124eb9cba4ebc/68747470733a2f2f63646e2e6a7364656c6976722e6e65742f67682f617361706163682f70656572666c69782d736572766572406d61737465722f6170702f696d616765732f6c6f676f2e737667' height=\"200\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>PEERFLIX-SERVER<br />Streaming torrent client for node.js with web ui.</h3></center><br>\n",
        "\n",
        "import os\n",
        "import time\n",
        "import pathlib\n",
        "import urllib.request\n",
        "from json import dump\n",
        "from IPython.display import clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    findProcess,\n",
        "    PortForward_wrapper\n",
        ")\n",
        "\n",
        "#####################################\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "pathlib.Path('peerflix').mkdir(mode=0o777, exist_ok=True)\n",
        "loadingAn()\n",
        "\n",
        "#CONFIG\n",
        "if findProcess(\"node\", \"peerflix-server\"):\n",
        "  !pkill -f \"node /tools/node/bin/peerflix-server\"\n",
        "configPath = f\"{HOME}/.config/peerflix-server/config.json\"\n",
        "data = {}  \n",
        "trackers = urllib.request.urlopen(\n",
        "          \"https://trackerslist.com/best.txt\"\n",
        "      ).read().decode().split(\"\\n\\n\")\n",
        "data['connections'] = 500\n",
        "data['path'] = \"peerflix\" \n",
        "data['dht'] = True \n",
        "data['tracker'] = True\n",
        "data['trackers'] = trackers\n",
        "try:\n",
        "  os.mkdir(f'{HOME}/.config/peerflix-server/')\n",
        "except:\n",
        "  pass\n",
        "with open(configPath, \"w+\") as configFile:\n",
        "  dump(data, configFile)\n",
        "\n",
        "if not os.path.isfile(\"/tools/node/bin/peerflix-server\"):\n",
        "  runSh('npm install -g peerflix-server')\n",
        "  \n",
        "#Opening Peerflix-server in background\n",
        "if not findProcess(\"node\", \"peerflix-server\"):\n",
        "  PORT = 4445\n",
        "  cmdC = f'PORT={PORT} peerflix-server &'\n",
        "  for run in range(10):    \n",
        "    runSh(cmdC, shell=True)\n",
        "    time.sleep(3)\n",
        "    try:\n",
        "      urllib.request.urlopen(f\"http://localhost:{PORT}\")\n",
        "      break\n",
        "    except:\n",
        "      print(\"Error: Peerflix-server not starting. Retrying ...\")\n",
        "\n",
        "# START_SERVER\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['simple-torrent', 4444, 'http'], \n",
        "    ['peerflix-server', 4445, 'http']], 'us', \n",
        "    [f\"{HOME}/.ngrok2/sTpS.yml\", 4040]\n",
        ").start('peerflix-server', 'r')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "hIk32mGsriDJ",
        "colab": {}
      },
      "source": [
        "\n",
        "#@markdown <br><center><img src='https://i.imgur.com/YWSbyoZ.png' height=\"50\" alt=\"netdata\"/></center>\n",
        "#@markdown <br><center><h1>CLEAN DOWNLODAS FOLDER</center>\n",
        "#@markdown <br><center>PEERFLIX-SERVER don't delete removed torrent task file. So you do this manually after remove torrent task.\n",
        "!touch /content/downloads/errorRemove\n",
        "!cd downloads/ && sudo rm -r *\n",
        "print(\"All Deleted on /content/peerflix\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rGgDHPbtYJBg",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://upload.wikimedia.org/wikipedia/commons/c/c5/Deluge_icon.png' height=\"30\" alt=\"Deluge\" /> __Deluge__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k_z4f8_4U7Ac",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://upload.wikimedia.org/wikipedia/commons/c/c5/Deluge_icon.png' height=\"200\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>Deluge<br />Deluge is a BitTorrent client written in Python.</h3></center><br>\n",
        "#@markdown <center><h5>Auto upload to gdrive after task completed. if gdrive is mounted<br>Default output path /content/downloads/</h5></center><br>\n",
        "import os, urllib.request, pathlib\n",
        "from IPython.display import clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    findProcess,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper\n",
        ")\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "\n",
        "loadingAn()\n",
        "\n",
        "pathlib.Path('downloads').mkdir(exist_ok=True)\n",
        "pathlib.Path(f\"{HOME}/.config/deluge/\").mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "if not (findProcess(\"/usr/bin/python\", \"deluged\") or findProcess(\"/usr/bin/python\", \"deluge-web\")):\n",
        "  runSh('sudo apt install -y deluged deluge-console deluge-webui')\n",
        "  runSh(\n",
        "        f\"wget -qq https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/res/deluge/core.conf \\\n",
        "            -O {HOME}/.config/deluge/core.conf\"\n",
        "    )\n",
        "  runSh(\n",
        "        f\"wget -qq https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/res/deluge/web.conf \\\n",
        "            -O {HOME}/.config/deluge/web.conf\"\n",
        "    )\n",
        "  runSh('deluged &> /dev/null &', shell=True)\n",
        "  runSh('deluge-web --fork', shell=True)\n",
        "  runSh(\"\"\"sed -i 's/if s.hexdigest() == config\\[\"pwd_sha1\"\\]:/if True:/' /usr/lib/python2.7/dist-packages/deluge/ui/web/auth.py\"\"\")\n",
        "  runSh(\"sed -i 's/onShow:function(){this.passwordField.focus(.*)}/onShow:function(){this.onLogin();}/' /usr/lib/python2.7/dist-packages/deluge/ui/web/js/deluge-all.js\")\n",
        "\n",
        "# START_SERVER\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['deluge', 8112, 'http'],\n",
        "                            ['utorrent', 5454, 'http']], 'eu', \n",
        "    [f\"{HOME}/.ngrok2/delugeUtorrent.yml\", 4042]\n",
        ").start('deluge')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PGMUhd7sVOY9",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_qbittorrent.png' height=\"45\" alt=\"qBittorrent\"/> <font size=1px>_Enhanced Edition_</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0oCsnKJK-VXb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, time, urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    checkAvailable,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    runSh,\n",
        "    displayUrl,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "def addUtils():\n",
        "    if not checkAvailable(\"/usr/local/sessionSettings\"):\n",
        "        runSh(\"mkdir -p -m 777 /usr/local/sessionSettings\")\n",
        "    if not checkAvailable(\"/content/upload.txt\"):\n",
        "        runSh(\"touch /content/upload.txt\")\n",
        "    if not checkAvailable(\"checkAptUpdate.txt\", userPath=True):\n",
        "        runSh(\"apt update -qq -y\")\n",
        "        runSh(\"apt-get install -y iputils-ping\")\n",
        "\n",
        "def configTimezone(auto=True):\n",
        "    if checkAvailable(\"timezone.txt\", userPath=True):\n",
        "        return\n",
        "    if not auto:\n",
        "        runSh(\"sudo dpkg-reconfigure tzdata\")\n",
        "    else:\n",
        "        runSh(\"sudo ln -fs /usr/share/zoneinfo/Asia/Ho_Chi_Minh /etc/localtime\")\n",
        "        runSh(\"sudo dpkg-reconfigure -f noninteractive tzdata\")\n",
        "\n",
        "def uploadQBittorrentConfig():\n",
        "    if checkAvailable(\"updatedQBSettings.txt\", userPath=True):\n",
        "        return\n",
        "    runSh(\n",
        "        \"mkdir -p -m 666 /content/qBittorrent /root/.qBittorrent_temp /root/.config/qBittorrent\"\n",
        "    )\n",
        "    runSh(\n",
        "        \"wget -qq https://raw.githubusercontent.com/tofuliang/RLabClone/master/res/qbittorrent/qBittorrent.conf \\\n",
        "            -O /root/.config/qBittorrent/qBittorrent.conf\"\n",
        "    )\n",
        "\n",
        "\n",
        "def prepareSession():\n",
        "    if checkAvailable(\"ready.txt\", userPath=True):\n",
        "        return\n",
        "    else:\n",
        "        addUtils()\n",
        "        configTimezone()\n",
        "        uploadQBittorrentConfig()\n",
        "\n",
        "def installQBittorrent():\n",
        "    if checkAvailable(\"/usr/bin/qbittorrent-nox\"):\n",
        "        return\n",
        "    else:\n",
        "        try:\n",
        "            runSh(\"add-apt-repository -y ppa:poplite/qbittorrent-enhanced\")\n",
        "            runSh(\"apt-get install qbittorrent-enhanced-nox -qq -y\")\n",
        "        except:\n",
        "            raise Exception('Error installing qbittorrent-enhanced-nox')\n",
        "\n",
        "def startQBService():\n",
        "    prepareSession()\n",
        "    installQBittorrent()\n",
        "    if not findProcess(\"qbittorrent-nox\", \"-d --webui-port\"):\n",
        "        runSh(f\"qbittorrent-nox -d --webui-port={QB_Port}\")\n",
        "        time.sleep(1)\n",
        "\n",
        "QB_Port = 10001\n",
        "loadingAn()\n",
        "startQBService()\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['qbittorrent', QB_Port, 'http']], 'sa', \n",
        "    [f\"{HOME}/.ngrok2/qbittorrent.yml\", 4088]\n",
        ").start('qbittorrent', displayB=False)\n",
        "displayUrl(server, pNamU='QBT_enhanced : ')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "63bRZrGJEZnI",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://upload.wikimedia.org/wikipedia/commons/9/9f/UTorrent_%28logo%29.png' height=\"25\" alt=\"µTorrent\" /> ___µTorrent___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "92bz-A8-ZBHM",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://upload.wikimedia.org/wikipedia/commons/9/9f/UTorrent_%28logo%29.png' height=\"200\" alt=\"µTorrent\"/></center>\n",
        "#@markdown <center><h3>µTorrent<br />uTorrent is a proprietary adware BitTorrent client owned and developed by BitTorrent, Inc.</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "# OUTPUT_DIR = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "r = get_ipython()\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess,\n",
        "    displayUrl\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "#uTorrent installing...\n",
        "if not os.path.exists(\"/usr/bin/utserver\"):\n",
        "  os.makedirs(\"downloads\", exist_ok=True)\n",
        "  r.system_raw(\"apt install libssl1.0.0 libssl-dev\")\n",
        "  r.system_raw(r\"wget http://download-new.utorrent.com/endpoint/utserver/os/linux-x64-ubuntu-13-04/track/beta/ -O utserver.tar.gz\")\n",
        "  r.system_raw(r\"tar -zxvf utserver.tar.gz -C /opt/\")\n",
        "  r.system_raw(\"rm -f utserver.tar.gz\")\n",
        "  r.system_raw(\"mv /opt/utorrent-server-* /opt/utorrent\")\n",
        "  os.chmod(\"/opt/utorrent\", 0o777)\n",
        "  r.system_raw(\"ln -s /opt/utorrent/utserver /usr/bin/utserver\")\n",
        "  urllib.request.urlretrieve(\n",
        "      \"https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/res/utorrent/utserver.conf\",\n",
        "      \"/opt/utorrent/utserver.conf\")\n",
        "if not findProcess(\"utserver\", \"-settingspath\"):\n",
        "  cmd = \"utserver -settingspath /opt/utorrent/\" \\\n",
        "        \" -configfile /opt/utorrent/utserver.conf\" \\\n",
        "        \" -daemon\"\n",
        "  runSh(cmd, shell=True)\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['deluge', 8112, 'http'],\n",
        "                            ['utorrent', 5454, 'http']], 'eu', \n",
        "    [f\"{HOME}/.ngrok2/delugeUtorrent.yml\", 4042]\n",
        ").start('utorrent', displayB=False)\n",
        "displayUrl(Server, pNamU='uTorrent : ', \n",
        "           ExUrl=fr\"http://admin:admin@{Server['url'][7:]}/gui\",\n",
        "           btc=\"g\")\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aknJQM1dqDqk",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://dominicm.com/wp-content/uploads/2017/03/rtorrent-arch-linux-450x450.png' height=\"25\" alt=\"rTorrent\"/> __rTorrent__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1TMHcOnhyYtS",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/Flood-UI/flood/master/flood.png' height=\"200\" alt=\"flood\"/></center>\n",
        "#@markdown <center>Flood-UI<h3>A web UI for rTorrent with a Node.js backend and React frontend.</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from shutil import copyfile\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "#@markdown Default <br>&emsp;username : admin<br>&emsp;password : admin\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess,\n",
        "    displayUrl,\n",
        "    textAn\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs('tools/', exist_ok=True)\n",
        "os.makedirs(\"/content/downloads\", mode=0o775, exist_ok=True)\n",
        "os.makedirs(\"/content/tools/rtorrent/session\", mode=0o775, exist_ok=True)\n",
        "\n",
        "configData = \"\"\"\n",
        "# Where rTorrent saves the downloaded files\n",
        "directory = /content/downloads\n",
        "\n",
        "# Where rTorrent saves the session\n",
        "session = /content/tools/rtorrent/session\n",
        "\n",
        "# Which ports rTorrent can use (Make sure to open them in your router)\n",
        "port_range = 50000-50000\n",
        "port_random = no\n",
        "\n",
        "# Check the hash after the end of the download\n",
        "check_hash = yes\n",
        "\n",
        "# Enable DHT (for torrents without trackers)\n",
        "dht = auto\n",
        "dht_port = 6881\n",
        "peer_exchange = yes\n",
        "\n",
        "# Authorize UDP trackers\n",
        "use_udp_trackers = yes\n",
        "\n",
        "# Enable encryption when possible\n",
        "encryption = allow_incoming,try_outgoing,enable_retry\n",
        "\n",
        "# SCGI port, used to communicate with Flood\n",
        "scgi_port = 127.0.0.1:5000\n",
        "\"\"\"\n",
        "with open(\"/root/.rtorrent.rc\", 'w') as rC:\n",
        "  rC.write(configData)\n",
        "\n",
        "if not os.path.exists(\"/content/tools/flood/config.js\"):\n",
        "  runSh(\"apt install rtorrent screen mediainfo -y\")\n",
        "  runSh(\"git clone --depth 1 https://github.com/jfurrow/flood.git tools/flood\",\n",
        "        shell=True)\n",
        "  copyfile(\"tools/flood/config.template.js\", \"tools/flood/config.js\")\n",
        "  runSh(\"npm install\", shell=True, cd=\"tools/flood/\")\n",
        "  runSh(\"npm install pm2 -g\", shell=True, cd=\"tools/flood/\")\n",
        "  runSh(\"npm run build\", shell=True, cd=\"tools/flood/\")\n",
        "\n",
        "  userDB = r\"\"\"{\"username\":\"admin\",\"password\":\"$argon2i$v=19$m=4096,t=3,p=1$3hJdjMSgwdUnJ86uYBhOnA$dud5j5/IokJ3hyb+v5aqmDK0jwP9X5W2pz6Qqek++Tk\",\"host\":\"127.0.0.1\",\"port\":\"5000\",\"isAdmin\":true,\"_id\":\"jLJcPySMAEgp35uB\"}\n",
        "{\"$$indexCreated\":{\"fieldName\":\"username\",\"unique\":true,\"sparse\":false}}\n",
        "\"\"\"\n",
        "  userSettingsDB = r\"\"\"{\"id\":\"startTorrentsOnLoad\",\"data\":true,\"_id\":\"5leeeHwIN9rKLgG9\"}\n",
        "{\"id\":\"torrentListColumnWidths\",\"data\":{\"sizeBytes\":61,\"ratio\":56,\"peers\":62},\"_id\":\"PnB52rZSPg5fLEN9\"}\n",
        "{\"id\":\"torrentDestination\",\"data\":\"/content/downloads\",\"_id\":\"YcGroeyigKYWM8Ol\"}\n",
        "{\"id\":\"mountPoints\",\"data\":[\"/\"],\"_id\":\"gJlGwWqOsyPfkLyJ\"}\n",
        "{\"id\":\"torrentListViewSize\",\"data\":\"expanded\",\"_id\":\"q0CmirE9c0KnDGV3\"}\n",
        "\"\"\"\n",
        "\n",
        "  os.makedirs(\"tools/flood/server/db/jLJcPySMAEgp35uB/settings\", exist_ok=True)\n",
        "  with open(\"tools/flood/server/db/users.db\", 'w') as wDB:\n",
        "    wDB.write(userDB)\n",
        "  with open(\"tools/flood/server/db/jLJcPySMAEgp35uB/settings/settings.db\", 'w') as wDB:\n",
        "    wDB.write(userSettingsDB)\n",
        "\n",
        "if not findProcess(\"rtorrent\", \"\"):\n",
        "  runSh(\"screen -d -m -fa -S rtorrent rtorrent\", shell=True)\n",
        "if not findProcess(\"node\", \"start.js\"):  \n",
        "  runSh(\"pm2 start server/bin/start.js\", shell=True, cd=\"tools/flood/\")\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['flood', 3000, 'http']], 'ap', \n",
        "    [f\"{HOME}/.ngrok2/flood.yml\", 1463]\n",
        ").start('flood', btc='b', displayB=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3di4eNDqStBp",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://github.com/ronggang/transmission-web-control/raw/master/src/tr-web-control/logo.png' height=\"55\" alt=\"Transmission-Web-Control\"/> "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MxNpg17v9X76",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, time, urllib.request, pathlib\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    checkAvailable,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    runSh,\n",
        "    displayUrl,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "\n",
        "loadingAn()\n",
        "if not os.path.exists('/usr/bin/transmission-daemon'):\n",
        "  os.makedirs('downloads', exist_ok=True)\n",
        "  os.makedirs('tools/transmission/', exist_ok=True)\n",
        "  runSh('apt install transmission-daemon')\n",
        "  nTWC = \"https://raw.githubusercontent.com/ronggang/\" \\\n",
        "    \"transmission-web-control/master/release/install-tr-control.sh\"\n",
        "  urllib.request.urlretrieve(nTWC, 'tools/transmission/trInstall.sh')\n",
        "  runSh('bash tools/transmission/trInstall.sh auto')\n",
        "  try:\n",
        "    pathlib.Path('tools/transmission/trInstall.sh').unlink()\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "\n",
        "if not findProcess('transmission-daemon', '--no-watch-dir'):\n",
        "  !transmission-daemon --no-watch-dir --config-dir tools/transmission \\\n",
        "    --port 9091 --download-dir /content/downloads/ --dht --utp --no-portmap \\\n",
        "    --peerlimit-global 9999 --peerlimit-torrent 9999 --no-global-seedratio \\\n",
        "    -u admin -v admin --auth\n",
        "\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['vuze', 9595, 'http'], \n",
        "                            ['transmission', 9091, 'http']], 'sa', \n",
        "    [f\"{HOME}/.ngrok2/transmissionVuze.yml\", 4058]\n",
        ").start('transmission', displayB=False)\n",
        "displayUrl(server, pNamU='Transmission : ', \n",
        "           ExUrl=fr\"http://admin:admin@{server['url'][7:]}\",\n",
        "           btc='r')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "C2--6Vt2uBIj"
      },
      "source": [
        "## <img src='http://remote.vuze.com/img/remote_logo_med.png' height=\"55\" alt=\"vuze webui\"/> "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "jnS03d_luBIu",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, time, urllib.request, pathlib\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    checkAvailable,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    runSh,\n",
        "    displayUrl,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "def latestTag():\n",
        "  import re\n",
        "  from urllib.request import urlopen\n",
        "  htmlF = urlopen(\"http://dev.vuze.com/\").read().decode('UTF-8')\n",
        "  return re.findall(r'\\sVuze_(\\d{4})\\sRelease\\s', htmlF)[0]\n",
        "\n",
        "\n",
        "loadingAn()\n",
        "if not os.path.exists('tools/vuze/Vuze.jar'):\n",
        "  os.makedirs('downloads', exist_ok=True)\n",
        "  os.makedirs('tools/vuze/', exist_ok=True)\n",
        "  runSh('wget -r --level=1 -np -nH -R index.html -nd -k http://svn.vuze.com/public/client/trunk/uis/lib/',\n",
        "        cd='tools/vuze/')\n",
        "  rv = latestTag()\n",
        "  dlink = f\"https://netcologne.dl.sourceforge.net/project/azureus/vuze/Vuze_{rv}/Vuze_{rv}.jar\"\n",
        "  urllib.request.urlretrieve(dlink, 'tools/vuze/Vuze.jar') \n",
        "\n",
        "  # All command found in set command ex: java -jar Vuze.jar --ui=console -c set\n",
        "  runScript = \"\"\"plugin install xmwebui\n",
        "pair enable\n",
        "set \"Plugin.xmwebui.Port\" 9595 int\n",
        "set \"Plugin.xmwebui.Password Enable\" true boolean\n",
        "set \"Plugin.xmwebui.Pairing Enable\" false boolean\n",
        "set \"Plugin.xmwebui.User\" \"root\" string\n",
        "set \"Plugin.xmwebui.Password\" \"yesme\" password\n",
        "set \"Completed Files Directory\" \"/content/downloads/\" string\n",
        "set \"General_sDefaultSave_Directory\" \"/content/downloads/\" string\n",
        "set \"General_sDefaultTorrent_Directory\" \"/content/downloads/\" string\n",
        "\"\"\"\n",
        "  with open('tools/vuze/Rscript.sh', 'w') as w:\n",
        "    w.write(runScript)\n",
        "\n",
        "if not findProcess('java', '-jar Vuze.jar'):\n",
        "  runSh('java -jar Vuze.jar --ui=console -e Rscript.sh &', \n",
        "        cd='tools/vuze/',\n",
        "        shell=True)\n",
        "  time.sleep(7)\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['vuze', 9595, 'http'], \n",
        "                            ['transmission', 9091, 'http']], 'sa', \n",
        "    [f\"{HOME}/.ngrok2/transmissionVuze.yml\", 4058]\n",
        ").start('vuze', displayB=False)\n",
        "displayUrl(server, pNamU='vuze : ', \n",
        "           ExUrl=fr\"http://root:yesme@{server['url'][7:]}\",\n",
        "           btc='b')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9KIWnL2jCRB-",
        "colab_type": "text"
      },
      "source": [
        "#`transferTools(`<font size=\"3x\" color=\"#ee0e15\">`Mega` </font>,<font size=\"3px\" color=\"#3f79ad\"> `Rclone`</font>`)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kSvUMUuTPX7r",
        "colab_type": "text"
      },
      "source": [
        "##![alt text](https://mega.nz/favicon.ico?v=3) __TRANSFERE to MEGA__\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q3uC2Lo5R6N9",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown <center><h2>INPUT YOUR MEGA ID</h2></center><br>\n",
        "from functools import wraps\n",
        "import errno\n",
        "import os\n",
        "import signal\n",
        "import subprocess\n",
        "import shlex\n",
        "\n",
        "\n",
        "class TimeoutError(Exception):\n",
        "    pass\n",
        "\n",
        "\n",
        "def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):\n",
        "    def decorator(func):\n",
        "        def _handle_timeout(signum, frame):\n",
        "            raise TimeoutError(error_message)\n",
        "\n",
        "        def wrapper(*args, **kwargs):\n",
        "            signal.signal(signal.SIGALRM, _handle_timeout)\n",
        "            signal.alarm(seconds)\n",
        "            try:\n",
        "                result = func(*args, **kwargs)\n",
        "            finally:\n",
        "                signal.alarm(0)\n",
        "            return result\n",
        "\n",
        "        return wraps(func)(wrapper)\n",
        "\n",
        "    return decorator\n",
        "\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/ttmg.py\"):\n",
        "    from subprocess import run\n",
        "    from shlex import split\n",
        "\n",
        "    shellCmd = \"wget -qq https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/res/ttmg.py \\\n",
        "                    -O /root/.ipython/ttmg.py\"\n",
        "    run(split(shellCmd))\n",
        "from ttmg import runSh\n",
        "\n",
        "@timeout(10)\n",
        "def runShT(args):\n",
        "    return runSh(args, output=True)\n",
        "\n",
        "\n",
        "# MEGAcmd installing\n",
        "if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "    print(\"Installing MEGA ...\")\n",
        "    runSh('sudo apt-get -y update')\n",
        "    runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "    runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "    runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "    print(\"MEGA is installed.\")\n",
        "else:\n",
        "    !pkill mega-cmd\n",
        "\n",
        "# INPUT YOUR MEGA ID\n",
        "\n",
        "USERNAME = \"\"  # @param {type:\"string\"}\n",
        "PASSWORD = \"\"  # @param {type:\"string\"}\n",
        "if not (USERNAME == \"\" or PASSWORD == \"\"):\n",
        "    try:\n",
        "        runShT(f\"mega-login {USERNAME} {PASSWORD}\")\n",
        "    except TimeoutError:\n",
        "        runSh('mega-whoami', output=True)\n",
        "else:\n",
        "    print(\"Please Input your Mega IDs.\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E3N6hyM2I6hk",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown ##### Quick move (check and leave all boxs):\n",
        "# @markdown #####{\n",
        "import time\n",
        "import subprocess\n",
        "import contextlib\n",
        "from IPython.display import clear_output\n",
        "Simple_torrent = False  # @param{type: \"boolean\"}\n",
        "Peerflix = False  # @param{type: \"boolean\"}\n",
        "# @markdown ##### }\n",
        "# @markdown <br><center><img src='https://www.impactcomputing.co.uk/uploads/files/services/managed-office-365.svg' height=\"100\" alt=\"netdata\"/></center>\n",
        "# @markdown <center><h2>TRANSFERE NOW</h2></center><br>\n",
        "# TRANSFERE NOW\n",
        "\n",
        "PATH_TO_FILE = \"\"  # @param {type:\"string\"}\n",
        "# Unix, Windows and old Macintosh end-of-line\n",
        "newlines = ['\\n', '\\r\\n', '\\r']\n",
        "\n",
        "\n",
        "def unbuffered(proc, stream='stdout'):\n",
        "    stream = getattr(proc, stream)\n",
        "    with contextlib.closing(stream):\n",
        "        while True:\n",
        "            out = []\n",
        "            last = stream.read(1)\n",
        "            # Don't loop forever\n",
        "            if last == '' and proc.poll() is not None:\n",
        "                break\n",
        "            while last not in newlines:\n",
        "                # Don't loop forever\n",
        "                if last == '' and proc.poll() is not None:\n",
        "                    break\n",
        "                out.append(last)\n",
        "                last = stream.read(1)\n",
        "            out = ''.join(out)\n",
        "            yield out\n",
        "\n",
        "\n",
        "def transfare():\n",
        "    cmd = \"\"\n",
        "    if Simple_torrent:\n",
        "        cmd = ['mega-put', 'downloads', '/colab']\n",
        "    elif Peerflix:\n",
        "        cmd = ['mega-put', 'peerflix', '/colab']\n",
        "    else:\n",
        "        cmd = ['mega-put', PATH_TO_FILE, '/colab']\n",
        "    proc = subprocess.Popen(\n",
        "        cmd,\n",
        "        stdout=subprocess.PIPE,\n",
        "        stderr=subprocess.STDOUT,\n",
        "        # Make all end-of-lines '\\n'\n",
        "        universal_newlines=True,\n",
        "    )\n",
        "    for line in unbuffered(proc):\n",
        "        clear_output(wait=True)\n",
        "        print(line)\n",
        "\n",
        "try:\n",
        "    transfare()\n",
        "except FileNotFoundError:\n",
        "    print(\"Login your account!\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XlDyLy_JZJ03",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "import sys, os, urllib.request\n",
        "import time\n",
        "import subprocess\n",
        "import contextlib\n",
        "from IPython.display import clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        ")\n",
        "#@title MEGA public link download\n",
        "URL = \"\" #@param {type:\"string\"}\n",
        "OUTPUT_PATH = \"\" #@param {type:\"string\"}\n",
        "if not OUTPUT_PATH:\n",
        "  os.makedirs(\"downloads\", exist_ok=True)\n",
        "  OUTPUT_PATH = \"downloads\"\n",
        "# MEGAcmd installing\n",
        "if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "    loadingAn()\n",
        "    print(\"Installing MEGA ...\")\n",
        "    runSh('sudo apt-get -y update')\n",
        "    runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "    runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "    runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "    print(\"MEGA is installed.\")\n",
        "    clear_output()\n",
        "\n",
        "# Unix, Windows and old Macintosh end-of-line\n",
        "newlines = ['\\n', '\\r\\n', '\\r']\n",
        "\n",
        "def unbuffered(proc, stream='stdout'):\n",
        "    stream = getattr(proc, stream)\n",
        "    with contextlib.closing(stream):\n",
        "        while True:\n",
        "            out = []\n",
        "            last = stream.read(1)\n",
        "            # Don't loop forever\n",
        "            if last == '' and proc.poll() is not None:\n",
        "                break\n",
        "            while last not in newlines:\n",
        "                # Don't loop forever\n",
        "                if last == '' and proc.poll() is not None:\n",
        "                    break\n",
        "                out.append(last)\n",
        "                last = stream.read(1)\n",
        "            out = ''.join(out)\n",
        "            yield out\n",
        "\n",
        "\n",
        "def transfare():\n",
        "    import codecs\n",
        "    decoder = codecs.getincrementaldecoder(\"UTF-8\")()\n",
        "    cmd = [\"mega-get\", URL, OUTPUT_PATH]\n",
        "    proc = subprocess.Popen(\n",
        "        cmd,\n",
        "        stdout=subprocess.PIPE,\n",
        "        stderr=subprocess.STDOUT,\n",
        "        # Make all end-of-lines '\\n'\n",
        "        universal_newlines=True,\n",
        "    )\n",
        "    for line in unbuffered(proc):\n",
        "        print(line)\n",
        "        \n",
        "\n",
        "\n",
        "transfare()\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOnMe4O3jtXf",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_rclonelab.svg' height=\"45\" alt=\"RcloneLab\"/>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9qOSyk-RCTCz",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute rClone\n",
        "\n",
        "# @markdown ##### Quick move (Select and leave all boxes):\n",
        "# @markdown #####{\n",
        "Quick_Move = \"None\"  # @param [\"None\",\"simpleTorrent\", \"Peerflix\", \"qBittorrent\", \"extract\", \"error\"]\n",
        "# @markdown #####}\n",
        "\n",
        "Mode = \"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": "GUqn6vGlfZ_x",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h3>Rclone MOUNT / UNMOUNT</h3>Mount the remote as file system on a mountpoint.</center>\n",
        "Cache_Directory = \"DISK\" #@param [\"RAM\", \"DISK\"]\n",
        "import os\n",
        "from IPython.display import HTML, clear_output\n",
        "import uuid\n",
        "import ipywidgets as widgets\n",
        "from google.colab import output\n",
        "import re\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",
        "    runSh,\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        ")\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback, style):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "    self._style = style\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    if self._style != \"\":\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "    else:\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "    template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "    return html\n",
        "  \n",
        "def ShowAC():\n",
        "  clear_output(wait=True)\n",
        "  display(\n",
        "      widgets.HBox(\n",
        "          [widgets.VBox(\n",
        "              [widgets.HTML(\n",
        "                  '''<h3 style=\"font-family:Trebuchet MS;color:#4f8bd6;margin-top:0px;\">\n",
        "                  Rclone available config...</h3>\n",
        "                  '''\n",
        "                  ),\n",
        "               mountNam]\n",
        "               )\n",
        "          ]\n",
        "          )\n",
        "      )\n",
        "  \n",
        "  display(HTML(\"<br>\"), MakeButton(\"Mount\", MountCMD, \"primary\"),\n",
        "          MakeButton(\"Unmount\", unmountCMD, \"danger\"))\n",
        "\n",
        "prepareSession()\n",
        "content = open(f\"{PATH_RClone_Config}/rclone.conf\").read()\n",
        "avCon = re.findall(r\"^\\[(.+)\\]$\", content, re.M)\n",
        "mountNam = widgets.Dropdown(options=avCon)\n",
        "\n",
        "if Cache_Directory == 'RAM':\n",
        "  cache_path = '/dev/shm'\n",
        "elif Cache_Directory == 'DISK':\n",
        "  os.makedirs('/tmp', exist_ok=True)\n",
        "  cache_path = '/tmp'\n",
        "\n",
        "def MountCMD():\n",
        "    mPoint = f\"/content/drives/{mountNam.value}\"\n",
        "    os.makedirs(mPoint, exist_ok=True)\n",
        "    cmd = rf\"rclone mount {mountNam.value}: {mPoint}\" \\\n",
        "      rf\" --config {PATH_RClone_Config}/rclone.conf\" \\\n",
        "      ' --user-agent \"Mozilla\"' \\\n",
        "      ' --buffer-size 256M' \\\n",
        "      ' --transfers 10' \\\n",
        "      ' --vfs-cache-mode full' \\\n",
        "      ' --vfs-cache-max-age 0h0m1s' \\\n",
        "      ' --vfs-cache-poll-interval 0m1s' \\\n",
        "      f' --cache-dir {cache_path}' \\\n",
        "      ' --allow-other' \\\n",
        "      ' --daemon'\n",
        "\n",
        "    if runSh(cmd, shell=True) == 0:\n",
        "      print(f\"Mount success! - \\t{mPoint}\")\n",
        "    else:\n",
        "      print(f\"Mount failed! - \\t{mPoint}\")\n",
        "\n",
        "def unmountCMD():\n",
        "  mPoint = f\"/content/drives/{mountNam.value}\"\n",
        "  if os.system(f\"fusermount -uz {mPoint}\") == 0:\n",
        "    runSh(f\"rm -r {mPoint}\")\n",
        "    print(f\"Unmounted success! - \\t{mPoint}\")\n",
        "  else:\n",
        "    runSh(f\"fusermount -uz {mPoint}\", output=True)\n",
        "\n",
        "ShowAC()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "whyei9P7GIsM",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h3>Rclone webui</h3></center><br>\n",
        "import os, signal\n",
        "import random\n",
        "import string\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "import time\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "#@markdown Default <br>&emsp;username : user<br>&emsp;password : pass\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "runW = get_ipython()\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\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",
        "    PortForward_wrapper,\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",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, 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/tofuliang/\" \\\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",
        "    PortForward_wrapper\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",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, 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/tofuliang/Google-Colab-CloudTorrent/master/src/rclone_config_create.gif\" target=\"_blank\">See how</a><br><br>'))\n",
        "print(f\"{Server['url']}\", end=\"\\n\\n\")\n",
        "_run_command(f\"rclone config --config {PATH_RClone_Config}/rclone.conf\", False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uB-vkVstVpVs",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute Upload Local File\n",
        "MODE = \"RCONFIG\"  # @param ['UTILS', 'RCONFIG', 'RCONFIG_append', \"GENERATELIST\"]\n",
        "REMOTE = \"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 #### ⬅️ Download config file.\n",
        "MODE = \"RCONFIG\"  # @param ['UTILS', 'RCONFIG']\n",
        "# ================================================================ #\n",
        "from google.colab import files\n",
        "\n",
        "def downloadFile():\n",
        "  if MODE == \"UTILS\":\n",
        "      filePath = \"/root/.ipython/rlab_utils.py\"\n",
        "  elif MODE == \"RCONFIG\":\n",
        "      filePath = f\"{PATH_RClone_Config}/rclone.conf\"\n",
        "  else:\n",
        "      pass\n",
        "  try:\n",
        "    files.download(filePath)\n",
        "  except FileNotFoundError:\n",
        "    print(\"File not found!\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "  downloadFile()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bRurZqpoVtT6",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ SYNC Backups\n",
        "FAST_LIST = True\n",
        "# ================================================================ #\n",
        "\n",
        "from os import path as _p\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run  # nosec\n",
        "\n",
        "    shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                    -O /root/.ipython/rlab_utils.py\"\n",
        "    run(_spl(shellCmd))  # nosec\n",
        "\n",
        "from rlab_utils import (\n",
        "    runSh,\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        ")\n",
        "\n",
        "\n",
        "def generateCmd(src, dst):\n",
        "    block=f\"{'':=<117}\"\n",
        "    title=f\"\"\"+{f'Now Synchronizing... \"{src}\" > \"{dst}\" Fast List : {\"ON\" if FAST_LIST else \"OFF\"}':^{len(block)-2}}+\"\"\"\n",
        "    print(f\"{block}\\n{title}\\n{block}\")\n",
        "    cmd = f'rclone sync \"{src}\" \"{dst}\" --config {PATH_RClone_Config}/rclone.conf {\"--fast-list\" if FAST_LIST else \"\"} --user-agent \"Mozilla\" --transfers 20 --checkers 20 --drive-server-side-across-configs -c --buffer-size 256M --drive-chunk-size 256M --drive-upload-cutoff 256M --drive-acknowledge-abuse --drive-keep-revision-forever --tpslimit 95 --tpslimit-burst 40 --stats-one-line --stats=5s -v'\n",
        "    return cmd\n",
        "\n",
        "\n",
        "def executeSync():\n",
        "    prepareSession()\n",
        "    runSh(generateCmd(\"tdTdnMov:Movies\",\"tdMovRa4:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnTvs:TV Shows\",\"tdTvsRa5:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnRa6:Games\",\"tdGamRa7:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnRa8:Software\",\"tdSofRa9:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnR11:Tutorials\",\"tdTutR12:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnR13:Anime\",\"tdAniR14:\"), output=True)\n",
        "    # runSh(generateCmd(\"tdTdn14:Music\",\"tdMusR15:\"), output=True)\n",
        "\n",
        "\n",
        "executeSync()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NuyWhC0U_Dzv",
        "colab_type": "text"
      },
      "source": [
        "#`useFulTools(`<font size=\"3px\" color=\"#a05fc3\">`Jellyfin` </font> , <font size=\"3px\" color=\"#ff55cc\">`V2Ray` </font> , <font size=\"3px\" color=\"#ffce42\">`pyLoad` </font> , <font size=\"3px\" color=\"#2ebd59\">`spotify-downloader` </font> , <font size=\"3px\" color=\"#21b5f7\">`aria2Rpc` </font> , <font size=\"3px\" color=\"#85ffbb\"> `aria2Cli`</font> , <font size=\"3px\" color=\"#ffc107\"> `JDownloader`</font> , <font size=\"3px\" color=\"#ff4c41\"> `YouTube-DL`</font> , <font size=\"3px\" color=\"#88caf0\"> `zip-tar-rar`</font>`)`\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "znqEQoWfTjGx",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://jellyfin.org/favicon.ico' height=\"25\" alt=\"V2Ray\" /> __Jellyfin__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_ljeW5fKB0fx",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://github.com/jellyfin/jellyfin-ux/raw/master/branding/SVG/banner-dark-dev.svg' height=\"200\" alt=\"jellyfin\"/></center>\n",
        "#@markdown <center><h3>Jellyfin<br />The Free Software Media System.</h3></center><br>\n",
        "import os, zipfile, tarfile\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "REGION = \"US\" #@param [\"US\", \"EU\", \"AP\", \"AU\", \"SA\", \"JP\", \"IN\"]\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "#@markdown Default <br>&emsp;username : admin\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs('tools/jellyfin/temp', exist_ok=True)\n",
        "os.makedirs('tools/jellyfin/transcodes', exist_ok=True)\n",
        "os.makedirs('downloads', exist_ok=True)\n",
        "\n",
        "# github latest releases tag define\n",
        "def latestTag(link):\n",
        "  import re\n",
        "  from urllib.request import urlopen\n",
        "  htmlF = urlopen(link+\"/releases/latest\").read().decode('UTF-8')\n",
        "  return re.findall(r'.+\\/tag\\/([.0-9A-Za-z-]+)\".+/', htmlF)[0]\n",
        "\n",
        "def ff_loader(name):\n",
        "  import requests\n",
        "\n",
        "  url = requests.get(\n",
        "    \"https://ffbinaries.com/api/v1/version/latest\"\n",
        "    ).json()['bin']['linux-64'][name]\n",
        "  urllib.request.urlretrieve(url, f'tools/jellyfin/L{name}.zip')\n",
        "\n",
        "  with zipfile.ZipFile(f'tools/jellyfin/L{name}.zip', 'r') as zip_ref:\n",
        "      zip_ref.extractall('tools/jellyfin/')\n",
        "  os.remove(f\"tools/jellyfin/L{name}.zip\")\n",
        "  os.chmod(f\"tools/jellyfin/{name}\", 0o755)\n",
        "  runSh(\"rm -rf tools/jellyfin/__MACOSX\")\n",
        "  \n",
        "# Download jellyfin\n",
        "if not os.path.exists(\"/usr/bin/jellyfin\"):\n",
        "  \n",
        "  # JellyfinMain \n",
        "  BASE_URL = r\"https://github.com/jellyfin/jellyfin/\"\n",
        "  LATEST_TAG = latestTag(BASE_URL)\n",
        "  urlF = f'{BASE_URL}/releases/download/{LATEST_TAG}/' \\\n",
        "              f'jellyfin_{LATEST_TAG[1:]}-1_ubuntu-amd64.deb'\n",
        "  urllib.request.urlretrieve(urlF, 'tools/jellyfin/jellyfin.deb')\n",
        "  \n",
        "  # Jellyfin-ffmpeg\n",
        "  BASE_URL = r\"https://github.com/jellyfin/jellyfin-ffmpeg\"\n",
        "  LATEST_TAG = latestTag(BASE_URL)\n",
        "  urlF = f'{BASE_URL}/releases/download/{LATEST_TAG}/' \\\n",
        "              f'jellyfin-ffmpeg_{LATEST_TAG[1:]}-bionic_amd64.deb'\n",
        "  urllib.request.urlretrieve(urlF, 'tools/jellyfin/jellyfin-ffmpeg.deb')\n",
        "\n",
        "  # Default config data\n",
        "  defaultConfig = \"https://github.com/biplobsd/Google-Colab-CloudTorrent\" \\\n",
        "    \"/raw/master/res/jellyfin/data.tar.gz\"\n",
        "  outputFile = 'tools/jellyfin/temp/data.tar.gz'\n",
        "  urllib.request.urlretrieve(defaultConfig, outputFile)\n",
        "  with tarfile.open(outputFile, 'r:gz') as tar_ref:\n",
        "      tar_ref.extractall('/content/tools/jellyfin')\n",
        "  os.remove(outputFile)\n",
        "  \n",
        "\n",
        "  # ffmpeg\n",
        "  ff_loader('ffmpeg')\n",
        "\n",
        "  # ffprobe\n",
        "  ff_loader('ffprobe')\n",
        "  os.replace(\"tools/jellyfin/ffprobe\", \"/usr/bin/ffprobe\")\n",
        "\n",
        "\n",
        "  # Installing jellyfin\n",
        "  cmd = \"apt install -y --no-install-recommends \\\n",
        "\tat \\\n",
        "\ti965-va-driver \\\n",
        "\tlibfontconfig1 \\\n",
        "\tlibfreetype6 \\\n",
        "\tlibssl1.0.0 \\\n",
        "\tmesa-va-drivers\"\n",
        "  runSh(cmd, shell=True)\n",
        "  runSh(\"dpkg -i tools/jellyfin/jellyfin-ffmpeg.deb\", shell=True)\n",
        "  runSh(\"dpkg -i tools/jellyfin/jellyfin.deb\", shell=True)\n",
        "\n",
        "\n",
        "# Starting jellyfin\n",
        "if not findProcess(\"jellyfin\", \"--ffmpeg\"):\n",
        "  from subprocess import Popen\n",
        "  CM = \"jellyfin --noautorunwebapp --ffmpeg tools/jellyfin/ffmpeg \" \\\n",
        "    f\"-C /content/tools/jellyfin -d /content/tools/jellyfin\"\n",
        "  Popen(CM.split())\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['jellyfin', 8096, 'http']],\n",
        "    REGION.lower(), [f\"{HOME}/.ngrok2/jellyfin.yml\", 7097]\n",
        ").start('jellyfin', displayB=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "AOrO7nJ_7wjh"
      },
      "source": [
        "## <img src='https://www.v2ray.com/resources/v2ray_1024.png' height=\"25\" alt=\"V2Ray\" /> __V2Ray__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "maDRAy2D7wjk",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://www.v2ray.com/resources/v2ray_1024.png' height=\"100\" alt=\"V2Ray\"/></center>\n",
        "#@markdown <center><h3>V2Ray<br />An free and open-source proxy server</h3></center><br>\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "REGION = \"SA\" #@param [\"US\", \"EU\", \"AP\", \"AU\", \"SA\", \"JP\", \"IN\"]\n",
        "ID=\"\"  # @param {type:\"string\"}\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "# ================================================================ #\n",
        "\n",
        "import json\n",
        "import base64\n",
        "import uuid\n",
        "import os\n",
        "import urllib\n",
        "import re\n",
        "from IPython.display import HTML, clear_output\n",
        "from subprocess import Popen\n",
        "import pandas as pd\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import PortForward_wrapper\n",
        "\n",
        "def show_qr(text, v=True):\n",
        "  try:\n",
        "    from MyQR import myqr\n",
        "  except:\n",
        "    Popen(\"pip install myqr\".split()).wait()\n",
        "  Popen([\"myqr\",text]+\"--version 5 --level H -n qrcode.png -d /tmp\".split()).wait()\n",
        "  if v:\n",
        "    from PIL import Image\n",
        "    im = Image.open(\"/tmp/qrcode.png\")\n",
        "    os.remove(\"/tmp/qrcode.png\")\n",
        "    im.show()\n",
        "    import matplotlib.pyplot as plt\n",
        "    plt.figure(figsize=(5,5))\n",
        "    plt.imshow(im)\n",
        "    plt.axis('off')\n",
        "    plt.show()\n",
        "  else:\n",
        "    with open(\"/tmp/qrcode.png\", \"rb\") as imageFile:\n",
        "      imgb64 = base64.b64encode(imageFile.read())\n",
        "    os.remove(\"/tmp/qrcode.png\")\n",
        "    return imgb64\n",
        "\n",
        "def v2ray(id=None,port=9999):\n",
        "  if not os.path.exists(\"/v2raybin\"):\n",
        "    os.system('mkdir -m 777 /v2raybin  &&  cd /v2raybin  && curl -L -H \"Cache-Control: no-cache\" -o v2ray.zip https://github.com/v2ray/v2ray-core/releases/latest/download/v2ray-linux-64.zip  && unzip v2ray.zip  && chmod +x /v2raybin/v2ray  && rm -rf v2ray.zip  && chgrp -R 0 /v2raybin  && chmod -R g+rwX /v2raybin')\n",
        "  CONFIG_JSON1=\"{\\\"log\\\":{\\\"access\\\":\\\"\\\",\\\"error\\\":\\\"\\\",\\\"loglevel\\\":\\\"warning\\\"},\\\"inbound\\\":{\\\"protocol\\\":\\\"vmess\\\",\\\"port\\\":\"\n",
        "  CONFIG_JSON2=\",\\\"settings\\\":{\\\"clients\\\":[{\\\"id\\\":\\\"\"\n",
        "  CONFIG_JSON3=\"\\\",\\\"alterId\\\":64}]},\\\"streamSettings\\\":{\\\"network\\\":\\\"ws\\\"}},\\\"inboundDetour\\\":[],\\\"outbound\\\":{\\\"protocol\\\":\\\"freedom\\\",\\\"settings\\\":{}}}\"\n",
        "  with open(\"config.json\",\"w\") as f:\n",
        "    f.write(CONFIG_JSON1+str(port)+CONFIG_JSON2+id+CONFIG_JSON3)\n",
        "  return Popen(\"/v2raybin/v2ray\")\n",
        "\n",
        "port=9910\n",
        "\n",
        "if not ID:\n",
        "  ID=str(uuid.uuid4())\n",
        "print(\"Setting up v2ray server ... \")\n",
        "v2ray(ID,port)\n",
        "print(\"Setting up tunnel ... \")\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['v2ray', port, 'http']],\n",
        "    REGION.lower(), [f\"{HOME}/.ngrok2/V2ray.yml\", 8097]\n",
        ").start('v2ray', displayB=False)\n",
        "\n",
        "d=json.loads('{\"add\":\"{0}\",\"aid\":\"64\",\"host\":\"\",\"id\":\"{1}\",\"net\":\"ws\",\"path\":\"\",\"port\":\"80\",\"ps\":\"1\",\"tls\":\"\",\"type\":\"none\",\"v\":\"2\"}')\n",
        "d[\"add\"]=re.search(\"(?<=//).*?(/|$)\",Server[\"url\"]).group()\n",
        "d[\"id\"]=ID\n",
        "clear_output()\n",
        "# print(d)\n",
        "config=\"vmess://\"+base64.b64encode(json.dumps(d).encode()).decode(\"utf-8\")\n",
        "# print(config)\n",
        "imgb64 = show_qr(config, v=False).decode()\n",
        "df_marks = pd.Series(d).to_frame(\"V2Ray Config\")\n",
        "html = df_marks.to_html(classes=\"zui-table blueBG\")\n",
        "display(HTML(\"\"\"<style>@import url('https://fonts.googleapis.com/css?family=Source+Code+Pro:200,900');  :root {   --text-color: hsla(210, 50%, 85%, 1);   --shadow-color: hsla(210, 40%, 52%, .4);   --btn-color: hsl(210, 80%, 42%);   --bg-color: #141218; }  * {   box-sizing: border-box; } button { position:relative; padding: 10px 20px;     border: none;   background: none;      font-family: \"Source Code Pro\";   font-weight: 900;font-size: 100%;     color: var(--text-color);      background-color: var(--btn-color);   box-shadow: var(--shadow-color) 2px 2px 22px;   border-radius: 4px;    z-index: 0;overflow: hidden; -webkit-user-select: text;-moz-user-select: text;-ms-user-select: text;user-select: text;}  button:focus {   outline-color: transparent;   box-shadow: var(--btn-color) 2px 2px 22px; }  .right::after, button::after {   content: var(--content);   display: block;   position: absolute;   white-space: nowrap;   padding: 40px 40px;   pointer-events:none; }  button::after{   font-weight: 200;   top: -30px;   left: -20px; }   .right, .left {   position: absolute;   width: 100%;   height: 100%;   top: 0; } .right {   left: 66%; } .left {   right: 66%; } .right::after {   top: -30px;   left: calc(-66% - 20px);      background-color: var(--bg-color);   color:transparent;   transition: transform .4s ease-out;   transform: translate(0, -90%) rotate(0deg) }  button:hover .right::after {   transform: translate(0, -47%) rotate(0deg) }  button .right:hover::after {   transform: translate(0, -50%) rotate(-7deg) }  button .left:hover ~ .right::after {   transform: translate(0, -50%) rotate(7deg) }  /* bubbles */ button::before {   content: '';   pointer-events: none;   opacity: .6;   background:     radial-gradient(circle at 20% 35%,  transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 75% 44%, transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 46% 52%, transparent 0, transparent 4px, var(--text-color) 5px, var(--text-color) 6px, transparent 6px);    width: 100%;   height: 300%;   top: 0;   left: 0;   position: absolute;   animation: bubbles 5s linear infinite both; }  @keyframes bubbles {   from {     transform: translate();   }   to {     transform: translate(0, -66.666%);   } }.zui-table {border: solid 1px #DDEEEE;    border-collapse: collapse;    border-spacing: 0;    font: normal 13px;}.zui-table thead th {    background-color: #DDEFEF;    border: solid 1px #DDEEEE;    color: #0000009e;    padding: 10px;    text-align: left;}.zui-table tbody td {border: solid 1px #effff97a;color: #ffffffd1;    padding: 10px;}</style><center><button style=\"width: 60%\"><img style=\"width: 40%;\" src=\"data:image/png;base64, \"\"\"+imgb64+\"\"\"\"/><div style=\"text-align: -webkit-center;\">\"\"\"+html+\"\"\"</div><a target=\"_blank\" style=\"text-decoration: none;color: hsla(210, 50%, 85%, 1);font-size: 10px;\" href=\"https://bit.ly/34E09QG\">NB. How to setup this's config. [Click ME]</a></button><center>\"\"\"))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VDInERXVmnm8",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://github.com/pyload/pyload-webui/raw/master/media/banner.png' height=\"60\" alt=\"pyLoad\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GgY-Xq0Jm0gc",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://github.com/pyload/pyload-webui/raw/master/media/banner.png' height=\"100\" alt=\"pyLoad\"/></center>\n",
        "#@markdown <center><h3>pyLoad Webinterface<br />The free and open-source Download Manager written in pure Python</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "#@markdown Default <br>&emsp;username : admin<br>&emsp;password : admin\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs('downloads', exist_ok=True)\n",
        "os.makedirs('tools/pyload', exist_ok=True)\n",
        "\n",
        "# Downloading latest version of pyload\n",
        "if not os.path.exists(\"tools/pyload/pyload-stable\"):\n",
        "  urlF = 'https://github.com/pyload/pyload/archive/stable.zip'\n",
        "  conf = 'https://raw.githubusercontent.com/tofuliang/' \\\n",
        "          'Google-Colab-CloudTorrent/master/res/pyload/pyload.conf'\n",
        "  db = 'https://github.com/biplobsd/Google-Colab-CloudTorrent/raw/master/' \\\n",
        "        'res/pyload/files.db'\n",
        "  urllib.request.urlretrieve(urlF, 'tools/pyload.zip')\n",
        "  urllib.request.urlretrieve(conf, 'tools/pyload/pyload.conf')\n",
        "  urllib.request.urlretrieve(db, 'tools/pyload/files.db')\n",
        "  with zipfile.ZipFile('tools/pyload.zip', 'r') as zip_ref:\n",
        "      zip_ref.extractall('tools/pyload')\n",
        "  try:\n",
        "    pathlib.Path('tools/pyload.zip').unlink()\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "\n",
        "  runSh(\"apt install python-pycurl python-qt4 tesseract-ocr libtesseract-dev\")\n",
        "  runSh(\"pip2 install pycrypto pyOpenSSL Jinja2 tesseract tesseract-ocr\")\n",
        "\n",
        "if not findProcess(\"python2.7\", \"pyLoadCore.py\"):\n",
        "  runCmd = \"python2.7 /content/tools/pyload/pyload-stable/pyLoadCore.py\" \\\n",
        "          \" --configdir=/content/tools/pyload\" \\\n",
        "          \" --no-remote\" \\\n",
        "          \" --daemon\"\n",
        "  runSh(runCmd, shell=True)\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['rcloneConfig', 53682, 'http'], \n",
        "                            ['pyload', 8000, 'http']], 'sa', \n",
        "    [f\"{HOME}/.ngrok2/rclonePyload.yml\", 4074]\n",
        ").start('pyload')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PE5J1UDzQXSp",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/spotify-downloader.png' height=\"25\" alt=\"spotify-downloader\" /> spotify-downloader"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v71nnHGOlaSb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/spotify-downloader.png' height=\"100\" alt=\"spotify-downloader\"/></center>\n",
        "#@markdown <center><h3>spotify-downloader<br />Download Spotify playlists from YouTube with albumart and meta-tags</h3></center><br>\n",
        "\n",
        "import os, uuid, urllib.parse, re\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from glob import glob\n",
        "from urllib.parse import urlparse, parse_qs\n",
        "from IPython.display import HTML, clear_output, YouTubeVideo\n",
        "from IPython.utils.io import ask_yes_no\n",
        "from google.colab import output, files\n",
        "\n",
        "\n",
        "os.makedirs('tools/spotify-downloader/', exist_ok=True)\n",
        "os.makedirs('downloads', exist_ok=True)\n",
        "\n",
        "# # Config files\n",
        "# data = \"\"\"spotify-downloader:\n",
        "#   avconv: false\n",
        "#   download-only-metadata: false\n",
        "#   dry-run: false\n",
        "#   file-format: '{artist} - {track_name}'\n",
        "#   folder: /home/user/Music\n",
        "#   input-ext: .m4a\n",
        "#   log-level: INFO\n",
        "#   manual: false\n",
        "#   music-videos-only: false\n",
        "#   no-fallback-metadata: false\n",
        "#   no-metadata: false\n",
        "#   no-spaces: false\n",
        "#   output-ext: .mp3\n",
        "#   overwrite: prompt\n",
        "#   search-format: '{artist} - {track_name} lyrics'\n",
        "#   skip: null\n",
        "#   spotify_client_id: 4fe3fecfe5334023a1472516cc99d805\n",
        "#   spotify_client_secret: 0f02b7c483c04257984695007a4a8d5c\n",
        "#   trim-silence: false\n",
        "#   write-successful: null\n",
        "#   write-to: null\n",
        "#   youtube-api-key: null\n",
        "# \"\"\"\n",
        "# with open('tools/spotify-downloader/config.yml', 'w') as wnow:\n",
        "#   wnow.write(data)\n",
        "\n",
        "Links = widgets.Textarea(placeholder='''Link list\n",
        "(one link per line)''')\n",
        "\n",
        "fileFormat = widgets.Text(\n",
        "    value='{artist} - {track_name}',\n",
        "    placeholder='File name format',\n",
        "    description=\"\"\"File Name : file format to save the downloaded track with, each\n",
        "                        tag is surrounded by curly braces. Possible formats:\n",
        "                        ['track_name', 'artist', 'album', 'album_artist',\n",
        "                        'genre', 'disc_number', 'duration', 'year',\n",
        "                        'original_date', 'track_number', 'total_tracks',\n",
        "                        'isrc']\"\"\",\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "searchFormat = widgets.Text(\n",
        "    value='{artist} - {track_name} lyrics',\n",
        "    placeholder='Search format',\n",
        "    description=\"\"\"Search Format : search format to search for on YouTube, each tag is\n",
        "                        surrounded by curly braces. Possible formats:\n",
        "                        ['track_name', 'artist', 'album', 'album_artist',\n",
        "                        'genre', 'disc_number', 'duration', 'year',\n",
        "                        'original_date', 'track_number', 'total_tracks',\n",
        "                        'isrc']\"\"\",\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "tab = widgets.Tab()\n",
        "\n",
        "LinksType = widgets.RadioButtons(\n",
        "    options=['Songs', 'Playlist', 'Album', 'Username', 'Artist'],\n",
        "    value='Songs',\n",
        "    layout={'width': 'max-content'},\n",
        "    description='Links type:',\n",
        "    disabled=False,\n",
        ")\n",
        "\n",
        "SavePathYT = widgets.Dropdown(options=[\"/content/downloads\", \"/content\"])\n",
        "\n",
        "Extension = widgets.Select(options=[\"aac\", \"flac\", \"mp3\", \"m4a\", \"opus\", \"vorbis\", \"wav\"], value=\"mp3\")\n",
        "\n",
        "TrimSilence = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Trim silence',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='remove silence from the start of the audio',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "writeM3u = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Write .m3u playlist',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''generate an .m3u playlist file with youtube links\n",
        "               given a text file containing tracks''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "noMeta = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No metadata',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='do not embed metadata in tracks',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "nf = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No fallback metadata',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''do not use YouTube as fallback for metadata if track\n",
        "                        not found on Spotify''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "dryRun = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Dry run',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip=''' show only track title and YouTube URL, and then skip\n",
        "                        to the next track (if any)''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "MusicVidOnly = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Music Videos Only',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''search only for music videos on Youtube (works only\n",
        "                        when YouTube API key is set''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "NoSpaces = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No Spaces',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''replace spaces with underscores in file names''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "manual = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='manually',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''choose the track to download manually from a list of\n",
        "                        matching tracks''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "nr = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Keep original',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''do not remove the original file after conversion''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "ExtraArg = widgets.Text(placeholder=\"Extra Arguments\")\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback, style):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "    self._style = style\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    if self._style != \"\":\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "    else:\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "    template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RefreshPathYT():\n",
        "  if os.path.exists(\"/content/drive/\"):\n",
        "    if os.path.exists(\"/content/drive/Shared drives/\"):\n",
        "      SavePathYT.options = [\"/content\", \"/content/downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\") + glob(\"/content/drive/Shared drives/*/\")\n",
        "    else:\n",
        "      SavePathYT.options = [\"/content\", \"/content/downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\")\n",
        "  else:\n",
        "    SavePathYT.options = [\"/content/downloads\", \"/content\"]\n",
        "\n",
        "\n",
        "def ShowYT():\n",
        "  clear_output(wait=True)\n",
        "  RefreshPathYT()\n",
        "  mainTab = widgets.Box([widgets.HBox([widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Link:</b>\"), Links,\n",
        "                                      LinksType, searchFormat, fileFormat, widgets.HBox([TrimSilence, writeM3u, noMeta]), widgets.HBox([nf, dryRun, MusicVidOnly]),widgets.HBox([NoSpaces, manual, nr])]),\n",
        "                        widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extension:</b>\"), Extension,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extra Arguments:</b>\"), ExtraArg])])])\n",
        "  tab.children = [mainTab]\n",
        "  tab.set_title(0, 'spotify-downloader')\n",
        "  display(tab)\n",
        "  display(HTML(\"<h4 style=\\\"color:#888888;\\\">Save Location:</h4>\"), SavePathYT, MakeButton(\"Refresh\", RefreshPathYT, \"\"))\n",
        "  if not os.path.exists(\"/content/drive/\"):\n",
        "    display(HTML(\"*If you want to save in Google Drive please run the cell below.\"))\n",
        "  display(HTML(\"<br>\"), MakeButton(\"Download\", DownloadYT, \"info\"))\n",
        "\n",
        "def DownloadYT():\n",
        "  if Links.value.strip():\n",
        "    Count = 0\n",
        "    Total = str(len(Links.value.splitlines()))\n",
        "    if writeM3u.value:\n",
        "      M3u = '--write-m3u'\n",
        "    else:\n",
        "      M3u = ''\n",
        "    if TrimSilence.value:\n",
        "      trmS = '--trim-silence'\n",
        "    else:\n",
        "      trmS = ''\n",
        "    if noMeta.value:\n",
        "      noM = '--no-metadata'\n",
        "    else:\n",
        "      noM = ''\n",
        "    if nf.value:\n",
        "      nfv = '--no-fallback-metadata'\n",
        "    else:\n",
        "      nfv = ''\n",
        "    if dryRun.value:\n",
        "      drR = '--dry-run'\n",
        "    else:\n",
        "      drR = ''\n",
        "    if MusicVidOnly.value:\n",
        "      MsV = '--music-videos-only'\n",
        "    else:\n",
        "      MsV = ''\n",
        "    if NoSpaces.value:\n",
        "      NoS = '--no-spaces'\n",
        "    else:\n",
        "      NoS = ''\n",
        "    if manual.value:\n",
        "      mal = '--manual'\n",
        "    else:\n",
        "      mal = ''\n",
        "    if nr.value:\n",
        "      nro = '--no-remove-original' \n",
        "    else:\n",
        "      nro = ''\n",
        "    if not searchFormat.value == '{artist} - {track_name} lyrics':\n",
        "      seFor = f'--search-format \"{searchFormat.value}\"'\n",
        "    else:\n",
        "      seFor = ''\n",
        "    if not fileFormat.value == '{artist} - {track_name}':\n",
        "      fiFor = f'--file-format \"{fileFormat.value}\"'\n",
        "    else:\n",
        "      fiFor = ''\n",
        "    \n",
        "    if not LinksType.value == 'Songs':\n",
        "      with open('tools/spotify-downloader/finish.txt', 'a+') as master:\n",
        "        for Link in Links.value.splitlines():\n",
        "          if LinksType.value == 'Playlist':\n",
        "            outFileName = !spotdl --playlist $Link\n",
        "          elif LinksType.value == 'Album':\n",
        "            outFileName = !spotdl --album $Link\n",
        "          elif LinksType.value == 'Username':\n",
        "            outFileName = !spotdl -u $Link\n",
        "          elif LinksType.value == 'Artist':\n",
        "            outFileName = !spotdl --all-albums $Link\n",
        "          filename = re.search(r\"to\\s(.+\\.txt)\", outFileName[-1]).group(1)\n",
        "          with open(filename, 'r') as r:\n",
        "            master.write(r.read())\n",
        "    else:\n",
        "      for Link in Links.value.splitlines():\n",
        "        with open('tools/spotify-downloader/finish.txt', 'w') as master:\n",
        "          master.write(Link)\n",
        "    # Extra Arguments\n",
        "    \n",
        "    extraargC = ExtraArg.value\n",
        "    cmd = r\"spotdl -l 'tools/spotify-downloader/finish.txt' \" \\\n",
        "      fr\"-f {SavePathYT.value} \" \\\n",
        "      fr\"-o .{Extension.value} \" \\\n",
        "      f\"--overwrite skip \" \\\n",
        "      f\"{seFor} {fiFor} \" \\\n",
        "      f\"{M3u} {trmS} {noM} {nfv} {drR} {MsV} {NoS} {mal} {nro}\" \n",
        "    !$cmd\n",
        "    ShowYT()\n",
        "\n",
        "if not os.path.isfile(\"/usr/local/bin/spotdl\"):\n",
        "  get_ipython().system_raw(\"pip3 install spotdl && apt-get install ffmpeg\")\n",
        "\n",
        "ShowYT()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fJ7W2Z0gcYa5",
        "colab_type": "text"
      },
      "source": [
        "## <img src='http://pic2.orsoon.com/2017/0719/20170719091439708.png' height=\"60\" alt=\"aria2\" />___aria2___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yN2xLpinUbl6",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='http://pic2.orsoon.com/2017/0719/20170719091439708.png' height=\"200\" alt=\"aria2\"/></center>\n",
        "#@markdown <center><h3>aria2<br />The next generation download utility.</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "# Aria2 Service\n",
        "Aria2_rpc = True  # @param {type:\"boolean\"}\n",
        "Ariang_WEBUI = True  # @param {type:\"boolean\"}\n",
        "\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "# OUTPUT_DIR = \"\"  # @param {type:\"string\"}\n",
        "PORT = 8221\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    CWD,\n",
        "    displayUrl,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "# Ariang SETUP\n",
        "runSh('sudo apt install -y aria2')\n",
        "pathlib.Path('ariang').mkdir(mode=0o777, exist_ok=True)\n",
        "pathlib.Path('downloads').mkdir(mode=0o777, exist_ok=True)\n",
        "\n",
        "# github latest releases tag define\n",
        "def latestTag(link):\n",
        "  import re\n",
        "  from urllib.request import urlopen\n",
        "  htmlF = urlopen(link+\"/releases/latest\").read().decode('UTF-8')\n",
        "  return re.findall(r'.+\\/tag\\/([.0-9A-Za-z]+)\".+/', htmlF)[0]\n",
        "\n",
        "# Downloading latest version of ariang\n",
        "if not os.path.exists(\"ariang/index.html\"):\n",
        "  BASE_URL = r\"https://github.com/mayswind/AriaNg\"\n",
        "  LATEST_TAG = latestTag(BASE_URL)\n",
        "  urlF = f'{BASE_URL}/releases/download/{LATEST_TAG}/' \\\n",
        "              f'AriaNg-{LATEST_TAG}-AllInOne.zip'\n",
        "  urllib.request.urlretrieve(urlF, 'ariang/new.zip')\n",
        "  with zipfile.ZipFile('ariang/new.zip', 'r') as zip_ref:\n",
        "      zip_ref.extractall('ariang')\n",
        "  try:\n",
        "    pathlib.Path('ariang/new.zip').unlink()\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "\n",
        "# START_ARIANG_WEBUI_AND_ARIA2_RPC\n",
        "try:\n",
        "  if not OUTPUT_DIR:\n",
        "    OUTPUT_DIR = f\"downloads/\"\n",
        "  elif not os.path.exists(OUTPUT_DIR):\n",
        "    clear_output()\n",
        "    print(\"Error: Your set path not found! Create path!\")\n",
        "    exx()\n",
        "except:\n",
        "  OUTPUT_DIR = f\"{CWD}/downloads/\"\n",
        "if Aria2_rpc:\n",
        "  if not findProcess(\"aria2c\", \"--enable-rpc\"):\n",
        "    try:\n",
        "      trackers = urllib.request.urlopen(\n",
        "          \"https://trackerslist.com/best_aria2.txt\"\n",
        "      ).read().decode()\n",
        "      cmdC = r\"aria2c --enable-rpc --rpc-listen-port=6800 -D \" \\\n",
        "            fr\"-d {OUTPUT_DIR} \" \\\n",
        "            r\"-j 20 \" \\\n",
        "            r\"-c \" \\\n",
        "            fr\"--bt-tracker={trackers} \" \\\n",
        "            r\"--bt-request-peer-speed-limit=0 \" \\\n",
        "            r\"--bt-max-peers=0 \" \\\n",
        "            r\"--seed-ratio=0.0 \" \\\n",
        "            r\"--max-connection-per-server=10 \" \\\n",
        "            r\"--min-split-size=10M \" \\\n",
        "            r\"--follow-torrent=mem \" \\\n",
        "            r\" &\"\n",
        "      runSh(\n",
        "          cmdC,\n",
        "          shell=True\n",
        "      )\n",
        "    except:\n",
        "      print(\"aria2 rpc not enabling. Try again later!\")\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['Aria2_rpc', 6800, 'http'], \n",
        "    ['Ariang', 8221, 'http']], 'jp', \n",
        "    [f\"{HOME}/.ngrok2/aria2.yml\", 5042]\n",
        ")\n",
        "if Aria2_rpc:\n",
        "  data = Server.start('Aria2_rpc', displayB=False)\n",
        "  Host = data['url'][7:] \n",
        "  port = \"80\"\n",
        "  clear_output()\n",
        "if Ariang_WEBUI:\n",
        "  if Aria2_rpc:\n",
        "    filePath = 'ariang/index.html'\n",
        "    with open(filePath, 'r+') as f:\n",
        "      read_data = f.read()\n",
        "      f.seek(0)\n",
        "      f.truncate(0)\n",
        "      read_data = re.sub(r'(rpcHost:\"\\w+.\")|rpcHost:\"\"', \n",
        "                        f'rpcHost:\"{Host}\"', read_data)\n",
        "      read_data = re.sub(r'protocol:\"\\w+.\"', r'protocol:\"ws\"', read_data)\n",
        "      read_data = re.sub(r'rpcPort:\"\\d+.\"', f'rpcPort:\"{port}\"', read_data)\n",
        "      f.write(read_data)\n",
        "  try:\n",
        "    urllib.request.urlopen(f\"http://localhost:{PORT}\")\n",
        "  except:\n",
        "    runSh(f\"python3 -m http.server {PORT} &\", shell=True, cd=\"ariang/\")\n",
        " \n",
        "  data2 = Server.start('Ariang', displayB=False)\n",
        "  displayUrl(data2, pNamU='Ariang : ')\n",
        "\n",
        "if Aria2_rpc:\n",
        "  display(HTML(\"\"\"<style>@import url('https://fonts.googleapis.com/css?family=Source+Code+Pro:200,900');  :root {   --text-color: hsla(210, 50%, 85%, 1);   --shadow-color: hsla(210, 40%, 52%, .4);   --btn-color: hsl(210, 80%, 42%);   --bg-color: #141218; }  * {   box-sizing: border-box; } button { position:relative; padding: 10px 20px;     border: none;   background: none;      font-family: \"Source Code Pro\";   font-weight: 900;font-size: 100%;     color: var(--text-color);      background-color: var(--btn-color);   box-shadow: var(--shadow-color) 2px 2px 22px;   border-radius: 4px;    z-index: 0;overflow: hidden; -webkit-user-select: text;-moz-user-select: text;-ms-user-select: text;user-select: text;}  button:focus {   outline-color: transparent;   box-shadow: var(--btn-color) 2px 2px 22px; }  .right::after, button::after {   content: var(--content);   display: block;   position: absolute;   white-space: nowrap;   padding: 40px 40px;   pointer-events:none; }  button::after{   font-weight: 200;   top: -30px;   left: -20px; }   .right, .left {   position: absolute;   width: 100%;   height: 100%;   top: 0; } .right {   left: 66%; } .left {   right: 66%; } .right::after {   top: -30px;   left: calc(-66% - 20px);      background-color: var(--bg-color);   color:transparent;   transition: transform .4s ease-out;   transform: translate(0, -90%) rotate(0deg) }  button:hover .right::after {   transform: translate(0, -47%) rotate(0deg) }  button .right:hover::after {   transform: translate(0, -50%) rotate(-7deg) }  button .left:hover ~ .right::after {   transform: translate(0, -50%) rotate(7deg) }  /* bubbles */ button::before {   content: '';   pointer-events: none;   opacity: .6;   background:     radial-gradient(circle at 20% 35%,  transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 75% 44%, transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 46% 52%, transparent 0, transparent 4px, var(--text-color) 5px, var(--text-color) 6px, transparent 6px);    width: 100%;   height: 300%;   top: 0;   left: 0;   position: absolute;   animation: bubbles 5s linear infinite both; }  @keyframes bubbles {   from {     transform: translate();   }   to {     transform: translate(0, -66.666%);   } }.zui-table {    border: solid 1px #DDEEEE;    border-collapse: collapse;    border-spacing: 0;    font: normal 13px;}.zui-table thead th {    background-color: #DDEFEF;    border: solid 1px #DDEEEE;    color: #0000009e;    padding: 10px;    text-align: left;}.zui-table tbody td {border: solid 1px #effff97a;color: #ffffffd1;    padding: 10px;}</style><center><button><table class=\"zui-table blueBG\"><p>Aria2 rpc config<p><thead>        <tr>            <th>Protocol</th>            <th>Host</th>            <th>Port</th>        </tr>    </thead>    <tbody>        <tr>            <td>WebSocket</td><td>\"\"\"+Host+\"\"\"</td><td>\"\"\"+port+\"\"\"</td></tr></tbody></table><a target=\"_blank\" style=\"text-decoration: none;color: hsla(210, 50%, 85%, 1);font-size: 10px;\" href=\"http://bit.ly/2qoOw0a\">NB. How to setup this's config. [Click ME]</a></button><center>\"\"\"))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ttv0CeCqLX0t",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/aria2cli.png' height=\"45\" alt=\"aira2\"/> <font size=1px >___Direct link downloader___</font>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ASgRAOtBnVDT"
      },
      "source": [
        "___Auto share link supported : Disk.yandex.com, Gdrive and youtube-dl all extractor...___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "plgToqkpLV5q",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "URL = \"\" #@param {type:\"string\"}\n",
        "#@markdown <center><h5>Default output path /content/downloads/</h5></center>\n",
        "OUTPUT_PATH = \"\" #@param {type:\"string\"}\n",
        "\n",
        "import pathlib\n",
        "import shutil\n",
        "import hashlib\n",
        "import requests\n",
        "from urllib.parse import urlparse\n",
        "from os import path, mkdir\n",
        "if not path.exists(\"/root/.ipython/ttmg.py\"): \n",
        "    from subprocess import run\n",
        "    from shlex import split\n",
        "\n",
        "    shellCmd = \"wget -qq https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py \\\n",
        "                    -O /root/.ipython/ttmg.py\"\n",
        "    run(split(shellCmd))\n",
        "from ttmg import updateCheck, runSh\n",
        "\n",
        "def youtubedlInstall():\n",
        "  if not path.isfile(\"/usr/local/bin/youtube-dl\"):\n",
        "    cmdC = \"rm -rf /content/sample_data/ && \" \\\n",
        "            \" mkdir -p -m 666 /root/.YouTube-DL/ &&\" \\\n",
        "            \" apt-get install atomicparsley &&\" \\\n",
        "            \" curl -L https://yt-dl.org/downloads/latest/youtube-dl \" \\\n",
        "            \"-o /usr/local/bin/youtube-dl &&\" \\\n",
        "            \" chmod a+rx /usr/local/bin/youtube-dl\"\n",
        "    get_ipython().system_raw(cmdC)\n",
        "\n",
        "def aria2Install():\n",
        "  runSh('apt install -y aria2')\n",
        "\n",
        "def istmd(URL): \n",
        "  link = urlparse(URL)\n",
        "    \n",
        "  #YandexDisk\n",
        "  if link.netloc == \"yadi.sk\":\n",
        "    API_ENDPOINT = 'https://cloud-api.yandex.net/v1/disk/public/resources/' \\\n",
        "                    '?public_key={}&path=/{}&offset={}'\n",
        "    dry = False\n",
        "    def md5sum(file_path):\n",
        "        md5 = hashlib.md5()\n",
        "        with open(file_path, 'rb') as f:\n",
        "            for chunk in iter(lambda: f.read(128 * md5.block_size), b''):\n",
        "                md5.update(chunk)\n",
        "        return md5.hexdigest()\n",
        "\n",
        "\n",
        "    def check_and_download_file(target_path, url, size, checksum):\n",
        "        if path.isfile(target_path):\n",
        "            if size == path.getsize(target_path):\n",
        "                if checksum == md5sum(target_path):\n",
        "                    print('URL {}'.format(url))\n",
        "                    print('skipping correct {}'.format(target_path))\n",
        "                    return\n",
        "        if not dry:\n",
        "            print('URL {}'.format(url))\n",
        "            print('downloading {}'.format(target_path))\n",
        "            runSh(f'aria2c -x 16 -s 16 -k 1M -d {OUTPUT_PATH} {url}', output=True)\n",
        "            # r = requests.get(url, stream=True)\n",
        "            # with open(target_path, 'wb') as f:\n",
        "            #     shutil.copyfileobj(r.raw, f)\n",
        "\n",
        "\n",
        "    def download_path(target_path, public_key, source_path, offset=0):\n",
        "        print('getting \"{}\" at offset {}'.format(source_path, offset))\n",
        "        current_path = path.join(target_path, source_path)\n",
        "        pathlib.Path(current_path).mkdir(parents=True, exist_ok=True)\n",
        "        jsn = requests.get(API_ENDPOINT.format(public_key, source_path, offset)).json()\n",
        "        def try_as_file(j):\n",
        "            if 'file' in j:\n",
        "                file_save_path = path.join(current_path, j['name'])\n",
        "                check_and_download_file(file_save_path, j['file'], j['size'], j['md5'])\n",
        "                return True\n",
        "            return False\n",
        "\n",
        "        # first try to treat the actual json as a single file description\n",
        "        if try_as_file(jsn):\n",
        "            return\n",
        "\n",
        "        # otherwise treat it as a directory\n",
        "        emb = jsn['_embedded']\n",
        "        items = emb['items']\n",
        "        for i in items:\n",
        "            # each item can be a file...\n",
        "            if try_as_file(i):\n",
        "                continue\n",
        "            # ... or a directory\n",
        "            else:\n",
        "                subdir_path = path.join(source_path, i['name'])\n",
        "                download_path(target_path, public_key, subdir_path)\n",
        "\n",
        "        # check if current directory has more items\n",
        "        last = offset + emb['limit']\n",
        "        if last < emb['total']:\n",
        "            download_path(target_path, public_key, source_path, last)\n",
        "    download_path(OUTPUT_PATH, URL, '')\n",
        "    return False  \n",
        "  return URL\n",
        "\n",
        "if not OUTPUT_PATH:\n",
        "  OUTPUT_PATH = \"/content/downloads/\"\n",
        "  \n",
        "if not URL == \"\":\n",
        "  aria2Install()\n",
        "  youtubedlInstall()\n",
        "  try:\n",
        "    mkdir(\"downloads\")\n",
        "  except FileExistsError:\n",
        "    pass\n",
        "  url = istmd(URL)\n",
        "  if url != False:\n",
        "    print('URL {}'.format(URL))\n",
        "    cmdC = f'youtube-dl -o \"{OUTPUT_PATH}/%(title)s\" {URL} ' \\\n",
        "            '--external-downloader aria2c ' \\\n",
        "            '--external-downloader-args \"-x 16 -s 16 -k 1M\"'\n",
        "    runSh(cmdC, output=True)\n",
        "else:\n",
        "  print(\"Please input url\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7dTNq8TFD6a-",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_jdownloader.png' height=\"45\" alt=\"JDownloader\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2fQoIcEOD1yu",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute JDownloader\n",
        "NEW_Account = True  # @param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "from os import path as _p\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run  # nosec\n",
        "\n",
        "    shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                    -O /root/.ipython/rlab_utils.py\"\n",
        "    run(_spl(shellCmd))  # nosec\n",
        "\n",
        "from rlab_utils import handleJDLogin\n",
        "\n",
        "handleJDLogin(NEW_Account)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SoxLe8ciEyAc",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_youtube-dl.png' height=\"45\" alt=\"Youtube-DL\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2u2LsQC8EtQJ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute YouTube-DL\n",
        "# @markdown 📝 Note: if you want to change an archive file just run this cell again.\n",
        "Archive = False #@param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os, uuid, urllib.parse\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from glob import glob\n",
        "from urllib.parse import urlparse, parse_qs\n",
        "from IPython.display import HTML, clear_output, YouTubeVideo\n",
        "from IPython.utils.io import ask_yes_no\n",
        "from google.colab import output, files\n",
        "\n",
        "Links = widgets.Textarea(placeholder='''Video/Playlist Link\n",
        "(one link per line)''')\n",
        "\n",
        "VideoQ = widgets.Dropdown(options=[\"Best Quality (VP9 upto 4K)\", \"Best Compatibility (H.264 upto 1080p)\"])\n",
        "\n",
        "AudioQ = widgets.Dropdown(options=[\"Best Quality (Opus)\", \"Best Compatibility (M4A)\"])\n",
        "\n",
        "Subtitle = widgets.ToggleButton(value=True, description=\"Subtitle\", button_style=\"info\", tooltip=\"Subtitle\")\n",
        "\n",
        "SavePathYT = widgets.Dropdown(options=[\"/content\", \"/content/Downloads\"])\n",
        "\n",
        "AudioOnly = widgets.ToggleButton(value=False, description=\"Audio Only\", button_style=\"\", tooltip=\"Audio Only\")\n",
        "\n",
        "Resolution = widgets.Select(options=[\"Highest\", \"4K\", \"1440p\", \"1080p\", \"720p\", \"480p\", \"360p\", \"240p\", \"144p\"], value=\"Highest\")\n",
        "\n",
        "Extension = widgets.Select(options=[\"mkv\", \"webm\"], value=\"mkv\")\n",
        "\n",
        "UsernameYT = widgets.Text(placeholder=\"Username\")\n",
        "\n",
        "PasswordYT = widgets.Text(placeholder=\"Password\")\n",
        "\n",
        "SecAuth = widgets.Text(placeholder=\"2nd Factor Authentication\")\n",
        "\n",
        "VideoPW = widgets.Text(placeholder=\"Video Password\")\n",
        "\n",
        "GEOBypass = widgets.Dropdown(options=[\"Disable\", \"Hide\", \"AD\", \"AE\", \"AF\", \"AG\", \"AI\", \"AL\", \"AM\", \"AO\", \"AQ\", \"AR\", \"AS\", \"AT\", \"AU\", \"AW\", \"AX\", \"AZ\", \"BA\", \"BB\", \"BD\", \"BE\", \"BF\", \"BG\", \"BH\", \"BI\", \"BJ\", \"BL\", \"BM\", \"BN\", \"BO\", \"BQ\", \"BR\", \"BS\", \"BT\", \"BV\", \"BW\", \"BY\", \"BZ\", \"CA\", \"CC\", \"CD\", \"CF\", \"CG\", \"CH\", \"CI\", \"CK\", \"CL\", \"CM\", \"CN\", \"CO\", \"CR\", \"CU\", \"CV\", \"CW\", \"CX\", \"CY\", \"CZ\", \"DE\", \"DJ\", \"DK\", \"DM\", \"DO\", \"DZ\", \"EC\", \"EE\", \"EG\", \"EH\", \"ER\", \"ES\", \"ET\", \"FI\", \"FJ\", \"FK\", \"FM\", \"FO\", \"FR\", \"GA\", \"GB\", \"GD\", \"GE\", \"GF\", \"GG\", \"GH\", \"GI\", \"GL\", \"GM\", \"GN\", \"GP\", \"GQ\", \"GR\", \"GS\", \"GT\", \"GU\", \"GW\", \"GY\", \"HK\", \"HM\", \"HN\", \"HR\", \"HT\", \"HU\", \"ID\", \"IE\", \"IL\", \"IM\", \"IN\", \"IO\", \"IQ\", \"IR\", \"IS\", \"IT\", \"JE\", \"JM\", \"JO\", \"JP\", \"KE\", \"KG\", \"KH\", \"KI\", \"KM\", \"KN\", \"KP\", \"KR\", \"KW\", \"KY\", \"KZ\", \"LA\", \"LB\", \"LC\", \"LI\", \"LK\", \"LR\", \"LS\", \"LT\", \"LU\", \"LV\", \"LY\", \"MA\", \"MC\", \"MD\", \"ME\", \"MF\", \"MG\", \"MH\", \"MK\", \"ML\", \"MM\", \"MN\", \"MO\", \"MP\", \"MQ\", \"MR\", \"MS\", \"MT\", \"MU\", \"MV\", \"MW\", \"MX\", \"MY\", \"MZ\", \"NA\", \"NC\", \"NE\", \"NF\", \"NG\", \"NI\", \"NL\", \"NO\", \"NP\", \"NR\", \"NU\", \"NZ\", \"OM\", \"PA\", \"PE\", \"PF\", \"PG\", \"PH\", \"PK\", \"PL\", \"PM\", \"PN\", \"PR\", \"PS\", \"PT\", \"PW\", \"PY\", \"QA\", \"RE\", \"RO\", \"RS\", \"RU\", \"RW\", \"SA\", \"SB\", \"SC\", \"SD\", \"SE\", \"SG\", \"SH\", \"SI\", \"SJ\", \"SK\", \"SL\", \"SM\", \"SN\", \"SO\", \"SR\", \"SS\", \"ST\", \"SV\", \"SX\", \"SY\", \"SZ\", \"TC\", \"TD\", \"TF\", \"TG\", \"TH\", \"TJ\", \"TK\", \"TL\", \"TM\", \"TN\", \"TO\", \"TR\", \"TT\", \"TV\", \"TW\", \"TZ\", \"UA\", \"UG\", \"UM\", \"US\", \"UY\", \"UZ\", \"VA\", \"VC\", \"VE\", \"VG\", \"VI\", \"VN\", \"VU\", \"WF\", \"WS\", \"YE\", \"YT\", \"ZA\", \"ZM\", \"ZW\"])\n",
        "\n",
        "ProxyYT = widgets.Text(placeholder=\"Proxy URL\")\n",
        "\n",
        "MinSleep = widgets.BoundedIntText(value=0, min=0, max=300, step=1, description=\"Min:\")\n",
        "\n",
        "MaxSleep = widgets.BoundedIntText(value=0, min=0, max=300, step=1, description=\"Max:\")\n",
        "\n",
        "ExtraArg = widgets.Text(placeholder=\"Extra Arguments\")\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback, style):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "    self._style = style\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    if self._style != \"\":\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "    else:\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "    template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def upload_archive():\n",
        "  if ask_yes_no(\"Do you already have an archive file? (y/n)\", default=\"\", interrupt=\"\"):\n",
        "    try:\n",
        "      display(HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Please upload an archive from your computer.</h2><br>\"))\n",
        "      UploadConfig = files.upload().keys()\n",
        "      clear_output(wait=True)\n",
        "      if len(UploadConfig) == 0:\n",
        "        return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">File upload has been cancelled during upload file.</h2><br></center>\"))\n",
        "      elif len(UploadConfig) == 1:\n",
        "        for fn in UploadConfig:\n",
        "          if os.path.isfile(\"/content/\" + fn):\n",
        "            get_ipython().system_raw(\"mv -f \" + \"\\\"\" + fn + \"\\\" /root/.youtube-dl.txt && chmod 666 /root/.youtube-dl.txt\")\n",
        "            AudioOnly.observe(AudioOnlyChange)\n",
        "            Subtitle.observe(SubtitleChange)\n",
        "            AudioQ.observe(AudioQChange)\n",
        "            ShowYT()\n",
        "          else:\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">File upload has been failed during upload file.</h2><br></center>\"))\n",
        "      else:\n",
        "        for fn in UploadConfig:\n",
        "          get_ipython().system_raw(\"rm -f \" + \"\\\"\" + fn + \"\\\"\")\n",
        "        return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Please uploading only one file at a time.</h2><br></center>\"))\n",
        "    except:\n",
        "      clear_output(wait=True)\n",
        "      return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Error occurred during upload file.</h2><br></center>\"))\n",
        "  else:\n",
        "    get_ipython().system_raw(\"touch '/root/.youtube-dl.txt'\")\n",
        "    AudioOnly.observe(AudioOnlyChange)\n",
        "    Subtitle.observe(SubtitleChange)\n",
        "    AudioQ.observe(AudioQChange)\n",
        "    ShowYT()\n",
        "\n",
        "def RefreshPathYT():\n",
        "  if os.path.exists(\"/content/drive/\"):\n",
        "    if os.path.exists(\"/content/drive/Shared drives/\"):\n",
        "      SavePathYT.options = [\"/content\", \"/content/Downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\") + glob(\"/content/drive/Shared drives/*/\")\n",
        "    else:\n",
        "      SavePathYT.options = [\"/content\", \"/content/Downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\")\n",
        "  else:\n",
        "    SavePathYT.options = [\"/content\", \"/content/Downloads\"]\n",
        "\n",
        "def AudioOnlyChange(change):\n",
        "  if change[\"type\"] == \"change\" and change[\"new\"]:\n",
        "    VideoQ.disabled = True\n",
        "    Subtitle.disabled = True\n",
        "    if Subtitle.value:\n",
        "      Subtitle.button_style = \"info\"\n",
        "    else:\n",
        "      Subtitle.button_style = \"\"\n",
        "    Resolution.disabled = True\n",
        "    Extension.options = [\"best\", \"aac\", \"flac\", \"mp3\", \"m4a\", \"opus\", \"vorbis\", \"wav\"]\n",
        "    Extension.value = \"best\"\n",
        "    AudioOnly.button_style = \"info\"\n",
        "  elif change[\"type\"] == \"change\" and change[\"new\"] == False:\n",
        "    VideoQ.disabled = False\n",
        "    Subtitle.disabled = False\n",
        "    if Subtitle.value:\n",
        "      Subtitle.button_style = \"info\"\n",
        "    else:\n",
        "      Subtitle.button_style = \"\"\n",
        "    Resolution.disabled = False\n",
        "    if AudioQ.value == \"Best Quality (Opus)\":\n",
        "      Extension.options = [\"mkv\", \"webm\"]\n",
        "    else:\n",
        "      Extension.options = [\"mkv\", \"mp4\", \"webm\"]\n",
        "    Extension.value = \"mkv\"\n",
        "    AudioOnly.button_style = \"\"\n",
        "\n",
        "def SubtitleChange(change):\n",
        "  if change[\"type\"] == \"change\" and change[\"new\"]:\n",
        "    Subtitle.button_style = \"info\"\n",
        "  elif change[\"type\"] == \"change\" and change[\"new\"] == False:\n",
        "    Subtitle.button_style = \"\"\n",
        "\n",
        "def AudioQChange(change):\n",
        "  if change[\"type\"] == \"change\" and change[\"new\"] == \"Best Quality (Opus)\":\n",
        "    Extension.options = [\"mkv\", \"webm\"]\n",
        "    Extension.value = \"mkv\"\n",
        "  elif change[\"type\"] == \"change\" and change[\"new\"] == \"Best Compatibility (M4A)\":\n",
        "    Extension.options = [\"mkv\", \"mp4\", \"webm\"]\n",
        "    Extension.value = \"mkv\"\n",
        "\n",
        "def ShowYT():\n",
        "  clear_output(wait=True)\n",
        "  RefreshPathYT()\n",
        "  display(widgets.HBox([widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Link:</b>\"), Links,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">For website that require an account:</b>\"), UsernameYT, PasswordYT, SecAuth, VideoPW,\n",
        "                                      widgets.HTML(\"<b><a href=\\\"https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements\\\" target=\\\"_blank\\\">GEO Bypass Country:</a></b>\"), GEOBypass,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Proxy:</b>\"), ProxyYT,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Sleep Interval (second):</b>\"), MinSleep, MaxSleep]),\n",
        "                        widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Video Quality:</b>\"), VideoQ, widgets.HTML(\"<b style=\\\"color:#888888;\\\">Resolution:</b>\"), Resolution,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Audio Quality:</b>\"), AudioQ, widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extension:</b>\"), Extension,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extra Options:</b>\"), widgets.HBox([Subtitle, AudioOnly]),\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extra Arguments:</b>\"), ExtraArg])]), HTML(\"<h4 style=\\\"color:#888888;\\\">Save Location:</h4>\"),\n",
        "          SavePathYT, MakeButton(\"Refresh\", RefreshPathYT, \"\"))\n",
        "  if not os.path.exists(\"/content/drive/\"):\n",
        "    display(HTML(\"*If you want to save in Google Drive please run the cell below.\"))\n",
        "  display(HTML(\"<br>\"), MakeButton(\"Download\", DownloadYT, \"info\"))\n",
        "\n",
        "def DownloadYT():\n",
        "  if Links.value.strip():\n",
        "    Count = 0\n",
        "    Total = str(len(Links.value.splitlines()))\n",
        "    # Account Check\n",
        "    if UsernameYT.value.strip() and PasswordYT.value.strip():\n",
        "      accountC = \"--username \\\"\" + UsernameYT.value + \"\\\" --password \\\"\" + PasswordYT.value + \"\\\"\"\n",
        "    else:\n",
        "      accountC = \"\"\n",
        "    if SecAuth.value.strip():\n",
        "      secauthC = \"-2 \" + SecAuth.value\n",
        "    else:\n",
        "      secauthC = \"\"\n",
        "    if VideoPW.value.strip():\n",
        "      videopwC = \"--video-password \" + VideoPW.value\n",
        "    else:\n",
        "      videopwC = \"\"\n",
        "    # Proxy\n",
        "    if ProxyYT.value.strip():\n",
        "      proxyytC = \"--proxy \" + ProxyYT.value\n",
        "    else:\n",
        "      proxyytC = \"\"\n",
        "    # GEO Bypass\n",
        "    if GEOBypass.value == \"Disable\":\n",
        "      geobypass = \"\"\n",
        "    elif GEOBypass.value == \"Hide\":\n",
        "      geobypass = \"--geo-bypass\"\n",
        "    else:\n",
        "      geobypass = \"--geo-bypass-country \" + GEOBypass.value\n",
        "    # Video Quality\n",
        "    if VideoQ.value == \"Best Quality (VP9 upto 4K)\":\n",
        "      videoqC = \"webm\"\n",
        "    else:\n",
        "      videoqC = \"mp4\"\n",
        "    # Audio Quality\n",
        "    if AudioQ.value == \"Best Quality (Opus)\":\n",
        "      audioqC = \"webm\"\n",
        "    else:\n",
        "      audioqC = \"m4a\"\n",
        "    # Audio Only Check\n",
        "    if AudioOnly.value:\n",
        "      subtitleC = \"\"\n",
        "      thumbnailC = \"\"\n",
        "      extC = \"-x --audio-quality 0 --audio-format \" + Extension.value\n",
        "      codecC = \"bestaudio[ext=\" + audioqC + \"]/bestaudio/best\"\n",
        "    else:\n",
        "      if Subtitle.value:\n",
        "        subtitleC = \"--all-subs --convert-subs srt --embed-subs\"\n",
        "      else:\n",
        "        subtitleC = \"\"\n",
        "      if Extension.value == \"mp4\":\n",
        "        thumbnailC = \"--embed-thumbnail\"\n",
        "      else:\n",
        "        thumbnailC = \"\"\n",
        "      extC = \"--merge-output-format \" + Extension.value\n",
        "      if Resolution.value == \"Highest\":\n",
        "        codecC = \"bestvideo[ext=\" + videoqC + \"]+bestaudio[ext=\" + audioqC + \"]/bestvideo+bestaudio/best\"\n",
        "      else:\n",
        "        codecC = \"bestvideo[ext=\" + videoqC + \",height<=\" + Resolution.value.replace(\"4K\", \"2160\").replace(\"p\", \"\") + \"]+bestaudio[ext=\" + audioqC + \"]/bestvideo[height<=\" + Resolution.value.replace(\"4K\", \"2160\").replace(\"p\", \"\") + \"]+bestaudio/bestvideo+bestaudio/best\"\n",
        "    # Archive\n",
        "    if os.path.isfile(\"/root/.youtube-dl.txt\"):\n",
        "      archiveC = \"--download-archive \\\"/root/.youtube-dl.txt\\\"\"\n",
        "    else:\n",
        "      archiveC = \"\"\n",
        "    # Sleep Interval\n",
        "    if MinSleep.value > 0 and MaxSleep.value > 0:\n",
        "      minsleepC = \"--min-sleep-interval \" + MinSleep.value\n",
        "      maxsleepC = \"--max-sleep-interval \" + MaxSleep.value\n",
        "    else:\n",
        "      minsleepC = \"\"\n",
        "      maxsleepC = \"\"\n",
        "    # Extra Arguments\n",
        "    extraargC = ExtraArg.value\n",
        "    for Link in Links.value.splitlines():\n",
        "      clear_output(wait=True)\n",
        "      Count += 1\n",
        "      display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Processing link \" + str(Count) + \" out of \" + Total + \"</h3>\"))\n",
        "      if \"youtube.com\" in Link or \"youtu.be\" in Link:\n",
        "        display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Currently downloading...</h3><br>\"), YouTubeVideo(Link, width=640, height=360), HTML(\"<br>\"))\n",
        "      else:\n",
        "        display(HTML(\"<h3 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Currently downloading <a href=\\\"\" + Link + \"\\\">\" + Link + \"</a></h3><br>\"))\n",
        "      if (\"youtube.com\" in Link or \"youtu.be\" in Link) and \"list=\" in Link:\n",
        "        !youtube-dl -i --no-warnings --yes-playlist --add-metadata $accountC $secauthC $videopwC $minsleepC $maxsleepC $geobypass $proxyytC $extC $thumbnailC $subtitleC $archiveC $extraargC -f \"$codecC\" -o \"/root/.YouTube-DL/%(playlist)s/%(playlist_index)s - %(title)s.%(ext)s\" \"$Link\"\n",
        "      else:\n",
        "        !youtube-dl -i --no-warnings --yes-playlist --add-metadata $accountC $secauthC $videopwC $minsleepC $maxsleepC $geobypass $proxyytC $extC $thumbnailC $subtitleC $archiveC $extraargC -f \"$codecC\" -o \"/root/.YouTube-DL/%(title)s.%(ext)s\" \"$Link\"\n",
        "      if not os.path.exists(SavePathYT.value):\n",
        "        get_ipython().system_raw(\"mkdir -p -m 666 \" + SavePathYT.value)\n",
        "      get_ipython().system_raw(\"mv /root/.YouTube-DL/* '\" + SavePathYT.value + \"/'\")\n",
        "    # Archive Download\n",
        "    if os.path.isfile(\"/root/.youtube-dl.txt\"):\n",
        "      files.download(\"/root/.youtube-dl.txt\")\n",
        "    ShowYT()\n",
        "\n",
        "if not os.path.isfile(\"/usr/local/bin/youtube-dl\"):\n",
        "  get_ipython().system_raw(\"rm -rf /content/sample_data/ && mkdir -p -m 666 /root/.YouTube-DL/ && apt-get install atomicparsley && curl -L https://yt-dl.org/downloads/latest/youtube-dl -o /usr/local/bin/youtube-dl && chmod a+rx /usr/local/bin/youtube-dl\")\n",
        "if Archive:\n",
        "  upload_archive()\n",
        "else:\n",
        "  AudioOnly.observe(AudioOnlyChange)\n",
        "  Subtitle.observe(SubtitleChange)\n",
        "  AudioQ.observe(AudioQChange)\n",
        "  ShowYT()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c3cOMk38t8Zm",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/zip.png' height=\"30\" alt=\"netdata\"> __Extracte/Archive Zip/Tar/Rar__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aK-ly9_92Chr",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Extract Files\n",
        "MODE = \"UNZIP\"  # @param [\"UNZIP\", \"UNTAR\", \"UNRAR\", \"7Z\"]\n",
        "PATH_TO_FILE = \"\"  # @param {type:\"string\"}\n",
        "extractPath = \"\"  # @param {type:\"string\"}\n",
        "ARCHIVE_PASSWORD = \"\" #@param {type:\"string\"}\n",
        "\n",
        "# ================================================================ #\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    checkAvailable,\n",
        ")\n",
        "\n",
        "def extractFiles():\n",
        "    global extractPath\n",
        "    if ARCHIVE_PASSWORD:\n",
        "      passADD = f'-P {ARCHIVE_PASSWORD}'\n",
        "    else:\n",
        "      passADD = ''\n",
        "    if not extractPath:\n",
        "      extractPath = \"/content/extract\"\n",
        "    os.makedirs(extractPath, exist_ok=True)\n",
        "    if MODE == \"UNZIP\":\n",
        "        runSh('unzip '+passADD+f' \"{PATH_TO_FILE}\" -d \"{extractPath}\"', output=True)\n",
        "    elif MODE == \"UNRAR\":\n",
        "        runSh(f'unrar x \"{PATH_TO_FILE}\" \"{extractPath}\" '+passADD+' -o+', output=True)\n",
        "    elif MODE == \"UNTAR\":\n",
        "        runSh(f'tar -C \"{extractPath}\" -xvf \"{PATH_TO_FILE}\"', output=True)\n",
        "    else:\n",
        "        runSh(f'7z x \"{PATH_TO_FILE}\" -o{extractPath} '+passADD, output=True)\n",
        "\n",
        "\n",
        "extractFiles()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OyIeKHClum9J",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Archive Files\n",
        "MODE = \"ZIP\" #@param [\"ZIP\", \"TAR\", \"7Z\"]\n",
        "FILENAME = \"\"  # @param {type:\"string\"}\n",
        "PATH_TO_FILE = \"\"  # @param {type:\"string\"}\n",
        "ARCHIVE_PASSWORD = \"\" #@param {type:\"string\"}\n",
        "\n",
        "# ================================================================ #\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    checkAvailable,\n",
        ")\n",
        "\n",
        "def extractFiles():\n",
        "    global FILENAME\n",
        "    if MODE == \"ZIP\":\n",
        "        if not FILENAME:\n",
        "          FILENAME = \"/content/NEW_FILE.ZIP\"\n",
        "        if ARCHIVE_PASSWORD:\n",
        "          passADD = f'--password \"{ARCHIVE_PASSWORD}\"'\n",
        "        else:\n",
        "          passADD = ''\n",
        "        runSh(f'zip {passADD} -r \"{FILENAME}\" \"{PATH_TO_FILE}\"', output=True)\n",
        "    elif MODE == \"TAR\":\n",
        "        if not FILENAME:\n",
        "          FILENAME = \"NEW_FILE\"\n",
        "        runSh(f'tar -zcvf \"{FILENAME}.tar.gz\" {PATH_TO_FILE}', output=True)\n",
        "    else:\n",
        "        if not FILENAME:\n",
        "            FILENAME = \"NEW_FILE\"\n",
        "        runSh(f'7z a \"{FILENAME}.7z\" {PATH_TO_FILE}', output=True)\n",
        "\n",
        "\n",
        "extractFiles()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7U8mMA7ZBRMl",
        "colab_type": "text"
      },
      "source": [
        "#`sysTools(`<font size=\"3px\" color=\"#05ba02\">`_['>ssh']`</font> , <font size=\"3px\" color=\"#f8f800\">`noVNC`</font> , <font size=\"3px\" color=\"#aaabad\">`IceWM`</font> , <font size=\"3px\" color=\"#00c853\"> `netdata`</font>`)`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "6bkIZt2oYnnQ",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Check VM's Status\n",
        "Check_IP = True \n",
        "Loop_Check = False  #@param {type:\"boolean\"}\n",
        "Loop_Interval = 3600 \n",
        "# ================================================================ #\n",
        "\n",
        "import time, requests\n",
        "from IPython.display import clear_output\n",
        "\n",
        "Loop = True\n",
        "try:\n",
        "    while Loop == True:\n",
        "        clear_output(wait=True)\n",
        "        !top -bcn1 -w512\n",
        "        sessionIP = f\"\\nYour Public IP: {requests.get('http://ip.42.pl/raw').text}:12121\"\n",
        "        if Check_IP: \n",
        "            print(sessionIP)             \n",
        "        print(\"====\")\n",
        "        if Loop_Check == False:\n",
        "            Loop = False\n",
        "        else:\n",
        "            time.sleep(Loop_Interval)\n",
        "except:\n",
        "  clear_output()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "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. Then it'll help you for Rclone cache file storage increase (Recommend for a first run this cell) </i>\n",
        "some_str = ' ' * 5120000000000"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "i5K4z5KBuGEx"
      },
      "source": [
        "## <img src='https://avatars3.githubusercontent.com/u/29124883' height=\"25\" alt=\"iceWM\" /> ___IceWM with noVNC___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "aNswlxgbuGE0",
        "colab": {}
      },
      "source": [
        "#@markdown <br><center><img src='https://avatars3.githubusercontent.com/u/29124883' height=\"200\" alt=\"iceWM\"/></center>\n",
        "#@markdown <center><h3>IceWM window manager</h3></center><br>\n",
        "import os\n",
        "import random\n",
        "import string\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "import time\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True # @param {type:\"boolean\"}\n",
        "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/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    displayUrl,\n",
        "    findProcess,\n",
        "    CWD,\n",
        "    textAn,\n",
        ")\n",
        "\n",
        "# github latest releases tag define\n",
        "def latestTag(link):\n",
        "  import re\n",
        "  from urllib.request import urlopen\n",
        "  htmlF = urlopen(link+\"/releases/latest\").read().decode('UTF-8')\n",
        "  return re.findall(r'.+\\/tag\\/([.0-9A-Za-z]+)\".+/', htmlF)[0]\n",
        "\n",
        "\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs(\"tools/noVnc\", exist_ok=True)\n",
        "\n",
        "# password ganarate\n",
        "try:\n",
        "  print(f\"Found old password! : {password}\")\n",
        "except:\n",
        "  password = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(20))\n",
        "\n",
        "\n",
        "clear_output()\n",
        "if not findProcess(\"Xtightvnc\", \":1\"):\n",
        "  textAn(\"Wait for almost 60 seconds. It's doing for VNC ready ...\")\n",
        "  os.makedirs(f'{HOME}/.vnc', exist_ok=True)\n",
        "  runW.system_raw('apt update -y')\n",
        "  runW.system_raw('apt install -y icewm firefox tightvncserver autocutsel xterm')\n",
        "\n",
        "  runW.system_raw(rf'echo \"{password}\" | vncpasswd -f > ~/.vnc/passwd')\n",
        "  data = \"\"\"\n",
        "#!/bin/bash\n",
        "xrdb $HOME/.Xresources\n",
        "xsetroot -solid black -cursor_name left_ptr\n",
        "autocutsel -fork\n",
        "icewm-session &\n",
        "\"\"\"\n",
        "  with open(f'{HOME}/.vnc/xstartup', 'w+') as wNow:\n",
        "    wNow.write(data)\n",
        "  os.chmod(f'{HOME}/.vnc/xstartup', 0o755)\n",
        "  os.chmod(f'{HOME}/.vnc/passwd', 0o400)\n",
        "  \n",
        "  runSh('sudo vncserver :1 -geometry 1440x870 -economictranslate -dontdisconnect &', \n",
        "        shell=True)\n",
        "\n",
        "  BASE_URL = \"https://github.com/geek1011/easy-novnc\"\n",
        "  LATEST_TAG = latestTag(BASE_URL)\n",
        "  output_file = \"tools/noVnc/easy-noVnc_linux-64bit\"\n",
        "  file_name = f\"easy-novnc_linux-64bit\"\n",
        "  urlF = f\"{BASE_URL}/releases/download/{LATEST_TAG}/{file_name}\"\n",
        "  try:\n",
        "    urllib.request.urlretrieve(urlF, output_file)\n",
        "  except OSError:\n",
        "    pass\n",
        "  os.chmod(output_file, 0o755)\n",
        "\n",
        "if not findProcess(\"easy-noVnc_linux-64bit\", '--addr \"0.0.0.0:6080\"'):\n",
        "  cmdDo = \"./easy-noVnc_linux-64bit --addr 0.0.0.0:6080 --port 5901\" \\\n",
        "    \" &\"\n",
        "  runSh(cmdDo, \n",
        "        cd=\"tools/noVnc/\",\n",
        "        shell=True)\n",
        "\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['vnc', 6080, 'http']], 'in', \n",
        "               [f\"{HOME}/.ngrok2/noVncFast.yml\", 4455])\n",
        "\n",
        "data = Server.start('vnc', displayB=False)\n",
        "# clear_output()\n",
        "displayUrl(data, pNamU='noVnc : ',\n",
        "            EcUrl=f'/vnc.html?autoconnect=true&password={password}&path=vnc&resize=scale&reconnect=true&show_dot=true')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4rMlpsk3jv5r",
        "colab_type": "text"
      },
      "source": [
        "## <img src='http://icons.iconarchive.com/icons/blackvariant/button-ui-system-apps/1024/Terminal-icon.png' height=\"25\" alt=\"ssh\" />___SSH and noVNC___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E4mhEMnmj5-s",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to create ssh tunnel</h3>\n",
        "#@markdown <br><center><img src='http://icons.iconarchive.com/icons/blackvariant/button-ui-system-apps/1024/Terminal-icon.png' height=\"200\" alt=\"ssh\"/></center>\n",
        "#@markdown <center><h3>Forward ssh now</h3></center><br>\n",
        "import os\n",
        "import random\n",
        "import string\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "import time\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = False\n",
        "CREATE_VNC = True # @param {type:\"boolean\"}\n",
        "CREATE_SSH = True # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "runW = get_ipython()\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    displayUrl,\n",
        "    findProcess,\n",
        "    CWD,\n",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn()\n",
        "\n",
        "# password ganarate\n",
        "try:\n",
        "  print(f\"Found old password! : {password}\")\n",
        "except:\n",
        "  password = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(20))\n",
        "\n",
        "if CREATE_SSH:\n",
        "  USE_FREE_TOKEN = False\n",
        "\n",
        "#Set root password\n",
        "if CREATE_SSH  and os.path.exists('/var/run/sshd') == False:\n",
        "  #Setup sshd\n",
        "  runSh('apt install -qq -o=Dpkg::Use-Pty=0 openssh-server pwgen')\n",
        "  runW.system_raw(\"echo root:$password | chpasswd\")\n",
        "  os.makedirs(\"/var/run/sshd\", exist_ok=True)\n",
        "  runW.system_raw('echo \"PermitRootLogin yes\" >> /etc/ssh/sshd_config')\n",
        "  runW.system_raw('echo \"PasswordAuthentication yes\" >> /etc/ssh/sshd_config')\n",
        "  runW.system_raw('echo \"LD_LIBRARY_PATH=/usr/lib64-nvidia\" >> /root/.bashrc')\n",
        "  runW.system_raw('echo \"export LD_LIBRARY_PATH\" >> /root/.bashrc')\n",
        "\n",
        "  #Run sshd\n",
        "  if not findProcess(\"/usr/sbin/sshd\", command=\"-D\"):\n",
        "    runSh('/usr/sbin/sshd -D &', shell=True)\n",
        "\n",
        "if CREATE_VNC:\n",
        "  clear_output()\n",
        "  #start = time.time()\n",
        "  textAn(\"Wait for almost 2 minutes. It's doing for VNC ready...\")\n",
        "  os.makedirs(f'{HOME}/.vnc', exist_ok=True)\n",
        "  runW.system_raw('add-apt-repository -y ppa:apt-fast/stable < /dev/null')\n",
        "  runW.system_raw('echo debconf apt-fast/maxdownloads string 16 | debconf-set-selections')\n",
        "  runW.system_raw('echo debconf apt-fast/dlflag boolean true | debconf-set-selections')\n",
        "  runW.system_raw('echo debconf apt-fast/aptmanager string apt-get | debconf-set-selections')\n",
        "  runW.system_raw('apt install -y apt-fast')\n",
        "  runW.system_raw('apt-fast install -y xfce4 xfce4-goodies firefox tightvncserver autocutsel')\n",
        "  runW.system_raw(rf'echo \"{password}\" | vncpasswd -f > ~/.vnc/passwd')\n",
        "  data = \"\"\"\n",
        "#!/bin/bash\n",
        "xrdb $HOME/.Xresources\n",
        "autocutsel -fork\n",
        "startxfce4 &\n",
        "\"\"\"\n",
        "  with open(f'{HOME}/.vnc/xstartup', 'w+') as wNow:\n",
        "    wNow.write(data)\n",
        "  os.chmod(f'{HOME}/.vnc/xstartup', 0o755)\n",
        "  os.chmod(f'{HOME}/.vnc/passwd', 0o400)\n",
        "  runSh('sudo vncserver &', shell=True)\n",
        "  runSh(f'git clone https://github.com/novnc/noVNC.git {CWD}/noVNC')\n",
        "  runSh(\"bash noVNC/utils/launch.sh --listen 6080 --vnc localhost:5901 &\",\n",
        "        shell=True)\n",
        "  #end = time.time()\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['ssh', 22, 'tcp'], \n",
        "               ['vnc', 6080, 'http']], 'in', \n",
        "               [f\"{HOME}/.ngrok2/sshVnc.yml\", 4455])\n",
        "data = Server.start('ssh', displayB=False)\n",
        "\n",
        "# output\n",
        "Host,port = data['url'][7:].split(':')\n",
        "data2 = Server.start('vnc', displayB=False)\n",
        "clear_output()\n",
        "if CREATE_VNC:\n",
        "  displayUrl(data2, pNamU='noVnc : ',\n",
        "            EcUrl=f'/vnc.html?autoconnect=true&password={password}')\n",
        "if CREATE_SSH:\n",
        "  display(HTML(\"\"\"<style>@import url('https://fonts.googleapis.com/css?family=Source+Code+Pro:200,900');  :root {   --text-color: hsla(210, 50%, 85%, 1);   --shadow-color: hsla(210, 40%, 52%, .4);   --btn-color: hsl(210, 80%, 42%);   --bg-color: #141218; }  * {   box-sizing: border-box; } button { position:relative; padding: 10px 20px;     border: none;   background: none;      font-family: \"Source Code Pro\";   font-weight: 900;font-size: 100%;     color: var(--text-color);      background-color: var(--btn-color);   box-shadow: var(--shadow-color) 2px 2px 22px;   border-radius: 4px;    z-index: 0;overflow: hidden; -webkit-user-select: text;-moz-user-select: text;-ms-user-select: text;user-select: text;}  button:focus {   outline-color: transparent;   box-shadow: var(--btn-color) 2px 2px 22px; }  .right::after, button::after {   content: var(--content);   display: block;   position: absolute;   white-space: nowrap;   padding: 40px 40px;   pointer-events:none; }  button::after{   font-weight: 200;   top: -30px;   left: -20px; }   .right, .left {   position: absolute;   width: 100%;   height: 100%;   top: 0; } .right {   left: 66%; } .left {   right: 66%; } .right::after {   top: -30px;   left: calc(-66% - 20px);      background-color: var(--bg-color);   color:transparent;   transition: transform .4s ease-out;   transform: translate(0, -90%) rotate(0deg) }  button:hover .right::after {   transform: translate(0, -47%) rotate(0deg) }  button .right:hover::after {   transform: translate(0, -50%) rotate(-7deg) }  button .left:hover ~ .right::after {   transform: translate(0, -50%) rotate(7deg) }  /* bubbles */ button::before {   content: '';   pointer-events: none;   opacity: .6;   background:     radial-gradient(circle at 20% 35%,  transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 75% 44%, transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 46% 52%, transparent 0, transparent 4px, var(--text-color) 5px, var(--text-color) 6px, transparent 6px);    width: 100%;   height: 300%;   top: 0;   left: 0;   position: absolute;   animation: bubbles 5s linear infinite both; }  @keyframes bubbles {   from {     transform: translate();   }   to {     transform: translate(0, -66.666%);   } }.zui-table {    border: solid 1px #DDEEEE;    border-collapse: collapse;    border-spacing: 0;    font: normal 13px;}.zui-table thead th {    background-color: #DDEFEF;    border: solid 1px #DDEEEE;    color: #0000009e;    padding: 10px;    text-align: left;}.zui-table tbody td {border: solid 1px #effff97a;color: #ffffffd1;    padding: 10px;}</style><center><button><table class=\"zui-table blueBG\"><p>Ssh config<p><thead>        <tr>        <th>Host</th>            <th>Port</th>        <th>Password</th> </tr>    </thead>    <tbody>        <tr><td>\"\"\"+Host+\"\"\"</td><td>\"\"\"+port+\"\"\"</td><td>\"\"\"+password+\"\"\"</td></tr></tbody></table><center><br><table class=\"zui-table blueBG\"><thead>        <tr> <th></th>       <th>Simple ssh command</th></tr>    </thead>    <tbody>        <tr><td>Terminal connect</td><td>ssh root@\"\"\"+Host+\"\"\" -p \"\"\"+port+\"\"\"</td></tr><tr><td>Socks5 proxy</td><td>ssh -D 8282 -q -C -N root@\"\"\"+Host+\"\"\" -p \"\"\"+port+\"\"\"</td></tr></tbody></table></center><a target=\"_blank\" style=\"text-decoration: none;color: hsla(210, 50%, 85%, 1);font-size: 10px;\" href=\"http://bit.ly/2RDhV0c\">NB. How to setup this's config. [Click ME]</a></button><center>\"\"\"))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FVvFaJrZ0bxg",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://szyha.github.io/RcloneLabArchive/img/title_netdata.png' height=\"45\" alt=\"netdata\"/>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H0Q1ERYX0Vrb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <br><center><img src='https://szyha.github.io/RcloneLabArchive/img/title_netdata.png' height=\"100\" alt=\"netdata\"/></center>\n",
        "#@markdown <center><h3>Real-time Server Monitoring</h3></center><br>\n",
        "# ============================= FORM ============================= #\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "# ============================= FORM ============================= #\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil, subprocess, shlex\n",
        "from IPython.display import HTML, clear_output\n",
        "import time\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    shellCmd = \"wget -qq https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\" \\\n",
        "                f\" -O {HOME}/.ipython/ttmg.py\"\n",
        "    subprocess.run(shlex.split(shellCmd))\n",
        "\n",
        "from ttmg import (\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    runSh,\n",
        "    textAn\n",
        ")\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "\n",
        "def Start_ServerMT():\n",
        "  if CheckProcess(\"netdata\", \"\") != True:\n",
        "    runSh('/usr/sbin/netdata', shell=True)\n",
        "\n",
        "loadingAn()      \n",
        "\n",
        "if not os.path.isfile(\"/usr/sbin/netdata\"):\n",
        "  clear_output(wait=True)\n",
        "  textAn(\"[Installing] Wait for almost 2 minutes...\")\n",
        "  #start = time.time()\n",
        "  get_ipython().system_raw(\"bash <(curl -Ss https://my-netdata.io/kickstart.sh) --dont-wait --dont-start-it\")\n",
        "  #end = time.time()\n",
        "  clear_output(wait=True)\n",
        "Start_ServerMT()\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['netdata', 19999, 'http'], \n",
        "                            ['cloudcmd', 7007, 'http']], 'au', \n",
        "    [f\"{HOME}/.ngrok2/netdataCloudcmd.yml\", 7044]\n",
        ").start('netdata', 'g')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qtAvLGCMBx1L",
        "colab_type": "text"
      },
      "source": [
        "#`fileManager(`<font size=\"3px\" color=\"#2876f8\">`filebrowser`</font> , <font size=\"3px\" color=\"#41afe6\">`cloudCommander`</font>`)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gz_8S4IOni_1",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://blobscdn.gitbook.com/v0/b/gitbook-28427.appspot.com/o/spaces%2F-LV-MXWFGfo4YU_ahhaj%2Favatar.png?generation=1546194591038935&alt=media' height=\"25\" alt=\"filebrowser\" /> ___filebrowser___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oieqNETPNVny",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://blobscdn.gitbook.com/v0/b/gitbook-28427.appspot.com/o/spaces%2F-LV-MXWFGfo4YU_ahhaj%2Favatar.png?generation=1546194591038935&alt=media' height=\"200\" alt=\"filebrowser\"/></center>\n",
        "#@markdown <center><h3>filebrowser<br />📂 Web File Browser which can be used as a middleware or standalone app</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "# OUTPUT_DIR = \"\"  # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs('tools/filebrowser/', exist_ok=True)\n",
        "\n",
        "get_ipython().system_raw(r\"curl -fsSL https://filebrowser.xyz/get.sh | bash\")\n",
        "if not findProcess(\"filebrowser\", \"--noauth\"):\n",
        "  runSh(\"filebrowser --noauth -r /content/ -p 4000 -d tools/filebrowser/filebrowser.db &\", shell=True)\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['rclone', 5572, 'http'],\n",
        "                            ['filebrowser', 4000, 'http']], 'ap', \n",
        "    [f\"{HOME}/.ngrok2/filebrowserRclone.yml\", 4099]\n",
        ").start('filebrowser')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "INCWjTDRLye6",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_cloud_commander.png' height=\"45\" alt=\"cloudCommander\"/>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SX9z-_6PLpb8",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3>⬅️ Install Cloud Commander (file manager)</h3>\n",
        "#@markdown <br><center><img src='https://biplobsd.github.io/RLabClone/img/title_cloud_commander.png' height=\"60\" alt=\"netdata\"/></center>\n",
        "# ================================================================ #\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "import os, psutil, time, urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        ")\n",
        "\n",
        "loadingAn()\n",
        "if os.path.isfile(\"/tools/node/bin/cloudcmd\") == False:\n",
        "  get_ipython().system_raw(\"npm cache clean -f && npm install -g n && n stable && npm i cloudcmd -g --force\")\n",
        "\n",
        "try:\n",
        "  urllib.request.urlopen('http://localhost:7007')\n",
        "except urllib.error.URLError:\n",
        "  !nohup cloudcmd --online --no-auth --show-config --show-file-name \\\n",
        "        --editor 'deepword' --packer 'tar' --port 7007 \\\n",
        "        --no-confirm-copy --confirm-move --name 'File Manager' \\\n",
        "        --keys-panel --no-contact --console --sync-console-path \\\n",
        "        --no-terminal --no-vim --columns 'name-size-date' --no-log &\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['netdata', 19999, 'http'], \n",
        "                            ['cloudcmd', 7007, 'http']], 'au', \n",
        "    [f\"{HOME}/.ngrok2/netdataCloudcmd.yml\", 7044]\n",
        ").start('cloudcmd')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fhhDx-Svhrp3"
      },
      "source": [
        "#`programming(`<font size=\"3px\" color=\"#2876f8\">`code-server(VScode)`</font>`)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "HsvEZZy0hrp6"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/cdr/code-server/master/src/browser/media/pwa-icon-96.png' height=\"25\" alt=\"filebrowser\" /> ___code-server___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "DK114refhrp6",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://github.com/cdr/code-server/blob/master/src/browser/media/pwa-icon-512.png?raw=true' height=\"200\" alt=\"code-server\"/></center>\n",
        "#@markdown <center><h3>code-server<br />code-server is VS Code running on a remote server, accessible through the browser.</h3></center><br>\n",
        "import os, pathlib, zipfile, re, tarfile, shutil\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "INSTALL_EXTENSION = \"ms-python.python ritwickdey.LiveServer ms-vscode.cpptools\"  # @param {type:\"string\"}\n",
        "USER_DATA_DIR = \"/content/tools/code-server/userdata\" # @param {type:\"string\"}\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess,\n",
        "    displayUrl\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs('tools/code-server/', exist_ok=True)\n",
        "os.makedirs('tools/temp', exist_ok=True)\n",
        "\n",
        "# github latest releases tag define\n",
        "def latestTag(link):\n",
        "  import re\n",
        "  from urllib.request import urlopen\n",
        "  htmlF = urlopen(link+\"/releases/latest\").read().decode('UTF-8')\n",
        "  return re.findall(r'.+\\/tag\\/([.0-9A-Za-z]+)\".+/', htmlF)[0]\n",
        "\n",
        "\n",
        "\n",
        "# Downloading latest version of code-server\n",
        "if not os.path.exists(\"tools/code-server/code-server\"):\n",
        "  os.system(\"sudo apt install net-tools -y\")\n",
        "\n",
        "  BASE_URL = r\"https://github.com/cdr/code-server/\"\n",
        "  LATEST_TAG = latestTag(BASE_URL)\n",
        "  output_file = \"tools/temp/code-server.tar.gz\"\n",
        "  file_name = f\"code-server-{LATEST_TAG}-linux-x86_64.tar.gz\"\n",
        "  urlF = f\"{BASE_URL}/releases/download/{LATEST_TAG}/{file_name}\"\n",
        "  urllib.request.urlretrieve(urlF, output_file)\n",
        "  \n",
        "  with tarfile.open(output_file, 'r:gz') as tar_ref:\n",
        "      tar_ref.extractall('tools/temp/')\n",
        "  os.renames(\"tools/temp/\"+file_name[:-7], 'tools/code-server/')\n",
        "  try:\n",
        "    pathlib.Path(output_file).unlink()\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "  \n",
        "  if INSTALL_EXTENSION:\n",
        "    perExtension = INSTALL_EXTENSION.split(' ')\n",
        "    for l in perExtension:\n",
        "      cmdE = \"./code-server \" \\\n",
        "      f\"--user-data-dir {USER_DATA_DIR}\" \\\n",
        "      f\" --install-extension {l}\"\n",
        "      runSh(cmdE, cd=\"tools/code-server/\", shell=True)\n",
        "\n",
        "\n",
        "if not findProcess(\"node\", \"--extensions-dir\"):\n",
        "  cmdDo = \"./code-server --auth none --disable-updates --disable-ssh \" \\\n",
        "    f\" --port 5050 --user-data-dir {USER_DATA_DIR}\" \\\n",
        "    \" &\"\n",
        "  runSh(cmdDo, \n",
        "        cd=\"tools/code-server/\",\n",
        "        shell=True)\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['code-server', 5050, 'http']], 'in', \n",
        "    [f\"{HOME}/.ngrok2/code-server.yml\", 30499]\n",
        ").start('code-server', displayB=False)\n",
        "displayUrl(server, EcUrl=\"/?folder=/content/\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "z434OhiBZ2ZZ",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h3>Port forward (NGROK)</h3></center>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True \n",
        "TOKEN = \"\" \n",
        "PORT_LIST = \"80, 8080, 4040\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown <font size=2px>Input PORT which you can want to forward. Separate two PORT between by comma. <br>Ex `80, 8080, 4040`</font>\n",
        "REGION = \"US\" #@param [\"US\", \"EU\", \"AP\", \"AU\", \"SA\", \"JP\", \"IN\"]\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess,\n",
        "    displayUrl,\n",
        "    textAn\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs('tools/', exist_ok=True)\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "m = []\n",
        "splitPortList = PORT_LIST.split(',')\n",
        "for p in splitPortList:\n",
        "  p = int(p)\n",
        "  m.append([f\"s{p}\", p, 'http'])\n",
        "\n",
        "\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, m, REGION.lower(), \n",
        "    [f\"{HOME}/.ngrok2/randomPortOpen.yml\", 45535]\n",
        ")\n",
        "\n",
        "for l in m:\n",
        "  displayUrl(Server.start(l[0], displayB=False, v=False), \n",
        "             pNamU=f\"{l[0][1:]} -> \", cls=False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Z1YQc9zZ45wW"
      },
      "source": [
        "#`pentester(`<font size=\"3px\" color=\"#06989a\">`SocialFish`</font> , <font size=\"3px\" color=\"#6279e3\">`L3MON`</font> , <font size=\"3px\" color=\"#0dd10d\">`SayCheese`</font>`)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yL1BRPGVwfbt",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/UndeadSec/SocialFishMobile/master/content/logo.png' height=\"30\" alt=\"SocialFish\" /> SocialFish"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qPQcUGetoHU9",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <br><center><img src='https://raw.githubusercontent.com/UndeadSec/SocialFishMobile/master/content/logo.png' height=\"100\" alt=\"SocialFish\"/></center>\n",
        "#@markdown <center><h3>SocialFish<br />Educational Phishing Tool & Information Collector</h3></center><br>\n",
        "import os, pathlib, zipfile, re\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "USERNAME = \"\"  # @param {type:\"string\"}\n",
        "PASSWORD = \"\"  # @param {type:\"string\"}\n",
        "#@markdown Default <br>&emsp;username : admin<br>&emsp;password : admin\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess,\n",
        "    displayUrl,\n",
        "    textAn\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs('tools/', exist_ok=True)\n",
        "\n",
        "# Downloading SocialFish\n",
        "if not os.path.exists(\"tools/SocialFish/SocialFish.py\"):\n",
        "  clear_output()\n",
        "  textAn(\"[Installing] Wait for almost 1 minutes...\")\n",
        "  # runSh('apt install -y texlive-latex-extra')\n",
        "  runSh('git clone https://github.com/biplobsd/SocialFish.git', cd='tools/')\n",
        "  runSh('pip install -r requirements.txt', cd='tools/SocialFish')\n",
        "  os.chmod(\"tools/SocialFish/SocialFish.py\", 0o755)\n",
        "\n",
        "if not findProcess(\"python3\", \"./SocialFish.py\"):\n",
        "  runCmd = \"./SocialFish.py \" \\\n",
        "    f\"{USERNAME if USERNAME else 'admin'} \" \\\n",
        "    f\"{PASSWORD if PASSWORD else 'admin'} &\"\n",
        "  runSh(runCmd, shell=True, cd='tools/SocialFish/')\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['SocialFish', 5000, 'http']], 'us', \n",
        "    [f\"{HOME}/.ngrok2/SocialFish.yml\", 4063]\n",
        ").start('SocialFish', displayB=False)\n",
        "\n",
        "displayUrl(Server, pNamU='SocialFish : ', \n",
        "           EcUrl=\"/neptune\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1EP1o4UDLS6f",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://github.com/D3VL/L3MON/raw/master/server/assets/webpublic/logo.png' height=\"45\" alt=\"L3MON\" /><font size=1px>___DEMO___</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lgzzseqdMSTA",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <br><center><img src='https://github.com/D3VL/L3MON/raw/master/server/assets/webpublic/logo.png' height=\"100\" alt=\"L3MON\"/></center>\n",
        "#@markdown <center><h3>L3MON<br /> Remote Android Managment Suite</h3></center><br>\n",
        "import os, pathlib, zipfile, re, json, hashlib, time\n",
        "import urllib.request\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = True  # @param {type:\"boolean\"}\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "USERNAME = \"\"  # @param {type:\"string\"}\n",
        "PASSWORD = \"\"  # @param {type:\"string\"}\n",
        "RUN_Dir = \"/content/tools/L3MON\"  # @param {type:\"string\"}\n",
        "#@markdown Default <br>&emsp;username : admin<br>&emsp;password : admin\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess,\n",
        "    displayUrl,\n",
        "    textAn\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "if not RUN_Dir:\n",
        "  RUN_Dir = \"tools/L3MON\"\n",
        "os.makedirs(RUN_Dir, exist_ok=True)\n",
        "\n",
        "\n",
        "def md5(txt):\n",
        "  return hashlib.md5(txt.encode('utf-8')).hexdigest()\n",
        "\n",
        "# github latest releases tag define\n",
        "def latestTag(link):\n",
        "  import re\n",
        "  from urllib.request import urlopen\n",
        "  htmlF = urlopen(link+\"/releases/latest\").read().decode('UTF-8')\n",
        "  return re.findall(r'.+\\/tag\\/([.0-9A-Za-z]+)\".+/', htmlF)[0]\n",
        "\n",
        "# Downloading latest version of L3MON\n",
        "if not os.path.exists(f\"{RUN_Dir}/index.js\"):\n",
        "  BASE_URL = r\"https://github.com/D3VL/L3MON\"\n",
        "  LATEST_TAG = latestTag(BASE_URL)\n",
        "  urlF = f'{BASE_URL}/releases/download/{LATEST_TAG}/' \\\n",
        "              f'L3MON-v{LATEST_TAG}.zip'\n",
        "  urllib.request.urlretrieve(urlF, f'{RUN_Dir}/newL3MON.zip')\n",
        "  with zipfile.ZipFile(f'{RUN_Dir}/newL3MON.zip', 'r') as zip_ref:\n",
        "      zip_ref.extractall(RUN_Dir)\n",
        "  try:\n",
        "    pathlib.Path(f'{RUN_Dir}/newL3MON.zip').unlink()\n",
        "  except FileNotFoundError:\n",
        "    pass\n",
        "\n",
        "  # Installing L3MON\n",
        "  runSh('npm install pm2 -g')\n",
        "\n",
        "  # Uninstalling latest java\n",
        "  runSh('apt purge openjdk-\\* icedtea-\\* icedtea6-\\*')\n",
        "  # Install version 8\n",
        "  runSh('apt install openjdk-8-jre')\n",
        "\n",
        "  runSh('npm install', cd=RUN_Dir)\n",
        "  runSh('pm2 start index.js', cd=RUN_Dir)\n",
        "  time.sleep(2)\n",
        "  runSh('pm2 stop index.js', cd=RUN_Dir)\n",
        "  with open(f'{RUN_Dir}/maindb.json', 'r+') as f:\n",
        "      data = json.load(f)\n",
        "      if USERNAME:\n",
        "        data['admin']['username'] = USERNAME\n",
        "      if PASSWORD:\n",
        "        data['admin']['password'] = md5(PASSWORD)\n",
        "      else:\n",
        "        data['admin']['password'] = md5('admin')\n",
        "      f.seek(0)        \n",
        "      json.dump(data, f, indent=4)\n",
        "      f.truncate()\n",
        "\n",
        "if not findProcess('node' f'{RUN_Dir}/index.js'):\n",
        "  runSh('pm2 restart all', shell=True, cd=RUN_Dir)\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\" #@param [\"ngrok\", \"localhost\"]\n",
        "Server = PortForward_wrapper(\n",
        "    PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['L3MON', 22533, 'http'], \n",
        "                            ['L3MON_Client', 22222, 'http']], 'ap', \n",
        "    [f\"{HOME}/.ngrok2/L3MON.yml\", 4051]\n",
        ")\n",
        "data = Server.start('L3MON')\n",
        "data2 = Server.start('L3MON_Client', displayB=False, v=False)\n",
        "Host, port = data2['url'][7:], '80'\n",
        "\n",
        "display(HTML(\"\"\"<style>@import url('https://fonts.googleapis.com/css?family=Source+Code+Pro:200,900');  :root {   --text-color: hsla(210, 50%, 85%, 1);   --shadow-color: hsla(210, 40%, 52%, .4);   --btn-color: hsl(210, 80%, 42%);   --bg-color: #141218; }  * {   box-sizing: border-box; } button { position:relative; padding: 10px 20px;     border: none;   background: none;      font-family: \"Source Code Pro\";   font-weight: 900;font-size: 20px;     color: var(--text-color);      background-color: var(--btn-color);   box-shadow: var(--shadow-color) 2px 2px 22px;   border-radius: 4px;    z-index: 0;overflow: hidden; -webkit-user-select: text;-moz-user-select: text;-ms-user-select: text;user-select: text;}  button:focus {   outline-color: transparent;   box-shadow: var(--btn-color) 2px 2px 22px; }  .right::after, button::after {   content: var(--content);   display: block;   position: absolute;   white-space: nowrap;   padding: 40px 40px;   pointer-events:none; }  button::after{   font-weight: 200;   top: -30px;   left: -20px; }   .right, .left {   position: absolute;   width: 100%;   height: 100%;   top: 0; } .right {   left: 66%; } .left {   right: 66%; } .right::after {   top: -30px;   left: calc(-66% - 20px);      background-color: var(--bg-color);   color:transparent;   transition: transform .4s ease-out;   transform: translate(0, -90%) rotate(0deg) }  button:hover .right::after {   transform: translate(0, -47%) rotate(0deg) }  button .right:hover::after {   transform: translate(0, -50%) rotate(-7deg) }  button .left:hover ~ .right::after {   transform: translate(0, -50%) rotate(7deg) }  /* bubbles */ button::before {   content: '';   pointer-events: none;   opacity: .6;   background:     radial-gradient(circle at 20% 35%,  transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 75% 44%, transparent 0,  transparent 2px, var(--text-color) 3px, var(--text-color) 4px, transparent 4px),     radial-gradient(circle at 46% 52%, transparent 0, transparent 4px, var(--text-color) 5px, var(--text-color) 6px, transparent 6px);    width: 100%;   height: 300%;   top: 0;   left: 0;   position: absolute;   animation: bubbles 5s linear infinite both; }  @keyframes bubbles {   from {     transform: translate();   }   to {     transform: translate(0, -66.666%);   } }.zui-table {    border: solid 1px #DDEEEE;    border-collapse: collapse;    border-spacing: 0;    font: normal 13px;}.zui-table thead th {    background-color: #DDEFEF;    border: solid 1px #DDEEEE;    color: #0000009e;    padding: 10px;    text-align: left;}.zui-table tbody td {border: solid 1px #effff97a;color: #ffffffd1;    padding: 10px;}</style><center><button><table class=\"zui-table blueBG\"><p>Listening address<p><thead>        <tr>        <th>Host</th>            <th>Port</th> </tr>    </thead>    <tbody>        <tr><td>\"\"\"+Host+\"\"\"</td><td>\"\"\"+port+\"\"\"</td></tr></tbody></table><a target=\"_blank\" style=\"text-decoration: none;color: hsla(210, 50%, 85%, 1);font-size: 10px;\" href=\"http://bit.ly/3agnZDu\">NB. How to setup this's config. [Click ME]</a></button><center>\"\"\"))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bOOBrzjbEGo_",
        "colab_type": "text"
      },
      "source": [
        "## ___SayCheese v1.0___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U8-zrqX8EEah",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h3><h2>SayCheese v1.0</h2>Remote Android Managment Suite</h3></center><br>\n",
        "import os, urllib.request\n",
        "from IPython.display import clear_output\n",
        "\n",
        "Version = '1.3.0'\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/tofuliang/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    updateCheck,\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "RUN_Dir = \"tools/\"\n",
        "os.makedirs(RUN_Dir, exist_ok=True)\n",
        "\n",
        "# Downloading saycheese\n",
        "if not os.path.exists(f'{RUN_Dir}/saycheese/saycheese.sh'):\n",
        "  runSh('apt update')\n",
        "  runSh('apt install -y php')\n",
        "  runSh('git clone https://github.com/thelinuxchoice/saycheese.git',\n",
        "        cd=RUN_Dir)\n",
        "clear_output()\n",
        "print('')\n",
        "!cd tools/saycheese && bash saycheese.sh"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6EGHwznNv05g",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown #### Download output File\n",
        "makeArchive = True #@param {type:\"boolean\"}\n",
        "makeVideo = False #@param {type:\"boolean\"}\n",
        "from google.colab import files\n",
        "\n",
        "def downloadFile():\n",
        "  try:\n",
        "    if makeVideo:\n",
        "      !cd tools/saycheese && ffmpeg -y -r 1 -pattern_type glob -i 'cam*.png' -c:v libx264 out.mp4\n",
        "      files.download('tools/saycheese/out.mp4')\n",
        "    if makeArchive:\n",
        "      !cd tools/saycheese && zip -9 -r save.zip cam*.png out.mp4 saved.ip.txt\n",
        "      files.download('tools/saycheese/save.zip')\n",
        "  except FileNotFoundError:\n",
        "    print(\"File not found!\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "  downloadFile()\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}