All_in_One_2_0_7.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "All_in_One_2_0_6.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "Cqy3vXXOMI06",
        "zRTgBdCpBWMh",
        "cOUZEXihsqCD",
        "bNAroQWy6hL3",
        "wZMZjX127rmx",
        "Ov6PHWiF4QuO",
        "ercDPZ6CIlVz",
        "SZBgJu8E-W7M",
        "4E-uzYrv5o0B",
        "Q_wvtTnLaCA_",
        "3btCxs20aJ8E",
        "NkFQ5VDxpteH",
        "JnIOQZ2I-aDT",
        "StT2bKf2WmKj",
        "Ttv0CeCqLX0t",
        "AGVmJ2Y43o_C",
        "LPEhexXnE4EF",
        "7dTNq8TFD6a-",
        "fE-iFnR538-O",
        "PE5J1UDzQXSp",
        "SoxLe8ciEyAc",
        "bZYwgcAq8Yr_",
        "A0y8bdJSpbmD",
        "WanlireZOjvx",
        "WMWJ2mDPBoEx",
        "-hMkAxkD3F_i",
        "Dci4OK_X3kS_",
        "rGgDHPbtYJBg",
        "JXsqLabj3uhU",
        "POtlxClK3sFC",
        "FTzmh4qB4EIQ",
        "oLAlYZqk3xSL",
        "aknJQM1dqDqk",
        "u1qvPjlc3z5i",
        "cHTe9qp2E6f5",
        "7wez354M4ZeV",
        "H0rhgZhIDyPu",
        "lvhndnrYZpx-",
        "kSvUMUuTPX7r",
        "dySANcIIMdFU",
        "ex_k738n2mO3",
        "zajDdD9kKNw9",
        "c3cOMk38t8Zm",
        "nnK31oX-jC5p",
        "eplOxOmrjC7R",
        "boIJhB5zjC76",
        "NKQKbbO5jC8f",
        "ukxnQC4c0nuR",
        "EFOqhHG6hOVH",
        "RDHuIkoi6l9a",
        "NQ0TxfKeghR8",
        "FpJXJiRl6-gK",
        "2f-THZmDoOaY",
        "MSUasbRUDP3B",
        "dHsPVmB0Ot4F",
        "yakbThfRnJr1",
        "ey6-UveDalxR",
        "Sj3Yk9nuAH6J",
        "SNDGdMRn3PA-",
        "KFcIThDuBii_",
        "8qgQqQyD3kvv",
        "Fj7AI-wW9KKU",
        "GahMjYf8miNs",
        "NqB2mnt78bxA",
        "-4LLBs7U06a5",
        "7-3O4en4C4IL",
        "Ja95mvvq8oei",
        "-ybk7sETcjF8",
        "t5WlZQzIB4z2",
        "ZRtpK-cvCONa",
        "GBLpYMn_o-RN",
        "XcXnvXYB2pq_",
        "FVvFaJrZ0bxg",
        "R3GKSyko4gNT",
        "gz_8S4IOni_1",
        "wEqlN9_o4kkm",
        "oMvrMlGa4m4L",
        "faiHqIzq4pRM",
        "0xI8WiUPji3k",
        "HsvEZZy0hrp6",
        "znqEQoWfTjGx",
        "l5effYOqoxEc",
        "QlsUJhNwyeV3",
        "9-av0-3J7gfF",
        "dJcI3M0oD5bJ",
        "zwnehE_ln7A4",
        "cau5CTZPUu-n",
        "SdrIv5gpjTfw",
        "STq65Y8NlBSX",
        "XxaUO8fPKz-w",
        "eAbATGsb5fwf",
        "53E8ZNYZxvjL",
        "BHgi3YnTgXzX",
        "IK9lYTykdbtt",
        "kHsXa3yKXiFH",
        "ZjPqTBNoohK9",
        "_gjQ6LbYiP9j",
        "0cKdTCuv4tXh",
        "JuVn21kt40Gw",
        "hqwOlJG4MdLC",
        "tUNVcbujhm00",
        "WTuyUxgdLA13",
        "avAcSL_uvtq_",
        "yHR91DXFmxaw",
        "SNNyVy6KzowY",
        "cdO_RxQZLahB",
        "EaMj6XDu-C8r",
        "uCEixJujApc8",
        "mF1QME7YBwvo",
        "m5jM8gHbzWUW",
        "kFQ2LUeT4TS4",
        "i5K4z5KBuGEx",
        "E0XKsDQyxAQh",
        "YKlMJI6CFvzN"
      ],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/totalleecher/codemaster-mm/blob/master/All_in_One_2_0_7.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "uGAJFdQNdUcM"
      },
      "source": [
        "<a href=\"https://github.com/totalleecher/Codemaster\">\n",
        "<img src=\"https://github.com/fluidicon.png\" height=100px, align=\"left\"></a>\n",
        "\n",
        "\n",
        "\n",
        "<center><h1><b>Welcome to My Page</h1></b><h5>You can remote upload and download torrent to your <b>Google Drive</b> Here</center></h5>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cqy3vXXOMI06",
        "colab_type": "text"
      },
      "source": [
        "# ✦ *Colab Still Alive Console Script:*\n",
        "<p><font size=2px ><font color=\"red\"> Tip - Set a javascript interval to click on the connect button every 60 seconds. Open developer-settings (in your web-browser) with Ctrl+Shift+I then click on console tab and type this on the console prompt. (for mac press Option+Command+I)</font></p><b>Copy script in hidden cell and paste at your browser console !!! DO NOT CLOSE YOUR BROWSER IN ORDER TO STILL RUNNING SCRIPT</b>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Z8cK8h2Avbv",
        "colab_type": "text"
      },
      "source": [
        "<code>function ClickConnect(){\n",
        "console.log(\"Working\"); \n",
        "document.querySelector(\"colab-connect-button\").click() \n",
        "}setInterval(ClickConnect,6000)</code>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jtClEMAMLVHw",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown ← This cell runs JS code to automatic reconnect to runtime.\n",
        "\n",
        "\n",
        "import IPython\n",
        "from google.colab import output\n",
        "\n",
        "display(IPython.display.Javascript('''\n",
        " function ClickConnect(){\n",
        "   btn = document.querySelector(\"colab-connect-button\")\n",
        "   if (btn != null){\n",
        "     console.log(\"Click colab-connect-button\"); \n",
        "     btn.click() \n",
        "     }\n",
        "   \n",
        "   btn = document.getElementById('ok')\n",
        "   if (btn != null){\n",
        "     console.log(\"Click reconnect\"); \n",
        "     btn.click() \n",
        "     }\n",
        "  }\n",
        "  \n",
        "setInterval(ClickConnect,60000)\n",
        "'''))\n",
        "\n",
        "print(\"Done.\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "jh6rdhAQRA-C",
        "colab": {}
      },
      "source": [
        "#@markdown  ← ឵឵GPU count and name\n",
        "!nvidia-smi -L"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zRTgBdCpBWMh"
      },
      "source": [
        "# ✦ *Quick Useful Scripts:*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cOUZEXihsqCD",
        "colab_type": "text"
      },
      "source": [
        "## ✧ MediaInfo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NTULRguzu0b0",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "path = \"\" #@param {type:\"string\"}\n",
        "save_txt = False #@param {type:\"boolean\"}\n",
        "import os, uuid, re, IPython\n",
        "import ipywidgets as widgets\n",
        "import time\n",
        "\n",
        "from glob import glob\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output, drive\n",
        "\n",
        "def mediainfo():\n",
        "  display(HTML(\"<br>\"))\n",
        "#   print(path.split(\"/\")[::-1][0])\n",
        "  display(HTML(\"<br>\"))\n",
        "#   media = !mediainfo \"$path\"\n",
        "#   media = \"\\n\".join(media).replace(os.path.dirname(path)+\"/\", \"\")\n",
        "  get_ipython().system_raw(\"\"\"mediainfo --LogFile=\"/root/.nfo\" \"$path\" \"\"\")\n",
        "  with open('/root/.nfo', 'r') as file:\n",
        "    media = file.read()\n",
        "    media = media.replace(os.path.dirname(path)+\"/\", \"\")\n",
        "  print(media)\n",
        "  get_ipython().system_raw(\"rm -f '/root/.nfo'\")\n",
        "  \n",
        "  if save_txt:\n",
        "    txt = path.rpartition('.')[0] + \".txt\"\n",
        "    if os.path.exists(txt):\n",
        "      get_ipython().system_raw(\"rm -f '$txt'\")\n",
        "    !curl -s https://pastebin.com/raw/TApKLQfM -o \"$txt\"\n",
        "    with open(txt, 'a+') as file:\n",
        "      file.write(\"\\n\\n\")\n",
        "      file.write(media)\n",
        "\n",
        "while not os.path.exists(\"/content/drive\"):\n",
        "  try:\n",
        "    drive.mount(\"/content/drive\")\n",
        "    clear_output(wait=True)\n",
        "  except:\n",
        "    clear_output()\n",
        "    \n",
        "if not os.path.exists(\"/usr/bin/mediainfo\"):\n",
        "  get_ipython().system_raw(\"apt-get install mediainfo\")\n",
        "  \n",
        "mediainfo()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bNAroQWy6hL3",
        "colab_type": "text"
      },
      "source": [
        "## ✧ Generate Streamable Video Links from Google Drive\n",
        "##### *Note: This cell will only work with links that are shared publically*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "W4EXnKHuwmq0",
        "colab": {}
      },
      "source": [
        "import re\n",
        "\n",
        "shared_file_link = \"\" #@param {type:\"string\"}\n",
        "result = re.search(\"[\\w-]{33}\", shared_file_link)\n",
        "your_api_key = \"\" #@param {type:\"string\"}\n",
        "drive_file_id = result.group(0)\n",
        "\n",
        "beg_url = \"https://www.googleapis.com/drive/v3/files/\"\n",
        "end_url = \"/?key=\" + your_api_key + \"&alt=media\"\n",
        "\n",
        "print(beg_url + drive_file_id + end_url)\n",
        "\n",
        "## *This cell will only work with links that are shared publically*"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wZMZjX127rmx",
        "colab_type": "text"
      },
      "source": [
        "## ✧ Crash Colab to clear all RAM"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OH3xVkwWmPYL",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title ← ឵឵ ឵Run this cell to crash your current Runtime if you're low on memory\n",
        "#@markdown <i>After crashing, you'll have access to all the preoccupied storage</i>\n",
        "some_str = ' ' * 5120000000000"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ov6PHWiF4QuO",
        "colab_type": "text"
      },
      "source": [
        "## ✧ Check Your Notebook Spec: Here\n",
        "> The VM used for Colaboratory appears to have 13GB RAM and 2 vCPU when checking using psutil (so a n1-highmem-2 instance)\n",
        "\n",
        "- 2-core Xeon 2.2GHz\n",
        "- 13GB RAM\n",
        "- 33GB HDD\n",
        "\n",
        "maximum lifetime of a VM is 12 hours. Idle VMs time out after 90m"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5GfC8NDx1IOO",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown <h3>⬅️ Click Here to START check your notebook</h3><p>\n",
        "from psutil import *"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A-Jw-Oli8tfO",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Current Python Version\n",
        "!python -V"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xEk87QsflHfP",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Notebook's Internet Speed\n",
        "!sudo apt install speedtest-cli\n",
        "!speedtest-cli"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0BEnwM-W23Y4",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← OS Ver, etc.\n",
        "!cat /proc/version\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "01i75DIjKA5D",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Cpu model\n",
        "!lscpu |grep 'Model name'\n",
        "!cat /proc/cpuinfo"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WPJdbG8K1LZI",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Cpu Count\n",
        "cpu_count()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hJVLg_-4P-Pe",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← no.of sockets i.e available slots for physical processors\n",
        "!lscpu | grep 'Socket(s):'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7yL1tbVeuolJ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← no.of cores each processor is having \n",
        "!lscpu | grep 'Core(s) per socket:'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O09Z1aBpta_e",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← no.of threads each core is having\n",
        "!lscpu | grep 'Thread(s) per core'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7q3wBeTmb4I9",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← L3 cache\n",
        "!lscpu | grep \"L3 cache\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "se9YH4Ps2YAC",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Cpu State\n",
        "cpu_stats()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rYhXUmlNdfFa",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← if it had turbo boost it would've shown Min and Max MHz also but it is only showing current frequency this means it always operates at 2.3GHz\n",
        "!lscpu | grep \"MHz\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ojGuEt8MpJhA",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← use this command to see GPU activity while doing Deep Learning tasks, for this command 'nvidia-smi' and for above one to work, go to 'Runtime > change runtime type > Hardware Accelerator > GPU'\n",
        "!nvidia-smi"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wWkNAM6_OQel",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Click Here to test Notebook's GPU\n",
        "\n",
        "import tensorflow as tf\n",
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gsqXZwauphVV",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← ឵឵GPU count and name\n",
        "!nvidia-smi -L"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GBTdcSKu2VI4",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Gpu test\n",
        "from tensorflow.python.client import device_lib\n",
        "device_lib.list_local_devices()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CjqPaVrihUur",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← memory that we can use\n",
        "!cat /proc/meminfo | grep 'MemAvailable'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YELZKyxU4BiX",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← Virtual Memory\n",
        "virtual_memory()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HfLRIyH83che",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← HDD info\n",
        "!df -h"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qvyB0VG4j4zx",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown  ← hard disk that we can use\n",
        "!df -h / | awk '{print $4}'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ercDPZ6CIlVz"
      },
      "source": [
        "# <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/600px-Google_Drive_logo.png\" height=30px>      ___Mount / Unmount Gdrive!___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "U2avD1zRIlWA",
        "colab": {}
      },
      "source": [
        "#@markdown <br><center><img src='https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/600px-Google_Drive_logo.png' height=\"50\" alt=\"Gdrive logo\"/></center>\n",
        "#@markdown <center><h3>Mount Gdrive to /content/drive</h3></center><br>\n",
        "MODE = \"MOUNT\" #@param [\"MOUNT\", \"UNMOUNT\"]\n",
        "#Mount your Gdrive! \n",
        "from google.colab import drive\n",
        "drive.mount._DEBUG = False\n",
        "if MODE == \"MOUNT\":\n",
        "  drive.mount('/content/drive', force_remount=True)\n",
        "elif MODE == \"UNMOUNT\":\n",
        "  try:\n",
        "    drive.flush_and_unmount()\n",
        "  except ValueError:\n",
        "    pass\n",
        "  get_ipython().system_raw(\"rm -rf /root/.config/Google/DriveFS\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IsQPA4qZD4hK",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h4><b>←</b> ឵឵Click Here to <b>Force Remount</b> your Google Drive</h4>\n",
        "#@markdown <h5><i>(Only use if needed)</i></h5>\n",
        "drive.mount(\"/content/drive\", force_remount=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "SZBgJu8E-W7M"
      },
      "source": [
        "# <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/600px-Google_Drive_logo.png\" height=30px> ___*Google SDK*___<p>Directly downloaded to your <b>Gdirve</b>. No need to worry about Notebook's space (Alpha Ver.)</p>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IVHR7j91hzdC",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Getting your google account information (JSON)</h3>\n",
        "View_info = True #@param {type:\"boolean\"}\n",
        "import os\n",
        "from IPython.display import HTML, clear_output\n",
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials\n",
        "!pip install PyDrive\n",
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)\n",
        "clear_output()\n",
        "#============================\n",
        "f = open('adc.json', 'r')\n",
        "sdk = f.read()\n",
        "f.close\n",
        "if View_info:\n",
        " print(sdk)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C6MUykpFnfvO",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←   Click Here to Mount Google SDK</h3><p>\n",
        "\n",
        "\n",
        "#@markdown - Only works with <img src='https://colab.research.google.com/img/colab_favicon_256px.png' height=\"30\" alt=\"colab\" /> Torrent to Google drive <img src='https://colab.research.google.com/img/colab_favicon_256px.png' height=\"30\" alt=\"colab\" />  \n",
        "#Upload_my_JSON = True #@param {type:\"boolean\"}\n",
        "#Direct_url_to_my_JSON = \"https://raw.githubusercontent.com/totalleecher/codemaster-mm/master/adb.json\" #@param {type:\"string\"}\n",
        "#if Upload_my_JSON:\n",
        "# !wget \"$Direct_url_to_my_JSON\"\n",
        "#!apt-get install -y -qq software-properties-common python-software-properties module-init-tools\n",
        "!add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null\n",
        "!apt-get update -qq 2>&1 > /dev/null\n",
        "!apt-get -y install -qq google-drive-ocamlfuse fuse\n",
        "from google.colab import auth\n",
        "auth.authenticate_user()\n",
        "from oauth2client.client import GoogleCredentials\n",
        "creds = GoogleCredentials.get_application_default()\n",
        "import getpass\n",
        "!google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL\n",
        "vcode = getpass.getpass()\n",
        "!echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}\n",
        "\n",
        "##\n",
        "!mkdir -p downloads\n",
        "!google-drive-ocamlfuse drive downloads\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "clear_output()\n",
        "\n",
        "print(\"Installed Successfully\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4E-uzYrv5o0B",
        "colab_type": "text"
      },
      "source": [
        "# <img src='https://forum.rclone.org/uploads/default/original/2X/d/da6ccb2784ff3fa73d9339300530e0aae4d6cebd.png' height=\"46\" alt=\"rclone\"/><i>         __Mounting with rclone__</i>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q_wvtTnLaCA_",
        "colab_type": "text"
      },
      "source": [
        "### ← *Method 1*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "ytWCqgUYX4Fx",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@title <font size=\"4\"><b>Step 1. </b>Upload your <code>rclone.conf</code> profile</font> { vertical-output: true }\n",
        "#@markdown <h6>*<i>Required to mount your drive!</i></h4>\n",
        "## @markdown <h7>Your <code>rclone.conf</code> file is located at:</i></h4>\n",
        "# @markdown ### <font size=1px><i>For not able to upload local file : https://stackoverflow.com/a/58661947</font>\n",
        "# ================================================================ #\n",
        "MODE = \"RCONFIG\"\n",
        "from os import path as _p\n",
        "from IPython.display import clear_output\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://raw.githubusercontent.com/totalleecher/RLabClone/master/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(\"Upload 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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "W_kC9VQ0X7KS",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@title <font size=\"4\"><b>Step 2</b>. Mount your Drive with rclone</font> { vertical-output: true }\n",
        "Cache_Directory = \"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:#127ACC;margin-top:0px;\">\n",
        "                  Choose Drive to Mount:</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",
        "      ' --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": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "3btCxs20aJ8E"
      },
      "source": [
        "### ← *Method 2*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iroeLPFdXbif",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>Step 1. </b>Upload your <code>rclone.conf</code> profile</h3>\n",
        "#@markdown <h6>*<i>required to mount your drive!</i></h4>\n",
        "#@markdown \n",
        "Setup_Time_Zone = False \n",
        "\n",
        "import os; from google.colab import files; from IPython.display import HTML, clear_output\n",
        "\n",
        "def upload_conf():\n",
        "  try:\n",
        "    display(HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#446785;\\\">Please upload the config file of rclone (rclone.conf) from your computer.</h2><br>\"))\n",
        "    UploadConfig = files.upload().keys()\n",
        "    clear_output(wait=True)\n",
        "    if len(UploadConfig) == 0:\n",
        "      return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">File upload has been cancelled during upload file.</h2><br></center>\"))\n",
        "    elif len(UploadConfig) == 1:\n",
        "      for fn in UploadConfig:\n",
        "        if os.path.isfile(\"/content/\" + fn) == True:\n",
        "          os.environ[\"rclone_conf\"] = fn\n",
        "          !mv -f \"$rclone_conf\" /root/.rclone.conf\n",
        "          !chmod 666 /root/.rclone.conf\n",
        "          if Setup_Time_Zone == True:\n",
        "            !sudo dpkg-reconfigure tzdata\n",
        "            clear_output(wait=True)\n",
        "          if os.path.isfile(\"/usr/bin/rclone\") == True:\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#00b24c;\\\">Config has been changed.</h2><br></center>\"))\n",
        "          else:\n",
        "            !rm -rf /content/sample_data/\n",
        "            !curl -s https://rclone.org/install.sh | sudo bash\n",
        "            clear_output(wait=True)\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#446785;\\\">Installation has been successfully completed.</h2><br></center>\"))\n",
        "        else:\n",
        "          return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">File upload has been failed during upload file.</h2><br></center>\"))\n",
        "    else:\n",
        "      for fn in UploadConfig:\n",
        "        os.environ[\"rclone_conf\"] = fn\n",
        "        !rm -f \"$rclone_conf\"\n",
        "      return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Please uploading only one file at a time.</h2><br></center>\"))\n",
        "  except:\n",
        "    clear_output(wait=True)\n",
        "    return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Error occurred during upload file.</h2><br></center>\"))\n",
        "\n",
        "upload_conf()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mp6XoynaX4HN",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3><b>Step 2</b>. Mount your Drive with rclone</h3>\n",
        "#@markdown <ul><li><i>Replace values to match the </i><code>rclone.conf</code><i> file you just uploaded</i></li></ul>\n",
        "rclone_config_name = \"great\" #@param {type:\"string\"}\n",
        "local_mount_location = \"/content/\" #@param {type:\"string\"}\n",
        "# ============================= FORM ============================= #\n",
        "import time\n",
        "import os\n",
        "\n",
        "# clear nohup\n",
        "open(\"nohup.out\", 'w').close()\n",
        "\n",
        "\n",
        "# unmount first\n",
        "\n",
        "!fusermount -u $local_mount_location 2>/dev/null\n",
        "\n",
        "\n",
        "# mount without waiting for the command to complete\n",
        "!mkdir $local_mount_location 2>/dev/null\n",
        "!nohup rclone mount $rclone_config_name: $local_mount_location --buffer-size 96M & \n",
        "  \n",
        "\n",
        "\n",
        "# Show the output that was written to nohup\n",
        "time.sleep(3)\n",
        "f = open(r\"nohup.out\", \"r\")\n",
        "nohupText = f.read()\n",
        "f.close()\n",
        "\n",
        "\n",
        "dirs = os.listdir(local_mount_location)\n",
        "\n",
        "if len(dirs) > 0:\n",
        "  clear_output(wait=True)\n",
        "  print(\"Succeeded. \", str(len(dirs)), \"dirs found at\", local_mount_location)\n",
        "\n",
        "else:\n",
        "  print(\"\\n\\nNot succeeded. No files or directories in mounted location. \\nCheck your config name and content. If the rclone command was not found, run the cell above.\\n\\n\")\n",
        "  print(\"log:\\n\", nohupText)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "NkFQ5VDxpteH"
      },
      "source": [
        "# <center><b>Direct Link, Spotify, You Tube Link, Yandex, Google Drive Downloaders</b><h5>All of hidden cells are direct downloaders</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JnIOQZ2I-aDT",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://upload.wikimedia.org/wikipedia/commons/thumb/2/21/Icons8_flat_upload.svg/800px-Icons8_flat_upload.svg.png' height=\"45\" alt=\"RcloneLab\"/>___Remote Uploading___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tMxyvI91WEgy",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START SERVER</h3>\n",
        "\n",
        "import os\n",
        "\n",
        "%cd /content/drive/My Drive\n",
        "os.makedirs(\"DirectDownload\", exist_ok=True)\n",
        "%cd DirectDownload\n",
        "\n",
        "#####################################\n",
        "\n",
        "%pip install wget\n",
        "\n",
        "#####################################\n",
        "import wget\n",
        "url = input(\"Enter Remote Url\")\n",
        "initiateDownload = wget.download(url)\n",
        "initiateDownload\n",
        "\n",
        "##\n",
        "\n",
        "%ls /content/drive/My\\ Drive/DirectDownload\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "StT2bKf2WmKj",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://www.booleanworld.com/wp-content/webp-express/webp-images/doc-root/wp-content/uploads/2018/06/wget-cover-300x256@2x.png.webp' height=\"50\" alt=\"qBitTorrent\"/>   ___Wget___<h6>Direct Download / Remote Upload</h6>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_NiTOoCg-hLp",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title <h3><b>←</b> Run to Download a DDL File\n",
        "#@markdown <h5><i>Example URL:</i> <a src=\"\">https://files.catbox.moe/archive.zip</a>\n",
        "direct_URL = \"\" #@param {type:\"string\"}\n",
        "output_dir = \"/content\" #@param {type:\"string\"}\n",
        "\n",
        "!wget \"$Direct_URL\" \"$output_dir\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ttv0CeCqLX0t",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/totalleecher/Google-Colab-CloudTorrent/master/src/aria2cli.png' height=\"45\" alt=\"aira2\"/> <font size=1px >___Direct link downloader / Remote Uploading___</font>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ASgRAOtBnVDT"
      },
      "source": [
        "___Auto share link supported : Disk.yandex.com, Gdrive and youtube-dl all extractor...___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "plgToqkpLV5q",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "%cd /content/drive/My Drive\n",
        "%mkdir DirectDownload\n",
        "\n",
        "#\n",
        "\n",
        "URL = \"\" #@param {type:\"string\"}\n",
        "#@markdown <center><h5>Default output path <b>/content/drive/My Drive/DirectDownload</b></h5></center>\n",
        "OUTPUT_PATH = \"/content\" #@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/totalleecher/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py \\\n",
        "                    -O /root/.ipython/ttmg.py\"\n",
        "    run(split(shellCmd))\n",
        "from ttmg import updateCheck, runSh\n",
        "\n",
        "def youtubedlInstall():\n",
        "  if not path.isfile(\"/usr/local/bin/youtube-dl\"):\n",
        "    cmdC = \"rm -rf /content/sample_data/ && \" \\\n",
        "            \" mkdir -p -m 666 /root/.YouTube-DL/ &&\" \\\n",
        "            \" apt-get install atomicparsley &&\" \\\n",
        "            \" curl -L https://yt-dl.org/downloads/latest/youtube-dl \" \\\n",
        "            \"-o /usr/local/bin/youtube-dl &&\" \\\n",
        "            \" chmod a+rx /usr/local/bin/youtube-dl\"\n",
        "    get_ipython().system_raw(cmdC)\n",
        "\n",
        "def aria2Install():\n",
        "  runSh('apt install -y aria2')\n",
        "\n",
        "def istmd(URL): \n",
        "  link = urlparse(URL)\n",
        "    \n",
        "  #YandexDisk\n",
        "  if link.netloc == \"yadi.sk\":\n",
        "    API_ENDPOINT = 'https://cloud-api.yandex.net/v1/disk/public/resources/' \\\n",
        "                    '?public_key={}&path=/{}&offset={}'\n",
        "    dry = False\n",
        "    def md5sum(file_path):\n",
        "        md5 = hashlib.md5()\n",
        "        with open(file_path, 'rb') as f:\n",
        "            for chunk in iter(lambda: f.read(128 * md5.block_size), b''):\n",
        "                md5.update(chunk)\n",
        "        return md5.hexdigest()\n",
        "\n",
        "\n",
        "    def check_and_download_file(target_path, url, size, checksum):\n",
        "        if path.isfile(target_path):\n",
        "            if size == path.getsize(target_path):\n",
        "                if checksum == md5sum(target_path):\n",
        "                    print('URL {}'.format(url))\n",
        "                    print('skipping correct {}'.format(target_path))\n",
        "                    return\n",
        "        if not dry:\n",
        "            print('URL {}'.format(url))\n",
        "            print('downloading {}'.format(target_path))\n",
        "            runSh(f'aria2c -x 16 -s 16 -k 1M -d {OUTPUT_PATH} {url}', output=True)\n",
        "            # r = requests.get(url, stream=True)\n",
        "            # with open(target_path, 'wb') as f:\n",
        "            #     shutil.copyfileobj(r.raw, f)\n",
        "\n",
        "\n",
        "    def download_path(target_path, public_key, source_path, offset=0):\n",
        "        print('getting \"{}\" at offset {}'.format(source_path, offset))\n",
        "        current_path = path.join(target_path, source_path)\n",
        "        pathlib.Path(current_path).mkdir(parents=True, exist_ok=True)\n",
        "        jsn = requests.get(API_ENDPOINT.format(public_key, source_path, offset)).json()\n",
        "        def try_as_file(j):\n",
        "            if 'file' in j:\n",
        "                file_save_path = path.join(current_path, j['name'])\n",
        "                check_and_download_file(file_save_path, j['file'], j['size'], j['md5'])\n",
        "                return True\n",
        "            return False\n",
        "\n",
        "        # first try to treat the actual json as a single file description\n",
        "        if try_as_file(jsn):\n",
        "            return\n",
        "\n",
        "        # otherwise treat it as a directory\n",
        "        emb = jsn['_embedded']\n",
        "        items = emb['items']\n",
        "        for i in items:\n",
        "            # each item can be a file...\n",
        "            if try_as_file(i):\n",
        "                continue\n",
        "            # ... or a directory\n",
        "            else:\n",
        "                subdir_path = path.join(source_path, i['name'])\n",
        "                download_path(target_path, public_key, subdir_path)\n",
        "\n",
        "        # check if current directory has more items\n",
        "        last = offset + emb['limit']\n",
        "        if last < emb['total']:\n",
        "            download_path(target_path, public_key, source_path, last)\n",
        "    download_path(OUTPUT_PATH, URL, '')\n",
        "    return False  \n",
        "  return URL\n",
        "\n",
        "if not OUTPUT_PATH:\n",
        "  OUTPUT_PATH = \"/content/drive/My Drive/DirectDownload\"\n",
        "  \n",
        "if not URL == \"\":\n",
        "  aria2Install()\n",
        "  youtubedlInstall()\n",
        "  try:\n",
        "    mkdir(\"DirectDownload\")\n",
        "  except FileExistsError:\n",
        "    pass\n",
        "  url = istmd(URL)\n",
        "  if url != False:\n",
        "    print('URL {}'.format(URL))\n",
        "    cmdC = f'youtube-dl -o \"{OUTPUT_PATH}/%(title)s\" {URL} ' \\\n",
        "            '--external-downloader aria2c ' \\\n",
        "            '--external-downloader-args \"-x 16 -s 16 -k 1M\"'\n",
        "    runSh(cmdC, output=True)\n",
        "else:\n",
        "  print(\"Please input url\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AGVmJ2Y43o_C",
        "colab_type": "text"
      },
      "source": [
        "##<left><img src=\"https://ar.toneden.io/13766685/6070f58d-091b-4a80-bd5c-24378e308116\" height=\"50\" alt=\"Zippyshare logo\"/></left> <h6>___Zippyshare Downloader___</h6>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GEcLzHgFArPH",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "#@markdown <center><img src=\"https://ar.toneden.io/13766685/6070f58d-091b-4a80-bd5c-24378e308116\" height=\"100\" alt=\"Zippyshare logo\"/></center>\n",
        "#@markdown <center><h3>Remote upload from Zippyshare to Google drive</h3></center><br>\n",
        "\n",
        "\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "%cd /content\n",
        "!git clone https://github.com/mcrapet/plowshare.git\n",
        "%cd plowshare\n",
        "!make install\n",
        "!plowmod --install\n",
        "!apt-get install nodejs\n",
        "!cd ..\n",
        "\n",
        "\n",
        "clear_output()\n",
        "\n",
        "print(\"Server Started Successfully\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Gu5xTR0-reg",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START Download</h3>\n",
        "\n",
        "import os\n",
        "direct_URL = \"\" #@param {type:\"string\"}\n",
        "output_dir = \"/content/drive/My Drive\" #@param {type:\"string\"}\n",
        "\n",
        "!plowdown \"$direct_URL\" -o \"$output_dir\"\n",
        "\n",
        "%cd /content/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6WKY3zCQ86ev",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START Batch Download</h3>\n",
        "#@markdown <h5> Make \"download.txt\" file contaning batch links of zippyshare and upload here to down them all.\n",
        "\n",
        "%cd /content/plowshare\n",
        "\n",
        "!rm *.txt\n",
        "\n",
        "from google.colab import files\n",
        "files.upload()\n",
        "\n",
        "import os\n",
        "output_dir = \"/content/drive/My Drive\" #@param {type:\"string\"}\n",
        "\n",
        "!plowdown \"download.txt\" -m -o \"$output_dir\"\n",
        "\n",
        "%cd /content/\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LPEhexXnE4EF",
        "colab_type": "text"
      },
      "source": [
        "##<left><img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/5/57/01_mega_logo.svg/800px-01_mega_logo.svg.png\" height=\"50\" alt=\"Zippyshare logo\"/></left> <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Google_Drive_logo.png/600px-Google_Drive_logo.png\" height=50px align=\"right\">"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tp1Ta_s1F3p5",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h5>Easy to use but we recommend you to use <font color=\"red\"><b>Jdownloader</b></font> when download from mega.co.nz</h5></center><br>\n",
        "!pip install git+https://github.com/jeroenmeulenaar/python3-mega.git\n",
        "!pip install googleDriveFileDownloader\n",
        "\n",
        "##\n",
        "import os\n",
        "from IPython.display import HTML, clear_output\n",
        "%cd /content/drive/My Drive\n",
        "\n",
        "Gdrive_url = \"\" #@param {type:\"string\"}\n",
        "MegaNZ_url = \"\" #@param {type:\"string\"}\n",
        "Direct_Link = \"\" #@param {type:\"string\"}\n",
        "Download_from = \"MegaNZ\" #@param [\"MegaNZ\", \"Direct_Link\", \"Gdrive\"]\n",
        "clear_output()\n",
        "print('Downloading started')\n",
        "\n",
        "if Download_from == 'MegaNZ':\n",
        " os.makedirs(\"Mega\", exist_ok=True)\n",
        " %cd Mega\n",
        " from mega import Mega\n",
        " m = Mega.from_ephemeral()\n",
        " m.download_from_url(MegaNZ_url)\n",
        " print('Finished')\n",
        "\n",
        "if Download_from == 'Gdrive':\n",
        " os.makedirs(\"Gdrive\", exist_ok=True)\n",
        " %cd Gdrive\n",
        " from googleDriveFileDownloader import googleDriveFileDownloader\n",
        " a = googleDriveFileDownloader()\n",
        " a.downloadFile(Gdrive_url)  \n",
        " print('Finished')\n",
        "\n",
        "else:\n",
        "  os.makedirs(\"DirectDownload\", exist_ok=True)\n",
        "  %cd DirectDownload\n",
        "  import urllib\n",
        "  urllib.request.urlretrieve (Direct_Link)\n",
        "  print('Finished')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7dTNq8TFD6a-",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_jdownloader.png' height=\"45\" alt=\"JDownloader\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2fQoIcEOD1yu",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute JDownloader\n",
        "# @markdown Example : totalleecher@gmail.com\n",
        "NEW_Account = False  # @param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "from os import path as _p\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run  # nosec\n",
        "\n",
        "    shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                    -O /root/.ipython/rlab_utils.py\"\n",
        "    run(_spl(shellCmd))  # nosec\n",
        "\n",
        "from rlab_utils import handleJDLogin\n",
        "\n",
        "handleJDLogin(NEW_Account)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fE-iFnR538-O"
      },
      "source": [
        "## <img src='https://github.com/pyload/pyload-webui/raw/master/media/banner.png' height=\"60\" alt=\"pyLoad\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "RoAWHTF-38-Y",
        "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/totalleecher/\" \\\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/totalleecher/' \\\n",
        "          'Google-Colab-CloudTorrent/master/res/pyload/pyload.conf'\n",
        "  db = 'https://github.com/totalleecher/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 = \"localhost\" #@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/totalleecher/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/totalleecher/Google-Colab-CloudTorrent/master/src/spotify-downloader.png' height=\"100\" alt=\"spotify-downloader\"/></center>\n",
        "#@markdown <center><h3>spotify-downloader<br />Download Spotify playlists from YouTube with albumart and meta-tags</h3></center><br>\n",
        "\n",
        "import os, uuid, urllib.parse, re\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from glob import glob\n",
        "from urllib.parse import urlparse, parse_qs\n",
        "from IPython.display import HTML, clear_output, YouTubeVideo\n",
        "from IPython.utils.io import ask_yes_no\n",
        "from google.colab import output, files\n",
        "\n",
        "\n",
        "os.makedirs('tools/spotify-downloader/', exist_ok=True)\n",
        "os.makedirs('downloads', exist_ok=True)\n",
        "\n",
        "# # Config files\n",
        "# data = \"\"\"spotify-downloader:\n",
        "#   avconv: false\n",
        "#   download-only-metadata: false\n",
        "#   dry-run: false\n",
        "#   file-format: '{artist} - {track_name}'\n",
        "#   folder: /home/user/Music\n",
        "#   input-ext: .m4a\n",
        "#   log-level: INFO\n",
        "#   manual: false\n",
        "#   music-videos-only: false\n",
        "#   no-fallback-metadata: false\n",
        "#   no-metadata: false\n",
        "#   no-spaces: false\n",
        "#   output-ext: .mp3\n",
        "#   overwrite: prompt\n",
        "#   search-format: '{artist} - {track_name} lyrics'\n",
        "#   skip: null\n",
        "#   spotify_client_id: 4fe3fecfe5334023a1472516cc99d805\n",
        "#   spotify_client_secret: 0f02b7c483c04257984695007a4a8d5c\n",
        "#   trim-silence: false\n",
        "#   write-successful: null\n",
        "#   write-to: null\n",
        "#   youtube-api-key: null\n",
        "# \"\"\"\n",
        "# with open('tools/spotify-downloader/config.yml', 'w') as wnow:\n",
        "#   wnow.write(data)\n",
        "\n",
        "Links = widgets.Textarea(placeholder='''Link list\n",
        "(one link per line)''')\n",
        "\n",
        "fileFormat = widgets.Text(\n",
        "    value='{artist} - {track_name}',\n",
        "    placeholder='File name format',\n",
        "    description=\"\"\"File Name : file format to save the downloaded track with, each\n",
        "                        tag is surrounded by curly braces. Possible formats:\n",
        "                        ['track_name', 'artist', 'album', 'album_artist',\n",
        "                        'genre', 'disc_number', 'duration', 'year',\n",
        "                        'original_date', 'track_number', 'total_tracks',\n",
        "                        'isrc']\"\"\",\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "searchFormat = widgets.Text(\n",
        "    value='{artist} - {track_name} lyrics',\n",
        "    placeholder='Search format',\n",
        "    description=\"\"\"Search Format : search format to search for on YouTube, each tag is\n",
        "                        surrounded by curly braces. Possible formats:\n",
        "                        ['track_name', 'artist', 'album', 'album_artist',\n",
        "                        'genre', 'disc_number', 'duration', 'year',\n",
        "                        'original_date', 'track_number', 'total_tracks',\n",
        "                        'isrc']\"\"\",\n",
        "    disabled=False\n",
        ")\n",
        "\n",
        "tab = widgets.Tab()\n",
        "\n",
        "LinksType = widgets.RadioButtons(\n",
        "    options=['Songs', 'Playlist', 'Album', 'Username', 'Artist'],\n",
        "    value='Songs',\n",
        "    layout={'width': 'max-content'},\n",
        "    description='Links type:',\n",
        "    disabled=False,\n",
        ")\n",
        "\n",
        "SavePathYT = widgets.Dropdown(options=[\"/content/downloads\", \"/content\"])\n",
        "\n",
        "Extension = widgets.Select(options=[\"aac\", \"flac\", \"mp3\", \"m4a\", \"opus\", \"vorbis\", \"wav\"], value=\"mp3\")\n",
        "\n",
        "TrimSilence = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Trim silence',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='remove silence from the start of the audio',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "writeM3u = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Write .m3u playlist',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''generate an .m3u playlist file with youtube links\n",
        "               given a text file containing tracks''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "noMeta = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No metadata',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='do not embed metadata in tracks',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "nf = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No fallback metadata',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''do not use YouTube as fallback for metadata if track\n",
        "                        not found on Spotify''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "dryRun = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Dry run',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip=''' show only track title and YouTube URL, and then skip\n",
        "                        to the next track (if any)''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "MusicVidOnly = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Music Videos Only',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''search only for music videos on Youtube (works only\n",
        "                        when YouTube API key is set''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "NoSpaces = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='No Spaces',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''replace spaces with underscores in file names''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "manual = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='manually',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''choose the track to download manually from a list of\n",
        "                        matching tracks''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "nr = widgets.ToggleButton(\n",
        "    value=False,\n",
        "    description='Keep original',\n",
        "    disabled=False,\n",
        "    button_style='',\n",
        "    tooltip='''do not remove the original file after conversion''',\n",
        "    icon='check'\n",
        ")\n",
        "\n",
        "ExtraArg = widgets.Text(placeholder=\"Extra Arguments\")\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback, style):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "    self._style = style\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    if self._style != \"\":\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button mod-\" + self._style\n",
        "    else:\n",
        "      style_html = \"p-Widget jupyter-widgets jupyter-button widget-button\"\n",
        "    template = \"\"\"<button class=\"{style_html}\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id, style_html=style_html)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "def RefreshPathYT():\n",
        "  if os.path.exists(\"/content/drive/\"):\n",
        "    if os.path.exists(\"/content/drive/Shared drives/\"):\n",
        "      SavePathYT.options = [\"/content\", \"/content/downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\") + glob(\"/content/drive/Shared drives/*/\")\n",
        "    else:\n",
        "      SavePathYT.options = [\"/content\", \"/content/downloads\", \"/content/drive/My Drive\"] + glob(\"/content/drive/My Drive/*/\")\n",
        "  else:\n",
        "    SavePathYT.options = [\"/content/downloads\", \"/content\"]\n",
        "\n",
        "\n",
        "def ShowYT():\n",
        "  clear_output(wait=True)\n",
        "  RefreshPathYT()\n",
        "  mainTab = widgets.Box([widgets.HBox([widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Link:</b>\"), Links,\n",
        "                                      LinksType, searchFormat, fileFormat, widgets.HBox([TrimSilence, writeM3u, noMeta]), widgets.HBox([nf, dryRun, MusicVidOnly]),widgets.HBox([NoSpaces, manual, nr])]),\n",
        "                        widgets.VBox([widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extension:</b>\"), Extension,\n",
        "                                      widgets.HTML(\"<b style=\\\"color:#888888;\\\">Extra Arguments:</b>\"), ExtraArg])])])\n",
        "  tab.children = [mainTab]\n",
        "  tab.set_title(0, 'spotify-downloader')\n",
        "  display(tab)\n",
        "  display(HTML(\"<h4 style=\\\"color:#888888;\\\">Save Location:</h4>\"), SavePathYT, MakeButton(\"Refresh\", RefreshPathYT, \"\"))\n",
        "  if not os.path.exists(\"/content/drive/\"):\n",
        "    display(HTML(\"*If you want to save in Google Drive please run the cell below.\"))\n",
        "  display(HTML(\"<br>\"), MakeButton(\"Download\", DownloadYT, \"info\"))\n",
        "\n",
        "def DownloadYT():\n",
        "  if Links.value.strip():\n",
        "    Count = 0\n",
        "    Total = str(len(Links.value.splitlines()))\n",
        "    if writeM3u.value:\n",
        "      M3u = '--write-m3u'\n",
        "    else:\n",
        "      M3u = ''\n",
        "    if TrimSilence.value:\n",
        "      trmS = '--trim-silence'\n",
        "    else:\n",
        "      trmS = ''\n",
        "    if noMeta.value:\n",
        "      noM = '--no-metadata'\n",
        "    else:\n",
        "      noM = ''\n",
        "    if nf.value:\n",
        "      nfv = '--no-fallback-metadata'\n",
        "    else:\n",
        "      nfv = ''\n",
        "    if dryRun.value:\n",
        "      drR = '--dry-run'\n",
        "    else:\n",
        "      drR = ''\n",
        "    if MusicVidOnly.value:\n",
        "      MsV = '--music-videos-only'\n",
        "    else:\n",
        "      MsV = ''\n",
        "    if NoSpaces.value:\n",
        "      NoS = '--no-spaces'\n",
        "    else:\n",
        "      NoS = ''\n",
        "    if manual.value:\n",
        "      mal = '--manual'\n",
        "    else:\n",
        "      mal = ''\n",
        "    if nr.value:\n",
        "      nro = '--no-remove-original' \n",
        "    else:\n",
        "      nro = ''\n",
        "    if not searchFormat.value == '{artist} - {track_name} lyrics':\n",
        "      seFor = f'--search-format \"{searchFormat.value}\"'\n",
        "    else:\n",
        "      seFor = ''\n",
        "    if not fileFormat.value == '{artist} - {track_name}':\n",
        "      fiFor = f'--file-format \"{fileFormat.value}\"'\n",
        "    else:\n",
        "      fiFor = ''\n",
        "    \n",
        "    if not LinksType.value == 'Songs':\n",
        "      with open('tools/spotify-downloader/finish.txt', 'a+') as master:\n",
        "        for Link in Links.value.splitlines():\n",
        "          if LinksType.value == 'Playlist':\n",
        "            outFileName = !spotdl --playlist $Link\n",
        "          elif LinksType.value == 'Album':\n",
        "            outFileName = !spotdl --album $Link\n",
        "          elif LinksType.value == 'Username':\n",
        "            outFileName = !spotdl -u $Link\n",
        "          elif LinksType.value == 'Artist':\n",
        "            outFileName = !spotdl --all-albums $Link\n",
        "          filename = re.search(r\"to\\s(.+\\.txt)\", outFileName[-1]).group(1)\n",
        "          with open(filename, 'r') as r:\n",
        "            master.write(r.read())\n",
        "    else:\n",
        "      for Link in Links.value.splitlines():\n",
        "        with open('tools/spotify-downloader/finish.txt', 'w') as master:\n",
        "          master.write(Link)\n",
        "    # Extra Arguments\n",
        "    \n",
        "    extraargC = ExtraArg.value\n",
        "    cmd = r\"spotdl -l 'tools/spotify-downloader/finish.txt' \" \\\n",
        "      fr\"-f {SavePathYT.value} \" \\\n",
        "      fr\"-o .{Extension.value} \" \\\n",
        "      f\"--overwrite skip \" \\\n",
        "      f\"{seFor} {fiFor} \" \\\n",
        "      f\"{M3u} {trmS} {noM} {nfv} {drR} {MsV} {NoS} {mal} {nro}\" \n",
        "    !$cmd\n",
        "    ShowYT()\n",
        "\n",
        "if not os.path.isfile(\"/usr/local/bin/spotdl\"):\n",
        "  get_ipython().system_raw(\"pip3 install spotdl && apt-get install ffmpeg\")\n",
        "\n",
        "ShowYT()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SoxLe8ciEyAc",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_youtube-dl.png' height=\"45\" alt=\"Youtube-DL\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2u2LsQC8EtQJ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ Execute YouTube-DL\n",
        "# @markdown 📝 Note: if you want to change an archive file just run this cell again.\n",
        "Archive = False #@param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os, uuid, urllib.parse\n",
        "import ipywidgets as widgets\n",
        "\n",
        "from glob import glob\n",
        "from urllib.parse import urlparse, parse_qs\n",
        "from IPython.display import HTML, clear_output, YouTubeVideo\n",
        "from IPython.utils.io import ask_yes_no\n",
        "from google.colab import output, files\n",
        "os.system('sudo pip install youtube_dl')\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": "bZYwgcAq8Yr_",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://upload.wikimedia.org/wikipedia/commons/thumb/f/f1/Pornhub-logo.svg/512px-Pornhub-logo.svg.png' height=\"65\" alt=\"filebrowser\" />  <h5>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fJ3aJg1hx44A",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Install Require Modules</h3>\n",
        "\n",
        "#@title <font size=\"5\">← ឵឵<i>Upgrade FFmpeg to v4.2.2</font> { vertical-output: true }\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...\", ty='twg')\n",
        "os.system('pip3 install youtube-dl')\n",
        "os.system('pip3 install prettytable')\n",
        "os.system('pip3 install bs4')\n",
        "os.system('pip3 install requests')\n",
        "%cd /content\n",
        "os.system('git clone https://github.com/mariosemes/PornHub-downloader-python.git')\n",
        "\n",
        "clear_output()\n",
        "print(\"Install Finished\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bgml_v3z07ih",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to download video</h3>\n",
        "\n",
        "#@markdown - Single Download link Eg: https://www.pornhub.com/view_video.php?viewkey=ph5d69a2093729e\n",
        "#@markdown - The batch option will ask you for the full path of your .txt file where you can import multiple URLs at once.Take care that every single URL in the .txt file is in his own row.\n",
        "\n",
        "\n",
        "\n",
        "pornhub_url = '' #@param {type: \"string\"}\n",
        "option = \"single_download\" #@param [\"single_download\", \"batch_download\",\"add\",\"delete\"]\n",
        "\n",
        "%cd PornHub-downloader-python\n",
        "\n",
        "if option == 'single_download':\n",
        "  !python3 phdler.py custom \"$pornhub_url\"\n",
        "\n",
        "elif option == 'add':\n",
        "  !python3 phdler.py add \"$pornhub_url\"\n",
        "\n",
        "elif option == 'delete':\n",
        "  !python3 phdler.py delete \"$pornhub_url\"\n",
        "\n",
        "else:\n",
        "  !python3 phdler.py custom batch "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "A0y8bdJSpbmD"
      },
      "source": [
        "#<center><b>Torrent Downloaders</b><h5>All of hidden cells are torrent downloaders</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WanlireZOjvx",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://colab.research.google.com/img/colab_favicon_256px.png' height=\"50\" alt=\"colab\" />  __Torrent to Gdrive__\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "m6hF0emftx4h",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "\n",
        "\n",
        "\n",
        "!apt install python3-libtorrent\n",
        "\n",
        "import libtorrent as lt\n",
        "\n",
        "ses = lt.session()\n",
        "ses.listen_on(6881, 6891)\n",
        "downloads = []\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "clear_output()\n",
        "\n",
        "print(\"Server Started Successfully\")\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "0et2A6N3udA0",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to </h3>\n",
        "#@markdown <h3>Upload torrent file</h3>\n",
        "#@markdown <h5>You can run this cell to add more files as many times as you want</h5><br>\n",
        "\n",
        "\n",
        "\n",
        "from google.colab import files\n",
        "\n",
        "source = files.upload()\n",
        "params = {\n",
        "    \"save_path\": \"/content/drive/My Drive/Torrent\",\n",
        "    \"ti\": lt.torrent_info(list(source.keys())[0]),\n",
        "}\n",
        "downloads.append(ses.add_torrent(params))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cwi1GMlxy3te",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to </h3>\n",
        "#@markdown <h3>Add From Magnet Link</h3>\n",
        "#@markdown <h5>You can run this cell to add more files as many times as you want</h5><br>\n",
        "\n",
        "\n",
        "params = {\"save_path\": \"/content/drive/My Drive/Torrent\"}\n",
        "\n",
        "while True:\n",
        "    magnet_link = input(\"Enter Magnet Link Or Type Exit: \")\n",
        "    if magnet_link.lower() == \"exit\":\n",
        "        break\n",
        "    downloads.append(\n",
        "        lt.add_magnet_uri(ses, magnet_link, params)\n",
        "    )\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "DBNoYYoSuDBT",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to Start Download</h3>\n",
        "import time\n",
        "from IPython.display import display\n",
        "import ipywidgets as widgets\n",
        "\n",
        "state_str = [\n",
        "    \"queued\",\n",
        "    \"checking\",\n",
        "    \"downloading metadata\",\n",
        "    \"downloading\",\n",
        "    \"finished\",\n",
        "    \"seeding\",\n",
        "    \"allocating\",\n",
        "    \"checking fastresume\",\n",
        "]\n",
        "\n",
        "layout = widgets.Layout(width=\"auto\")\n",
        "style = {\"description_width\": \"initial\"}\n",
        "download_bars = [\n",
        "    widgets.FloatSlider(\n",
        "        step=0.01, disabled=True, layout=layout, style=style\n",
        "    )\n",
        "    for _ in downloads\n",
        "]\n",
        "display(*download_bars)\n",
        "\n",
        "while downloads:\n",
        "    next_shift = 0\n",
        "    for index, download in enumerate(downloads[:]):\n",
        "        bar = download_bars[index + next_shift]\n",
        "        if not download.is_seed():\n",
        "            s = download.status()\n",
        "\n",
        "            bar.description = \" \".join(\n",
        "                [\n",
        "                    download.name(),\n",
        "                    str(s.download_rate / 1000),\n",
        "                    \"kB/s\",\n",
        "                    state_str[s.state],\n",
        "                ]\n",
        "            )\n",
        "            bar.value = s.progress * 100\n",
        "        else:\n",
        "            next_shift -= 1\n",
        "            ses.remove_torrent(download)\n",
        "            downloads.remove(download)\n",
        "            bar.close() # Seems to be not working in Colab (see https://github.com/googlecolab/colabtools/issues/726#issue-486731758)\n",
        "            download_bars.remove(bar)\n",
        "            print(download.name(), \"complete\")\n",
        "    time.sleep(1)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "WMWJ2mDPBoEx"
      },
      "source": [
        "## <img src='https://avatars1.githubusercontent.com/u/223312?s=400&v=4' height=\"50\" alt=\"colab\" />  __Transmission__\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "5fSXrieIBoFD",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "\n",
        "\n",
        "!apt-get install transmission-cli\n",
        "from IPython.display import HTML, clear_output\n",
        "clear_output()\n",
        "print(\"Server Started Successfully\")\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "k9rBogRbBoGB",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to </h3>\n",
        "#@markdown <h3>Add From Magnet Link or .torrent Link</h3>\n",
        "#@markdown <h5>You can run this cell to add more files as many times as you want</h5><br>\n",
        "\n",
        "\n",
        "import os\n",
        "torrent_URL = \"\" #@param {type:\"string\"}\n",
        "output_dir = \"/content/drive/My Drive\" #@param {type:\"string\"}\n",
        "\n",
        "!transmission-cli -w \"$output_dir\" \"$torrent_URL\"\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "-hMkAxkD3F_i"
      },
      "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": "4FEoFmG93F_x",
        "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/totalleecher/\" \\\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/totalleecher/\" \\\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/totalleecher/\" \\\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": {
        "colab_type": "text",
        "id": "Dci4OK_X3kS_"
      },
      "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": "47q-le-V3kTL",
        "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/totalleecher/\" \\\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": "0XIAa_RP3kTu",
        "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/totalleecher/\" \\\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/totalleecher/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/totalleecher/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": {
        "colab_type": "text",
        "id": "JXsqLabj3uhU"
      },
      "source": [
        "## <img src='https://upload.wikimedia.org/wikipedia/commons/9/9f/UTorrent_%28logo%29.png' height=\"25\" alt=\"µTorrent\" /> ___µTorrent___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "eKiKa0uz3uhX",
        "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/totalleecher/\" \\\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/totalleecher/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": {
        "colab_type": "text",
        "id": "POtlxClK3sFC"
      },
      "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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "I1NzUYvH3sFH",
        "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/totalleecher/\" \\\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/biplobsd/RLabClone/master/res/qbittorrent/qBittorrent.conf \\\n",
        "            -O /root/.config/qBittorrent/qBittorrent.conf\"\n",
        "    )\n",
        "\n",
        "\n",
        "def prepareSession():\n",
        "    if checkAvailable(\"ready.txt\", userPath=True):\n",
        "        return\n",
        "    else:\n",
        "        addUtils()\n",
        "        configTimezone()\n",
        "        uploadQBittorrentConfig()\n",
        "\n",
        "def installQBittorrent():\n",
        "    if checkAvailable(\"/usr/bin/qbittorrent-nox\"):\n",
        "        return\n",
        "    else:\n",
        "        try:\n",
        "            runSh(\"add-apt-repository -y ppa:poplite/qbittorrent-enhanced\")\n",
        "            runSh(\"apt-get install qbittorrent-enhanced-nox -qq -y\")\n",
        "        except:\n",
        "            raise Exception('Error installing qbittorrent-enhanced-nox')\n",
        "\n",
        "def startQBService():\n",
        "    prepareSession()\n",
        "    installQBittorrent()\n",
        "    if not findProcess(\"qbittorrent-nox\", \"-d --webui-port\"):\n",
        "        runSh(f\"qbittorrent-nox -d --webui-port={QB_Port}\")\n",
        "        time.sleep(1)\n",
        "\n",
        "QB_Port = 10001\n",
        "loadingAn()\n",
        "startQBService()\n",
        "\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "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": {
        "colab_type": "text",
        "id": "FTzmh4qB4EIQ"
      },
      "source": [
        "## <img src='http://pic2.orsoon.com/2017/0719/20170719091439708.png' height=\"60\" alt=\"aria2\" />___aria2___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "27H5lZY24EIa",
        "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/totalleecher/\" \\\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": {
        "colab_type": "text",
        "id": "oLAlYZqk3xSL"
      },
      "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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "TD9KbFAY3xSO",
        "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/biplobsd/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "from ttmg import (\n",
        "    checkAvailable,\n",
        "    loadingAn,\n",
        "    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": {
        "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/totalleecher/\" \\\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": {
        "colab_type": "text",
        "id": "u1qvPjlc3z5i"
      },
      "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": "x2bazhlN3z5r",
        "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/totalleecher/\" \\\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 = \"localhost\" #@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": "cHTe9qp2E6f5",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://avatars1.githubusercontent.com/u/3368377?s=400&v=4' height=\"60\" alt=\"logo\"/><img src='https://raw.githubusercontent.com/linuxserver/docker-templates/master/linuxserver.io/img/nzbget-banner.png' height=\"52\" alt=\"nzbget\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "Qa0LbpPoaueF",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Click Here to Use NZBget (<i>ngrok</i>)</h3>\n",
        "#@markdown <center>Creat an account and Get Free Token  <a href=\"https://dashboard.ngrok.com/auth\">Here</a>  \n",
        "Ngrok_Token = \"\" #@param {type:\"string\"}\n",
        "\n",
        "import os, psutil, uuid, time, urllib.request, json; from IPython.display import clear_output\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output\n",
        "\n",
        "class MakeButton(object):\n",
        "  def __init__(self, title, callback):\n",
        "    self._title = title\n",
        "    self._callback = callback\n",
        "  def _repr_html_(self):\n",
        "    callback_id = 'button-' + str(uuid.uuid4())\n",
        "    output.register_callback(callback_id, self._callback)\n",
        "    template = \"\"\"<button class=\"p-Widget jupyter-widgets jupyter-button widget-button mod-info\" id=\"{callback_id}\">{title}</button>\n",
        "        <script>\n",
        "          document.querySelector(\"#{callback_id}\").onclick = (e) => {{\n",
        "            google.colab.kernel.invokeFunction('{callback_id}', [], {{}})\n",
        "            e.preventDefault();\n",
        "          }};\n",
        "        </script>\"\"\"\n",
        "    html = template.format(title=self._title, callback_id=callback_id)\n",
        "    return html\n",
        "  \n",
        "def MakeLabel(description, button_style):\n",
        "  return widgets.Button(description=description, disabled=True, button_style=button_style)\n",
        "\n",
        "if os.path.isfile(\"/usr/local/bin/ngrok\") == False:\n",
        "  !wget -q -c -nc https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n",
        "  !unzip -qq -n ngrok-stable-linux-amd64.zip\n",
        "  !mv ngrok /usr/local/bin/ngrok\n",
        "  !rm -f /content/ngrok-stable-linux-amd64.zip\n",
        "  print(\"ngrok successfully installed.\")\n",
        "  clear_output(wait=True)\n",
        "else:\n",
        "  print(\"ngrok already installed. Skipping... \")\n",
        "  clear_output(wait=True)\n",
        "  !pkill ngrok\n",
        "\n",
        "def RandomGenerator():\n",
        "  return time.strftime(\"%S\") + str(time.time()).split(\".\")[-1]\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "\n",
        "try:\n",
        "  try:\n",
        "    Random_NumberNZ\n",
        "  except NameError:\n",
        "    Random_NumberNZ = RandomGenerator()\n",
        "    display(MakeLabel('Installing in Progress', 'warning'))\n",
        "  if os.path.isfile(\"/content/nzbget/nzbget\") == False:\n",
        "    !mkdir /content/nzbget\n",
        "    get_ipython().system_raw(\"rm -rf /content/sample_data/ && wget https://nzbget.net/download/nzbget-latest-bin-linux.run && sh nzbget-latest-bin-linux.run\")\n",
        "  if CheckProcess(\"nzbget\", \"\") != True:\n",
        "    get_ipython().system_raw(\"/content/nzbget/nzbget -s &\")\n",
        "except:\n",
        "  clear_output(wait=True)\n",
        "\n",
        "get_ipython().system_raw('/usr/local/bin/ngrok authtoken $Ngrok_Token && /usr/local/bin/ngrok http 6789 &')\n",
        "time.sleep(10)\n",
        "clear_output(wait=True)\n",
        "with urllib.request.urlopen('http://localhost:4040/api/tunnels') as response:\n",
        "  data = json.loads(response.read().decode())\n",
        "  host = data['tunnels'][0]['public_url'][8:]\n",
        "  print(f'Open this link in new tab http://{host}')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "7wez354M4ZeV"
      },
      "source": [
        "## <img src='https://forum.rclone.org/uploads/default/original/2X/d/da6ccb2784ff3fa73d9339300530e0aae4d6cebd.png' height=\"45\" alt=\"RcloneLab\"/><h5>Here, rClone is tool to copy/move torrent downloaded file from **Simple torrent/qBittorrent,etc.** to your **google drive**</h5>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "XsKJ11C64Zen",
        "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 = \"Copy\"  # @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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "FSodCgjz4Ze6",
        "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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "0Zh-YKgw4ZfH",
        "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/totalleecher/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "  from shlex import split as _spl\n",
        "  from subprocess import run\n",
        "\n",
        "  shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                  -O /root/.ipython/rlab_utils.py\"\n",
        "  run(_spl(shellCmd))\n",
        "\n",
        "from ttmg import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    displayUrl,\n",
        "    findProcess,\n",
        "    CWD,\n",
        "    textAn,\n",
        "    checkAvailable\n",
        ")\n",
        "from rlab_utils import (\n",
        "    displayOutput,\n",
        "    checkAvailable,\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        "    accessSettingFile,\n",
        "    memGiB,\n",
        ")\n",
        "\n",
        "loadingAn()\n",
        "prepareSession()\n",
        "pid = findProcess(\"rclone\", \"rcd\", isPid=True)\n",
        "try:\n",
        "  os.kill(int(pid), signal.SIGTERM)\n",
        "except TypeError:\n",
        "  pass\n",
        "cmd = \"rclone rcd --rc-web-gui --rc-addr :5572\" \\\n",
        "      \" --rc-serve\" \\\n",
        "      \" --rc-user=user --rc-pass=pass\" \\\n",
        "      \" --rc-no-auth\" \\\n",
        "      rf\" --config {PATH_RClone_Config}/rclone.conf\" \\\n",
        "      ' --user-agent \"Mozilla\"' \\\n",
        "      ' --transfers 16' \\\n",
        "      \" &\"\n",
        "runSh(cmd, shell=True)\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['rclone', 5572, 'http'],\n",
        "                            ['filebrowser', 4000, 'http']], 'ap', \n",
        "    [f\"{HOME}/.ngrok2/filebrowserRclone.yml\", 4099]\n",
        ").start('rclone', displayB=False)\n",
        "# output\n",
        "clear_output()\n",
        "displayUrl(Server, pNamU='Rclone webUI : ', \n",
        "           ExUrl=fr\"http://user:pass@{Server['url'][7:]}\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "cm7tazGs4ZfT",
        "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/totalleecher/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "#####################################\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "  from shlex import split as _spl\n",
        "  from subprocess import run\n",
        "\n",
        "  shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                  -O /root/.ipython/rlab_utils.py\"\n",
        "  run(_spl(shellCmd))\n",
        "\n",
        "from rlab_utils import (\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        "    runSh\n",
        ")\n",
        "from ttmg import (\n",
        "    ngrok\n",
        ")\n",
        "\n",
        "###################################\n",
        "import codecs\n",
        "import contextlib\n",
        "import locale\n",
        "import os\n",
        "import pty\n",
        "import select\n",
        "import signal\n",
        "import subprocess\n",
        "import sys\n",
        "import termios\n",
        "import time\n",
        "\n",
        "\n",
        "from IPython.utils import text\n",
        "import six\n",
        "from google.colab import _ipython\n",
        "from google.colab import _message\n",
        "from google.colab.output import _tags\n",
        "\n",
        "# Linux read(2) limits to 0x7ffff000 so stay under that for clarity.\n",
        "_PTY_READ_MAX_BYTES_FOR_TEST = 2**20  # 1MB\n",
        "\n",
        "_ENCODING = 'UTF-8'\n",
        "\n",
        "class ShellResult(object):\n",
        "  \"\"\"Result of an invocation of the shell magic.\n",
        "\n",
        "  Note: This is intended to mimic subprocess.CompletedProcess, but has slightly\n",
        "  different characteristics, including:\n",
        "    * CompletedProcess has separate stdout/stderr properties. A ShellResult\n",
        "      has a single property containing the merged stdout/stderr stream,\n",
        "      providing compatibility with the existing \"!\" shell magic (which this is\n",
        "      intended to provide an alternative to).\n",
        "    * A custom __repr__ method that returns output. When the magic is invoked as\n",
        "      the only statement in the cell, Python prints the string representation by\n",
        "      default. The existing \"!\" shell magic also returns output.\n",
        "  \"\"\"\n",
        "\n",
        "  def __init__(self, args, returncode, command_output):\n",
        "    self.args = args\n",
        "    self.returncode = returncode\n",
        "    self.output = command_output\n",
        "\n",
        "  def check_returncode(self):\n",
        "    if self.returncode:\n",
        "      raise subprocess.CalledProcessError(\n",
        "          returncode=self.returncode, cmd=self.args, output=self.output)\n",
        "\n",
        "  def _repr_pretty_(self, p, cycle):  # pylint:disable=unused-argument\n",
        "    # Note: When invoking the magic and not assigning the result\n",
        "    # (e.g. %shell echo \"foo\"), Python's default semantics will be used and\n",
        "    # print the string representation of the object. By default, this will\n",
        "    # display the __repr__ of ShellResult. Suppress this representation since\n",
        "    # the output of the command has already been displayed to the output window.\n",
        "    if cycle:\n",
        "      raise NotImplementedError\n",
        "\n",
        "\n",
        "def _configure_term_settings(pty_fd):\n",
        "  term_settings = termios.tcgetattr(pty_fd)\n",
        "  # ONLCR transforms NL to CR-NL, which is undesirable. Ensure this is disabled.\n",
        "  # http://man7.org/linux/man-pages/man3/termios.3.html\n",
        "  term_settings[1] &= ~termios.ONLCR\n",
        "\n",
        "  # ECHOCTL echoes control characters, which is undesirable.\n",
        "  term_settings[3] &= ~termios.ECHOCTL\n",
        "\n",
        "  termios.tcsetattr(pty_fd, termios.TCSANOW, term_settings)\n",
        "\n",
        "\n",
        "def _run_command(cmd, clear_streamed_output):\n",
        "  \"\"\"Calls the shell command, forwarding input received on the stdin_socket.\"\"\"\n",
        "  locale_encoding = locale.getpreferredencoding()\n",
        "  if locale_encoding != _ENCODING:\n",
        "    raise NotImplementedError(\n",
        "        'A UTF-8 locale is required. Got {}'.format(locale_encoding))\n",
        "\n",
        "  parent_pty, child_pty = pty.openpty()\n",
        "  _configure_term_settings(child_pty)\n",
        "\n",
        "  epoll = select.epoll()\n",
        "  epoll.register(\n",
        "      parent_pty,\n",
        "      (select.EPOLLIN | select.EPOLLOUT | select.EPOLLHUP | select.EPOLLERR))\n",
        "\n",
        "  try:\n",
        "    temporary_clearer = _tags.temporary if clear_streamed_output else _no_op\n",
        "\n",
        "    with temporary_clearer(), _display_stdin_widget(\n",
        "        delay_millis=500) as update_stdin_widget:\n",
        "      # TODO(b/115531839): Ensure that subprocesses are terminated upon\n",
        "      # interrupt.\n",
        "      p = subprocess.Popen(\n",
        "          cmd,\n",
        "          shell=True,\n",
        "          executable='/bin/bash',\n",
        "          stdout=child_pty,\n",
        "          stdin=child_pty,\n",
        "          stderr=child_pty,\n",
        "          close_fds=True)\n",
        "      # The child PTY is only needed by the spawned process.\n",
        "      os.close(child_pty)\n",
        "\n",
        "      return _monitor_process(parent_pty, epoll, p, cmd, update_stdin_widget)\n",
        "  finally:\n",
        "    epoll.close()\n",
        "    os.close(parent_pty)\n",
        "\n",
        "\n",
        "class _MonitorProcessState(object):\n",
        "\n",
        "  def __init__(self):\n",
        "    self.process_output = six.StringIO()\n",
        "    self.is_pty_still_connected = True\n",
        "\n",
        "\n",
        "def _monitor_process(parent_pty, epoll, p, cmd, update_stdin_widget):\n",
        "  \"\"\"Monitors the given subprocess until it terminates.\"\"\"\n",
        "  state = _MonitorProcessState()\n",
        "\n",
        "  # A single UTF-8 character can span multiple bytes. os.read returns bytes and\n",
        "  # could return a partial byte sequence for a UTF-8 character. Using an\n",
        "  # incremental decoder is incrementally fed input bytes and emits UTF-8\n",
        "  # characters.\n",
        "  decoder = codecs.getincrementaldecoder(_ENCODING)()\n",
        "\n",
        "  num_interrupts = 0\n",
        "  echo_status = None\n",
        "  while True:\n",
        "    try:\n",
        "      result = _poll_process(parent_pty, epoll, p, cmd, decoder, state)\n",
        "      if result is not None:\n",
        "        return result\n",
        "      term_settings = termios.tcgetattr(parent_pty)\n",
        "      new_echo_status = bool(term_settings[3] & termios.ECHO)\n",
        "      if echo_status != new_echo_status:\n",
        "        update_stdin_widget(new_echo_status)\n",
        "        echo_status = new_echo_status\n",
        "    except KeyboardInterrupt:\n",
        "      try:\n",
        "        num_interrupts += 1\n",
        "        if num_interrupts == 1:\n",
        "          p.send_signal(signal.SIGINT)\n",
        "        elif num_interrupts == 2:\n",
        "          # Process isn't responding to SIGINT and user requested another\n",
        "          # interrupt. Attempt to send SIGTERM followed by a SIGKILL if the\n",
        "          # process doesn't respond.\n",
        "          p.send_signal(signal.SIGTERM)\n",
        "          time.sleep(0.5)\n",
        "          if p.poll() is None:\n",
        "            p.send_signal(signal.SIGKILL)\n",
        "      except KeyboardInterrupt:\n",
        "        # Any interrupts that occur during shutdown should not propagate.\n",
        "        pass\n",
        "\n",
        "      if num_interrupts > 2:\n",
        "        # In practice, this shouldn't be possible since\n",
        "        # SIGKILL is quite effective.\n",
        "        raise\n",
        "\n",
        "\n",
        "def _poll_process(parent_pty, epoll, p, cmd, decoder, state):\n",
        "  \"\"\"Polls the process and captures / forwards input and output.\"\"\"\n",
        "\n",
        "  terminated = p.poll() is not None\n",
        "  if terminated:\n",
        "    termios.tcdrain(parent_pty)\n",
        "    # We're no longer interested in write events and only want to consume any\n",
        "    # remaining output from the terminated process. Continuing to watch write\n",
        "    # events may cause early termination of the loop if no output was\n",
        "    # available but the pty was ready for writing.\n",
        "    epoll.modify(parent_pty,\n",
        "                 (select.EPOLLIN | select.EPOLLHUP | select.EPOLLERR))\n",
        "\n",
        "  output_available = False\n",
        "\n",
        "  events = epoll.poll()\n",
        "  input_events = []\n",
        "  for _, event in events:\n",
        "    if event & select.EPOLLIN:\n",
        "      output_available = True\n",
        "      raw_contents = os.read(parent_pty, _PTY_READ_MAX_BYTES_FOR_TEST)\n",
        "      import re\n",
        "      decoded_contents = re.sub(r\"http:\\/\\/127.0.0.1:53682\", Server[\"url\"], \n",
        "                                decoder.decode(raw_contents))\n",
        "      sys.stdout.write(decoded_contents)\n",
        "      state.process_output.write(decoded_contents)\n",
        "\n",
        "    if event & select.EPOLLOUT:\n",
        "      # Queue polling for inputs behind processing output events.\n",
        "      input_events.append(event)\n",
        "\n",
        "    # PTY was disconnected or encountered a connection error. In either case,\n",
        "    # no new output should be made available.\n",
        "    if (event & select.EPOLLHUP) or (event & select.EPOLLERR):\n",
        "      state.is_pty_still_connected = False\n",
        "\n",
        "  for event in input_events:\n",
        "    # Check to see if there is any input on the stdin socket.\n",
        "    # pylint: disable=protected-access\n",
        "    input_line = _message._read_stdin_message()\n",
        "    # pylint: enable=protected-access\n",
        "    if input_line is not None:\n",
        "      # If a very large input or sequence of inputs is available, it's\n",
        "      # possible that the PTY buffer could be filled and this write call\n",
        "      # would block. To work around this, non-blocking writes and keeping\n",
        "      # a list of to-be-written inputs could be used. Empirically, the\n",
        "      # buffer limit is ~12K, which shouldn't be a problem in most\n",
        "      # scenarios. As such, optimizing for simplicity.\n",
        "      input_bytes = bytes(input_line.encode(_ENCODING))\n",
        "      os.write(parent_pty, input_bytes)\n",
        "\n",
        "  # Once the process is terminated, there still may be output to be read from\n",
        "  # the PTY. Wait until the PTY has been disconnected and no more data is\n",
        "  # available for read. Simply waiting for disconnect may be insufficient if\n",
        "  # there is more data made available on the PTY than we consume in a single\n",
        "  # read call.\n",
        "  if terminated and not state.is_pty_still_connected and not output_available:\n",
        "    sys.stdout.flush()\n",
        "    command_output = state.process_output.getvalue()\n",
        "    return ShellResult(cmd, p.returncode, command_output)\n",
        "\n",
        "  if not output_available:\n",
        "    # The PTY is almost continuously available for reading input to provide\n",
        "    # to the underlying subprocess. This means that the polling loop could\n",
        "    # effectively become a tight loop and use a large amount of CPU. Add a\n",
        "    # slight delay to give resources back to the system while monitoring the\n",
        "    # process.\n",
        "    # Skip this delay if we read output in the previous loop so that a partial\n",
        "    # read doesn't unnecessarily sleep before reading more output.\n",
        "    # TODO(b/115527726): Rather than sleep, poll for incoming messages from\n",
        "    # the frontend in the same poll as for the output.\n",
        "    time.sleep(0.1)\n",
        "\n",
        "\n",
        "@contextlib.contextmanager\n",
        "def _display_stdin_widget(delay_millis=0):\n",
        "  \"\"\"Context manager that displays a stdin UI widget and hides it upon exit.\n",
        "\n",
        "  Args:\n",
        "    delay_millis: Duration (in milliseconds) to delay showing the widget within\n",
        "      the UI.\n",
        "\n",
        "  Yields:\n",
        "    A callback that can be invoked with a single argument indicating whether\n",
        "    echo is enabled.\n",
        "  \"\"\"\n",
        "  shell = _ipython.get_ipython()\n",
        "  display_args = ['cell_display_stdin', {'delayMillis': delay_millis}]\n",
        "  _message.blocking_request(*display_args, parent=shell.parent_header)\n",
        "\n",
        "  def echo_updater(new_echo_status):\n",
        "    # Note: Updating the echo status uses colab_request / colab_reply on the\n",
        "    # stdin socket. Input provided by the user also sends messages on this\n",
        "    # socket. If user input is provided while the blocking_request call is still\n",
        "    # waiting for a colab_reply, the input will be dropped per\n",
        "    # https://github.com/googlecolab/colabtools/blob/56e4dbec7c4fa09fad51b60feb5c786c69d688c6/google/colab/_message.py#L100.\n",
        "    update_args = ['cell_update_stdin', {'echo': new_echo_status}]\n",
        "    _message.blocking_request(*update_args, parent=shell.parent_header)\n",
        "\n",
        "  yield echo_updater\n",
        "\n",
        "  hide_args = ['cell_remove_stdin', {}]\n",
        "  _message.blocking_request(*hide_args, parent=shell.parent_header)\n",
        "\n",
        "\n",
        "@contextlib.contextmanager\n",
        "def _no_op():\n",
        "  yield\n",
        "\n",
        "###################################\n",
        "prepareSession()\n",
        "\n",
        "Server = ngrok(\n",
        "    TOKEN, USE_FREE_TOKEN, [['rcloneConfig', 53682, 'http'], \n",
        "                            ['pyload', 8000, 'http']], 'sa', \n",
        "    [f\"{HOME}/.ngrok2/rclonePyload.yml\", 4074]\n",
        ").start('rcloneConfig', displayB=False, v=False)\n",
        "\n",
        "printData = \"\"\"Copy this URL,\n",
        "  It's needed for authentication purposes.\n",
        "  After completing your account select, you redirect to a website, after back\n",
        "  you need to change http://127.0.0.0:53682 to {}\"\"\".format(Server['url'])\n",
        "print(printData)\n",
        "display(HTML('&emsp;&emsp;<a href=\"https://raw.githubusercontent.com/totalleecher/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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "D3Sd6BsO4Zfa",
        "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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "rev9TqhL4Zfj",
        "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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "DDOetuDA4Zfv",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown #### ⬅️ SYNC Backups\n",
        "FAST_LIST = True\n",
        "# ================================================================ #\n",
        "\n",
        "from os import path as _p\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/rlab_utils.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run  # nosec\n",
        "\n",
        "    shellCmd = \"wget -qq https://biplobsd.github.io/RLabClone/res/rlab_utils.py \\\n",
        "                    -O /root/.ipython/rlab_utils.py\"\n",
        "    run(_spl(shellCmd))  # nosec\n",
        "\n",
        "from rlab_utils import (\n",
        "    runSh,\n",
        "    prepareSession,\n",
        "    PATH_RClone_Config,\n",
        ")\n",
        "\n",
        "\n",
        "def generateCmd(src, dst):\n",
        "    block=f\"{'':=<117}\"\n",
        "    title=f\"\"\"+{f'Now Synchronizing... \"{src}\" > \"{dst}\" Fast List : {\"ON\" if FAST_LIST else \"OFF\"}':^{len(block)-2}}+\"\"\"\n",
        "    print(f\"{block}\\n{title}\\n{block}\")\n",
        "    cmd = f'rclone sync \"{src}\" \"{dst}\" --config {PATH_RClone_Config}/rclone.conf {\"--fast-list\" if FAST_LIST else \"\"} --user-agent \"Mozilla\" --transfers 20 --checkers 20 --drive-server-side-across-configs -c --buffer-size 256M --drive-chunk-size 256M --drive-upload-cutoff 256M --drive-acknowledge-abuse --drive-keep-revision-forever --tpslimit 95 --tpslimit-burst 40 --stats-one-line --stats=5s -v'\n",
        "    return cmd\n",
        "\n",
        "\n",
        "def executeSync():\n",
        "    prepareSession()\n",
        "    runSh(generateCmd(\"tdTdnMov:Movies\",\"tdMovRa4:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnTvs:TV Shows\",\"tdTvsRa5:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnRa6:Games\",\"tdGamRa7:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnRa8:Software\",\"tdSofRa9:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnR11:Tutorials\",\"tdTutR12:\"), output=True)\n",
        "    runSh(generateCmd(\"tdTdnR13:Anime\",\"tdAniR14:\"), output=True)\n",
        "    # runSh(generateCmd(\"tdTdn14:Music\",\"tdMusR15:\"), output=True)\n",
        "\n",
        "\n",
        "executeSync()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "xqBN9wyI5FEx",
        "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": {
        "colab_type": "text",
        "id": "H0rhgZhIDyPu"
      },
      "source": [
        "## <img src='https://forum.rclone.org/uploads/default/original/2X/d/da6ccb2784ff3fa73d9339300530e0aae4d6cebd.png' height=\"46\" alt=\"rclone\"/><font size=2px > Rclone config created by KMH</font>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "0VJ4VO1X8YE6",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> INSTALL Rclone modules</h3>\n",
        "\n",
        "!curl https://rclone.org/install.sh | sudo bash\n",
        "###\n",
        "!curl -O https://downloads.rclone.org/rclone-current-linux-amd64.zip\n",
        "!unzip rclone-current-linux-amd64.zip\n",
        "!cd rclone-*-linux-amd64\n",
        "###\n",
        "!sudo cp rclone /usr/bin/\n",
        "!sudo chown root:root /usr/bin/rclone\n",
        "!sudo chmod 755 /usr/bin/rclone\n",
        "###\n",
        "!sudo mkdir -p /usr/local/share/man/man1\n",
        "!sudo cp /content/rclone-v1.51.0-linux-amd64/rclone.1 /usr/local/share/man/man1/\n",
        "!sudo mandb \n",
        "###\n",
        "from IPython.display import HTML, clear_output\n",
        "clear_output()\n",
        "print(\"Successfully Installed\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "eKFLq4MvDyQZ",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> CONFIG Drives</h3>\n",
        "rclone_config_name = \"drive\" #@param {type:\"string\"}\n",
        "#=====================================================\n",
        "!rclone config create $rclone_config_name drive config_is_local false\n",
        "#!rclone config create gcached cache [--cache-remote $rclone_config_name]\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "hJQ4sW27T15I",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> CONFIG Shared Drives</h3>\n",
        "rclone_config_name = \"sdrive1\" #@param {type:\"string\"}\n",
        "#=====================================================\n",
        "!rclone config\n",
        "#!rclone config create gcached cache [--cache-remote $rclone_config_name]\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "ZXPjOW5yTTjh",
        "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\"/root/.config/rclone/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('/content/shared', exist_ok=True)\n",
        "  cache_path = '/content/shared'\n",
        "\n",
        "def MountCMD():\n",
        "    mPoint = f\"/content/{mountNam.value}\"\n",
        "    os.makedirs(mPoint, exist_ok=True)\n",
        "    cmd = rf\"rclone mount {mountNam.value}: {mPoint}\" \\\n",
        "      rf\" --config /root/.config/rclone/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": "markdown",
      "metadata": {
        "id": "lvhndnrYZpx-",
        "colab_type": "text"
      },
      "source": [
        "### **Others**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "xKZCA2-zMMte",
        "colab": {}
      },
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <h3><b>←</b> MOUNT Drive</h3>\n",
        "rclone_config_name = \"gdrive\" #@param {type:\"string\"}\n",
        "local_mount_location = \"/content/gdrive\" #@param {type:\"string\"}\n",
        "# ============================= FORM ============================= #\n",
        "import time\n",
        "import os\n",
        "\n",
        "# clear nohup\n",
        "open(\"nohup.out\", 'w').close()\n",
        "\n",
        "\n",
        "# unmount first\n",
        "\n",
        "!fusermount -u $local_mount_location 2>/dev/null\n",
        "\n",
        "\n",
        "\n",
        "# mount without waiting for the command to complete\n",
        "!mkdir $local_mount_location 2>/dev/null\n",
        "!nohup rclone mount $rclone_config_name: $local_mount_location --allow-other --allow-non-empty --daemon --buffer-size 256M --transfers 10 --vfs-cache-mode full &\n",
        "\n",
        "# Show the output that was written to nohup\n",
        "time.sleep(3)\n",
        "f = open(r\"nohup.out\", \"r\")\n",
        "nohupText = f.read()\n",
        "f.close()\n",
        "\n",
        "\n",
        "dirs = os.listdir(local_mount_location)\n",
        "\n",
        "if len(dirs) > 0:\n",
        "  clear_output(wait=True)\n",
        "  print(\"Succeeded. \", str(len(dirs)), \"dirs found at\", local_mount_location)\n",
        " \n",
        "else:\n",
        "  print(\"\\n\\nNot succeeded. No files or directories in mounted location. \\nCheck your config name and content. If the rclone command was not found, run the cell above.\\n\\n\")\n",
        "  print(\"log:\\n\", nohupText)# clear nohup\n",
        "open(\"nohup.out\", 'w').close()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fmObbq2sE1i9",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> PURGE Cache</h3>\n",
        "!rclone purge /content/shared"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yzzfo0Cekcxf",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> DELETE Configs</h3>\n",
        "rclone_config_name = \"gdrive\" #@param {type:\"string\"}\n",
        "#=====================================================\n",
        "!rclone config delete $rclone_config_name"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kSvUMUuTPX7r",
        "colab_type": "text"
      },
      "source": [
        "## ![alt text](https://mega.nz/favicon.ico?v=3) __TRANSFERE to MEGA__\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q3uC2Lo5R6N9",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown <center><h2>INPUT YOUR MEGA ID</h2></center><br>\n",
        "from functools import wraps\n",
        "import errno\n",
        "import os\n",
        "import signal\n",
        "import subprocess\n",
        "import shlex\n",
        "\n",
        "\n",
        "class TimeoutError(Exception):\n",
        "    pass\n",
        "\n",
        "\n",
        "def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):\n",
        "    def decorator(func):\n",
        "        def _handle_timeout(signum, frame):\n",
        "            raise TimeoutError(error_message)\n",
        "\n",
        "        def wrapper(*args, **kwargs):\n",
        "            signal.signal(signal.SIGALRM, _handle_timeout)\n",
        "            signal.alarm(seconds)\n",
        "            try:\n",
        "                result = func(*args, **kwargs)\n",
        "            finally:\n",
        "                signal.alarm(0)\n",
        "            return result\n",
        "\n",
        "        return wraps(func)(wrapper)\n",
        "\n",
        "    return decorator\n",
        "\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/ttmg.py\"):\n",
        "    from subprocess import run\n",
        "    from shlex import split\n",
        "\n",
        "    shellCmd = \"wget -qq https://raw.githubusercontent.com/totalleecher/Google-Colab-CloudTorrent/master/res/ttmg.py \\\n",
        "                    -O /root/.ipython/ttmg.py\"\n",
        "    run(split(shellCmd))\n",
        "from ttmg import runSh\n",
        "\n",
        "@timeout(10)\n",
        "def runShT(args):\n",
        "    return runSh(args, output=True)\n",
        "\n",
        "\n",
        "# MEGAcmd installing\n",
        "if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "    print(\"Installing MEGA ...\")\n",
        "    runSh('sudo apt-get -y update')\n",
        "    runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "    runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "    runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "    print(\"MEGA is installed.\")\n",
        "else:\n",
        "    !pkill mega-cmd\n",
        "\n",
        "# INPUT YOUR MEGA ID\n",
        "\n",
        "USERNAME = \"\"  # @param {type:\"string\"}\n",
        "PASSWORD = \"\"  # @param {type:\"string\"}\n",
        "if not (USERNAME == \"\" or PASSWORD == \"\"):\n",
        "    try:\n",
        "        runShT(f\"mega-login {USERNAME} {PASSWORD}\")\n",
        "    except TimeoutError:\n",
        "        runSh('mega-whoami', output=True)\n",
        "else:\n",
        "    print(\"Please Input your Mega IDs.\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E3N6hyM2I6hk",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "# @markdown ##### Quick move (check and leave all boxs):\n",
        "# @markdown #####{\n",
        "import time\n",
        "import subprocess\n",
        "import contextlib\n",
        "from IPython.display import clear_output\n",
        "Simple_torrent = False  # @param{type: \"boolean\"}\n",
        "Peerflix = False  # @param{type: \"boolean\"}\n",
        "# @markdown ##### }\n",
        "# @markdown <br><center><img src='https://www.impactcomputing.co.uk/uploads/files/services/managed-office-365.svg' height=\"100\" alt=\"netdata\"/></center>\n",
        "# @markdown <center><h2>TRANSFERE NOW</h2></center><br>\n",
        "# TRANSFERE NOW\n",
        "\n",
        "PATH_TO_FILE = \"\"  # @param {type:\"string\"}\n",
        "# Unix, Windows and old Macintosh end-of-line\n",
        "newlines = ['\\n', '\\r\\n', '\\r']\n",
        "\n",
        "\n",
        "def unbuffered(proc, stream='stdout'):\n",
        "    stream = getattr(proc, stream)\n",
        "    with contextlib.closing(stream):\n",
        "        while True:\n",
        "            out = []\n",
        "            last = stream.read(1)\n",
        "            # Don't loop forever\n",
        "            if last == '' and proc.poll() is not None:\n",
        "                break\n",
        "            while last not in newlines:\n",
        "                # Don't loop forever\n",
        "                if last == '' and proc.poll() is not None:\n",
        "                    break\n",
        "                out.append(last)\n",
        "                last = stream.read(1)\n",
        "            out = ''.join(out)\n",
        "            yield out\n",
        "\n",
        "\n",
        "def transfare():\n",
        "    cmd = \"\"\n",
        "    if Simple_torrent:\n",
        "        cmd = ['mega-put', 'downloads', '/colab']\n",
        "    elif Peerflix:\n",
        "        cmd = ['mega-put', 'peerflix', '/colab']\n",
        "    else:\n",
        "        cmd = ['mega-put', PATH_TO_FILE, '/colab']\n",
        "    proc = subprocess.Popen(\n",
        "        cmd,\n",
        "        stdout=subprocess.PIPE,\n",
        "        stderr=subprocess.STDOUT,\n",
        "        # Make all end-of-lines '\\n'\n",
        "        universal_newlines=True,\n",
        "    )\n",
        "    for line in unbuffered(proc):\n",
        "        clear_output(wait=True)\n",
        "        print(line)\n",
        "\n",
        "try:\n",
        "    transfare()\n",
        "except FileNotFoundError:\n",
        "    print(\"Login your account!\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XlDyLy_JZJ03",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "import os\n",
        "from IPython.display import clear_output\n",
        "#@title MEGA public link download\n",
        "URL = \"\" #@param {type:\"string\"}\n",
        "path_to_folder = \"\" #@param {type:\"string\"}\n",
        "if not path_to_folder:\n",
        "  os.makedirs(\"downloads\", exist_ok=True)\n",
        "  path_to_folder = \"downloads\"\n",
        "# MEGAcmd installing\n",
        "if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "    print(\"Installing MEGA ...\")\n",
        "    runSh('sudo apt-get -y update')\n",
        "    runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "    runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/MEGAsync/Debian_9.0/amd64/megacmd-Debian_9.0_amd64.deb', output=True)\n",
        "    runSh('sudo dpkg -i /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "    print(\"MEGA is installed.\")\n",
        "    clear_output()\n",
        "\n",
        "!mega-get $URL $path_to_folder "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "dySANcIIMdFU"
      },
      "source": [
        "# <center><b>Special Features</b><h5>Zipping, Encoding, Cloning</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ex_k738n2mO3"
      },
      "source": [
        "##<img src='https://www.gstatic.com/android/market_images/web/play_prism_hlock_2x.png' height=\"50\" alt=\"7zip\"><i>__Apk Downloader__</i>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jYsGTuj61QaM",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title ⬅️ Clone repo and install requirements - Need to restart runtime after installed\n",
        "\n",
        "%cd /content/\n",
        "!git clone https://github.com/HamidrezaMoradi/APK-Downloader.git\n",
        "#####\n",
        "%cd /content/APK-Downloader\n",
        "!pip3 install -r requirements.txt "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cSSJVg391pHb",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "!python3 APK-Downloader.py "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9IaxuTdh3276",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to move downloaded apk files to mounted gdrive</h3>\n",
        "\n",
        "import os\n",
        "\n",
        "%cd /content/drive/My Drive\n",
        "os.makedirs(\"Downloaded Apk\", exist_ok=True)\n",
        "\n",
        "\n",
        "#####\n",
        "%cd /content/APK-Downloader/File\n",
        "\n",
        "!mv *.apk \"/content/drive/My Drive/Downloaded Apk\"\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "clear_output()\n",
        "\n",
        "print(\"Files Successfully Moved\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zajDdD9kKNw9"
      },
      "source": [
        "##<img src='https://yuju.pw/y/qUkg.png' height=\"65\" alt=\"7zip\"><i>__7-Zip + UNRAR__</i>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "3fMs7cVkKNxA",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> <i>Required:</i> Install 7-Zip + UNRAR\n",
        "!sudo apt update\n",
        "!sudo apt install p7zip-full p7zip-rar unrar rar"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "BYmG1ZmqKNxM",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>» Run to change current working directory\n",
        "import os\n",
        "new_dir = \"\" #@param {type:\"string\"}\n",
        "\n",
        "%cd \"$new_dir\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "zuaySeQuKNxV",
        "colab": {}
      },
      "source": [
        "#@title » Extract Archive (<i>.zip, .rar, .7z, etc.</i>)\n",
        "import os, sys, re\n",
        "\n",
        "archive_file_path = \"\" #@param {type:\"string\"}\n",
        "output_path = \"\" #@param {type:\"string\"}\n",
        "os.environ['inputFile'] = archive_file_path\n",
        "os.environ['outputFile'] = output_path\n",
        "\n",
        "!7z e \"$inputFile\"  -o\"$outputFile\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "EJKWr_UwKNxj",
        "colab": {}
      },
      "source": [
        "#@title » Create .zip .7z from Folder\n",
        "import os, sys, re\n",
        "\n",
        "folder_path = \"\" #@param {type:\"string\"}\n",
        "archiving_method = 'zip' #@param [\"zip\", \"7z\" ]\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", folder_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", folder_path)\n",
        "folder_name = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "\n",
        "os.environ['inputDir'] = folder_path\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "os.environ['folderName'] = folder_name\n",
        "\n",
        "if archiving_method == 'zip':\n",
        "   !7z a -tzip \"$outputPath\"/\"$folderName\".zip \"$inputDir\"\n",
        "\n",
        "if archiving_method == '7z':\n",
        "   !7z a -t7z -m0=lzma -mx=9 -mfb=258 -md=32m -ms=on \"$outputPath\"/\"$folderName\".7z \"$inputDir\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c3cOMk38t8Zm",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/totalleecher/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/totalleecher/\" \\\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 = \"7Z\" #@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/totalleecher/\" \\\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": {
        "colab_type": "text",
        "id": "nnK31oX-jC5p"
      },
      "source": [
        "## <img src='https://rclone.org/img/rclone-32x32.png' height=\"46\" alt=\"rclone\"/><i>__Autorclone__</i>\n",
        "<h6> ✧  Break The 750GB Limit</h6>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "W61wx2ZLjC52",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run this cell to install all required modules</h3>\n",
        "\n",
        "!curl https://rclone.org/install.sh | sudo bash\n",
        "###\n",
        "%cd /content/\n",
        "!git clone https://github.com/totalleecher/AutoRclone.git\n",
        "###\n",
        "%cd /content/AutoRclone\n",
        "!sudo pip3 install -r requirements.txt\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "clear_output()\n",
        "print(\"Successfully Installed\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "XbcSRo0RjC6P",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Enable Drive Api & Get credentials.json</h3>\n",
        "!python3 gen_sa_accounts.py --quick-setup -1\n",
        "\n",
        "from IPython.display import Image, display\n",
        "display(Image(url = \"https://raw.githubusercontent.com/totalleecher/Codemaster/master/Screenshot_2020-03-24%20Python%20Quickstart%20Google%20Drive%20API%20Google%20Developers.png?token=AOP5QOFSDN3WE5Q42J3ANZ26XJ6AA\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "N8fETzRpjC6s",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Upload \"credentials.json\"</h3>\n",
        "\n",
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "LMoXkToAjC69",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Generate Service Accounts (if you already have service account please skip this step)</h3>\n",
        "\n",
        "!python3 gen_sa_accounts.py --quick-setup -1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "xIasBR9wZaMP",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Existing projects, you need to create a new \"Enter the number of the project to be healthy. For example, 5 represents a total of 5 projects and a total of 500 SAs. It is recommended to use googlegroups to manage.</h3>\n",
        "numbers = \"1\" #@param {type:\"string\"}\n",
        "\n",
        "!python3 gen_sa_accounts.py --quick-setup \"$numbers\" --new-only\n",
        "\n",
        "#@markdown <font size=\"4\" color=red><b>If the fourth step has been wrong, you may not have any project. Click here to open <a href=\"https://console.developers.google.com/\" target= \"_blank\">Google Cloud Platform</a>, press Select a project next to GoogleAPIs in the upper left corner, press NEW PROJECT in the upper right corner of the pop-up window. Then press CREATE. Go back and run the fourth step. </b></font>"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "eplOxOmrjC7R"
      },
      "source": [
        "### Method 1 (Adding Services Acc to **Team Drive**)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "_-MmxPYFjC7W",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run this cell to add all SAs to a Team Drive</h3>\n",
        "#@markdown </h5>Team Drive ID (TDid) = https://drive.google.com/drive/folders/<code>all-of-these-letters-numbers-and-symbols </code></h5>\n",
        "#@markdown <h5><i>This may take some time. Be patient!</i></h5> \n",
        "import os\n",
        "TDid = \"\" #@param {type:\"string\"}\n",
        "!python3 add_to_team_drive.py -d \"$TDid\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "ItewOXbSjC7r",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> **Final Step -** Running Autorclone</h3>\n",
        "#@markdown <p>- Add the Source Folder ID and then the Destination Folder ID</p>\n",
        "#@markdown <p>- Note: Your source*** *(*`src`*)* ***folder must be publically accessible***</p>\n",
        "\n",
        "#@markdown Folder IDs are found at the end of the URL:\n",
        "#@markdown ![](https://yuju.pw/y/qNvy.png)\n",
        "\n",
        "#@title <h3><b>←</b> Run to clone all folders + files from <code>src</code> to <code>dest</code>\n",
        "#@markdown <i>Paste only the Folder IDs for these values</i>:\n",
        "source = \"\" #@param {type:\"string\"}\n",
        "destination = \"\" #@param {type:\"string\"}\n",
        "sa = \"\" #@param {type:\"string\"}\n",
        "\n",
        "!python3 rclone_sa_magic.py -s \"$source\" -d \"$destination\" -b \"$sa\" -e 600\n",
        "\n",
        "#@markdown <b> Tip - sa start default 1 If you have copied 7.5T, then you should put 11 SA 750GB in 24 hours."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "boIJhB5zjC76"
      },
      "source": [
        "### Method 2 (Adding Services Acc to **Google Group**)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "GKX5NesojC7-",
        "colab": {}
      },
      "source": [
        "#@markdown Create Google Group then add the service accounts as members by hand. Limit is 10 at a time, 100 a day but if you read our warning and notes above, you would have 1 project and hence easily in your range.\n",
        "\n",
        "import os\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "print (\"https://groups.google.com/\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "FaeA_9ofyf_g",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Generate Service Accounts (if you already have service account please skip this step)</h3>\n",
        "\n",
        "!python3 gen_sa_accounts.py --quick-setup -1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "WbcASvZBjC8P",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> **Final Step -** Running Autorclone</h3>\n",
        "#@markdown <p>- Add the Source Folder ID and then the Destination Folder ID</p>\n",
        "#@markdown <p>- Note: ***Your source*** *(*`src`*)* ***folder must be publically accessible***</p>\n",
        "\n",
        "#@markdown Folder IDs are found at the end of the URL:\n",
        "#@markdown ![](https://yuju.pw/y/qNvy.png)\n",
        "\n",
        "#@title <h3><b>←</b> Run to clone all folders + files from <code>src</code> to <code>dest</code>\n",
        "#@markdown <i>Paste only the Folder IDs for these values</i>:\n",
        "source = \"\" #@param {type:\"string\"}\n",
        "destination = \"\" #@param {type:\"string\"}\n",
        "\n",
        "!python3 rclone_sa_magic.py -s \"$source\" -d \"$destination\" -b 1 -e 600"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "NKQKbbO5jC8f"
      },
      "source": [
        "### Extra (Checking File size & Qty)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "XWWAn0uujC8j",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Size of Source Directory</h3> \n",
        "!rclone --config rclone.conf size --disable ListR src001:"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "LsChZJ2FjC8y",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Size of Destination Directory</h3> \n",
        "!rclone --config rclone.conf size --disable ListR src001:"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "bNcxDO0AMSkk",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Deduplicate the target file after transfer</h3>\n",
        "!rclone --config rclone.conf dedupe dst001:"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z-0L1Mousoom",
        "colab_type": "text"
      },
      "source": [
        "###<font size=4 color=\"red\"><b><center>When you first run it, please back up SA(backup) at the end, next time you only need to configure the environment in step 1 when copying, 3(before Download the downloaded credentials.json) Restore Services Account to the configuration environment and start copying</center></b></font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_1pqEmj2nR3_",
        "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>Load Google Drive backup and restore the Accounts folder under Autoclone. </h3></center><br>\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "MODE = \"BACKUP\" #@param [\"BACKUP\", \"RESTORE\"]\n",
        "#备份SA!\n",
        "if MODE == \"BACKUP\": \n",
        "  !rclone copy \"/content/AutoRclone/accounts/\" \"/content/drive/My Drive/accounts/\"\n",
        "elif MODE == \"RESTORE\":\n",
        "  !rclone copy \"/content/drive/My Drive/accounts/\" \"/content/AutoRclone/accounts/\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K6yDnWXvlxfb",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://avatars3.githubusercontent.com/u/10668779?s=200&v=4' height=\"46\" alt=\"rclone\"/><i>__clone__</i>\n",
        "<h6> ✧  Break The 750GB Limit</h6>\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TxEYMYh0hMU6",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title ← Install Gclone\n",
        "!bash <(wget -qO- https://git.io/gclone.sh)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2y9lJItbhbOy",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "!gclone config\n",
        "\n",
        "#@markdown <p><b><h3><center> You only need to configure it once, and only one key to restore it after backup</center> </p>\n",
        "#@markdown <p><b>- Step 1 select n, and then give the remote a new name here with gc </p>\n",
        "#@markdown <p><b>- Step 2 choice 13, client_id and client_secret are not filled in by default. </p>\n",
        "#@markdown <p><b>- Step 3 select scope and fill in 1, root_folder_id is not filled in by default. </p>\n",
        "#@markdown <p><b>- Step 4 open the colab folder on the left and find the right copy path of any json file under Autorclone/accounts. For example = /content/AutoRclone/accounts/02d62cb52b2ac72d2c78c5b1b529b202acaf591a.json </ p>\n",
        "#@markdown <p><b>- Step 5 service_account_file_path> Fill in /content/AutoRclone/accounts/ </p>\n",
        "#@markdown <p><b>- Step 6 Edit advanced config? (y/n) Select n .</p>\n",
        "#@markdown <p><b>- Step 7 Configure this as a team drive? Fill in y."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lUyZKS7chofc",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h1> <p><b><center><font color=\"pink\">Start copying with Gclone</center></h>\n",
        "source = \"0AL51pdekZf0xUk9PVA\" #@param {type:\"string\"}\n",
        "destination = \"0AFws8i4wNMFVUk9PVA\" #@param {type:\"string\"}\n",
        "folder = \"\" #@param {type:\"string\"}\n",
        "cmd = f\"gclone copy gc:{{{source}}} gc:{{{destination}}}{folder} --drive-server-side-across-configs -v\"\n",
        "!$cmd\n",
        "\n",
        "#@markdown <p>- folder is the format of the folder to be saved is /Movie/Domestic/Jackie Collection No spaces.</p>\n",
        "#@markdown <p>- If you are afraid of losing the file, execute it 1 or 2 more times, and automatically skip existing resources. </p>"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sDwfInCbMVsL",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3> <p><center>Gclone deduplication tool</center></h>\n",
        "\n",
        "folder = \"\" #@param {type:\"string\"}\n",
        "\n",
        "cmd = f\"gclone dedupe --dedupe-mode newest gc:{folder}\"\n",
        "!$cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cy_hNQxHn-jO",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <center><h3>One-click backup and restore Gclone configuration file-<font color=\"red\">No configuration is needed after restoring</font></h3></center>\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "MODE = \"RESTORE\" #@param [\"BACKUP\", \"RESTORE\"]\n",
        "#Backup SA!\n",
        "if MODE == \"BACKUP\": \n",
        "  !rclone copy \"/root/.config/rclone/rclone.conf\" \"/content/drive/My Drive/gclone/\"\n",
        "elif MODE == \"RESTORE\":\n",
        "  !rclone copy \"/content/drive/My Drive/gclone/\" \"/root/.config/rclone/\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ukxnQC4c0nuR",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://www.vozidea.com/wp-content/uploads/2018/05/ffmpeg-logo-grande.png ' height=\"57\" alt=\"RcloneLab\"/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EFOqhHG6hOVH",
        "colab_type": "text"
      },
      "source": [
        "## ***Required to use Scripts:*** Install FFmpeg, VCSI & Mkvtoolnix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G3JHGE0Jtzme",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Click Here to Install FFmpeg, VCSI, Mkvtoolnix, Firefox, Furiousmount & Handbrake</h3>\n",
        "\n",
        "#@title <font size=\"5\">← ឵឵<i>Upgrade FFmpeg to v4.2.2</font> { vertical-output: true }\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...\", ty='twg')\n",
        "#os.system('pip install git+git://github.com/AWConant/jikanpy.git') //GPU Not supported\n",
        "#os.system('add-apt-repository -y ppa:jonathonf/ffmpeg-4') //GPU Not supported\n",
        "os.system('apt-get update')\n",
        "os.system('apt-get install ffmpeg')\n",
        "os.system('apt-get install mkvtoolnix')\n",
        "os.system('pip install vcsi')\n",
        "#os.system('sudo apt-get install synaptic')\n",
        "#os.system('sudo apt install firefox')\n",
        "os.system('sudo add-apt-repository ppa:stebbins/handbrake-releases -y')\n",
        "os.system('sudo apt update -y')\n",
        "os.system('sudo apt install --install-recommends handbrake-gtk handbrake-cli')\n",
        "#os.system('sudo apt-get install furiusisomount')\n",
        "\n",
        "clear_output()\n",
        "print(\"Install Finished\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ey6-UveDalxR"
      },
      "source": [
        "###» Re-encode a Video to a Different Resolution (*H265*) - Need GPU - Nvidia Telsa P100 or T4 (Support Both Single & Batch Processing)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tsY6jhC9SXvF",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Check GPU\n",
        "#@markdown Run this to connect to a Colab Instance, and see what GPU Google gave you.\n",
        "\n",
        "gpu = !nvidia-smi --query-gpu=gpu_name --format=csv\n",
        "print(gpu[1])\n",
        "print(\"The Tesla T4 and P100 are fast and support hardware encoding. The K80 and P4 are slower.\")\n",
        "print(\"Sometimes resetting the instance in the 'runtime' tab will give you a different GPU.\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "Zam_JHPDalxc",
        "colab": {}
      },
      "source": [
        "path = \"\" #@param {type:\"string\"}\n",
        "save_txt = False #@param {type:\"boolean\"}\n",
        "import os, uuid, re, IPython\n",
        "import ipywidgets as widgets\n",
        "import time\n",
        "\n",
        "from glob import glob\n",
        "from IPython.display import HTML, clear_output\n",
        "from google.colab import output, drive\n",
        "\n",
        "def mediainfo():\n",
        "  display(HTML(\"<br>\"))\n",
        "#   print(path.split(\"/\")[::-1][0])\n",
        "  display(HTML(\"<br>\"))\n",
        "#   media = !mediainfo \"$path\"\n",
        "#   media = \"\\n\".join(media).replace(os.path.dirname(path)+\"/\", \"\")\n",
        "  get_ipython().system_raw(\"\"\"mediainfo --LogFile=\"/root/.nfo\" \"$path\" \"\"\")\n",
        "  with open('/root/.nfo', 'r') as file:\n",
        "    media = file.read()\n",
        "    media = media.replace(os.path.dirname(path)+\"/\", \"\")\n",
        "  print(media)\n",
        "  get_ipython().system_raw(\"rm -f '/root/.nfo'\")\n",
        "  \n",
        "  if save_txt:\n",
        "    txt = path.rpartition('.')[0] + \".txt\"\n",
        "    if os.path.exists(txt):\n",
        "      get_ipython().system_raw(\"rm -f '$txt'\")\n",
        "    !curl -s https://pastebin.com/raw/TApKLQfM -o \"$txt\"\n",
        "    with open(txt, 'a+') as file:\n",
        "      file.write(\"\\n\\n\")\n",
        "      file.write(media)\n",
        "\n",
        "while not os.path.exists(\"/content/drive\"):\n",
        "  try:\n",
        "    drive.mount(\"/content/drive\")\n",
        "    clear_output(wait=True)\n",
        "  except:\n",
        "    clear_output()\n",
        "    \n",
        "if not os.path.exists(\"/usr/bin/mediainfo\"):\n",
        "  get_ipython().system_raw(\"apt-get install mediainfo\")\n",
        "  \n",
        "mediainfo()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "SHBPElqualx6",
        "colab": {}
      },
      "source": [
        "import os, sys, re\n",
        "#@markdown <b>Encoder</b>\n",
        "Encoder = \"CPU\" #@param [\"GPU\", \"CPU\"]\n",
        "codec = \"x264\" #@param [\"x264\", \"x265\"]\n",
        "#@markdown <b>Encoding all videos in folder</b>\n",
        "video_folder_path = '' #@param {type:\"string\"}\n",
        "#@markdown ---\n",
        "#@markdown <b>Encoding selected videos</b>\n",
        "video_file_path1 = '' #@param {type:\"string\"}\n",
        "video_file_path2 = '' #@param {type:\"string\"}\n",
        "video_file_path3 = '' #@param {type:\"string\"}\n",
        "video_file_path4 = '' #@param {type:\"string\"}\n",
        "video_file_path5 = '' #@param {type:\"string\"}\n",
        "\n",
        "#counting\n",
        "if video_file_path1 != \"\":\n",
        "  coa = 1\n",
        "else:\n",
        "  coa = 0\n",
        "\n",
        "if video_file_path2 != \"\":\n",
        "  cob = 1\n",
        "else:\n",
        "  cob = 0\n",
        "\n",
        "if video_file_path3 != \"\":\n",
        "  coc = 1\n",
        "else:\n",
        "  coc = 0\n",
        "\n",
        "if video_file_path4 != \"\":\n",
        "  cod = 1\n",
        "else:\n",
        "  cod = 0\n",
        "\n",
        "if video_file_path5 != \"\":\n",
        "  coe = 1\n",
        "else:\n",
        "  coe = 0\n",
        "\n",
        "#@markdown ---\n",
        "resolution = '360p' #@param [\"2160p\",\"1440p\",\"1080p\", \"720p\", \"480p\", \"360p\", \"240p\", \"same as input\"]\n",
        "encode_setting = 'Advance' #@param [\"Advance\", \"HEVC\", \"HEVC 10 Bit\"]\n",
        "file_type = 'mkv' #@param [\"mkv\", \"mp4\"]\n",
        "rip_audio = False #@param {type:\"boolean\"}\n",
        "rip_subtitle = False #@param {type:\"boolean\"}\n",
        "\n",
        "if rip_audio == False:\n",
        "  rip_audio_string =  \"-acodec copy\"\n",
        "else:\n",
        "  rip_audio_string =  \"-an\"\n",
        "\n",
        "if rip_subtitle == False:\n",
        "  rip_subtitle_string = \"-scodec copy\"\n",
        "else:\n",
        "  rip_subtitle_string = \"-sn\"\n",
        "\n",
        "\n",
        "if resolution == '2160p':\n",
        "   w = '3840'\n",
        "elif resolution == '1440p':\n",
        "   w = '2560'\n",
        "elif resolution == '1080p':\n",
        "   w = '1980'\n",
        "elif resolution == '720p':\n",
        "   w = '1280'\n",
        "elif resolution == '480p':\n",
        "   w = '854'\n",
        "elif resolution == '360p':\n",
        "   w = '640'\n",
        "elif resolution == '240p':\n",
        "   w = '426'\n",
        "else:\n",
        "   w = ''\n",
        "\n",
        "if  (w == '3840' or w == '2560' or w == '1980' or w == '1280' or w == '854' or w == '640' or w == '426'):\n",
        "  scale_string = \"-vf  scale=\"+(w)+\":-1:flags=lanczos\" \n",
        "else:\n",
        "  scale_string = \"\"\n",
        "\n",
        "ext = \".mp4\",\".MP4\",\".MTS\",\".mts\",\".m2ts\",\".mkv\",\".avi\",\".MOV\",\".mov\",\".wmv\",\".WMV\",\".flv\",\".mpg\",\".webm\",\".WEBM\"\n",
        "# As file at filePath is deleted now, so we should check if file exists or not not before deleting them\n",
        "filePath = \"ffmpeg.txt\"\n",
        "if os.path.exists(filePath):\n",
        "     os.remove(filePath)\n",
        "\n",
        "if video_folder_path == \"\":\n",
        " #try:\n",
        "  f = open(\"ffmpeg.txt\", \"+w\")\n",
        "  x = (video_file_path1) + \"\\n\" + (video_file_path2) + \"\\n\" +(video_file_path3) + \"\\n\" +(video_file_path4) +\"\\n\" + (video_file_path5)\n",
        "  f.write(x)\n",
        "  f.close()\n",
        "  count = coa+cob+coc+cod+coe\n",
        " #except:\n",
        "  #err = 1\n",
        "\n",
        "else:\n",
        "#writing temp file\n",
        " for file in os.listdir(video_folder_path):\n",
        "    if file.endswith(tuple(ext)):\n",
        "        \n",
        "     x = os.path.join(video_folder_path, file) \n",
        "     #print(x)\n",
        "     print(x, file=open(\"ffmpeg.txt\", \"+a\"))    \n",
        "\n",
        "#counting line\n",
        " thefilepath = \"ffmpeg.txt\"\n",
        " count = len(open(thefilepath).readlines(  ))\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown <h4>Advance Settings</h4>\n",
        "#@markdown <b>Video Setting</b>\n",
        "preset = 'slow' #@param [\"slow\", \"medium\", \"fast\", \"hq\", \"hp\", \"bd\", \"ll\", \"llhq\", \"llhp\", \"lossless\", \"losslesshp\"]\n",
        "level = '5.2' #@param [\"default\",\"4.1\", \"5.1\", \"5.2\", \"6.2\"]\n",
        "tier = 'main' #@param [\"default\",\"main\", \"high\"]\n",
        "#@markdown <code>Setting only for GPU Encoding</code>\n",
        "profile = 'main' #@param [\"main\", \"main10\", \"rext\"]\n",
        "pixfmt = 'p010le' #@param [\"nv12\", \"yuv420p\", \"p010le\", \"yuv444p\", \"p016le\", \"yuv444p16le\"]\n",
        "rc = 'vbr_hq' #@param [\"vbr\", \"cbr\", \"vbr_2pass\", \"ll_2pass_size\", \"vbr_hq\", \"cbr_hq\"]\n",
        "rcla = '32' #@param [\"8\", \"16\", \"32\", \"64\"]\n",
        "overall_bitrate = 2500 #@param {type:\"slider\", min:500, max:10000, step:100}\n",
        "max_bitrate = 20000 #@param {type:\"slider\", min:500, max:50000, step:100}\n",
        "buffer_size = 60000 #@param {type:\"slider\", min:500, max:90000, step:100}\n",
        "deblock = -3 #@param {type:\"slider\", min:-6, max:6, step:1}\n",
        "reframe = 5 #@param {type:\"slider\", min:1, max:6, step:1}\n",
        "surfaces = 64 #@param {type:\"slider\", min:0, max:64, step:1}\n",
        "#@markdown <code>Setting only for CPU Encoding</code>\n",
        "profile_cpu = 'main10' #@param [\"main10\"]\n",
        "pixfmt_cpu = 'yuv420p10le' #@param [\"yuv420p\",\"yuv420p10le\",\"yuv444p\",\"yuv444p16le\"]\n",
        "threads = 16 #@param {type:\"slider\", min:0, max:16, step:1}\n",
        "crf = 28 #@param {type:\"slider\", min:0, max:30, step:1}\n",
        "\n",
        "\n",
        "if level != \"default\":\n",
        "  l_string =  \"-level \"+str(level)\n",
        "else:\n",
        "  l_string =\"\"\n",
        "\n",
        "if tier != \"default\":\n",
        " t_string =  \"-tier \"+str(tier)\n",
        "else:\n",
        " t_string = \"\"\n",
        "\n",
        "#tp = '1' #@param [\"0\", \"1\"]\n",
        "#cq = '21' #@param {type:\"string\"}\n",
        "#qm ='21' #@param {type:\"string\"}\n",
        "#qmx = '27' #@param {type:\"string\"}\n",
        "#qp = '23' #@param {type:\"string\"}\n",
        "#qb = '25' #@param {type:\"string\"}\n",
        "#qi = '21' #@param {type:\"string\"}\n",
        "\n",
        "#@markdown <b>Audio Setting</b>\n",
        "\n",
        "audio_output = 'No audio' #@param [\"None\", \"copy\", \"flac\", \"aac\", \"libopus\", \"eac3\", \"No audio\", \"same as input\"]\n",
        "channel = 'same as input' #@param [\"DownMix 2CH\", \"same as input\"]\n",
        "\n",
        "if audio_output == \"same as input\":\n",
        "  audio_string = \"-acodec copy\"\n",
        "elif audio_output == \"No audio\":\n",
        "  audio_string = \"-an\"\n",
        "elif audio_output == \"None\":\n",
        "  audio_string = \"\"\n",
        "else:\n",
        "  audio_string = \"-c:a \"+(audio_output)\n",
        "\n",
        "if channel == \"DownMix 2CH\":\n",
        "  channel_string =\"-ac 2\"\n",
        "else:\n",
        "  channel_string =\"\"\n",
        "\n",
        "#@markdown <b>Subtitle Setting</b>\n",
        "#@markdown <h5>Please use <code>ass</code> file for hardsub</h5>\n",
        "hardsub = False #@param {type:\"boolean\"}\n",
        "subtitle_option = 'same as input' #@param [\"None\",\"No sub\", \"Add custom sub\",\"same as input\"]\n",
        "custom_subtitle_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown <b>Custom Added Setting</b>\n",
        "custom_command = \"\" #@param {type:\"string\"}\n",
        "\n",
        "\n",
        "if hardsub == False:\n",
        "\n",
        " if subtitle_option == \"No sub\":\n",
        "  subtitle_string = \"-sn\"\n",
        " elif subtitle_option == \"same as input\":\n",
        "  subtitle_string = \"-scodec copy\"\n",
        " elif subtitle_option == \"None\":\n",
        "  subtitle_string = \"\"\n",
        " else:\n",
        "  subtitle_string = \"-i \"+(custom_subtitle_path)\n",
        "\n",
        "else:\n",
        "  subtitle_string = \"ass=\"+(custom_subtitle_path)\n",
        "#=================\n",
        "if custom_command != \"\":\n",
        " c_string = custom_command\n",
        "else:\n",
        " c_string = \"\"\n",
        "#=================\n",
        "\n",
        "os.environ['ps'] = preset\n",
        "os.environ['pf'] = profile\n",
        "os.environ['pf_cpu'] = profile_cpu\n",
        "os.environ['pfm'] = pixfmt\n",
        "os.environ['pfmcpu'] = pixfmt_cpu\n",
        "os.environ['br'] = str(overall_bitrate)\n",
        "os.environ['max'] = str(max_bitrate)\n",
        "os.environ['buff'] = str(buffer_size)\n",
        "os.environ['de'] = str(deblock)\n",
        "os.environ['ref'] = str(reframe)\n",
        "os.environ['sur'] = str(surfaces)\n",
        "os.environ['lv'] = l_string\n",
        "os.environ['ti'] = t_string\n",
        "os.environ['rc'] = rc\n",
        "os.environ['rl'] = rcla\n",
        "os.environ['thr'] = str(threads)\n",
        "os.environ['crf'] = str(crf)\n",
        "os.environ['res'] = resolution\n",
        "#os.environ['tp'] = tp\n",
        "#os.environ['cq'] = cq\n",
        "#os.environ['qP'] = qp\n",
        "#os.environ['qB'] = qb\n",
        "#os.environ['qI'] = qi\n",
        "#os.environ['qm'] = qm\n",
        "#os.environ['qmx'] = qmx\n",
        "os.environ['scs'] = str(scale_string)\n",
        "os.environ['aus'] = audio_string\n",
        "os.environ['chc'] = channel_string\n",
        "os.environ['sus'] = subtitle_string\n",
        "os.environ['cus'] = str(c_string)\n",
        "#=================\n",
        "#Batch Encoding\n",
        "if count != 0:\n",
        " f=open('ffmpeg.txt')\n",
        " lines=f.readlines()\n",
        "\n",
        " i = 0\n",
        " while i < count:\n",
        "  video_file_path = lines[i]\n",
        "  video_file_path = video_file_path.rstrip(\"\\n\")\n",
        "  #print(video_file_path)\n",
        "\n",
        "  delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "  testsplit = video_file_path.split(\"/\")\n",
        "  filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "  filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "  resolution_raw = re.search(\"[^p]{3,4}\", resolution)\n",
        "  output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "\n",
        "  os.environ['inputFile'] = video_file_path\n",
        "  os.environ['outputPath'] = output_file_path.group(0)\n",
        "  os.environ['fileName'] = filename_raw\n",
        "  os.environ['fileType'] = file_type\n",
        "  os.environ['resolutionWidth'] = resolution_raw.group(0)\n",
        "\n",
        "  if Encoder == \"GPU\":\n",
        "   if codec == \"x265\":\n",
        "    if encode_setting == \"Advance\":\n",
        "\n",
        "     !ffmpeg -hwaccel cuvid -i \"$inputFile\" -stats -flags +loop -c:v hevc_nvenc -preset:v \"$ps\" -rc \"$rc\" -2pass 1 -b:v \"$br\"k -maxrate \"$max\"k -bufsize \"$buff\"k -profile:v \"$pf\" $lv $ti -pix_fmt \"$pfm\" -rc-lookahead \"$rl\" -no-scenecut 1 -weighted_pred 1 -deblock:v \"$de\":\"$de\" -refs:v \"$ref\" -surfaces \"$sur\" $scs $aus $chs $sus $cus \"$outputPath\"/\"$fileName\"-\"$res\".\"$fileType\" \n",
        "  \n",
        "    elif encode_setting == \"HEVC\":\n",
        "     !ffmpeg -hwaccel cuvid -i \"$inputFile\" -stats -flags +loop -c:v hevc_nvenc -preset:v slow -rc vbr_hq -2pass 1 -b:v 2500k -maxrate 20M -bufsize 60M -cq 1 -forced-idr 1 -nonref_p 1 -pix_fmt p010le -rc-lookahead 32 -no-scenecut 1  -weighted_pred 1 -deblock:v -3:-3 -refs:v 5  -surfaces 64 $scs $aus $sus \"$outputPath\"/\"$fileName\"-\"$res\".\"$fileType\" \n",
        "\n",
        "    else:\n",
        "     !ffmpeg -hwaccel cuvid  -stats -flags +loop -c:v hevc_nvenc -preset:v slow -rc vbr_hq -2pass 1 -b:v 2500k -maxrate 20M -bufsize 60M -cq 1 -forced-idr 1 -nonref_p 1 -profile:v main10 -pix_fmt p010le -rc-lookahead 32 -no-scenecut 1  -weighted_pred 1 -deblock:v -3:-3 -refs:v 5  -surfaces 64 $scs $aus $sus \"$outputPath\"/\"$fileName\"-\"$res\".\"$fileType\" \n",
        "   else:\n",
        "     !ffmpeg -hwaccel cuvid -i \"$inputFile\" -c:v h264_cuvid $scs $aus $sus \"$outputPath\"/\"$fileName\"-\"$res\".\"$fileType\" \n",
        "     \n",
        "  else:\n",
        "   if codec == \"x265\":\n",
        "    if encode_setting == \"Advance\":\n",
        "     !ffmpeg -i \"$inputFile\" -flags +loop -c:v libx265 -profile:v \"$pf_cpu\" $lv $ti -pix_fmt \"$pfmcpu\" -threads \"$thr\" -thread_type frame -preset:v \"$ps\" -crf \"$crf\" -x265-params \"rc-lookahead=40:bframes=4:b-adapt=2:ref=6:aq-mode=0:aq-strength=0:aq-motion=0:me=hex:subme=3:max-merge=3:weightb=1:no-fast-intra=1:tskip-fast=0:rskip=0:strong-intra-smoothing=0:b-intra=1:early-skip=0:sao=0:rd=1:psy-rd=0:deblock=-5,-5\" $scs $aus $chs  $sus $cus \"$outputPath\"/\"$fileName\"-\"$res\".\"$fileType\" \n",
        "   \n",
        "    elif encode_setting == \"HEVC\":\n",
        "     !ffmpeg -i \"$inputFile\" -c:v libx265 -crf 28 -threads 6 -thread_type frame $scs $aus $sus \"$outputPath\"/\"$fileName\"-\"$res\".\"$fileType\" \n",
        "\n",
        "    else:\n",
        "     !ffmpeg -i \"$inputFile\" -c:v libx265 -profile:v main10 -crf 28 -threads 6 -thread_type frame $scs $aus $sus \"$outputPath\"/\"$fileName\"-\"$res\".\"$fileType\" \n",
        "   else:\n",
        "     !ffmpeg -hide_banner -i \"$inputFile\" -c:v libx264 -preset \"$ps\" -crf \"$crf\" -threads \"$thr\" -strict experimental $scs $aus $sus \"$outputPath\"/\"$fileName\"-\"$res\".\"$fileType\" \n",
        "\n",
        "  i += 1\n",
        "\n",
        " else:\n",
        "  print(\"All Finished\")\n",
        "  os.remove(filePath)\n",
        "else:\n",
        "  print(\"Please input file or folder path\")\n",
        "#End of Code V1.5 - Codemater -  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "GahMjYf8miNs"
      },
      "source": [
        "###» Generate Thumbnails - Preview from Video "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0nY7QbDIrnGl",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Click Here to generate thumbnail for all video in input folder path</h3>\n",
        "\n",
        "import os\n",
        "folder_path = \"\" #@param {type:\"string\"}\n",
        "ext = \".mp4\",\".MP4\",\".MTS\",\".mts\",\".m2ts\",\".mkv\",\".avi\",\".MOV\",\".mov\",\".wmv\",\".WMV\",\".flv\",\".mpg\",\".webm\",\".WEBM\"\n",
        "video_path = '' #@param {type:\"string\"}\n",
        "\n",
        "\n",
        "#counting\n",
        "if video_path != \"\":\n",
        "  count = 1\n",
        "else:\n",
        "  count = 0\n",
        "\n",
        "# As file at filePath is deleted now, so we should check if file exists or not not before deleting them\n",
        "filePath = \"vcsi.txt\"\n",
        "if os.path.exists(filePath):\n",
        "     os.remove(filePath)\n",
        "\n",
        "\n",
        "\n",
        "if (folder_path == \"\") and (video_path != \"\"):\n",
        " #try:\n",
        "  f = open(\"vcsi.txt\", \"+w\")\n",
        "  f.write(video_path)\n",
        "  f.close()\n",
        "  count = 1\n",
        "\n",
        "elif (folder_path == \"\") and (video_path == \"\"):\n",
        "  count = 0\n",
        "\n",
        "else:\n",
        "#writing temp file\n",
        " for file in os.listdir(folder_path):\n",
        "    if file.endswith(tuple(ext)):\n",
        "        \n",
        "     x = os.path.join(folder_path, file) \n",
        "     #print(x)\n",
        "     print(x, file=open(\"vcsi.txt\", \"+a\"))    \n",
        "\n",
        "#counting line\n",
        " thefilepath = \"vcsi.txt\"\n",
        " count = len(open(thefilepath).readlines(  ))\n",
        "\n",
        "\n",
        "import os, sys, re\n",
        "from IPython.display import Image, display\n",
        "os.makedirs(\"/content/drive/My Drive/Thumbnail\", exist_ok=True)\n",
        "\n",
        "output_file_type = 'png' #@param [\"png\", \"jpg\"]\n",
        "creation_engine = 'vcsi' #@param [\"ffmpeg\", \"vcsi\"]\n",
        "output_path = 'same folder' #@param [\"same folder\", \"My Drive/Thumbnail\"]\n",
        "#@markdown <code>Eg : gird 3 = 3x3</code>\n",
        "grid = 4 #@param {type:\"slider\", min:1, max:20, step:1}\n",
        "default_grid = True #@param {type:\"boolean\"}\n",
        "time_stamp = False #@param {type:\"boolean\"}\n",
        "\n",
        "\n",
        "if time_stamp == True:\n",
        "  t_string = \"-t\"\n",
        "else:\n",
        "  t_string = \"\"\n",
        "\n",
        "if default_grid == False:\n",
        "  g_string = \"-g \" + str(grid) + \"x\" + str(grid) \n",
        "else:\n",
        "  g_string = \"\"\n",
        "\n",
        "os.environ['ts'] = t_string\n",
        "os.environ['gs'] = g_string\n",
        "#Batch Encoding\n",
        "if count != 0:\n",
        " f=open('vcsi.txt')\n",
        " lines=f.readlines()\n",
        "\n",
        " i = 0\n",
        " while i < count:\n",
        "  video_file_path = lines[i]\n",
        "  video_file_path = video_file_path.rstrip(\"\\n\")\n",
        "  print(video_file_path)\n",
        "  \n",
        "  output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "  output_file_path_raw = output_file_path.group(0)\n",
        "  delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "  filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "  filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "  file_extension = re.search(\".{3}$\", filename)\n",
        "  file_extension_raw = file_extension.group(0)\n",
        "\n",
        "  os.environ['inputFile'] = video_file_path\n",
        "  os.environ['outputPath'] = output_file_path_raw\n",
        "  os.environ['outputExtension'] = output_file_type\n",
        "  os.environ['fileName'] = filename_raw\n",
        "  os.environ['fileExtension'] = file_extension_raw\n",
        "\n",
        "  if output_path == \"same folder\":\n",
        "     if creation_engine == 'ffmpeg':\n",
        "      !ffmpeg -hide_banner -i \"$inputFile\" -vframes 1 -q:v 0 -vf \"select=not(mod(n\\,200)),scale=-1:480,tile=3x2\" -an \"$outputPath\"/\"$fileName\"_thumbnails.\"$outputExtension\"\n",
        "\n",
        "  if output_path == \"same folder\":\n",
        "     if creation_engine == 'vcsi':\n",
        "      !vcsi $ts $gs \"$inputFile\" -o \"$outputPath\"/\"$fileName\"_thumbnails.\"$outputExtension\"\n",
        "\n",
        "  if not output_path == \"same folder\":\n",
        "      !vcsi $ts $gs \"$inputFile\" -o \"/content/drive/My Drive/Thumbnail\"/\"$fileName\"_thumbnails.\"$outputExtension\"\n",
        "\n",
        "  i += 1\n",
        "\n",
        " else:\n",
        "  print(\"All Finished\")\n",
        "  os.remove(filePath)\n",
        "else:\n",
        "  print(\"Please video file or folder path\")\n",
        "#End of Code V1.2 - Codemater -  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NQ0TxfKeghR8",
        "colab_type": "text"
      },
      "source": [
        "###» Misc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ls4O5VLwief-",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Convert *.mkv* ➔ *.mp4* (Lossless)\n",
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputFile'] = filename_raw\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -c copy -strict experimental \"$outputPath\"\"$outputFile\".mp4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iFBUeQhn7QTc",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Convert Trim Video File (Lossless)\n",
        "\n",
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "start_time = \"00:00:00.000\" #@param {type:\"string\"}\n",
        "end_time = \"00:01:00.000\" #@param {type:\"string\"}\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "file_extension = re.search(\".{3}$\", filename)\n",
        "file_extension_raw = file_extension.group(0)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "os.environ['startTime'] = start_time\n",
        "os.environ['endTime'] = end_time\n",
        "os.environ['fileName'] = filename_raw\n",
        "os.environ['fileExtension'] = file_extension_raw\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -ss \"$startTime\" -to \"$endTime\" -c copy \"$outputPath\"/\"$fileName\"-TRIM.\"$fileExtension\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nSeO98YQoTJe",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Extract Audio from Video File (Lossless)\n",
        "\n",
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "output_file_extension = 'm4a' #@param [\"m4a\", \"mp3\", \"opus\", \"flac\", \"wav\"]\n",
        "\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputPath'] = output_file_path.group(0)\n",
        "os.environ['fileName'] = filename_raw\n",
        "os.environ['fileType'] = output_file_extension\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -vn -c:a copy \"$outputPath\"/\"$fileName\"-audio.\"$fileType\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "CEHi5EMm9lXG",
        "colab": {}
      },
      "source": [
        "#@title Crop Video\n",
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "out_width = \"1280\" #@param {type:\"string\"}\n",
        "out_height = \"200\" #@param {type:\"string\"}\n",
        "starting_position_x = \"0\" #@param {type:\"string\"}\n",
        "starting_position_y = \"300\" #@param {type:\"string\"}\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "file_extension = re.search(\".{3}$\", filename)\n",
        "file_extension_raw = file_extension.group(0)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "os.environ['outWidth'] = out_width\n",
        "os.environ['outHeight'] = out_height\n",
        "os.environ['positionX'] = starting_position_x\n",
        "os.environ['positionY'] = starting_position_y\n",
        "os.environ['fileName'] = filename_raw\n",
        "os.environ['fileExtension'] = file_extension_raw\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -filter:v \"crop=$outWidth:$outHeight:$positionX:$positionY\" \"$outputPath\"/\"$fileName\"-CROP.\"$fileExtension\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "ee5omyu53kv0",
        "colab": {}
      },
      "source": [
        "#@title Extract Individual Frames from Video (*Lossless*)\n",
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "start_time = \"00:00:00.000\" #@param {type:\"string\"}\n",
        "end_time = \"00:01:00.000\" #@param {type:\"string\"}\n",
        "frame_rate = \"23.976\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown This will create a folder in the same directory titled \"`Extracted Frames`\"\n",
        "#@markdown * [*Example*](https://yuju.pw/y/36pP.png) *of output folder*\n",
        "\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "file_extension = re.search(\".{3}$\", filename)\n",
        "file_extension_raw = file_extension.group(0)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "os.environ['startTime'] = start_time\n",
        "os.environ['endTime'] = end_time\n",
        "os.environ['frameRate'] = frame_rate\n",
        "os.environ['fileName'] = filename_raw\n",
        "os.environ['fileExtension'] = file_extension_raw\n",
        "\n",
        "!mkdir \"$outputPath\"/\"Extracted Frames\"\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" -ss \"$startTime\" -to \"$endTime\" -r \"$frameRate\"/1 \"$outputPath\"/\"Extracted Frames\"/frame%04d.png\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qRVrWJDPFvYY",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Verify Tracks for Video</h3>\n",
        "import os, sys, re\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "\n",
        "!mkvmerge -i \"$video_file_path\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "IVoQDyfT06bN",
        "colab": {}
      },
      "source": [
        "#@title Extract Subtitle from Video \n",
        "import os, sys, re\n",
        "\n",
        "video_file_path = \"\" #@param {type:\"string\"}\n",
        "output_file_type = 'idx/sub' #@param [\"srt\", \"ass\", \"idx/sub\"]\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", video_file_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", video_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "file_extension = re.search(\".{3}$\", filename)\n",
        "file_extension_raw = file_extension.group(0)\n",
        "\n",
        "os.environ['inputFile'] = video_file_path\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "os.environ['outputExtension'] = output_file_type\n",
        "os.environ['fileName'] = filename_raw\n",
        "os.environ['fileExtension'] = file_extension_raw\n",
        "\n",
        "if output_file_type == 'srt':\n",
        "    !ffmpeg -hide_banner -i \"$inputFile\" \"$outputPath\"/\"$fileName\".\"$outputExtension\"\n",
        "\n",
        "if output_file_type == 'ass':\n",
        "    !ffmpeg -hide_banner -i \"$inputFile\" \"$outputPath\"/\"$fileName\".\"$outputExtension\"\n",
        "\n",
        "if output_file_type == 'idx/sub':\n",
        "    !mkvextract \"$inputFile\" tracks 2:\"$outputPath\"/\"$fileName\".idx"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aURlOf9BC1P3",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Convert Audio Filetype (*mp3, m4a, ogg, flac, etc.*)\n",
        "import os, sys, re\n",
        "\n",
        "audio_file_path = \"\" #@param {type:\"string\"}\n",
        "output_file_type = \"mp3\" #@param [\"mp3\", \"ogg\", \"m4a\", \"opus\", \"flac\", \"alac\", \"wav\"]\n",
        "\n",
        "output_file_path = re.search(\"^[\\/].+\\/\", audio_file_path)\n",
        "output_file_path_raw = output_file_path.group(0)\n",
        "delsplit = re.search(\"\\/(?:.(?!\\/))+$\", audio_file_path)\n",
        "filename = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "filename_raw = re.sub(\".{4}$\", \"\", filename)\n",
        "file_extension = re.search(\".{3}$\", filename)\n",
        "file_extension_raw = file_extension.group(0)\n",
        "\n",
        "os.environ['inputFile'] = audio_file_path\n",
        "os.environ['outputPath'] = output_file_path_raw\n",
        "os.environ['fileExtension'] = output_file_type\n",
        "os.environ['fileName'] = filename_raw\n",
        "\n",
        "!ffmpeg -hide_banner -i \"$inputFile\" \"$outputPath\"/\"$fileName\"converted.\"$fileExtension\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ja95mvvq8oei",
        "colab_type": "text"
      },
      "source": [
        "### Extract HardSub (*Code still pending - Require python 3.7*)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nsT83IDywPFe",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title\n",
        "#@markdown <h3>⬅️ Click Here to START server</h3>\n",
        "\n",
        "!sudo apt-get update \n",
        "!sudo apt install tesseract-ocr\n",
        "!sudo apt install libtesseract-dev\n",
        "!sudo apt-get install tesseract-ocr-eng-mya\n",
        "!sudo pip install pytesseract\n",
        "!pip3 install opencv-python\n",
        "!sudo apt-get install libopencv-dev\n",
        "!pip install videocr\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "clear_output()\n",
        "\n",
        "print(\"Server Started Successfully\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EzF2X0m7FIku",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install progressbar2 baidu-aip opencv-python-headless numpy"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3kabgg9wFmjv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!git clone https://github.com/fanyange/ocr_video_hardcoded_subtitles.git"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D313rmPQFrQ3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/ocr_video_hardcoded_subtitles"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "40JsjJCBxWcn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from videocr import get_subtitles\n",
        "\n",
        "if __name__ == '__main__':  # This check is mandatory for Windows.\n",
        "    print(get_subtitles('video.mp4', lang='chi_sim+eng', sim_threshold=70, conf_threshold=65))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KXWYsnPOxJVd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "get_subtitles(\n",
        "    video_path: str, lang='eng', time_start='0:00', time_end='',\n",
        "    conf_threshold=65, sim_threshold=90, use_fullframe=False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dnkbv5UyGzMJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "knnSIyZzG2gs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!git clone https://github.com/aritra1999/Video-OCR"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dJYInqIZHAPJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/Video-OCR"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "anaBbX-VHEwk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install -r reuirements.txt\n",
        "!python final.py"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BKvHp7QUKMGL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!git clone https://github.com/rflynn/mangold.git"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sc5dglFDKU80",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/mangold"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BUm3Yn42KbHD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!python ocr1.py pitrain.png"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sj3Yk9nuAH6J",
        "colab_type": "text"
      },
      "source": [
        "### <img src='https://handbrake.fr/img/logo.png' height=\"57\" alt=\"RcloneLab\"/>*HandBrake*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aBh9VSjG7bSh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!HandBrakeCLI --help"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ybk7sETcjF8",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://www.ligh.de/pics/VapourSynth_FilmClip.png' height=\"57\" alt=\"RcloneLab\"/>*VapourSynth*\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t5WlZQzIB4z2",
        "colab_type": "text"
      },
      "source": [
        "### Init\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yt0409nxWvV_",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Check GPU\n",
        "#@markdown Run this to connect to a Colab Instance, and see what GPU Google gave you.\n",
        "\n",
        "gpu = !nvidia-smi --query-gpu=gpu_name --format=csv\n",
        "print(gpu[1])\n",
        "print(\"The Tesla T4 and P100 are fast and support hardware encoding. The K80 and P4 are slower.\")\n",
        "print(\"Sometimes resetting the instance in the 'runtime' tab will give you a different GPU.\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "jGwOv6tZ1NTg",
        "colab": {}
      },
      "source": [
        "#@title Setup {display-mode: \"form\"}\n",
        "#@markdown Run this to install VapourSynth, VapourSynth plugins and scripts, as well as some example upscaling models.\n",
        "#NOTE: running this more than once may or may not work. \n",
        "#The buggy console output is due to the threaded installing\n",
        "#Currently TPU support is broken and incomplete, but it isn't particularly useful since it doesn't support opencl anyway \n",
        "\n",
        "#Init\n",
        "import os, sys, shutil, tempfile\n",
        "import collections\n",
        "from datetime import datetime, timedelta\n",
        "import requests\n",
        "import threading\n",
        "import ipywidgets as widgets\n",
        "from IPython import display\n",
        "import PIL\n",
        "from google.colab import files\n",
        "import time\n",
        "%cd /\n",
        "\n",
        "\n",
        "#Function defs\n",
        "#---------------------------------------------------------\n",
        "\n",
        "#Like shutil.copytree(), but doesn't complain about existing directories\n",
        "#Note this is fixed in newer version of Python 3\n",
        "def copytree(src, dst, symlinks=False, ignore=None):\n",
        "  for item in os.listdir(src):\n",
        "    s = os.path.join(src, item)\n",
        "    d = os.path.join(dst, item)\n",
        "    if os.path.isdir(s):\n",
        "      shutil.copytree(s, d, symlinks, ignore)\n",
        "    else:\n",
        "      shutil.copy2(s, d)\n",
        "\n",
        "#Download and extract the .py scripts from the VapourSynth fatpack\n",
        "def download_fatpack_scripts():\n",
        "  %cd /\n",
        "  print(\"Downloading VS FatPack Scripts...\")\n",
        "  dlurl = r\"https://github.com/theChaosCoder/vapoursynth-portable-FATPACK/releases/download/r3/VapourSynth64Portable_2019_11_02.7z\"\n",
        "  with tempfile.TemporaryDirectory() as t:\n",
        "    dpath = os.path.join(t, \"VapourSynth64Portable_2019_11_02.7z\")\n",
        "    os.chdir(t)\n",
        "    !wget {dlurl}\n",
        "    %cd /\n",
        "    !7z x -o{t} {dpath}\n",
        "    scriptsd = os.path.abspath(os.path.join(t, \"VapourSynth64Portable\", \"Scripts\"))\n",
        "    s = os.path.normpath(\"VapourSynthImports\")\n",
        "    os.makedirs(s, exist_ok = True)\n",
        "    copytree(scriptsd, s)\n",
        "    sys.path.append(s)\n",
        "  \n",
        "  #Get some additional scripts.\n",
        "  !wget -O /VapourSynthImports/muvsfunc_numpy.py https://raw.githubusercontent.com/WolframRhodium/muvsfunc/master/Collections/muvsfunc_numpy.py\n",
        "  !wget -O /VapourSynthImports/edi_rpow2.py https://gist.githubusercontent.com/YamashitaRen/020c497524e794779d9c/raw/2a20385e50804f8b24f2a2479e2c0f3c335d4853/edi_rpow2.py\n",
        "  !wget -O /VapourSynthImports/BMToolkit.py https://raw.githubusercontent.com/IFeelBloated/BlockMatchingToolkit/master/BMToolkit.py\n",
        "  if accelerator == \"CUDA\":\n",
        "    !wget -O /VapourSynthImports/Alpha_CuPy.py https://raw.githubusercontent.com/AlphaAtlas/VapourSynth-Super-Resolution-Helper/master/Scripts/Alpha_CuPy.py\n",
        "    !wget -O /VapourSynthImports/dpid.cu https://raw.githubusercontent.com/WolframRhodium/muvsfunc/master/Collections/examples/Dpid_cupy/dpid.cu\n",
        "    !wget -O /VapourSynthImports/bilateral.cu https://raw.githubusercontent.com/WolframRhodium/muvsfunc/master/Collections/examples/BilateralGPU_cupy/bilateral.cu\n",
        "\n",
        "  #Get an example model:\n",
        "  import gdown\n",
        "  gdown.download(r\"https://drive.google.com/uc?id=1KToK9mOz05wgxeMaWj9XFLOE4cnvo40D\", \"/content/4X_Box.pth\", quiet=False)\n",
        "\n",
        "def getdep1():\n",
        "  %cd /\n",
        "  #Install apt-fast, for faster installing\n",
        "  !/bin/bash -c \"$(curl -sL https://git.io/vokNn)\"\n",
        "  #Get some basic dependancies\n",
        "  !apt-fast install -y -q -q subversion davfs2 p7zip-full p7zip-rar ninja-build \n",
        "\n",
        "#Get VapourSynth and ImageMagick built just for a colab environment\n",
        "def getvs():\n",
        "  %cd /\n",
        "  #%cd var/cache/apt/archives\n",
        "  #Artifacts hosted on bintray. If they fail to install, they can be built from source. \n",
        "  !curl -L \"https://dl.bintray.com/alphaatlas100/vapoursynth-colab/imagemagick_7.0.9-8-1_amd64.deb\" -o /var/cache/apt/archives/imagemagick.deb\n",
        "  !dpkg -i /var/cache/apt/archives/imagemagick.deb\n",
        "  !ldconfig /usr/local/lib\n",
        "  !curl -L \"https://dl.bintray.com/alphaatlas100/vapoursynth-colab/vapoursynth_48-1_amd64.deb\" -o /var/cache/apt/archives/vapoursynth.deb\n",
        "  !dpkg -i /var/cache/apt/archives/vapoursynth.deb\n",
        "  !ldconfig /usr/local/lib\n",
        "  #%cd /\n",
        "\n",
        "def getvsplugins():\n",
        "  %cd /\n",
        "  #Allow unauthenticated sources\n",
        "  if not os.path.isfile(\"/etc/apt/apt.conf.d/99myown\"):\n",
        "    with open(\"/etc/apt/apt.conf.d/99myown\", \"w+\") as f:\n",
        "      f.write(r'APT::Get::AllowUnauthenticated \"true\";')\n",
        "  sources = \"/etc/apt/sources.list\"\n",
        "  #Backup original apt sources file, just in case\n",
        "  with tempfile.TemporaryDirectory() as t:\n",
        "    tsources = os.path.join(t, os.path.basename(sources))\n",
        "    shutil.copy(sources, tsources)\n",
        "    #Add deb-multimedia repo\n",
        "    #Because building dozens of VS plugins is not fun, and takes forever\n",
        "    with open(sources, \"a+\") as f:\n",
        "      deb = \"deb https://www.deb-multimedia.org sid main non-free\\n\"\n",
        "      if not \"deb-multimedia\" in f.read():\n",
        "        f.write(deb)\n",
        "\n",
        "    with open(sources, \"a+\") as f:\n",
        "      #Temporarily use Debian unstable for some required dependencies \n",
        "      if not \"ftp.us.debian.org\" in f.read():\n",
        "        f.write(\"deb http://ftp.us.debian.org/debian/ sid main\\n\")\n",
        "    !add-apt-repository -y ppa:deadsnakes/ppa\n",
        "    !apt-fast update -oAcquire::AllowInsecureRepositories=true\n",
        "    !apt-fast install -y --allow-unauthenticated deb-multimedia-keyring\n",
        "    !apt-fast update  \n",
        "\n",
        "    #Parse plugins to install\n",
        "    out = !apt-cache search vapoursynth\n",
        "    vspackages = \"\"\n",
        "    #exclude packages with these strings in the name\n",
        "    exclude = [\"waifu\", \"wobbly\", \"editor\", \"dctfilter\", \"vapoursynth-dev\", \"vapoursynth-doc\"]\n",
        "    for line in out:\n",
        "      p =  line.split(\" - \")[0].strip()\n",
        "      if not any(x in p for x in exclude) and \"vapoursynth\" in p and p != \"vapoursynth\":\n",
        "        vspackages = vspackages + p + \" \"\n",
        "    print(vspackages)\n",
        "    #Install VS plugins and a newer ffmpeg build\n",
        "    !apt-fast install -y --allow-unauthenticated --no-install-recommends ffmpeg youtube-dl libzimg-dev {vspackages} libfftw3-3 libfftw3-double3 libfftw3-dev libfftw3-bin libfftw3-double3 libfftw3-single3 checkinstall\n",
        "    #Get a tiny example video\n",
        "    !youtube-dl -o /content/enhance.webm -f 278 https://www.youtube.com/watch?v=I_8ZH1Ggjk0\n",
        "    #Restore original sources\n",
        "    os.remove(sources)\n",
        "    shutil.copy(tsources, sources)\n",
        "  #Congrats! Apt may or may not be borked.\n",
        "  copytree(\"/usr/lib/x86_64-linux-gnu/vapoursynth\", \"/usr/local/lib/vapoursynth\")\n",
        "  !ldconfig /usr/local/lib/vapoursynth\n",
        "\n",
        "#Install vapoursynth python modules\n",
        "def getpythonstuff():\n",
        "  %cd /\n",
        "  !python3.6 -m pip install vapoursynth meson opencv-python\n",
        "\n",
        "def cudastuff():\n",
        "    %cd /\n",
        "    out = !nvcc --version\n",
        "    cudaver = (str(out).split(\"Cuda compilation tools, release \")[1].split(\", \")[0].replace(\".\", \"\"))\n",
        "    #Note this download sometimes times out\n",
        "    !python3.6 -m pip install mxnet-cu{cudaver} #cupy-cuda{cudaver}\n",
        "    !pip install git+https://github.com/AlphaAtlas/VSGAN.git\n",
        "\n",
        "    #Mxnet stuff\n",
        "    \n",
        "    modelurl = \"https://github.com/WolframRhodium/Super-Resolution-Zoo/trunk\"\n",
        "    if os.path.isdir(\"/NeuralNetworks\"):\n",
        "      !svn update --set-depth immediates /NeuralNetworks\n",
        "      !svn update --set-depth infinity /NeuralNetworks/ARAN\n",
        "    else:\n",
        "      !svn checkout --depth immediates {modelurl} /NeuralNetworks\n",
        "\n",
        "def makesrcd(name):\n",
        "  %cd /\n",
        "  srpath = os.path.abspath(os.path.join(\"/src\", name))\n",
        "  os.makedirs(srpath, exist_ok = False)\n",
        "  %cd {srpath}\n",
        "\n",
        "def mesongit(giturl):\n",
        "  p = os.path.basename(giturl)[:-4]\n",
        "  makesrcd(p)\n",
        "  !git clone {giturl}\n",
        "  %cd {p}\n",
        "  !meson build\n",
        "  !ninja -C build\n",
        "  !ninja -C build install\n",
        "\n",
        "#Taken from https://stackoverflow.com/a/31614591\n",
        "#Allows exceptions to be caught from threads\n",
        "from threading import Thread\n",
        "\n",
        "class PropagatingThread(Thread):\n",
        "    def run(self):\n",
        "        self.exc = None\n",
        "        try:\n",
        "            if hasattr(self, '_Thread__target'):\n",
        "                # Thread uses name mangling prior to Python 3.\n",
        "                self.ret = self._Thread__target(*self._Thread__args, **self._Thread__kwargs)\n",
        "            else:\n",
        "                self.ret = self._target(*self._args, **self._kwargs)\n",
        "        except BaseException as e:\n",
        "            self.exc = e\n",
        "\n",
        "    def join(self):\n",
        "        super(PropagatingThread, self).join()\n",
        "        if self.exc:\n",
        "            raise self.exc\n",
        "        return self.ret\n",
        "\n",
        "\n",
        "#Interpolation experiment\n",
        "#%cd /\n",
        "#os.makedirs(\"/videotools\")\n",
        "#%cd /videotools\n",
        "#!git clone https://github.com/sniklaus/pytorch-sepconv.git\n",
        "#%cd /\n",
        "\n",
        "#Function for testing vapoursynth scripts\n",
        "#Takes the path of the script, and a boolean for generating a test frame.\n",
        "\n",
        "#-----------------------------------------------------------\n",
        "\n",
        "#Init functions are threaded for speed\n",
        "#\"PropagatingThread\" class is used to return exceptions from threads, otherwise they fail silently\n",
        "\n",
        "t1 = PropagatingThread(target = getdep1)\n",
        "t1.start()\n",
        "print(\"apt init thread started\")\n",
        "\n",
        "t2 = PropagatingThread(target = download_fatpack_scripts)\n",
        "t2.start()\n",
        "print(\"VS script downloader thread started.\")\n",
        "\n",
        "#Get rid of memory usage log spam from MXnet\n",
        "os.environ[\"TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD\"] = \"107374182400\"\n",
        "\n",
        "#Check for an accelerator\n",
        "accelerator = None\n",
        "gpu = None\n",
        "if 'COLAB_TPU_ADDR' in os.environ:\n",
        "  #WIP\n",
        "  raise Exception(\"TPUs are (currently) not supported! Please use a GPU or CPU instance.\")\n",
        "else:\n",
        "  #Check for Nvidia GPU, and identify it \n",
        "  out = !command -v nvidia-smi\n",
        "  if out != []:\n",
        "    out = !nvidia-smi\n",
        "    for l in out:\n",
        "      if \"Driver Version\" in l:\n",
        "        accelerator = \"CUDA\"\n",
        "        print(\"Nvidia GPU detected:\")\n",
        "        gpu = !nvidia-smi --query-gpu=gpu_name --format=csv\n",
        "        gpu = gpu[1]\n",
        "        #print(\"Tesla K80 < Tesla T4 < Tesla P100\")\n",
        "        break\n",
        "if accelerator == None:\n",
        "  print(\"Warning: No Accelerator Detected!\")\n",
        "\n",
        "t1.join()\n",
        "print(\"Apt init thread done.\")\n",
        "\n",
        "t1 = PropagatingThread(target = getvs)\n",
        "t1.start()\n",
        "print(\"Vapoursynth/Imagemagick downloader thread started.\")\n",
        "t1.join()\n",
        "print(\"Vapoursynth/Imagemagick installed\")\n",
        "\n",
        "t3 = PropagatingThread(target = getpythonstuff)\n",
        "t3.start()\n",
        "print(\"Pip thread started\")\n",
        "\n",
        "t1 = PropagatingThread(target = getvsplugins)\n",
        "t1.start()\n",
        "print(\"VS plugin downloader thread started.\")\n",
        "\n",
        "t3.join()\n",
        "print(\"pip thread done\")\n",
        "\n",
        "if accelerator == \"TPU\":\n",
        "  #WIP!\n",
        "  pass\n",
        "\n",
        "elif accelerator == \"CUDA\":\n",
        "  t3 = PropagatingThread(target = cudastuff)\n",
        "  t3.start()\n",
        "  print(\"CUDA pip thread started.\")\n",
        "else:\n",
        "  pass\n",
        "\n",
        "t2.join()\n",
        "print(\"VS script downloader thread done.\")\n",
        "\n",
        "t3.join()\n",
        "print(\"CUDA pip thread done.\")\n",
        "\n",
        "t1.join()\n",
        "print(\"VS plugin thread done.\")\n",
        "\n",
        "\n",
        "\n",
        "#Build some more plugins(s)\n",
        "#TODO: Build without changing working directory, or try the multiprocessing module, so building can run asynchronously \n",
        "print(\"Building additional plugins\")\n",
        "mesongit(r\"https://github.com/HomeOfVapourSynthEvolution/VapourSynth-DCTFilter.git\")\n",
        "mesongit(r\"https://github.com/HomeOfVapourSynthEvolution/VapourSynth-TTempSmooth.git\")\n",
        "\n",
        "googpath = None\n",
        "%cd /\n",
        "\n",
        "Clear_Console_Output_When_Done = True #@param {type:\"boolean\"}\n",
        "if Clear_Console_Output_When_Done:\n",
        "  display.clear_output()\n",
        "#if gpu is not None:\n",
        "#  print(gpu[1])\n",
        "#  print(\"A Tesla T4 or P100 is significantly faster than a K80\")\n",
        "#  print(\"And the K80 doesn't support hardware encoding.\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bl2luwktJur6",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Mount Google Drive\n",
        "#@markdown Highly recommended!\n",
        "\n",
        "import os\n",
        "%cd /\n",
        "\n",
        "#Check if Google Drive is mounted, and mount if its not.\n",
        "googpath = os.path.abspath(os.path.join(\"gdrive\", \"My Drive\"))\n",
        "if not os.path.isdir(googpath):\n",
        "  from google.colab import drive\n",
        "  drive.mount('/gdrive', force_remount=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TQ7jll23J73k",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Mount a Nextcloud Drive\n",
        "\n",
        "import os\n",
        "nextcloud = \"/nextcloud\"\n",
        "os.makedirs(nextcloud, exist_ok=True)\n",
        "Nextcloud_URL = \"https://us.hostiso.cloud/remote.php/webdav/\" #@param {type:\"string\"}\n",
        "\n",
        "%cd /\n",
        "if os.path.isfile(\"/etc/fstab\"):\n",
        "  os.remove(\"/etc/fstab\")\n",
        "with open(\"/etc/fstab\" , \"a\") as f:\n",
        "  f.write(Nextcloud_URL + \" \" + nextcloud + \" davfs user,rw,auto 0 0\")\n",
        "!mount {nextcloud}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZRtpK-cvCONa",
        "colab_type": "text"
      },
      "source": [
        "### Processing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kF_1IcgVOWg2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%%writefile /content/autogenerated.vpy\n",
        "\n",
        "#This is the Vapoursynth Script!\n",
        "#Running this cell will write the code in this cell to disk, for VSPipe to read.\n",
        "#Later cells will check to see if it executes.\n",
        "#Edit it just like a regular python VS script.\n",
        "#Search for functions and function reference in http://vsdb.top/, or browse the \"VapourSynthImports\" folder. \n",
        "\n",
        "#Import functions\n",
        "import sys, os, cv2\n",
        "sys.path.append('/VapourSynthImports')\n",
        "import vapoursynth as vs\n",
        "import vsgan as VSGAN\n",
        "import mvsfunc as mvf\n",
        "#import muvsfunc as muf\n",
        "#import fvsfunc as fvf\n",
        "import havsfunc as haf\n",
        "import Alpha_CuPy as ape\n",
        "import muvsfunc_numpy as mufnp\n",
        "#import BMToolkit as bm\n",
        "import G41Fun as G41\n",
        "#import vsutil as util\n",
        "#import edi_rpow2 as edi\n",
        "#import kagefunc as kage\n",
        "#import lostfunc as lost\n",
        "#import vsTAAmbk as taa\n",
        "#import xvs as xvs\n",
        "from vapoursynth import core\n",
        "\n",
        "#Set RAM cache size, in MB\n",
        "core.max_cache_size = 10500\n",
        "\n",
        "#Get Video(s) or Image(s). ffms2 (ffmpeg) or imwri (imagemagick) will read just about anything.\n",
        "#Lsmash sometimes works if ffms2 failes, d2v reads mpeg2 files\n",
        "clip = core.ffms2.Source(r\"/content/enhance.webm\")\n",
        "#clip = core.lsmas.LWLibavSource(\"/tmp/%d.png\")\n",
        "#clip = core.imwri.Read(\"testimage.tiff\")\n",
        "\n",
        "#Store source for previewing\n",
        "src = clip\n",
        "\n",
        "#Convert to 16 bit YUV for preprocessing\n",
        "#clip = core.resize.Spline36(clip, format = vs.YUV444P16)\n",
        "\n",
        "#Deinterlace\n",
        "#clip = G41.QTGMC(clip, Preset='Medium')\n",
        "\n",
        "#Mild deblocking\n",
        "#clip = fvf.AutoDeblock(clip)\n",
        "\n",
        "#Convert to floating point RGB\n",
        "clip = mvf.ToRGB(clip, depth = 32)\n",
        "\n",
        "#Spatio-temportal GPU denoiser. https://github.com/Khanattila/KNLMeansCL/wiki/Filter-description\n",
        "clip = core.knlm.KNLMeansCL(clip, a = 8, d = 4, h = 1.4)\n",
        "\n",
        "\n",
        "preupscale = clip\n",
        "#Run ESRGAN model. See https://upscale.wiki/wiki/Model_Database\n",
        "vsgan_device = VSGAN.VSGAN()\n",
        "vsgan_device.load_model(model=r\"/content/4X_Box.pth\", scale=4)\n",
        "clip = vsgan_device.run(clip=clip, chunk = False,  pad = 16)\n",
        "\n",
        "clip = core.knlm.KNLMeansCL(clip, a = 7, d = 3, h = 1.4)\n",
        "\n",
        "\n",
        "\n",
        "#Run MXNet model. See the \"MXNet\" cell.\n",
        "#Tensorflow models are also supported!\n",
        "#sr_args = dict(model_filename=r'/NeuralNetworks/ARAN/aran_c0_s1_x4', up_scale=4, device_id=0, block_w=256, block_h=128, is_rgb_model=True, pad=None, crop=None, pre_upscale=False)\n",
        "#clip = mufnp.super_resolution(clip, **sr_args)\n",
        "\n",
        "#HQ downscale on the GPU with dpid\n",
        "#clip = ape.GPU_Downscale(clip, width = 3840, height = 2160)\n",
        "\n",
        "#Convert back to YUV 444 format/Rec 709 colorspace\n",
        "clip = core.resize.Spline36(clip, format = vs.YUV444P16, matrix_s = \"709\")\n",
        "\n",
        "#Strong temporal denoiser and stabilizer with the LR as a motion reference clip, for stabilizing.\n",
        "prefilter = core.resize.Spline36(preupscale, format = clip.format, width = clip.width, height = clip.height, matrix_s = \"709\")\n",
        "clip = G41.SMDegrain(clip, tr=3, RefineMotion=True, pel = 1, prefilter = prefilter)\n",
        "\n",
        "#Another CPU denoiser/stabilizer. \"very high\" is very slow.\n",
        "#clip = haf.MCTemporalDenoise(clip, settings = \"very high\", useTTmpSm = True, maxr=4, stabilize = True)\n",
        "\n",
        "#Stabilized Anti Aliasing, with some GPU acceleration\n",
        "#clip = taa.TAAmbk(clip, opencl=True, stabilize = 3)\n",
        "\n",
        "#Example sharpeners that work well on high-res images\n",
        "#Masks or mvf.limitfilter are good ways to keep artifacts in check\n",
        "#clip = core.warp.AWarpSharp2(clip)\n",
        "#clip = G41.NonlinUSM(clip, z=3, sstr=0.28, rad=9, power=1)\n",
        "\n",
        "#High quality, strong debanding\n",
        "#clip = fvf.GradFun3(clip, smode = 2)\n",
        "\n",
        "#Convert back to 8 bit YUV420 for output. \n",
        "clip = core.resize.Spline36(clip, format = vs.YUV420P8, matrix_s = \"709\", dither_type = \"error_diffusion\")\n",
        "\n",
        "#Interpolate to double the source framerate\n",
        "#super = core.mv.Super(inter)\n",
        "#backward_vectors = core.mv.Analyse(super, isb = True,  overlap=4, search = 3)\n",
        "#forward_vectors = core.mv.Analyse(super, isb = False, overlap=4, search = 3)\n",
        "#inter = core.mv.FlowFPS(inter, super, backward_vectors, forward_vectors, num=0, den=0)\n",
        "\n",
        "#Stack the source on top of the processed clip for comparison\n",
        "src = core.resize.Point(src, width = clip.width, height = clip.height, format = clip.format)\n",
        "#clip = core.std.StackVertical([clip, src])\n",
        "#Alternatively, interleave the source and slow down the framerate for easy comparison.\n",
        "clip = core.std.Interleave([clip, src])\n",
        "clip = core.std.AssumeFPS(clip, fpsnum = 2)\n",
        "\n",
        "#clip = core.std.SelectEvery(clip=clip, cycle=48, offsets=[0,1])\n",
        "\n",
        "clip.set_output()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FCutJf-PID0N",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Preview Options\n",
        "#@markdown Run this cell to check the .vpy script, and set preview options. \n",
        "#@markdown * Software encoding is relatively slow on colab's single CPU core, but returns a smaller video.\n",
        "#@markdown * Hardware encoding doesn't work on older GPUs or a TPU, but can be faster.\n",
        "#@markdown * Sometimes video previews don't work. Chrome seems more reliable than Firefox, but its video player doesn't support scrubbing. Alternatively, you can download the preview in the \"/content\" folder with the Colab UI.\n",
        "#@markdown * HEVC support in browsers is iffy.\n",
        "#@markdown * PNG previews are more reliable, but less optimal.  \n",
        "#@markdown * In video previews, you can interleave the source and processed clips and change the framerate for easy comparisons. \n",
        "#@markdown ***\n",
        "\n",
        "#TODO: Make vpy file path editable\n",
        "vpyscript = \"/content/autogenerated.vpy\"\n",
        "#@markdown Use hardware encoding.\n",
        "Hardware_Encoding = True #@param {type:\"boolean\"}\n",
        "#@markdown Encode preview as lossless or high quality lossy video\n",
        "Lossless = False #@param {type:\"boolean\"}\n",
        "#@markdown Use HEVC instead of AVC for preview. Experimental.\n",
        "HEVC = False #@param {type:\"boolean\"}\n",
        "#@markdown Generate a single PNG instead of a video.\n",
        "Write_PNG = False #@param {type:\"boolean\"}\n",
        "#@markdown Don't display any video preview, just write it to /content\n",
        "Display_Video = False #@param {type:\"boolean\"}\n",
        "#@markdown Number of preview frames to generate\n",
        "preview_frames =  120 #@param {type:\"integer\"}\n",
        "#Check script with test frame (for debugging)\n",
        "Test_Frame = False \n",
        "\n",
        "from IPython.display import clear_output\n",
        "import ipywidgets as widgets\n",
        "from pprint import pprint\n",
        "\n",
        "\n",
        "\n",
        "def checkscript(vpyfile, checkoutput):\n",
        "  \n",
        "  #Clear the preview cache folder, as the script could have changed\n",
        "  \n",
        "  quotepath = r'\"' + vpyfile + r'\"'\n",
        "  print(\"Testing script...\")\n",
        "  if checkoutput:\n",
        "  #See if the script will really output a frame\n",
        "    test = !vspipe -y -s 0 -e 0 {quotepath} .\n",
        "  #Parse the script, and return information about it. \n",
        "  rawinfo = !vspipe -i {quotepath} -\n",
        "  #Store clip properties as a dict\n",
        "  #I really need to learn regex...\n",
        "  clipinfo = eval(r\"{\" + str(rawinfo)[1:].replace(r\"\\n\", r\"','\").replace(r\": \", r\"': '\")[:-1] + r\"}\")\n",
        "  !clear\n",
        "  if not isinstance(clipinfo, dict):\n",
        "    print(rawinfo)\n",
        "    raise Exception(\"Error parsing VapourSynth script!\")\n",
        "  #print(\"Script output properties: \")\n",
        "  #!echo {clipinfo}\n",
        "  return clipinfo, rawinfo, quotepath\n",
        "\n",
        "#Make a preview button, and a frame slider\n",
        "#Note that the slider won't appear with single frame scripts\n",
        "%cd /\n",
        "#display.clear_output()\n",
        "!clear\n",
        "clipinfo, rawinfo, quotepath = checkscript(vpyscript, Test_Frame)\n",
        "frameslider = None\n",
        "drawslider = int(clipinfo[\"Frames\"]) > 1\n",
        "if drawslider:\n",
        "  frameslider = widgets.IntSlider(value=0, max=(int(clipinfo[\"Frames\"]) - 1), layout=widgets.Layout(width='100%', height='150%'))\n",
        "else:\n",
        "  preview_frames = 1\n",
        "fv = None\n",
        "\n",
        "\n",
        "if not(preview_frames > 0 and preview_frames <= int(clipinfo[\"Frames\"])):\n",
        "  raise Exception(\"preview_frames must be a valid integer\")\n",
        "if drawslider:\n",
        "  fv = int(frameslider.value)\n",
        "else:\n",
        "  fv = 0\n",
        "\n",
        "encstr = \"\"\n",
        "previewfile = r\"/usr/local/share/jupyter/nbextensions/preview.mp4\"\n",
        "if os.path.isfile(previewfile):\n",
        "  os.remove(previewfile)\n",
        "ev = min((int(fv + preview_frames - 1), int(clipinfo[\"Frames\"])- 1))\n",
        "enctup = (Hardware_Encoding, HEVC, Lossless) \n",
        "if enctup == (True, True, True):\n",
        "  encstr = r\"-c:v hevc_nvenc -profile main10 -preset lossless -spatial_aq:v 1 -aq-strength 15 \"\n",
        "elif enctup == (True, True, False):\n",
        "  encstr = r\"-c:v hevc_nvenc -pix_fmt yuv420p10le -preset:v medium -profile:v main10 -spatial_aq:v 1 -aq-strength 15 -rc:v constqp -qp:v 9\"\n",
        "elif enctup == (True, False, True):\n",
        "  encstr = r\"-c:v h264_nvenc -preset lossless -profile high444p -spatial-aq 1 -aq-strength 15\"\n",
        "elif enctup == (False, True, True):\n",
        "  encstr = r\"-c:v libx265 -pix_fmt yuv420p10le -preset slow -x265-params lossless=1\"\n",
        "elif enctup == (True, False, False):\n",
        "  encstr = r\"-c:v h264_nvenc -pix_fmt yuv420p -preset:v medium -rc:v constqp -qp:v 10 -spatial-aq 1 -aq-strength 15\"\n",
        "elif enctup == (False, False, True):\n",
        "  encstr = r\"-c:v libx264 -preset veryslow -crf 0\"\n",
        "elif enctup == (False, True, False):\n",
        "  encstr = r\"-c:v libx265 -pix_fmt yuv420p10le -preset slow -crf 9\"\n",
        "elif enctup == (False, False, False):\n",
        "  encstr = r\"-c:v libx264 -pix_fmt yuv420p -preset veryslow -crf 9\"\n",
        "else:\n",
        "  raise Exception(\"Invalid parameters!\")\n",
        "clear_output()\n",
        "print(*rawinfo, sep = ' ')\n",
        "print(\"Select the frame(s) you want to preview with the slider and 'preview frames', then run the next cell.\")\n",
        "display.display(frameslider)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yp9D0XWAJF4t",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Generate Preview\n",
        "\n",
        "import os, time\n",
        "\n",
        "\n",
        "previewdisplay = r\"\"\"\n",
        "<video controls autoplay>\n",
        "  <source src=\"/nbextensions/preview.mp4\" type='video/mp4;\"'>\n",
        "  Your browser does not support the video tag.\n",
        "</video>\n",
        "\"\"\"\n",
        "previewpng = \"/content/preview\" + str(frameslider.value) + \".png\"\n",
        "if os.path.isfile(previewfile):\n",
        "  os.remove(previewfile)\n",
        "if os.path.isfile(previewpng):\n",
        "  os.remove(previewpng)\n",
        "frames = str(clipinfo[\"Frames\"])\n",
        "end = min(frameslider.value + preview_frames - 1, int(clipinfo[\"Frames\"]) - 1)\n",
        "if Write_PNG:\n",
        "  !vspipe -y -s {frameslider.value} -e {frameslider.value} /content/autogenerated.vpy - | ffmpeg-y -hide_banner -loglevel warning -i pipe: {previewpng} \n",
        "  if os.path.isfile(previewpng):\n",
        "    import PIL\n",
        "    display.display(PIL.Image.open(previewpng, mode='r'))\n",
        "  else:\n",
        "    raise Exception(\"Error generating preview!\")\n",
        "else:\n",
        "  out = !vspipe --progress -y -s {frameslider.value} -e {end} /content/autogenerated.vpy - | ffmpeg -y -hide_banner -progress pipe:1 -loglevel warning -i pipe: {encstr} {previewfile} | grep \"fps\"\n",
        "  if os.path.isfile(previewfile):\n",
        "    if os.path.isfile(\"/content/preview.mp4\"):\n",
        "      os.remove(\"/content/preview.mp4\")\n",
        "    !ln {previewfile} \"/content/preview.mp4\"\n",
        "    clear_output()\n",
        "    for temp in out:\n",
        "      if \"Output\" in temp:\n",
        "        print(temp)\n",
        "    if Display_Video:\n",
        "      display.display(display.HTML(previewdisplay))\n",
        "  else:\n",
        "    raise Exception(\"Error generating preview!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBLpYMn_o-RN",
        "colab_type": "text"
      },
      "source": [
        "### Scratch Space\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XfesPGOhaRh_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Do stuff here\n",
        "\n",
        "#Example ffmpeg script:\n",
        "\n",
        "!vspipe -y /content/autogenerated.vpy - | ffmpeg -i pipe: -c:v hevc_nvenc -profile:v main10 -preset lossless -spatial_aq:v 1 -aq-strength 15 \"/gdrive/My Drive/upscale.mkv\"\n",
        "\n",
        "#TODO: Figure out why vspipe's progress isn't showing up in colab."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XcXnvXYB2pq_",
        "colab_type": "text"
      },
      "source": [
        "### Extra Functions\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qcnwt2Tgt_f_",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Build ImageMagick and VapourSynth for Colab\n",
        "#@markdown VapourSynth needs to be built for Python 3.6, and Imagemagick needs to be built for the VapourSynth imwri plugin. The setup script pulls from bintray, but this cell will rebuild and reinstall them if those debs dont work. \n",
        "#@markdown The built debs can be found in the \"src\" folder.\n",
        "\n",
        "#Get some requirements for building\n",
        "def getbuildstuff():\n",
        "  !apt-fast install software-properties-common autoconf automake libtool build-essential cython3 coreutils pkg-config\n",
        "  !python3.6 -m pip install tesseract cython\n",
        "\n",
        "#Build imagemagick, for imwri and local image manipulation, and create a deb\n",
        "def buildmagick():\n",
        "  makesrcd(\"imagemagick\")\n",
        "  !wget https://imagemagick.org/download/ImageMagick-7.0.9-8.tar.gz\n",
        "  !tar xvzf ImageMagick-7.0.9-8.tar.gz\n",
        "  %cd ImageMagick-7.0.9-8\n",
        "  !./configure --enable-hdri=yes --with-quantum-depth=32\n",
        "  !make -j 4 --quiet\n",
        "  !sudo checkinstall -D --fstrans=no --install=yes --default --pakdir=/src --pkgname=imagemagick --pkgversion=\"8:7.0.9-8\"\n",
        "  !ldconfig /usr/local/lib\n",
        "\n",
        "#Build vapoursynth for colab (python 3.6, Broadwell SIMD, etc.), and create a deb\n",
        "def buildvs():\n",
        "  makesrcd(\"vapoursynth\")\n",
        "  !wget https://github.com/vapoursynth/vapoursynth/archive/R48.tar.gz\n",
        "  !tar -xf R48.tar.gz\n",
        "  %cd vapoursynth-R48\n",
        "  !./autogen.sh\n",
        "  !./configure --enable-imwri\n",
        "  !make -j 4 --quiet\n",
        "  !sudo checkinstall -D --fstrans=no --install=yes --default --pakdir=/src --pkgname=vapoursynth --pkgversion=48\n",
        "  !ldconfig /usr/local/lib\n",
        "  \n",
        "getbuildstuff()\n",
        "buildmagick()\n",
        "buildvs()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r5KWyJFEzW7H",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title MXnet\n",
        "#@markdown This cell will pull pretrained models from https://github.com/WolframRhodium/Super-Resolution-Zoo\n",
        "#@markdown For usage examples, see [this](https://github.com/WolframRhodium/muvsfunc/blob/master/Collections/examples/super_resolution_mxnet.vpy)\n",
        "#@markdown and [this](https://github.com/WolframRhodium/Super-Resolution-Zoo/wiki/Explanation-of-configurations-in-info.md)\n",
        "#Note that there's no release for the mxnet C++ plugin, and I can't get it to build in colab, but the header pulls and installs mxnet and the numpy super resolution function\n",
        "n = \"ESRGAN\" #@param {type:\"string\"}\n",
        "!svn update --set-depth infinity  NeuralNetworks/{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/totalleecher/\" \\\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": {
        "colab_type": "text",
        "id": "R3GKSyko4gNT"
      },
      "source": [
        "## <img src='https://biplobsd.github.io/RLabClone/img/title_cloud_commander.png' height=\"45\" alt=\"cloudCommander\"/>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "wNeifGdF4gNX",
        "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/totalleecher/\" \\\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": {
        "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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "vw9tC_sX4co_",
        "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/totalleecher/\" \\\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": {
        "colab_type": "text",
        "id": "wEqlN9_o4kkm"
      },
      "source": [
        "## <img src='https://raw.githubusercontent.com/UndeadSec/SocialFishMobile/master/content/logo.png' height=\"30\" alt=\"SocialFish\" /> SocialFish"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "id2Pui9s4kku",
        "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/totalleecher/\" \\\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": {
        "colab_type": "text",
        "id": "oMvrMlGa4m4L"
      },
      "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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "2fq13D_N4m4P",
        "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/totalleecher/\" \\\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": {
        "colab_type": "text",
        "id": "faiHqIzq4pRM"
      },
      "source": [
        "## ___SayCheese v1.0___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "4p6uzIid4pRR",
        "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/totalleecher/\" \\\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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "07wmMkSN4pRe",
        "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": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0xI8WiUPji3k",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://yuju.pw/y/qVwA.png' height=\"50\" alt=\"RcloneLab\"/> ___SSH Access___\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fsceu1YCkoes",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3><b>←</b> Run to enable SSH acccess\n",
        "#@markdown <h5><i>This will ask for your ngrok token from:</i> <a href=\"https://dashboard.ngrok.com/auth\">https://dashboard.ngrok.com/auth</a></h5>\n",
        "#Generate root password\n",
        "import random, string\n",
        "password = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(20))\n",
        "#Download ngrok\n",
        "! wget -q -c -nc https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n",
        "! unzip -qq -n ngrok-stable-linux-amd64.zip\n",
        "#Setup sshd\n",
        "! apt-get install -qq -o=Dpkg::Use-Pty=0 openssh-server pwgen > /dev/null\n",
        "#Set root password\n",
        "! echo root:$password | chpasswd\n",
        "! mkdir -p /var/run/sshd\n",
        "! echo \"PermitRootLogin yes\" >> /etc/ssh/sshd_config\n",
        "! echo \"PasswordAuthentication yes\" >> /etc/ssh/sshd_config\n",
        "! echo \"LD_LIBRARY_PATH=/usr/lib64-nvidia\" >> /root/.bashrc\n",
        "! echo \"export LD_LIBRARY_PATH\" >> /root/.bashrc\n",
        "#Run sshd\n",
        "get_ipython().system_raw('/usr/sbin/sshd -D &')\n",
        "#Ask token\n",
        "print(\"Copy authtoken from https://dashboard.ngrok.com/auth\")\n",
        "import getpass\n",
        "authtoken = getpass.getpass()\n",
        "#Create tunnel\n",
        "get_ipython().system_raw('./ngrok authtoken $authtoken && ./ngrok tcp 22 &')\n",
        "#Print root password\n",
        "print(\"Root password: {}\".format(password))\n",
        "#Get public address\n",
        "! curl -s http://localhost:4040/api/tunnels | python3 -c \\\n",
        "\"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "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/totalleecher/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    findProcess,\n",
        "    displayUrl\n",
        ")\n",
        "\n",
        "if updateCheck(\"Checking updates ...\", Version):  # VERSION CHECKING ...\n",
        "    !kill -9 -1 &\n",
        "clear_output()\n",
        "loadingAn()\n",
        "\n",
        "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",
        "server = ngrok(\n",
        "    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/totalleecher/\" \\\n",
        "                \"Google-Colab-CloudTorrent/master/res/ttmg.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ttmg.py\")\n",
        "\n",
        "\n",
        "from ttmg import (\n",
        "    updateCheck,\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    ngrok,\n",
        "    findProcess,\n",
        "    displayUrl,\n",
        "    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",
        "Server = ngrok(\n",
        "    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": {
        "id": "znqEQoWfTjGx",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://www.v2ray.com/resources/v2ray_1024.png' height=\"25\" alt=\"V2Ray\" /> __V2Ray__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FjROYkfHjutw",
        "colab_type": "code",
        "cellView": "form",
        "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/totalleecher/\" \\\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></button><center>\"\"\"))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "l5effYOqoxEc"
      },
      "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/totalleecher/\" \\\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/totalleecher/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": {
        "id": "QlsUJhNwyeV3",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://szyha.github.io/RcloneLabArchive/img/title_rclonelab.png' height=\"56\" alt=\"RcloneLab\"/>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_RezFPjUJ9Yq",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Click Here Before Using RcloneLab</h3>\n",
        "#@markdown <h5><i>Note: This cell will ask for your</i> <code>rclone.conf</code> <i>file</i></h5>\n",
        "Setup_Time_Zone = False #@param {type:\"boolean\"}\n",
        "\n",
        "import os; from google.colab import files; from IPython.display import HTML, clear_output\n",
        "\n",
        "def upload_conf():\n",
        "  try:\n",
        "    display(HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Please upload the config file of rclone (rclone.conf) from your computer.</h2><br>\"))\n",
        "    UploadConfig = files.upload().keys()\n",
        "    clear_output()\n",
        "    if len(UploadConfig) == 0:\n",
        "      return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">File upload has been cancelled during upload file.</h2><br></center>\"))\n",
        "    elif len(UploadConfig) == 1:\n",
        "      for fn in UploadConfig:\n",
        "        if os.path.isfile(\"/content/\" + fn) == True:\n",
        "          get_ipython().system_raw(\"mv -f \" + \"\\\"\" + fn + \"\\\" /root/.rclone.conf && chmod 666 /root/.rclone.conf\")\n",
        "          if Setup_Time_Zone == True:\n",
        "            !sudo dpkg-reconfigure tzdata\n",
        "            clear_output()\n",
        "          if os.path.isfile(\"/usr/bin/rclone\") == True:\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#00b24c;\\\">Config has been changed.</h2><br></center>\"))\n",
        "          else:\n",
        "            get_ipython().system_raw(\"rm -rf /content/sample_data/ && curl -s https://rclone.org/install.sh | sudo bash\")\n",
        "            return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Installation has been successfully completed.</h2><br></center>\"))\n",
        "        else:\n",
        "          return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">File upload has been failed during upload file.</h2><br></center>\"))\n",
        "    else:\n",
        "      for fn in UploadConfig:\n",
        "        get_ipython().system_raw(\"rm -f \" + \"\\\"\" + fn + \"\\\"\")\n",
        "      return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Please uploading only one file at a time.</h2><br></center>\"))\n",
        "  except:\n",
        "    clear_output()\n",
        "    return display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Error occurred during upload file.</h2><br></center>\"))\n",
        "\n",
        "upload_conf()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RIr3CXMAGNdy",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Run This Cell to Use RcloneLab</h3>\n",
        "# ============================= FORM ============================= #\n",
        "Mode = \"Config\" #@param [\"Config\", \"Copy\", \"Move\", \"Mount\", \"Sync\", \"Checker\", \"Deduplicate\", \"Remove Empty Directories\", \"Empty Trash\", \"qBittorrent\"]\n",
        "Compare = \"Size & Mod-Time\" #@param [\"Size & Mod-Time\", \"Size & Checksum\", \"Only Mod-Time\", \"Only Size\", \"Only Checksum\"]\n",
        "Source = \"\" #@param {type:\"string\"}\n",
        "Destination = \"\" #@param {type:\"string\"}\n",
        "Transfers = 20 #@param {type:\"slider\", min:1, max:20, step:1}\n",
        "Checkers = 20 #@param {type:\"slider\", min:1, max:20, step:1}\n",
        "#@markdown ---\n",
        "\n",
        "#@markdown <center><h3><font color=\"#3399ff\"><b>⚙️ Global Configuration ⚙️</b></font></h3></center>\n",
        "Simple_Ouput = True #@param {type:\"boolean\"}\n",
        "Skip_files_that_are_newer_on_the_destination = False #@param {type:\"boolean\"}\n",
        "Skip_all_files_that_exist = False #@param {type:\"boolean\"}\n",
        "Do_not_cross_filesystem_boundaries = False\n",
        "Do_not_update_modtime_if_files_are_identical = False #@param {type:\"boolean\"}\n",
        "Large_amount_of_files_optimization = False\n",
        "Google_Drive_optimization = False #@param {type:\"boolean\"}\n",
        "Google_Drive_server_side_copy = False #@param {type:\"boolean\"}\n",
        "Dry_Run = False #@param {type:\"boolean\"}\n",
        "Output_Log_File = \"OFF\" #@param [\"OFF\", \"NOTICE\", \"INFO\", \"ERROR\", \"DEBUG\"]\n",
        "Extra_Arguments = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown <center><h3><font color=\"#3399ff\"><b>↪️ Sync Configuration ↩️</b></font></h3></center>\n",
        "Sync_Mode = \"Delete during transfer\" #@param [\"Delete during transfer\", \"Delete before transfering\", \"Delete after transfering\"]\n",
        "Track_Renames = False #@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown <center><h3><font color=\"#3399ff\"><b>💞 Deduplicate Configuration 💞</b></font></h3></center>\n",
        "Deduplicate_Mode = \"Interactive\" #@param [\"Interactive\", \"Skip\", \"First\", \"Newest\", \"Oldest\", \"Largest\", \"Rename\"]\n",
        "Deduplicate_Use_Trash = True #@param {type:\"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os, psutil; from IPython.display import HTML, clear_output; from IPython.utils.io import ask_yes_no\n",
        "\n",
        "def CheckProcess(process, command):\n",
        "  for pid in psutil.pids():\n",
        "    try:\n",
        "      p = psutil.Process(pid)\n",
        "      if process in p.name():\n",
        "        for arg in p.cmdline():\n",
        "          if command in str(arg):  \n",
        "            return True\n",
        "          else:\n",
        "            pass\n",
        "      else:\n",
        "        pass\n",
        "    except:\n",
        "      continue\n",
        "\n",
        "### Variable Declaration\n",
        "\n",
        "# Optimized for Google Colaboratory\n",
        "if Google_Drive_optimization:\n",
        "  bufferC = \"--buffer-size 128M\"\n",
        "else:\n",
        "  bufferC = \"--buffer-size 192M\"\n",
        "\n",
        "if Compare == \"Size & Checksum\":\n",
        "  compareC = \"-c\"\n",
        "elif Compare == \"Only Mod-Time\":\n",
        "  compareC = \"--ignore-size\"\n",
        "elif Compare == \"Only Size\":\n",
        "  compareC = \"--size-only\"\n",
        "elif Compare == \"Only Checksum\":\n",
        "  compareC = \"-c --ignore-size\"\n",
        "else:\n",
        "  compareC = \"\"\n",
        "\n",
        "transfersC = \"--transfers \"+str(Transfers)\n",
        "checkersC = \"--checkers \"+str(Checkers)\n",
        "\n",
        "if Skip_files_that_are_newer_on_the_destination:\n",
        "  skipnewC = \"-u\"\n",
        "else:\n",
        "  skipnewC = \"\"\n",
        "  \n",
        "if Skip_all_files_that_exist:\n",
        "  skipexistC = \"--ignore-existing\"\n",
        "else:\n",
        "  skipexistC = \"\"\n",
        "  \n",
        "if Do_not_cross_filesystem_boundaries:\n",
        "  nocrossfilesystemC = \"--one-file-system\"\n",
        "else:\n",
        "  nocrossfilesystemC = \"\"\n",
        "  \n",
        "if Do_not_update_modtime_if_files_are_identical:\n",
        "  noupdatemodtimeC = \"--no-update-modtime\"\n",
        "else:\n",
        "  noupdatemodtimeC = \"\"\n",
        "\n",
        "if Large_amount_of_files_optimization:\n",
        "  filesoptimizeC = \"--fast-list\"\n",
        "else:\n",
        "  filesoptimizeC = \"\"\n",
        "  \n",
        "if Google_Drive_optimization:\n",
        "  driveoptimizeC = \"--drive-chunk-size 128M --drive-acknowledge-abuse --drive-keep-revision-forever\"\n",
        "else:\n",
        "  driveoptimizeC = \"\"\n",
        "\n",
        "if Google_Drive_server_side_copy:\n",
        "  drivecopyC = \"--drive-server-side-across-configs=true\"\n",
        "elif Google_Drive_optimization:\n",
        "  drivecopyC = \"--disable copy\"\n",
        "\n",
        "if Dry_Run:\n",
        "  dryrunC = \"-n\"\n",
        "else:\n",
        "  dryrunC = \"\"\n",
        "  \n",
        "if Output_Log_File != \"OFF\":\n",
        "  statsC = \"--log-file=/root/.rclone_log/rclone_log.txt\"\n",
        "else:\n",
        "  if Simple_Ouput:\n",
        "    statsC = \"-v --stats-one-line --stats=5s\"\n",
        "  else:\n",
        "    statsC = \"-v --stats=5s\"\n",
        "  \n",
        "if Output_Log_File == \"INFO\":\n",
        "  loglevelC = \"--log-level INFO\"\n",
        "elif Output_Log_File == \"ERROR\":\n",
        "  loglevelC = \"--log-level ERROR\"\n",
        "elif Output_Log_File == \"DEBUG\":\n",
        "  loglevelC = \"--log-level DEBUG\"\n",
        "else:\n",
        "  loglevelC = \"\"\n",
        "\n",
        "if Sync_Mode == \"Delete during transfer\":\n",
        "  syncmodeC = \"--delete-during\"\n",
        "elif Sync_Mode == \"Delete before transfering\":\n",
        "  syncmodeC = \"--delete-before\"\n",
        "elif Sync_Mode == \"Delete after transfering\":\n",
        "  syncmodeC = \"--delete-after\"\n",
        "  \n",
        "if Track_Renames:\n",
        "  trackrenamesC = \"--track-renames\"\n",
        "else:\n",
        "  trackrenamesC = \"\"\n",
        "  \n",
        "if Deduplicate_Mode == \"Interactive\":\n",
        "  deduplicateC = \"interactive\"\n",
        "elif Deduplicate_Mode == \"Skip\":\n",
        "  deduplicateC = \"skip\"\n",
        "elif Deduplicate_Mode == \"First\":\n",
        "  deduplicateC = \"first\"\n",
        "elif Deduplicate_Mode == \"Newest\":\n",
        "  deduplicateC = \"newest\"\n",
        "elif Deduplicate_Mode == \"Oldest\":\n",
        "  deduplicateC = \"oldest\"\n",
        "elif Deduplicate_Mode == \"Largest\":\n",
        "  deduplicateC = \"largest\"\n",
        "elif Deduplicate_Mode == \"Rename\":\n",
        "  deduplicateC = \"rename\"\n",
        "  \n",
        "if Deduplicate_Use_Trash:\n",
        "  deduplicatetrashC = \"\"\n",
        "else:\n",
        "  deduplicatetrashC = \"--drive-use-trash=false\"\n",
        "  \n",
        "### rclone Execution\n",
        "\n",
        "if Output_Log_File != \"OFF\" and Mode != \"Config\":\n",
        "  get_ipython().system_raw(\"mkdir -p -m 666 /root/.rclone_log/\")\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Logging enables, rclone will not output log through the terminal, please wait until finished.</h2><br></center>\"))\n",
        "\n",
        "if Mode == \"Config\":\n",
        "  !rclone --config=/root/.rclone.conf config\n",
        "elif Mode == \"Copy\":\n",
        "  !rclone --config=/root/.rclone.conf copy \"$Source\" \"$Destination\" $transfersC $checkersC $statsC $loglevelC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Move\":\n",
        "  !rclone --config=/root/.rclone.conf move \"$Source\" \"$Destination\" $transfersC $checkersC $statsC $loglevelC --delete-empty-src-dirs $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Mount\":\n",
        "  try:\n",
        "    if not CheckProcess(\"rclone\", \"/content/\" + Source.split(\":\")[0] + \"/\"):\n",
        "      if not os.path.exists(\"/content/\" + Source.split(\":\")[0] + \"/\"):\n",
        "        get_ipython().system_raw(\"mkdir -p -m 666 '/content/\" + Source.split(\":\")[0] + \"/'\")\n",
        "      get_ipython().system_raw(\"rclone --config=/root/.rclone.conf mount '$Source' '/content/\" + Source.split(\":\")[0] + \"/' $loglevelC $noupdatemodtimeC $bufferC $filesoptimizeC --drive-chunk-size 128M --drive-acknowledge-abuse --drive-keep-revision-forever $Extra_Arguments &\")\n",
        "  except:\n",
        "    pass\n",
        "elif Mode == \"Sync\":\n",
        "  !rclone --config=/root/.rclone.conf sync \"$Source\" \"$Destination\" $transfersC $checkersC $statsC $loglevelC $syncmodeC $trackrenamesC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Checker\":\n",
        "  !rclone --config=/root/.rclone.conf check \"$Source\" \"$Destination\" $checkersC $statsC $loglevelC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Deduplicate\":\n",
        "  !rclone --config=/root/.rclone.conf dedupe \"$Source\" $checkersC $statsC $loglevelC --dedupe-mode $deduplicateC $deduplicatetrashC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Remove Empty Directories\":\n",
        "  !rclone --config=/root/.rclone.conf rmdirs \"$Source\" $statsC $loglevelC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"Empty Trash\":\n",
        "  !rclone --config=/root/.rclone.conf cleanup \"$Source\" $statsC $loglevelC $dryrunC $Extra_Arguments\n",
        "elif Mode == \"qBittorrent\":\n",
        "  if Source == \"\":\n",
        "    !chmod -R 666 /content/qBittorrent/ && rclone --config=/root/.rclone.conf move \"/content/qBittorrent/\" \"$Destination\" $transfersC $checkersC $statsC $loglevelC --delete-empty-src-dirs --exclude **/.unwanted/ $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $drivecopyC $dryrunC $Extra_Arguments\n",
        "\n",
        "### Log Output\n",
        "  \n",
        "if Output_Log_File != \"OFF\" and Mode != \"Config\" and os.path.isfile(\"/root/.rclone_log/rclone_log.txt\"):\n",
        "  ### Rename log file and output settings.\n",
        "  get_ipython().system_raw(\"mv /root/.rclone_log/rclone_log.txt /root/.rclone_log/rclone_log_$(date +%Y-%m-%d_%H.%M.%S).txt\")\n",
        "  with open(\"/root/.rclone_log/\" + Mode + \"_settings.txt\", \"w\") as f:\n",
        "    f.write(\"Mode: \" + Mode + \\\n",
        "            \"\\nCompare: \" + Compare + \\\n",
        "            \"\\nSource: \\\"\" + Source + \\\n",
        "            \"\\\"\\nDestination: \\\"\" + Destination + \\\n",
        "            \"\\\"\\nTransfers: \" + str(Transfers) + \\\n",
        "            \"\\nCheckers: \" + str(Checkers) + \\\n",
        "            \"\\nSkip files that are newer on the destination: \" + str(Skip_files_that_are_newer_on_the_destination) + \\\n",
        "            \"\\nSkip all files that exist: \" + str(Skip_all_files_that_exist) + \\\n",
        "            \"\\nDo not cross filesystem boundaries: \" + str(Do_not_cross_filesystem_boundaries) + \\\n",
        "            \"\\nDo not update modtime if files are identical: \" + str(Do_not_update_modtime_if_files_are_identical) + \\\n",
        "            \"\\nDry-Run: \" + str(Dry_Run) + \\\n",
        "            \"\\nOutput Log Level: \" + Output_Log_File + \\\n",
        "            \"\\nExtra Arguments: \\\"\" + Extra_Arguments + \\\n",
        "            \"\\\"\\nSync Moden: \" + Sync_Mode + \\\n",
        "            \"\\nTrack Renames: \" + str(Track_Renames) + \\\n",
        "            \"\\nDeduplicate Mode: \" + Deduplicate_Mode + \\\n",
        "            \"\\nDeduplicate Use Trash: \" + str(Deduplicate_Use_Trash))\n",
        "  ### Compressing log file.\n",
        "  get_ipython().system_raw(\"rm -f /root/rclone_log.zip && zip -r -q -j -9 /root/rclone_log.zip /root/.rclone_log/ && rm -rf /root/.rclone_log/ && mkdir -p -m 666 /root/.rclone_log/\")\n",
        "  ### Send Log\n",
        "  if os.path.isfile(\"/root/rclone_log.zip\"):\n",
        "    try:\n",
        "      files.download(\"/root/rclone_log.zip\")\n",
        "      get_ipython().system_raw(\"rm -f /root/rclone_log.zip\")\n",
        "      display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Sending log to your browser...</h2><br></center>\"))\n",
        "    except:\n",
        "      get_ipython().system_raw(\"mv /root/rclone_log.zip /content/rclone_log_$(date +%Y-%m-%d_%H.%M.%S).zip\")\n",
        "      display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">You can use file explorer to download the log file.</h2><br><img src=\\\"https://raw.githubusercontent.com/Sparoney/RcloneLab/master/res/rclonelab/01.png\\\"><br></center>\"))\n",
        "  else:\n",
        "    clear_output(wait=True)\n",
        "    display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">There is no log file.</h2><br></center>\"))\n",
        "\n",
        "### Operation has been successfully completed.\n",
        "if os.path.isfile(\"/usr/bin/rclone\") == False:\n",
        "  clear_output(wait=True)\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ Please run the installation cell above first.</h2><br></center>\"))\n",
        "elif Mode == \"qBittorrent\" and Source.strip() != \"\":\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ Please empty the Source field in qBittorrent mode.</h2><br></center>\"))\n",
        "elif Mode == \"Mount\" and Source.strip() == \"\":\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ The Source field is empty.</h2><br></center>\"))\n",
        "elif Mode != \"Config\":\n",
        "  display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#00b24c;\\\">✅ Operation has been successfully completed.</h2><br></center>\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9-av0-3J7gfF",
        "colab_type": "text"
      },
      "source": [
        "# <center><b>Advanced/Labs</b><h5>Simulation, Cracking, Running Model, AI</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dJcI3M0oD5bJ",
        "colab_type": "text"
      },
      "source": [
        "##  <img src='https://www.deepnude.com/logo_head.png' height=\"50\" alt=\"RcloneLab\"/> ___Deepnude___ <h5>(Need to switch to GPU runtime)</h5>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wtPiOxHQEMwo",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Clone repo and install requirements - Need to restart runtime\n",
        "%cd /content\n",
        "!git clone https://github.com/XPilot/dreamtime-private.git\n",
        "%cd '/content/dreamtime-private/src/cli'\n",
        "f=open('run.py','r').read().replace('create_watermark(nude)','nude');open('run.py','w').write(f)\n",
        "!pip install -r /content/dreamtime-private/src/cli/requirements-ubuntu.txt\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...\", ty='twg')\n",
        "os.system('pip install git+https://github.com/jeroenmeulenaar/python3-mega.git')\n",
        "os.system('pip install mediafire')\n",
        "os.system('pip install googleDriveFileDownloader')\n",
        "\n",
        "\n",
        "clear_output()\n",
        "print(\"Install Finished\")\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zwnehE_ln7A4",
        "colab_type": "text"
      },
      "source": [
        "### I got link here: \n",
        "https://gitgud.io/dreamnet/dreamtime#download-mirrors\n",
        "\n",
        "Also you can find torrent, and manualy upload to Gdrive\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ko9abeEcihFZ",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Download checkpoints (pytorch models  *.lib x3)\n",
        "%cd \"/content/dreamtime-private/src/cli\"\n",
        "check_path = '/content/dreamtime-private/src/cli/checkpoints.zip'\n",
        "\n",
        "Gdrive_url = \"https://drive.google.com/uc?id=1p1pbiBkNLyStDqU2VBOMf4kTKJht9dtP&export=download\" #@param {type:\"string\"}\n",
        "MegaNZ_url = \"https://mega.nz/#!3ih2jIgB!EcfD4_K_blnjfNfVmqhV4drrsN_xh4gaMsZzSZIw17s\" #@param {type:\"string\"}\n",
        "Direct_Link = \"\" #@param {type:\"string\"}\n",
        "\n",
        "Download_from = \"Gdrive\" #@param [\"MegaNZ\", \"DirectLink\",\"Gdrive\"]\n",
        "\n",
        "from pathlib import Path\n",
        "if Path(check_path).exists():\n",
        "  q_delete = input('Already downloaded. Delete zip file? (y)/n')\n",
        "  if q_delete.lower() == 'y': \n",
        "    !rm $check_path\n",
        "\n",
        "if not Path(check_path).exists():\n",
        "  print('Downloading started')\n",
        "  if Download_from == 'MegaNZ':\n",
        "    from mega import Mega\n",
        "    m = Mega.from_ephemeral()\n",
        "    m.download_from_url(MegaNZ_url)\n",
        "\n",
        "if not Path(check_path).exists():\n",
        "   if Download_from == 'Gdrive':\n",
        "    from googleDriveFileDownloader import googleDriveFileDownloader\n",
        "    a = googleDriveFileDownloader()\n",
        "    a.downloadFile(Gdrive_url)                            \n",
        "                                \n",
        "else:\n",
        "     import urllib\n",
        "     urllib.request.urlretrieve ( Direct_Link, \"checkpoints.zip\" )\n",
        "     print('Finished')\n",
        "#пиздец я заебался эту хуйню писать. Надеюсь заработает\n",
        "\n",
        "def unzip(zip_path, dest_path):\n",
        "  unzip_cmd = \" unzip -q \" + zip_path + \" -d \"+dest_path\n",
        "  !$unzip_cmd\n",
        "  print(\"Unziped!\")\n",
        "\n",
        "%cd '/content/dreamtime-private/src/cli'\n",
        "check_dir_path = '/content/dreamtime-private/src/cli/checkpoints'\n",
        "\n",
        "from pathlib import Path\n",
        "if Path(check_dir_path).exists():\n",
        "  !mkdir $check_dir_path\n",
        "\n",
        "unzip('checkpoints.zip', 'checkpoints')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cau5CTZPUu-n",
        "colab_type": "text"
      },
      "source": [
        "### Photo edit"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y0TvGuWqN6Kl",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Upload Photo\n",
        "%cd /content/dreamtime-private/src/cli\n",
        "\n",
        "from pathlib import Path\n",
        "if not Path('photos').exists():\n",
        "  !mkdir photos\n",
        "\n",
        "if not Path('temp_photos').exists():\n",
        "  !mkdir temp_photos\n",
        "\n",
        "%cd /content/dreamtime-private/src/cli/temp_photos\n",
        "\n",
        "print('Choose 1 png file')\n",
        "target = 'test'\n",
        "from google.colab import files\n",
        "uploaded = files.upload()\n",
        "\n",
        "for name, bytes_ in uploaded.items():\n",
        "  if name.endswith('.png') or name.endswith('.jpg'):\n",
        "    target=name\n",
        "    break\n",
        "  else:\n",
        "    print('Only image')\n",
        " \n",
        "if target == 'test':\n",
        "  print('Timeout finished. Pls restart and be faster')\n",
        "else:\n",
        "  %matplotlib inline\n",
        "  from IPython.display import display\n",
        "  from PIL import Image, ImageDraw\n",
        "  from ipywidgets import widgets, interact\n",
        "  import matplotlib.pyplot as plt\n",
        "  import numpy as np\n",
        "\n",
        "  image = Image.open(target)\n",
        "  im_w, im_h = image.size\n",
        "  im_w+=int(im_w/2)\n",
        "  im_h+=int(im_h/2)\n",
        "  size = (im_w, im_h)\n",
        "\n",
        "  if size == (512, 512):\n",
        "    print('All right')\n",
        "    image.save('../photos/'+target[:-3]+'png')\n",
        "  else:\n",
        "    print('Pls resize image')\n",
        "    image.thumbnail(size, Image.ANTIALIAS)\n",
        "    background = Image.new('RGBA', size, (255, 255, 255, 0))\n",
        "    background.paste(\n",
        "        image, (int((size[0] - image.size[0]) / 2), int((size[1] - image.size[1]) / 2))\n",
        "    )\n",
        "    image = background\n",
        "\n",
        "    def f(BoxSize, x, y, save=False):\n",
        "      ed_image = image.copy()\n",
        "      draw = ImageDraw.Draw(ed_image)\n",
        "      draw.rectangle([(x, y), \n",
        "                      (x+BoxSize, y+BoxSize)], \n",
        "                     outline='red', \n",
        "                     width=4)\n",
        "      if save:\n",
        "        print('SAVED!')\n",
        "        crop_im = image.copy()\n",
        "        crop_im = crop_im.crop((x,y,x+BoxSize,y+BoxSize))\n",
        "        crop_im = crop_im.resize([512,512], Image.ANTIALIAS)\n",
        "        crop_im.save('../photos/'+target[:-3]+'png')\n",
        "      display_im = ed_image.copy()\n",
        "      display_im.thumbnail((700,700), Image.ANTIALIAS)\n",
        "      display(display_im)\n",
        "\n",
        "    def on_butt_clicked(event):\n",
        "      f(w_box.value,w_x.value,w_y.value,save=True)\n",
        "\n",
        "    w_box = widgets.IntSlider(min=100, max=int(image.size[1]/100*70), value=512)\n",
        "    w_x = widgets.IntSlider(min=0, max=int(image.size[0]/100*70), value=image.size[0]//5)\n",
        "    w_y = widgets.IntSlider(min=0, max=int(image.size[1]/100*70), value=image.size[1]//5)\n",
        "    butt = widgets.Button(description='Save')\n",
        "    butt.on_click(on_butt_clicked)\n",
        "\n",
        "    display(butt)\n",
        "    interact(f,  BoxSize=w_box, x=w_x, y=w_y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sml5WGa9NeMv",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Upload gif\n",
        "\n",
        "%cd /content/dreamtime-private/src/cli\n",
        "\n",
        "from pathlib import Path\n",
        "if not Path('gifs').exists():\n",
        "  !mkdir gifs\n",
        "\n",
        "%cd gifs\n",
        "from google.colab import files\n",
        "files.upload()\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SdrIv5gpjTfw",
        "colab_type": "text"
      },
      "source": [
        "### SEND NUDES!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bzRfBbINVfOW",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Image magic\n",
        "Pubic_Hair = True #@param {type:\"boolean\"}\n",
        "%cd \"/content/dreamtime-private/src/cli\"\n",
        "\n",
        "\n",
        "path='results'\n",
        "import os\n",
        "if not os.path.exists(path):\n",
        "    os.makedirs(path)\n",
        "\n",
        "from IPython.display import display\n",
        "from ipywidgets import widgets\n",
        "from os import listdir\n",
        "from os.path import isfile, join\n",
        "\n",
        "mypath = '/content/dreamtime-private/src/cli/photos'\n",
        "onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]\n",
        "\n",
        "if len(onlyfiles)>0:\n",
        "  filename_ch = widgets.Dropdown(\n",
        "      options=onlyfiles,\n",
        "      description='Choose file:',\n",
        "  )\n",
        "  butt = widgets.Button(description='Start')\n",
        "  def on_butt_clicked(b):\n",
        "      print(filename_ch.value)\n",
        "      %cd '/content/dreamtime-private/src/cli'\n",
        "      if Pubic_Hair == True:\n",
        "        !python main.py -i \"photos/$filename_ch.value\" -o \"results/$filename_ch.value\" --enablepubes --gpu 0\n",
        "      else:\n",
        "        !python main.py -i \"photos/$filename_ch.value\" -o \"results/$filename_ch.value\" --gpu 0\n",
        "      %cd '/content/dreamtime-private/src/cli/results'\n",
        "      from IPython.display import display, Image\n",
        "      display(Image(filename_ch.value))\n",
        "    \n",
        "\n",
        "\n",
        "  butt.on_click(on_butt_clicked)\n",
        "  # display\n",
        "  display(widgets.VBox([filename_ch,butt]))\n",
        "else:\n",
        "  print('Upload photo at first')\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oNP4dIX0_6LH",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Gif magic\n",
        "Pubic_Hair = True #@param {type:\"boolean\"}\n",
        "%cd \"/content/dreamtime-private/src/cli\"\n",
        "\n",
        "\n",
        "path='gifs'\n",
        "import os\n",
        "if not os.path.exists(path):\n",
        "    os.makedirs(path)\n",
        "\n",
        "path='gif_results'\n",
        "if not os.path.exists(path):\n",
        "    os.makedirs(path)\n",
        "\n",
        "from IPython.display import display\n",
        "from ipywidgets import widgets\n",
        "from os import listdir\n",
        "from os.path import isfile, join\n",
        "\n",
        "mypath = '/content/dreamtime-private/src/cli/gifs'\n",
        "onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]\n",
        "\n",
        "if len(onlyfiles)>0:\n",
        "  filename_ch = widgets.Dropdown(\n",
        "      options=onlyfiles,\n",
        "      description='Choose gif:',\n",
        "  )\n",
        "  butt = widgets.Button(description='Start')\n",
        "  def on_butt_clicked(b):\n",
        "      print(filename_ch.value)\n",
        "      %cd '/content/dreamtime-private/src/cli'\n",
        "      if Pubic_Hair == True:\n",
        "       !python main.py -i \"gifs/$filename_ch.value\" -o \"gif_results/$filename_ch.value\" --enablepubes --gpu 0 --gif\n",
        "      else:\n",
        "       !python main.py -i \"gifs/$filename_ch.value\" -o \"gif_results/$filename_ch.value\" --gpu 0 --gif\n",
        "      %cd '/content/dreamtime-private/src/cli/gif_results'\n",
        "      from IPython.display import display, Image\n",
        "      display(Image(filename_ch.value))\n",
        "\n",
        "  butt.on_click(on_butt_clicked)\n",
        "  # display\n",
        "  display(widgets.VBox([filename_ch,butt]))\n",
        "else:\n",
        "  print('Upload gif at first')\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "STq65Y8NlBSX",
        "colab_type": "text"
      },
      "source": [
        "### Tools"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sjrV5MvdpANy",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title List files\n",
        "!ls /content/dreamtime-private/src/cli/temp_photos\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OxqtO7Yrl4D1",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Crop\n",
        "%cd /content/dreamtime-private/src/cli/temp_photos\n",
        "target = '' #@param {type:\"string\"}\n",
        "%matplotlib inline\n",
        "from IPython.display import display\n",
        "from PIL import Image, ImageDraw\n",
        "from ipywidgets import widgets, interact\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "image = Image.open(target)\n",
        "im_w, im_h = image.size\n",
        "im_w+=int(im_w/2)\n",
        "im_h+=int(im_h/2)\n",
        "size = (im_w, im_h)\n",
        "\n",
        "if size == (512, 512):\n",
        "  print('All right')\n",
        "  image.save('../photos/'+target[:-3]+'png')\n",
        "else:\n",
        "  print('Pls resize image')\n",
        "  image.thumbnail(size, Image.ANTIALIAS)\n",
        "  background = Image.new('RGBA', size, (255, 255, 255, 0))\n",
        "  background.paste(\n",
        "      image, (int((size[0] - image.size[0]) / 2), int((size[1] - image.size[1]) / 2))\n",
        "  )\n",
        "  image = background\n",
        "\n",
        "  def f(BoxSize, x, y, save=False):\n",
        "    ed_image = image.copy()\n",
        "    draw = ImageDraw.Draw(ed_image)\n",
        "    draw.rectangle([(x, y), \n",
        "                    (x+BoxSize, y+BoxSize)], \n",
        "                   outline='red', \n",
        "                   width=4)\n",
        "    if save:\n",
        "      print('SAVED!')\n",
        "      crop_im = image.copy()\n",
        "      crop_im = crop_im.crop((x,y,x+BoxSize,y+BoxSize))\n",
        "      crop_im = crop_im.resize([512,512], Image.ANTIALIAS)\n",
        "      crop_im.save('../photos/'+target[:-3]+'png')\n",
        "    display_im = ed_image.copy()\n",
        "    display_im.thumbnail((700,700), Image.ANTIALIAS)\n",
        "    display(display_im)\n",
        "\n",
        "  def on_butt_clicked(event):\n",
        "    f(w_box.value,w_x.value,w_y.value,save=True)\n",
        "\n",
        "  w_box = widgets.IntSlider(min=100, max=int(image.size[1]/100*70), value=512)\n",
        "  w_x = widgets.IntSlider(min=0, max=int(image.size[0]/100*70), value=image.size[0]//5)\n",
        "  w_y = widgets.IntSlider(min=0, max=int(image.size[1]/100*70), value=image.size[1]//5)\n",
        "  butt = widgets.Button(description='Save')\n",
        "  butt.on_click(on_butt_clicked)\n",
        "\n",
        "  display(butt)\n",
        "  interact(f,  BoxSize=w_box, x=w_x, y=w_y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t5DHCX-RqxCI",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Rotate image\n",
        "%cd /content/dreamtime-private/src/cli/temp_photos\n",
        "target = '' #@param {type:\"string\"}\n",
        "ro_deg = -86 #@param {type:\"integer\"}\n",
        "\n",
        "from PIL import Image\n",
        "im_rotate= Image.open(target)\n",
        "im_rotate=im_rotate.rotate(ro_deg,expand=True)\n",
        "im_rotate.save(target)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XxaUO8fPKz-w",
        "colab_type": "text"
      },
      "source": [
        "##  <img src='https://www.deepnude.com/logo_head.png' height=\"50\" alt=\"RcloneLab\"/> ___DeepNude with DreamNet improvements.___ <h5>(Need to switch to GPU runtime)</h5>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iyeuWnymsX6K",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Clone repo and install requirements - Need to restart runtime</h3>\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...Please Wait....\", ty='twg')\n",
        "os.system('cd /content && git clone https://github.com/dreamnettech/dreampower.git && cd dreampower && pip install -r /content/dreampower/requirements.txt')\n",
        "\n",
        "\n",
        "clear_output()\n",
        "print(\"Installed Successfully, Restart Your Notebook\")\n",
        "#====================================\n",
        "from IPython.display import display\n",
        "import ipywidgets as widgets\n",
        "#====================================\n",
        "button = widgets.Button(description=\"Restart Notebook\")\n",
        "output = widgets.Output()\n",
        "\n",
        "display(button, output)\n",
        "\n",
        "def on_button_clicked(b):\n",
        "    with output:\n",
        "        print(\"Button clicked.\")\n",
        "        os._exit(00)\n",
        "\n",
        "button.on_click(on_button_clicked)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zp6U-ukSsz7w",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Download checkpoints (pytorch models  *.lib x3)</h3>\n",
        "import os\n",
        "from IPython.display import clear_output\n",
        "%cd /content/dreampower\n",
        "!wget https://github.com/dreamnettech/dreampower-checkpoints/releases/download/0.0.1/v0.0.1.zip\n",
        "os.rename(\"v0.0.1.zip\",\"checkpoints.zip\")\n",
        "!unzip \"checkpoints.zip\"\n",
        "\n",
        "clear_output()\n",
        "print(\"Download Finished\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "q435dQmbuPlr",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Local Upload Photo edit (Manual Crop option)</h3>\n",
        "%cd /content/dreampower\n",
        "\n",
        "\n",
        "from pathlib import Path\n",
        "if not Path('photos').exists():\n",
        "  !mkdir photos\n",
        "\n",
        "if not Path('temp_photos').exists():\n",
        "  !mkdir temp_photos\n",
        "\n",
        "%cd /content/dreampower/temp_photos\n",
        "\n",
        "print('Choose 1 png file')\n",
        "target = 'test'\n",
        "from google.colab import files\n",
        "uploaded = files.upload()\n",
        "\n",
        "for name, bytes_ in uploaded.items():\n",
        "  if name.endswith('.png') or name.endswith('.jpg'):\n",
        "    target=name\n",
        "    break\n",
        "  else:\n",
        "    print('Only image')\n",
        " \n",
        "if target == 'test':\n",
        "  print('Timeout finished. Pls restart and be faster')\n",
        "else:\n",
        "  %matplotlib inline\n",
        "  from IPython.display import display\n",
        "  from PIL import Image, ImageDraw\n",
        "  from ipywidgets import widgets, interact\n",
        "  import matplotlib.pyplot as plt\n",
        "  import numpy as np\n",
        "\n",
        "  image = Image.open(target)\n",
        "  im_w, im_h = image.size\n",
        "  im_w+=int(im_w/2)\n",
        "  im_h+=int(im_h/2)\n",
        "  size = (im_w, im_h)\n",
        "\n",
        "  if size == (512,512):\n",
        "    print('All right')\n",
        "    image.save('../photos/'+target[:-3]+'png')\n",
        "  else:\n",
        "    print('Pls resize image')\n",
        "    image.thumbnail(size, Image.ANTIALIAS)\n",
        "    background = Image.new('RGBA', size, (255, 255, 255, 0))\n",
        "    background.paste(\n",
        "        image, (int((size[0] - image.size[0]) / 2), int((size[1] - image.size[1]) / 2))\n",
        "    )\n",
        "    image = background\n",
        "\n",
        "    def f(BoxSize, x, y, save=False):\n",
        "      ed_image = image.copy()\n",
        "      draw = ImageDraw.Draw(ed_image)\n",
        "      draw.rectangle([(x, y), \n",
        "                      (x+BoxSize, y+BoxSize)], \n",
        "                     outline='red', \n",
        "                     width=4)\n",
        "      if save:\n",
        "        print('SAVED!')\n",
        "        crop_im = image.copy()\n",
        "        crop_im = crop_im.crop((x,y,x+BoxSize,y+BoxSize))\n",
        "        crop_im = crop_im.resize([512,512], Image.ANTIALIAS)\n",
        "        crop_im.save('../photos/'+target[:-3]+'png')\n",
        "      display_im = ed_image.copy()\n",
        "      display_im.thumbnail((700,700), Image.ANTIALIAS)\n",
        "      display(display_im)\n",
        "\n",
        "    def on_butt_clicked(event):\n",
        "      f(w_box.value,w_x.value,w_y.value,save=True)\n",
        "\n",
        "    w_box = widgets.IntSlider(min=100, max=int(image.size[1]/100*70), value=512)\n",
        "    w_x = widgets.IntSlider(min=0, max=int(image.size[0]/100*70), value=image.size[0]//5)\n",
        "    w_y = widgets.IntSlider(min=0, max=int(image.size[1]/100*70), value=image.size[1]//5)\n",
        "    butt = widgets.Button(description='Save')\n",
        "    butt.on_click(on_butt_clicked)\n",
        "\n",
        "    display(butt)\n",
        "    interact(f,  BoxSize=w_box, x=w_x, y=w_y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "q6aBSeiwi5WY",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Local Upload Photo edit (Overlay Option)</h3>\n",
        "%cd /content/dreampower\n",
        "\n",
        "\n",
        "from pathlib import Path\n",
        "if not Path('photos').exists():\n",
        "  !mkdir photos\n",
        "\n",
        "if not Path('temp_photos').exists():\n",
        "  !mkdir temp_photos\n",
        "\n",
        "%cd /content/dreampower/temp_photos\n",
        "\n",
        "print('Choose 1 png file')\n",
        "target = 'test'\n",
        "from google.colab import files\n",
        "uploaded = files.upload()\n",
        "\n",
        "for name, bytes_ in uploaded.items():\n",
        "  if name.endswith('.png') or name.endswith('.jpg'):\n",
        "    target=name\n",
        "    break\n",
        "  else:\n",
        "    print('Only image')\n",
        " \n",
        "if target == 'test':\n",
        "  print('Timeout finished. Pls restart and be faster')\n",
        "else:\n",
        "  %matplotlib inline\n",
        "  from IPython.display import display\n",
        "  from PIL import Image, ImageDraw\n",
        "  from ipywidgets import widgets, interact\n",
        "  import matplotlib.pyplot as plt\n",
        "  import numpy as np\n",
        "\n",
        "  image = Image.open(target)\n",
        "  im_w, im_h = image.size\n",
        "  im_w+=int(im_w/2)\n",
        "  im_h+=int(im_h/2)\n",
        "  size = (im_w, im_h)\n",
        "\n",
        "  if size == (512,512):\n",
        "    print('All right')\n",
        "    image.save('../photos/'+target[:-3]+'png')\n",
        "  else:\n",
        "    print('Pls resize image')\n",
        "    image.save('../photos/'+target[:-3]+'png')\n",
        "    image.thumbnail(size, Image.ANTIALIAS)\n",
        "    background = Image.new('RGBA', size, (255, 255, 255, 0))\n",
        "    background.paste(\n",
        "         image)\n",
        "    image = background\n",
        "  \n",
        "    \n",
        "\n",
        "    def f(BoxSize, x, y, save=False):\n",
        "      ed_image = image.copy()\n",
        "      draw = ImageDraw.Draw(ed_image)\n",
        "      draw.rectangle([(x, y), \n",
        "                      (x+BoxSize, y+BoxSize)], \n",
        "                     outline='red', \n",
        "                     width=4)\n",
        "      if save:\n",
        "        print('SAVED!')\n",
        "        overlay_x = x\n",
        "        overlay_y = y\n",
        "        overlay_size = BoxSize\n",
        "        overlay_dims = f'{overlay_x},{overlay_y}:{overlay_x+overlay_size},{overlay_y+overlay_size}'\n",
        "        print(overlay_dims)\n",
        "        %cd /content/dreampower\n",
        "        f = open(\"overlay.txt\",\"w\") \n",
        "        f.write(overlay_dims)\n",
        "        f.close() \n",
        "      \n",
        "\n",
        "      display_im = ed_image.copy()\n",
        "      display_im.thumbnail((2000,2000), Image.ANTIALIAS)\n",
        "      display(display_im)\n",
        "    \n",
        "\n",
        "    def on_butt_clicked(event):\n",
        "      f(w_box.value,w_x.value,w_y.value,save=True)\n",
        "\n",
        "    w_box = widgets.IntSlider(min=100, max=int(image.size[1]/100*70), value=512)\n",
        "    w_x = widgets.IntSlider(min=0, max=int(image.size[0]/100*70), value=image.size[0]//5)\n",
        "    w_y = widgets.IntSlider(min=0, max=int(image.size[1]/100*70), value=image.size[1]//5)\n",
        "    butt = widgets.Button(description='Save')\n",
        "    butt.on_click(on_butt_clicked)\n",
        "\n",
        "    display(butt)\n",
        "    interact(f,  BoxSize=w_box, x=w_x, y=w_y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_CGDZEjxvePP",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Send Nudes\n",
        "\n",
        "Option = \"Auto setting for Url upload\" #@param [\"Web upload\",\"Auto setting for Url upload\",\"local upload\",\"Auto setting for local upload\",\"Overlay\",\"Auto setting for Overlay option\"]\n",
        "\n",
        "if (Option == \"Overlay\" or Option == \"Auto setting for Overlay option\"):\n",
        " f = open('overlay.txt', 'r')\n",
        " overlay_dims = f.read()\n",
        " f.close\n",
        " print(overlay_dims)\n",
        "\n",
        "\n",
        "import os\n",
        "%cd /content/dreampower\n",
        "os.makedirs(\"photos\", exist_ok=True)\n",
        "%cd photos\n",
        "#@markdown Tip - Url only for <b>Web upload & Auto setting for Url upload</b> option\n",
        "source_image_url = '' #@param {type:\"string\"}\n",
        "if (Option == \"Web upload\" or Option == \"Auto setting for Url upload\"):\n",
        "  !wget -N \"$source_image_url\"\n",
        "  \n",
        "Number_of_cpu_core = 8 #@param {type:\"slider\", min:2, max:8, step:1}\n",
        "Pubic_Hair_Size = 1 #@param {type:\"slider\", min:0, max:1.5, step:0.1}\n",
        "\n",
        "#@markdown ----\n",
        "#@markdown Tip - If you select <b>Auto settings</b> option, below setting will not effect on output image\n",
        "Boob_Size = 1.8 #@param {type:\"slider\", min:0.3, max:2.0, step:0.1}\n",
        "Areola_Size = 0.7 #@param {type:\"slider\", min:0.3, max:2.0, step:0.1}\n",
        "Nipple_Size = 0.7 #@param {type:\"slider\", min:0.3, max:2.0, step:0.1}\n",
        "Vagina_Size = 1.5 #@param {type:\"slider\", min:0.3, max:1.5, step:0.1}\n",
        "\n",
        "color_transfer = False #@param {type:\"boolean\"}\n",
        "os.environ['n'] = str(Number_of_cpu_core)\n",
        "cpu_string = \"--n-cores $n\"\n",
        "\n",
        "if color_transfer == True:\n",
        "  color_string = \"--color-transfer\"\n",
        "else:\n",
        "  color_string = \"\"\n",
        "\n",
        "%cd /content/dreampower\n",
        "\n",
        "path='results'\n",
        "import os\n",
        "if not os.path.exists(path):\n",
        "    os.makedirs(path)\n",
        "\n",
        "from IPython.display import display\n",
        "from ipywidgets import widgets\n",
        "from os import listdir\n",
        "from os.path import isfile, join\n",
        "\n",
        "mypath = '/content/dreampower/photos'\n",
        "onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]\n",
        "\n",
        "if len(onlyfiles)>0:\n",
        "  filename_ch = widgets.Dropdown(\n",
        "      options=onlyfiles,\n",
        "      description='Choose file:',\n",
        "  )\n",
        "  butt = widgets.Button(description='Start')\n",
        "  def on_butt_clicked(b):\n",
        "      print(filename_ch.value)\n",
        "      %cd '/content/dreampower'\n",
        "      if Option == \"Web upload\":\n",
        "        !python main.py run -i \"photos/$filename_ch.value\" -o \"results/$filename_ch.value\" {color_string} --auto-resize-crop --hsize \"$Pubic_Hair_Size\" --gpu 0   \n",
        "      elif Option == \"Auto setting for Url upload\":\n",
        "        !python main.py run -i \"photos/$filename_ch.value\" -o \"results/$filename_ch.value\" {color_string} {cpu_string} --auto-resize-crop --hsize \"$Pubic_Hair_Size\" --gpu 0   \n",
        "      elif Option == \"Auto setting for Overlay option\":\n",
        "        !python main.py run -i \"photos/$filename_ch.value\" -o \"results/$filename_ch.value\" {color_string} --overlay \"$overlay_dims\" --hsize \"$Pubic_Hair_Size\" --gpu 0   \n",
        "      elif Option == \"Overlay\":\n",
        "        !python main.py run -i \"photos/$filename_ch.value\" -o \"results/$filename_ch.value\" {color_string} --overlay \"$overlay_dims\" --bsize \"$Boob_Size\" --asize \"$Areola_Size\" --nsize \"$Nipple_Size\" --vsize \"$Vagina_Size\" --hsize \"$Pubic_Hair_Size\"   --gpu 0  \n",
        "      elif Option == \"local upload\":\n",
        "        !python main.py run -i \"photos/$filename_ch.value\" -o \"results/$filename_ch.value\" {color_string} --bsize \"$Boob_Size\" --asize \"$Areola_Size\" --nsize \"$Nipple_Size\" --vsize \"$Vagina_Size\" --hsize \"$Pubic_Hair_Size\"   --gpu 0  \n",
        "      else:\n",
        "        !python main.py run -i \"photos/$filename_ch.value\" -o \"results/$filename_ch.value\" {color_string} --hsize \"$Pubic_Hair_Size\"   --gpu 0    \n",
        "      %cd '/content/dreampower/results'\n",
        "      from IPython.display import display, Image\n",
        "      display(Image(filename_ch.value))\n",
        "    \n",
        "\n",
        "\n",
        "  butt.on_click(on_butt_clicked)\n",
        "  # display\n",
        "  display(widgets.VBox([filename_ch,butt]))\n",
        "else:\n",
        "  print('Upload photo at first')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eAbATGsb5fwf",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://venturebeat.com/wp-content/uploads/2020/03/CORD-19.png?fit=578%2C259&strip=all' height=\"70\" alt=\"filebrowser\" />         ___**Modeling and Control of COVID-19 Outbreak**___"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "oGa0Q3yH-Zai"
      },
      "source": [
        "The following cell simulates a COVID-19 outbreak in campus population of size N starting with one infectious case.  The following parameter values for a standard SEIR model were selected from values given in the recent survey by Boldog, et al. (2020).\n",
        "\n",
        "| Parameter |  Symbol  | Typical |\n",
        "| :------- | :-- | :-----------: |\n",
        "| Reproduction number | $R_0$ | 2.4 |\n",
        "| Incubation period (days)| $\\tau_{incubation}$ | 5.1\n",
        "| Infectious period (days) | $\\tau_{infectious}$ | 3.3\n",
        "| Campus population | $N$ | 20,000 \n",
        "| Initial number exposed | $n$ | 10\n",
        "| Mitigation by social distancing | $u$ | 0.2\n",
        "| Start of social distancing following exposure (weeks) | $t_{sd}$ | 2\n",
        "\n",
        "To run the model, adjust the sliders below, then click the run arrow that appears in the left marging. The charts will automatically update when the sliders are readjusted."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "colab_type": "code",
        "id": "YXQnHy66r4QD",
        "colab": {}
      },
      "source": [
        "#@title SEIR Model with Social Distancing { run: \"auto\" }\n",
        "#@markdown \n",
        "#@markdown Reproduction number\n",
        "R0 = 2.4 #@param {type:\"slider\", min:0.9, max:5, step:0.1}\n",
        "#@markdown Disease periods in days\n",
        "t_incubation = 5.1 #@param {type:\"slider\", min:1, max:14, step:0.1}\n",
        "t_infective = 3.3 #@param {type:\"slider\", min:1, max:14, step:0.1}\n",
        "#@markdown Population Size\n",
        "N = 50000 #@param {type:\"slider\", min:1000, max:350000, step: 1000}\n",
        "#@markdown Initial number exposed\n",
        "n = 13 #@param {type:\"slider\", min:0, max:100, step:1}\n",
        "#@markdown Start of social distancing following exposure (weeks)\n",
        "t_social_distancing = 0.3 #@param {type:\"slider\", min:0, max:30, step:0.1}\n",
        "#@markdown Effectiveness of social distancing (0 to 100%)\n",
        "u_social_distancing = 41 #@param {type:\"slider\", min:0, max:100, step:1}\n",
        "\n",
        "import numpy as np\n",
        "from scipy.integrate import odeint\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# initial number of infected and recovered individuals\n",
        "e_initial = n/N\n",
        "i_initial = 0.00\n",
        "r_initial = 0.00\n",
        "s_initial = 1 - e_initial - i_initial - r_initial\n",
        "\n",
        "alpha = 1/t_incubation\n",
        "gamma = 1/t_infective\n",
        "beta = R0*gamma\n",
        "\n",
        "def step(t):\n",
        "    return 1 if t >= 7*t_social_distancing else 0\n",
        "\n",
        "# SEIR model differential equations.\n",
        "def deriv(x, t, u, alpha, beta, gamma):\n",
        "    s, e, i, r = x\n",
        "    dsdt = -(1-u*step(t)/100)*beta * s * i\n",
        "    dedt =  (1-u*step(t)/100)*beta * s * i - alpha * e\n",
        "    didt = alpha * e - gamma * i\n",
        "    drdt =  gamma * i\n",
        "    return [dsdt, dedt, didt, drdt]\n",
        "\n",
        "t = np.linspace(0, 210, 210)\n",
        "x_initial = s_initial, e_initial, i_initial, r_initial\n",
        "s, e, i, r = odeint(deriv, x_initial, t, args=(u_social_distancing, alpha, beta, gamma)).T\n",
        "s0, e0, i0, r0 = odeint(deriv, x_initial, t, args=(0, alpha, beta, gamma)).T\n",
        "\n",
        "# plot the data\n",
        "fig = plt.figure(figsize=(12, 10))\n",
        "ax = [fig.add_subplot(311, axisbelow=True), \n",
        "      fig.add_subplot(312)]\n",
        "\n",
        "pal = sns.color_palette()\n",
        "\n",
        "ax[0].stackplot(t/7, N*s, N*e, N*i, N*r, colors=pal, alpha=0.6)\n",
        "ax[0].set_title('Susceptible and Recovered Populations with {0:3.0f}% Effective Social Distancing'.format(u_social_distancing))\n",
        "ax[0].set_xlabel('Weeks following Initial Campus Exposure')\n",
        "ax[0].set_xlim(0, t[-1]/7)\n",
        "ax[0].set_ylim(0, N)\n",
        "ax[0].legend([\n",
        "    'Susceptible', \n",
        "    'Exposed/no symptoms', \n",
        "    'Infectious/symptomatic',\n",
        "    'Recovered'], \n",
        "    loc='best')\n",
        "ax[0].plot(np.array([t_social_distancing, t_social_distancing]), ax[0].get_ylim(), 'r', lw=3)\n",
        "ax[0].plot(np.array([0, t[-1]])/7, [N/R0, N/R0], lw=3, label='herd immunity')\n",
        "ax[0].annotate(\"Start of social distancing\",\n",
        "    (t_social_distancing, 0), (t_social_distancing + 1.5, N/10),\n",
        "    arrowprops=dict(arrowstyle='->'))\n",
        "ax[0].annotate(\"Herd Immunity without social distancing\",\n",
        "    (t[-1]/7, N/R0), (t[-1]/7 - 8, N/R0 - N/5),\n",
        "    arrowprops=dict(arrowstyle='->'))\n",
        "\n",
        "ax[1].stackplot(t/7, N*i0,N*e0, colors=pal[2:0:-1], alpha=0.5)\n",
        "ax[1].stackplot(t/7, N*i, N*e, colors=pal[2:0:-1], alpha=0.5)\n",
        "ax[1].set_title('Infected Population with no Social Distancing and with {0:3.0f}% Effective Social Distancing'.format(u_social_distancing))\n",
        "ax[1].set_xlim(0, t[-1]/7)\n",
        "ax[1].set_ylim(0, max(0.3*N, 1.05*max(N*(e + i))))\n",
        "ax[1].set_xlabel('Weeks following Initial Campus Exposure')\n",
        "ax[1].legend([\n",
        "    'Infective/Symptomatic', \n",
        "    'Exposed/Not Sympotomatic'],\n",
        "    loc='upper right')\n",
        "ax[1].plot(np.array([t_social_distancing, t_social_distancing]), ax[0].get_ylim(), 'r', lw=3)\n",
        "\n",
        "y0 = N*(e0 + i0)\n",
        "k0 = np.argmax(y0)\n",
        "ax[1].annotate(\"No social distancing\", (t[k0]/7, y0[k0] + 100))\n",
        "\n",
        "y = N*(e + i)\n",
        "k = np.argmax(y)\n",
        "ax[1].annotate(\"With {0:3.0f}% effective social distancing \".format(u_social_distancing), (t[k]/7, y[k] + 100))\n",
        "\n",
        "for a in ax:\n",
        "    a.xaxis.set_major_locator(plt.MultipleLocator(5))\n",
        "    a.xaxis.set_minor_locator(plt.MultipleLocator(1))\n",
        "    a.xaxis.set_major_formatter(plt.FormatStrFormatter('%d'))\n",
        "    a.grid(True)\n",
        "\n",
        "plt.tight_layout()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "53E8ZNYZxvjL",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://zdnet2.cbsistatic.com/hub/i/r/2015/12/09/5dcc5c80-b9a8-4bea-be99-1d08cbaa6b59/resize/270xauto/ab75ebe72e39435654d713524e970785/screen-shot-2015-12-09-at-09-49-26.png' height=\"65\" alt=\"filebrowser\" /><h5>(Need to switch to GPU runtime)</h5>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0jKi7CsmwCZn",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to install hashcat</h3>\n",
        "!apt install cmake build-essential -y && apt install checkinstall git -y && git clone https://github.com/hashcat/hashcat.git && cd hashcat && git submodule update --init && make && make install \n",
        "from IPython.display import HTML, clear_output\n",
        "clear_output()\n",
        "print(\"Server Started Successfully\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SeubAcoyxCsw",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to check Benchmark</h3>(Need to switch to GPU runtime)\n",
        "!hashcat -b"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RYdc8uL01DBX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!hashcat -h"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BHgi3YnTgXzX",
        "colab_type": "text"
      },
      "source": [
        "##<img src='http://pluspng.com/img-png/nvidia-png-nvidia-png-transparent-image-800.png' height=\"65\" alt=\"filebrowser\" /> StyleGAN 2 <h5>(Need to switch to GPU runtime)</h5>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2tBEmg5_Nl2g",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Install Require Modules</h3>\n",
        "%cd /content\n",
        "!pip install typeguard;\n",
        "!pip install psutil\n",
        "!pip install humanize\n",
        "!pip install tqdm\n",
        "!rm -rf stylegan2 && git clone https://github.com/NVlabs/stylegan2.git;\n",
        "%cd /content/stylegan2\n",
        "\n",
        "print(\"Installing\")\n",
        "\n",
        "from IPython.display import Image, clear_output\n",
        "from google.colab import files\n",
        "import sys\n",
        "import pickle\n",
        "import numpy as np\n",
        "import PIL\n",
        "import psutil\n",
        "import humanize\n",
        "import os\n",
        "import time\n",
        "from tqdm import tqdm\n",
        "\n",
        "from scipy import ndimage\n",
        "\n",
        "%tensorflow_version 1.x\n",
        "sys.path.append('/content/stylegan2/dnnlib')\n",
        "import dnnlib\n",
        "import dnnlib.tflib as tflib\n",
        "dnnlib.tflib.init_tf()\n",
        "\n",
        "entity_to_url = {\n",
        "  'faces': 'https://drive.google.com/uc?id=1erg93hWnekh57m3cwsAnqJYfYVceVVSe',\n",
        "  'celebs': 'https://drive.google.com/uc?id=1q8VldTeTbruoh34ih6GftOcybGNA0dcZ',\n",
        "  'bedrooms': 'https://drive.google.com/uc?id=15EV9JBiQ7ifoi-B-DQAZF4sYPdCAsiCY',\n",
        "  'cars': 'https://drive.google.com/uc?id=1QzWwIqJITrg5NWG7QyqrArhb_4UhStDy',\n",
        "  'cats': 'https://drive.google.com/uc?id=1Fz12B8TSPiRtzCqjhFxTH_W-rIZ5rSGr',\n",
        "  'anime': 'https://drive.google.com/uc?id=1z8N_-xZW9AU45rHYGj1_tDHkIkbnMW-R',\n",
        "  'chruch': 'https://drive.google.com/uc?id=1-0JMXPdCQLIVxkDE_S9pO8t8mWoEvhHl',\n",
        "  'horse': 'https://drive.google.com/uc?id=1-1oc3016pUDi2er1zEvjGcFy8FC-QAh3',\n",
        "  'anime': 'https://drive.google.com/uc?id=1-91fGZSsZJPNlFytg5iHvVLqxKWDLFt8',\n",
        "  'anime_portrait': 'https://drive.google.com/uc?id=1-Bw24cv9o7qjLtd8yq8bzzz9AjR9QAkL',\n",
        "  'faces2': 'https://drive.google.com/uc?id=18rJYK9oF6D7C607Be1B_Fu53rjjHUAT1',\n",
        "  'GOT': 'https://drive.google.com/uc?id=1-0LCuuUxUA0R6gdSd9prn5sP7T01iF0e',\n",
        "}\n",
        "\n",
        "model_cache = {}\n",
        "synthesis_kwargs = dict(output_transform=dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True), minibatch_size=20)\n",
        "\n",
        "def gen_pil_image(latents, zoom=1, psi=0.7):\n",
        "    fmt = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True)\n",
        "    image = Gs.run(latents, None, randomize_noise=True, output_transform=fmt, truncation_psi=psi)\n",
        "    if zoom == 1:\n",
        "        return PIL.Image.fromarray(image[0])\n",
        "    else:\n",
        "        print(image[0].shape)\n",
        "        return PIL.Image.fromarray(ndimage.zoom(image[0],(zoom,zoom,1)))\n",
        "\n",
        "import google.colab.output\n",
        "import random\n",
        "import io\n",
        "import base64\n",
        "\n",
        "def gen(l=None, psi=1):\n",
        "    if l is None:\n",
        "        l = [random.random()*2-1 for x in range(512)]\n",
        "    pimg = gen_pil_image(np.array(l).reshape(1,512), psi=psi)\n",
        "    bio = io.BytesIO()\n",
        "    pimg.save(bio, \"PNG\")\n",
        "    b = bio.getvalue()\n",
        "    return 'data:image/png;base64,'+str(base64.b64encode(b),encoding='utf-8')\n",
        "\n",
        "google.colab.output.register_callback('gen', gen)\n",
        "\n",
        "##\n",
        "def fetch_model(name):\n",
        "  if model_cache.get(name):\n",
        "    return model_cache[name]\n",
        "  url = entity_to_url[name]\n",
        "  with dnnlib.util.open_url(url, cache_dir='cache') as f:\n",
        "    _G, _D, Gs = pickle.load(f)\n",
        "    model_cache[name] = Gs\n",
        "  return model_cache[name]\n",
        "\n",
        "def fetch_file(filename):\n",
        "  with open(filename,'rb') as f:\n",
        "    return pickle.load(f)\n",
        "\n",
        "\n",
        "clear_output()\n",
        "print(\"Installed Successfully\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z-0082QSN12V",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Render Model</h3>\n",
        "#choose model here. default is ffhq\n",
        "import os\n",
        "Render_Model = \"faces\" #@param [\"faces\",\"faces2\",\"GOT\",\"celebs\",\"bedrooms\",\"cars\",\"cats\",\"chruch\",\"horse\",\"anime\"]\n",
        "\n",
        "\n",
        "if Render_Model == \"faces\":\n",
        " curr_model = \"faces\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"faces2\":\n",
        " curr_model = \"faces2\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"celebs\":\n",
        " curr_model = \"celebs\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"bedrooms\":\n",
        " curr_model = \"bedrooms\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"cars\":\n",
        " curr_model = \"cars\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"cats\":\n",
        " curr_model = \"cats\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"chruch\":\n",
        " curr_model = \"chruch\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"horse\":\n",
        " curr_model = \"horse\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"anime\":\n",
        " curr_model = \"anime\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"anime_portrait\":\n",
        " curr_model = \"anime_portrait\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n",
        "\n",
        "if Render_Model == \"GOT\":\n",
        " curr_model = \"GOT\" # can be faces, celebs, bedrooms, cars, cats, anime\n",
        " Gs = fetch_model(curr_model) # if you uploaded your own file, use fetch_file('path/to/file.pkl')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SyQlOnSBPvpF",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to run Model</h3>\n",
        "from IPython.display import HTML\n",
        "\n",
        "def get_latent_html(i):\n",
        "    return \"\"\"<div class=\"pure-control-group\">\n",
        "            <label for=\"l%i\">L%03i:</label>\n",
        "            <input type=\"number\" min=\"-999.99\" max=\"999.99\" step=\"0.01\" id=\"l%i\" value=\"%.2f\" style=\"background-color: white;\">\n",
        "    </div>\"\"\" % (i, i, i, (random.random()*2-1))\n",
        "\n",
        "def get_latents_html():\n",
        "    return '\\n'.join([get_latent_html(i) for i in range(512)])\n",
        "\n",
        "input_form = \"\"\"\n",
        "<link rel=\"stylesheet\" href=\"https://necolas.github.io/normalize.css/8.0.1/normalize.css\">\n",
        "<link rel=\"stylesheet\" href=\"https://unpkg.com/purecss@1.0.1/build/pure-min.css\" integrity=\"sha384-oAOxQR6DkCoMliIh8yFnu25d7Eq/PHS21PClpwjOTeU2jRSq11vu66rf90/cZr47\" crossorigin=\"anonymous\">\n",
        "\n",
        "<div style=\"background-color:white; border:solid #ccc; width:1200px; padding:20px; color: black;\">\n",
        "<p>You have currently loaded %s model</p>\n",
        "  <div class=\"pure-g\" style=\"width:1200px; margin-bottom: 25px;\">\n",
        "    <div class=\"pure-u-2-3\">\n",
        "      <img id=\"stylegan\" src=\"\" style=\"height:512px; width:512px;\">\n",
        "    </div>\n",
        "    <div class=\"pure-u-1-3\">\n",
        "      <div style=\"overflow-y:scroll; height:512px; width:300px\" class=\"pure-form pure-form-aligned\">\n",
        "        %s\n",
        "      </div>\n",
        "    </div>\n",
        "  </div>\n",
        "\n",
        "  <div class=\"pure-g\">\n",
        "    <div class=\"pure-u-1-6\">\n",
        "      <button class=\"pure-button pure-button-primary\" onclick=\"generate();\">Generate from latents</button>\n",
        "    </div>\n",
        "    <div class=\"pure-u-1-6 pure-form\">\n",
        "      <div class=\"pure-control-group\">\n",
        "            <label for=\"psi\">psi:</label>\n",
        "            <input type=\"number\" min=\"0\" max=\"999.99\" step=\"0.01\" id=\"psi\" value=\"0.7\" style=\"background-color: white;\">\n",
        "      </div>\n",
        "    </div>\n",
        "    <div class=\"pure-u-1-6\">\n",
        "      <button class=\"pure-button pure-button-primary\" onclick=\"mutate();\">Mutate randomly</button>\n",
        "    </div>\n",
        "    <div class=\"pure-u-1-6 pure-form\">\n",
        "      <div class=\"pure-control-group\">\n",
        "            <label for=\"mut_str\">Mutation strength:</label>\n",
        "            <input type=\"number\" min=\"0\" max=\"999.99\" step=\"0.01\" id=\"mut_str\" value=\"0.2\" style=\"background-color: white;\">\n",
        "      </div>\n",
        "    </div>\n",
        "    <div class=\"pure-u-1-6\">\n",
        "      <button class=\"pure-button pure-button-primary\" onclick=\"randomize();\">Random image</button>\n",
        "    </div>\n",
        "    <div class=\"pure-u-1-6\">\n",
        "      <button class=\"pure-button pure-button-primary\" onclick=\"nnormalize();\">Normalize latents</button>\n",
        "    </div>\n",
        "  </div>\n",
        "\n",
        "  <div class=\"pure-g\">\n",
        "    <div class=\"pure-u-1-3\">\n",
        "      <button class=\"pure-button pure-button-primary\" onclick=\"save();\">Save latents</button>\n",
        "      <button class=\"pure-button pure-button-primary\" onclick=\"load();\">Load latents</button>\n",
        "    </div>\n",
        "     <div class=\"pure-u-2-3 pure-form\">\n",
        "      <div class=\"pure-control-group\">\n",
        "            <input type=\"text\" id=\"save-input\" style=\"width:100%%; background-color: white;\" placeholder=\"Saved latents will show up here...\">\n",
        "      </div>\n",
        "    </div>\n",
        "  </div>\n",
        "\n",
        "</div>\n",
        "\"\"\" % (curr_model, get_latents_html())\n",
        "\n",
        "javascript = \"\"\"\n",
        "<img src onerror='generate()'>\n",
        "<script type=\"text/Javascript\">\n",
        "    function desanitize(text) {\n",
        "        return text.slice(1,-1).replace(/\\\\\\\\n/g, \"\\\\n\").replace(/\\\\\\\\'/g, \"'\");\n",
        "    };\n",
        "\n",
        "    function set_img(text) {\n",
        "        document.getElementById('stylegan').src = text;\n",
        "    };\n",
        "\n",
        "    function generate() {\n",
        "        var kernel = google.colab.kernel;\n",
        "        var latents = [];\n",
        "        var psi = parseFloat(document.getElementById('psi').value);\n",
        "        for (var i=0;i<512;i++) {\n",
        "            latents[i] = parseFloat(document.getElementById('l'+i).value);\n",
        "            //console.log(i);\n",
        "        };\n",
        "        console.log(latents);\n",
        "        var resultPromise = kernel.invokeFunction(\"gen\", [latents, psi]);\n",
        "        resultPromise.then(\n",
        "            function(value) {\n",
        "              console.log(value.data);\n",
        "              set_img(desanitize(value.data[\"text/plain\"]));\n",
        "              //document.getElementById('spinner').style = \"visibility: hidden;\";\n",
        "        });\n",
        "    };\n",
        "\n",
        "    function mutate() {\n",
        "        var kernel = google.colab.kernel;\n",
        "        var latents = [];\n",
        "        var psi = parseFloat(document.getElementById('psi').value);\n",
        "        var mutationStrength = parseFloat(document.getElementById('mut_str').value)\n",
        "        for (var i=0;i<512;i++) {\n",
        "            latents[i] = parseFloat(document.getElementById('l'+i).value);\n",
        "            latents[i] += (Math.random()*2-1) * mutationStrength;\n",
        "            document.getElementById('l'+i).value = latents[i];\n",
        "        };\n",
        "        console.log(latents);\n",
        "        var resultPromise = kernel.invokeFunction(\"gen\", [latents, psi]);\n",
        "        resultPromise.then(\n",
        "            function(value) {\n",
        "              console.log(value.data);\n",
        "              set_img(desanitize(value.data[\"text/plain\"]));\n",
        "              //document.getElementById('spinner').style = \"visibility: hidden;\";\n",
        "        });\n",
        "    };\n",
        "\n",
        "    function nnormalize() {\n",
        "        console.log('Any normies?');\n",
        "        var latents = [];\n",
        "        for (var i=0;i<512;i++) {\n",
        "            latents[i] = parseFloat(document.getElementById('l'+i).value);\n",
        "        };\n",
        "        var sum = latents.reduce((a, b) => a + b, 0);\n",
        "        for (var i=0;i<512;i++) {\n",
        "            latents[i] = latents[i]/sum;\n",
        "            document.getElementById('l'+i).value = latents[i];\n",
        "        };\n",
        "        console.log(latents);\n",
        "        generate();\n",
        "    };\n",
        "\n",
        "    function randomize() {\n",
        "        var latents = [];\n",
        "        for (var i=0;i<512;i++) {\n",
        "            latents[i] = Math.random()*2-1;\n",
        "            document.getElementById('l'+i).value = latents[i];\n",
        "        };\n",
        "        generate();\n",
        "    };\n",
        "\n",
        "    function save() {\n",
        "        var latents = [];\n",
        "        for (var i=0;i<512;i++) {\n",
        "            latents[i] = parseFloat(document.getElementById('l'+i).value);\n",
        "        };\n",
        "        document.getElementById('save-input').value = JSON.stringify(latents);\n",
        "    }\n",
        "\n",
        "    function load() {\n",
        "        var latents = JSON.parse(document.getElementById('save-input').value);\n",
        "        for (var i=0;i<512;i++) {\n",
        "            document.getElementById('l'+i).value = latents[i];\n",
        "        };\n",
        "        generate();\n",
        "    }\n",
        "\n",
        "</script>\n",
        "\"\"\"\n",
        "\n",
        "HTML(input_form + javascript)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IK9lYTykdbtt",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://upload.wikimedia.org/wikipedia/commons/0/0c/Blender_logo_no_text.svg' height=\"65\" alt=\"filebrowser\" /> Blender <h5>(Need to switch to GPU runtime)</h5>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8szOTQ7TTgNm",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Install Blender</h3>\n",
        "\n",
        "#@markdown <h3><center><b>Blender Render Script for Colab</b></center></h3>\n",
        "#@markdown <h5><center>This is a script for rendering in blender using Google Collab</center></h5>\n",
        "\n",
        "#@markdown <h4>Steps</h4>\n",
        "#@markdown <h5>- Make sure you have GPU enabled in your kernel (Also ensure that your blend file has GPU enabled)</h5>\n",
        "#@markdown <h5>- Use wget to download your file into the kernel</h5>\n",
        "#@markdown <h5>- In the blender command make sure that the correct filename is provided</h5>\n",
        "#========================================================================================================\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...\", ty='twg')\n",
        "os.system('apt install blender')\n",
        "os.system('apt install libboost-all-dev')\n",
        "os.system('apt install libgl1-mesa-dev')\n",
        "\n",
        "clear_output()\n",
        "print(\"Install Finished\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AWqlF827VDpn",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Download Blend file to render</h3>\n",
        "download_file_path = '' #@param {type: \"string\"}\n",
        "filename = '' #@param {type: \"string\"}\n",
        "filename+= '.blend'\n",
        "renderer = \"CYCLES\" #@param [\"CYCLES\", \"BLENDER_RENDER\"]\n",
        "frame = 1  #@param {type: \"number\"}\n",
        "\n",
        "!wget -O $filename $download_file_path\n",
        "##\n",
        "!ls -la\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hk2D1RK3WqVV",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Start Render</h3>\n",
        "!blender -b $filename -noaudio -o ./test_ -E $renderer -x 1 -f $frame\n",
        "\n",
        "from IPython.display import Image\n",
        "Image(filename='./test_0001.png')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kHsXa3yKXiFH",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://pngimage.net/wp-content/uploads/2018/06/ocr-png-5.png' height=\"65\" alt=\"filebrowser\" /> OCR <h5>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IwCbACK8d-Tn",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Install Require Modules</h3>\n",
        "\n",
        "#Install these Python Libraries\n",
        "\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...\", ty='twg')\n",
        "os.system('pip install pytesseract')\n",
        "os.system('apt install tesseract-ocr-eng')\n",
        "os.system('apt install tesseract-ocr-mya')\n",
        "os.system('apt install libtesseract-dev')\n",
        "os.system('pip3 install opencv-python')\n",
        "os.system('apt-get install libopencv-dev')\n",
        "\n",
        "clear_output()\n",
        "print(\"Installed Successfully\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E_oeP30ZXgpq",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Start Image OCR</h3>\n",
        "\n",
        "#Read Image and extract text\n",
        "\n",
        "from PIL import Image\n",
        "import PIL.Image\n",
        "from pytesseract import image_to_string\n",
        "import pytesseract\n",
        "ocr_file = '' #@param {type: \"string\"}\n",
        "pytesseract.tesseract_cmd = r'/usr/local/bin/pytesseract'\n",
        "TESSDATA_PREFIX = '/usr/local/bin/pytesseract'\n",
        "img = Image.open(ocr_file)\n",
        "\n",
        "\n",
        "Language = \"English\" #@param [\"Myanmar\", \"English\"]\n",
        "\n",
        "if Language == 'Myanmar':\n",
        " output = pytesseract.image_to_string (img, lang='mya')\n",
        "else:\n",
        " output = pytesseract.image_to_string (img, lang='eng')\n",
        "\n",
        "print (output)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ZjPqTBNoohK9"
      },
      "source": [
        "\n",
        "##<img src='https://scontent.frgn5-1.fna.fbcdn.net/v/t1.0-0/p320x320/10653877_472738456200409_4614784466362332725_n.png?_nc_cat=104&_nc_sid=85a577&efg=eyJpIjoiYiJ9&_nc_ohc=KsxPM460zb8AX_3CmcF&_nc_ht=scontent.frgn5-1.fna&oh=e6e57738399d267807328436c57e848f&oe=5EC2D478' height=\"65\" alt=\"filebrowser\" />  <h5>\n",
        "\n",
        "\n",
        "<h5>(Need to switch to GPU runtime and Python 3)</h5>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "-T-svuHytJ-8",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Install Colorizer</h3>\n",
        "#@markdown <center><img src='https://scontent.frgn5-2.fna.fbcdn.net/v/t31.0-8/24059638_680264242361237_3143229723815922153_o.png?_nc_cat=111&_nc_sid=6e5ad9&_nc_ohc=iOB_DdBSuJkAX9cAOCi&_nc_ht=scontent.frgn5-2.fna&oh=c24fc1a2fed7cf41966984d54071ef5c&oe=5EC3E4D1' height=\"200\" alt=\"filebrowser\" /></center> \n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...Wait for almost 60 seconds....\", ty='twg')\n",
        "os.system('cd /content && git clone https://github.com/jantic/DeOldify.git DeOldify')\n",
        "%cd DeOldify\n",
        "###\n",
        "#NOTE:  This must be the first call in order to work properly!\n",
        "from deoldify import device\n",
        "from deoldify.device_id import DeviceId\n",
        "#choices:  CPU, GPU0...GPU7\n",
        "device.set(device=DeviceId.GPU0)\n",
        "\n",
        "import torch\n",
        "\n",
        "if not torch.cuda.is_available():\n",
        "    print('GPU not available.')\n",
        "\n",
        "os.system('pip install -r colab_requirements.txt')\n",
        "\n",
        "###\n",
        "import fastai\n",
        "from deoldify.visualize import *\n",
        "from pathlib import Path\n",
        "torch.backends.cudnn.benchmark=True\n",
        "###\n",
        "os.makedirs(\"models\", exist_ok=True)\n",
        "os.system('wget https://www.dropbox.com/s/zkehq1uwahhbc2o/ColorizeArtistic_gen.pth?dl=0 -O ./models/ColorizeArtistic_gen.pth')\n",
        "os.system('wget https://www.dropbox.com/s/336vn9y4qwyg9yz/ColorizeVideo_gen.pth?dl=0 -O ./models/ColorizeVideo_gen.pth')\n",
        "os.system('wget https://media.githubusercontent.com/media/jantic/DeOldify/master/resource_images/watermark.png -O ./resource_images/watermark.png')\n",
        "\n",
        "\n",
        "\n",
        "clear_output()\n",
        "print(\"Installed Successfully\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X2-Lv3bvizE-",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Colorize image or video</h3>\n",
        "\n",
        "import os\n",
        "from IPython.display import clear_output\n",
        "#@markdown ⚙ Recommended image sources \n",
        "#@markdown * [/r/TheWayWeWere](https://www.reddit.com/r/TheWayWeWere/)\n",
        "\n",
        "\n",
        "#@markdown ⚙ Recommended video and gif sources \n",
        "#@markdown * [/r/Nickelodeons/](https://www.reddit.com/r/Nickelodeons/)\n",
        "#@markdown * [r/silentmoviegifs](https://www.reddit.com/r/silentmoviegifs/)\n",
        "#@markdown * https://twitter.com/silentmoviegifs \n",
        "\n",
        "#==================================================\n",
        "\n",
        "source_url = '' #@param {type:\"string\"}\n",
        "render_factor = 8  #@param {type: \"slider\", min: 7, max: 45}\n",
        "selection_option = \"Image\" #@param [\"Image\", \"Video/GIF\"]\n",
        "watermarked = False #@param {type:\"boolean\"}\n",
        "\n",
        "if selection_option == \"Image\":\n",
        " colorizer = get_image_colorizer(artistic=True)\n",
        " clear_output()\n",
        " if source_url is not None and source_url !='':\n",
        "  image_path = colorizer.plot_transformed_image_from_url(url=source_url, render_factor=render_factor, compare=True, watermarked=watermarked)\n",
        "  show_image_in_notebook(image_path)\n",
        " else:\n",
        "  print('Provide an image url and try again.')\n",
        "\n",
        "else:\n",
        " colorizer = get_video_colorizer()\n",
        " clear_output()\n",
        " if source_url is not None and source_url !='':\n",
        "  video_path = colorizer.colorize_from_url(source_url, 'video.mp4', render_factor, watermarked=watermarked)\n",
        "  show_video_in_notebook(video_path)\n",
        " else:\n",
        "  print('Provide a video url and try again.')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GT83IkMZizFX",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to See how well render_factor values perform </h3>\n",
        "\n",
        "selection_option = \"Image\" #@param [\"Image\", \"Video/GIF\"]\n",
        "\n",
        "if selection_option == \"Image\":\n",
        " for i in range(10,45,2):\n",
        "    colorizer.plot_transformed_image('test_images/image.png', render_factor=i, display_render_factor=True, figsize=(8,8))\n",
        "\n",
        "else:\n",
        " for i in range(10,45,2):\n",
        "    colorizer.vis.plot_transformed_image('video/bwframes/video/00001.jpg', render_factor=i, display_render_factor=True, figsize=(8,8))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_gjQ6LbYiP9j",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://media.istockphoto.com/vectors/identification-face-color-line-icon-eye-id-verifying-recognition-vector-id1172721433' height=\"65\" alt=\"filebrowser\" /> ___*Deepface*___  <h5>\n",
        "<h5>(Need to switch to GPU runtime )</h5>\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0cKdTCuv4tXh",
        "colab_type": "text"
      },
      "source": [
        "### Welcome to DFL-Colab!\n",
        "\n",
        "This is an adapted version of the DFL for Google Colab.\n",
        "\n",
        "\n",
        "# Overview\n",
        "*   Extractor works in full functionality.\n",
        "*   Training can work without preview.\n",
        "*   Merger works in full functionality.\n",
        "*   You can import/export workspace with your Google Drive.\n",
        "*   Import/export and another manipulations with workspace you can do in \"Manage workspace\" block\n",
        "*   Google Colab machine active for 12 hours. DFL-Colab makes a backup of your workspace in training mode.\n",
        "*   Google does not like long-term heavy calculations. Therefore, for training more than two sessions in a row, use two Google accounts. It is recommended to split your training over 2 accounts, but you can use one Google Drive account to store your workspace.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JuVn21kt40Gw",
        "colab_type": "text"
      },
      "source": [
        "### Install or update DeepFaceLab\n",
        "\n",
        "* Install or update DeepFAceLab directly from Github\n",
        "* Requirements install is automatically\n",
        "* Automatically sets timer to prevent random disconnects"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JG-f2WqT4fLK",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Install or update DeepFaceLab from Github\n",
        "\n",
        "Mode = \"install\" #@param [\"install\", \"update\"]\n",
        "\n",
        "from pathlib import Path\n",
        "if (Mode == \"install\"):\n",
        "  !git clone https://github.com/iperov/DeepFaceLab.git\n",
        "\n",
        "  # fix linux warning\n",
        "  # /usr/lib/python3.6/multiprocessing/semaphore_tracker.py:143: UserWarning: semaphore_tracker: There appear to be 1 leaked semaphores to clean up at shutdown\n",
        "  fin = open(\"/usr/lib/python3.6/multiprocessing/semaphore_tracker.py\", \"rt\")\n",
        "  data = fin.read()\n",
        "  data = data.replace('if cache:', 'if False:')\n",
        "  fin.close()\n",
        "\n",
        "  fin = open(\"/usr/lib/python3.6/multiprocessing/semaphore_tracker.py\", \"wt\")\n",
        "  fin.write(data)\n",
        "  fin.close()\n",
        "else:\n",
        "  %cd /content/DeepFaceLab\n",
        "  !git pull\n",
        "\n",
        "!pip install -r /content/DeepFaceLab/requirements-colab.txt\n",
        "!pip install --upgrade scikit-image\n",
        "!apt-get install cuda-10-0\n",
        "\n",
        "if not Path(\"/content/pretrain\").exists():\n",
        "  print(\"Downloading CelebA faceset ... \")\n",
        "  !wget -q --no-check-certificate -r 'https://github.com/chervonij/DFL-Colab/releases/download/pretrain-CelebA/pretrain_CelebA.zip' -O /content/pretrain_CelebA.zip\n",
        "  !mkdir /content/pretrain\n",
        "  !unzip -q /content/pretrain_CelebA.zip -d /content/pretrain/\n",
        "  !rm /content/pretrain_CelebA.zip\n",
        "\n",
        "if not Path(\"/content/pretrain_Q96\").exists():\n",
        "  print(\"Downloading Q96 pretrained model ...\")\n",
        "  !wget -q --no-check-certificate -r 'https://github.com/chervonij/DFL-Colab/releases/download/Q96_model_pretrained/Q96_model_pretrained.zip' -O /content/pretrain_Q96.zip\n",
        "  !mkdir /content/pretrain_Q96\n",
        "  !unzip -q /content/pretrain_Q96.zip -d /content/pretrain_Q96/\n",
        "  !rm /content/pretrain_Q96.zip\n",
        "\n",
        "if not Path(\"/content/workspace\").exists():\n",
        "  !mkdir /content/workspace; mkdir /content/workspace/data_src; mkdir /content/workspace/data_src/aligned; mkdir /content/workspace/data_dst; mkdir /content/workspace/data_dst/aligned; mkdir /content/workspace/model  \n",
        "\n",
        "import IPython\n",
        "from google.colab import output\n",
        "\n",
        "display(IPython.display.Javascript('''\n",
        " function ClickConnect(){\n",
        "   btn = document.querySelector(\"colab-connect-button\")\n",
        "   if (btn != null){\n",
        "     console.log(\"Click colab-connect-button\"); \n",
        "     btn.click() \n",
        "     }\n",
        "   \n",
        "   btn = document.getElementById('ok')\n",
        "   if (btn != null){\n",
        "     console.log(\"Click reconnect\"); \n",
        "     btn.click() \n",
        "     }\n",
        "  }\n",
        "  \n",
        "setInterval(ClickConnect,60000)\n",
        "'''))\n",
        "\n",
        "print(\"\\nDone!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hqwOlJG4MdLC",
        "colab_type": "text"
      },
      "source": [
        "### Manage workspace\n",
        "\n",
        "\n",
        "\n",
        "*   You can import/export workspace or individual data, like model files with Google Drive\n",
        "*   Also, you can use HFS (HTTP Fileserver) for directly import/export you workspace from your computer\n",
        "*   You can clear all workspace or delete part of it\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z4w_sUzgOQmL",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Import from Drive\n",
        "\n",
        "Mode = \"workspace\" #@param [\"workspace\", \"data_src\", \"data_dst\", \"data_src aligned\", \"data_dst aligned\", \"models\"]\n",
        "Archive_name = \"workspace.zip\" #@param {type:\"string\"}\n",
        "\n",
        "#Mount Google Drive as folder\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive', force_remount=True)\n",
        "\n",
        "def zip_and_copy(path, mode):\n",
        "  unzip_cmd=\" -q \"+Archive_name\n",
        "  \n",
        "  %cd $path\n",
        "  copy_cmd = \"/content/drive/My\\ Drive/\"+Archive_name+\" \"+path\n",
        "  !cp $copy_cmd\n",
        "  !unzip $unzip_cmd    \n",
        "  !rm $Archive_name\n",
        "\n",
        "if Mode == \"workspace\":\n",
        "  zip_and_copy(\"/content\", \"workspace\")\n",
        "elif Mode == \"data_src\":\n",
        "  zip_and_copy(\"/content/workspace\", \"data_src\")\n",
        "elif Mode == \"data_dst\":\n",
        "  zip_and_copy(\"/content/workspace\", \"data_dst\")\n",
        "elif Mode == \"data_src aligned\":\n",
        "  zip_and_copy(\"/content/workspace/data_src\", \"aligned\")\n",
        "elif Mode == \"data_dst aligned\":\n",
        "  zip_and_copy(\"/content/workspace/data_dst\", \"aligned\")\n",
        "elif Mode == \"models\":\n",
        "  zip_and_copy(\"/content/workspace\", \"model\")\n",
        "  \n",
        "print(\"Done!\")\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Y3WfuwoNXqC",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Export to Drive { form-width: \"30%\" }\n",
        "Mode = \"workspace\" #@param [\"workspace\", \"data_src\", \"data_dst\", \"data_src aligned\", \"data_dst aligned\", \"merged\", \"merged_mask\", \"models\", \"result video\", \"result_mask video\"]\n",
        "Archive_name = \"workspace.zip\" #@param {type:\"string\"}\n",
        "\n",
        "#Mount Google Drive as folder\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive', force_remount=True)\n",
        "\n",
        "def zip_and_copy(path, mode):\n",
        "  zip_cmd=\"-r -q \"+Archive_name+\" \"\n",
        "  \n",
        "  %cd $path\n",
        "  zip_cmd+=mode\n",
        "  !zip $zip_cmd\n",
        "  copy_cmd = \" \"+Archive_name+\"  /content/drive/My\\ Drive/\"\n",
        "  !cp $copy_cmd\n",
        "  !rm $Archive_name\n",
        "\n",
        "if Mode == \"workspace\":\n",
        "  zip_and_copy(\"/content\", \"workspace\")\n",
        "elif Mode == \"data_src\":\n",
        "  zip_and_copy(\"/content/workspace\", \"data_src\")\n",
        "elif Mode == \"data_dst\":\n",
        "  zip_and_copy(\"/content/workspace\", \"data_dst\")\n",
        "elif Mode == \"data_src aligned\":\n",
        "  zip_and_copy(\"/content/workspace/data_src\", \"aligned\")\n",
        "elif Mode == \"data_dst aligned\":\n",
        "  zip_and_copy(\"/content/workspace/data_dst\", \"aligned\")\n",
        "elif Mode == \"merged\":\n",
        "  zip_and_copy(\"/content/workspace/data_dst\", \"merged\")\n",
        "elif Mode == \"merged_mask\":\n",
        "  zip_and_copy(\"/content/workspace/data_dst\", \"merged_mask\")\n",
        "elif Mode == \"models\":\n",
        "  zip_and_copy(\"/content/workspace\", \"model\")\n",
        "elif Mode == \"result video\":\n",
        "  !cp /content/workspace/result.mp4 /content/drive/My\\ Drive/\n",
        "elif Mode == \"result_mask video\":\n",
        "  !cp /content/workspace/result_mask.mp4 /content/drive/My\\ Drive/\n",
        "  \n",
        "print(\"Done!\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0hIvJtxwTGcb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#@title Import from URL{ form-width: \"30%\", display-mode: \"form\" }\n",
        "URL = \"http://\" #@param {type:\"string\"}\n",
        "Mode = \"unzip to content\" #@param [\"unzip to content\", \"unzip to content/workspace\", \"unzip to content/workspace/data_src\", \"unzip to content/workspace/data_src/aligned\", \"unzip to content/workspace/data_dst\", \"unzip to content/workspace/data_dst/aligned\", \"unzip to content/workspace/model\", \"download to content/workspace\"]\n",
        "\n",
        "import urllib\n",
        "from pathlib import Path\n",
        "\n",
        "def unzip(zip_path, dest_path):\n",
        "\n",
        "    \n",
        "  unzip_cmd = \" unzip -q \" + zip_path + \" -d \"+dest_path\n",
        "  !$unzip_cmd  \n",
        "  rm_cmd = \"rm \"+dest_path + url_path.name\n",
        "  !$rm_cmd\n",
        "  print(\"Unziped!\")\n",
        "  \n",
        "\n",
        "if Mode == \"unzip to content\":\n",
        "  dest_path = \"/content/\"\n",
        "elif Mode == \"unzip to content/workspace\":\n",
        "  dest_path = \"/content/workspace/\"\n",
        "elif Mode == \"unzip to content/workspace/data_src\":\n",
        "  dest_path = \"/content/workspace/data_src/\"\n",
        "elif Mode == \"unzip to content/workspace/data_src/aligned\":\n",
        "  dest_path = \"/content/workspace/data_src/aligned/\"\n",
        "elif Mode == \"unzip to content/workspace/data_dst\":\n",
        "  dest_path = \"/content/workspace/data_dst/\"\n",
        "elif Mode == \"unzip to content/workspace/data_dst/aligned\":\n",
        "  dest_path = \"/content/workspace/data_dst/aligned/\"\n",
        "elif Mode == \"unzip to content/workspace/model\":\n",
        "  dest_path = \"/content/workspace/model/\"\n",
        "elif Mode == \"download to content/workspace\":\n",
        "  dest_path = \"/content/workspace/\"\n",
        "\n",
        "if not Path(\"/content/workspace\").exists():\n",
        "  cmd = \"mkdir /content/workspace; mkdir /content/workspace/data_src; mkdir /content/workspace/data_src/aligned; mkdir /content/workspace/data_dst; mkdir /content/workspace/data_dst/aligned; mkdir /content/workspace/model\"\n",
        "  !$cmd\n",
        "\n",
        "url_path = Path(URL)\n",
        "urllib.request.urlretrieve ( URL, dest_path + url_path.name )\n",
        "\n",
        "if (url_path.suffix == \".zip\") and (Mode!=\"download to content/workspace\"):\n",
        "  unzip(dest_path + url_path.name, dest_path)\n",
        "\n",
        "  \n",
        "print(\"Done!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7V1sc7rxNKLO",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Export to URL\n",
        "URL = \"http://\" #@param {type:\"string\"}\n",
        "Mode = \"upload workspace\" #@param [\"upload workspace\", \"upload data_src\", \"upload data_dst\", \"upload data_src aligned\", \"upload data_dst aligned\", \"upload merged\", \"upload model\", \"upload result video\"]\n",
        "\n",
        "cmd_zip = \"zip -r -q \"\n",
        "\n",
        "def run_cmd(zip_path, curl_url):\n",
        "  cmd_zip = \"zip -r -q \"+zip_path\n",
        "  cmd_curl = \"curl --silent -F \"+curl_url+\" -D out.txt > /dev/null\"\n",
        "  !$cmd_zip\n",
        "  !$cmd_curl\n",
        "\n",
        "\n",
        "if Mode == \"upload workspace\":\n",
        "  %cd \"/content\"\n",
        "  run_cmd(\"workspace.zip workspace/\",\"'data=@/content/workspace.zip' \"+URL)\n",
        "elif Mode == \"upload data_src\":\n",
        "  %cd \"/content/workspace\"\n",
        "  run_cmd(\"data_src.zip data_src/\", \"'data=@/content/workspace/data_src.zip' \"+URL)\n",
        "elif Mode == \"upload data_dst\":\n",
        "  %cd \"/content/workspace\"\n",
        "  run_cmd(\"data_dst.zip data_dst/\", \"'data=@/content/workspace/data_dst.zip' \"+URL)\n",
        "elif Mode == \"upload data_src aligned\":\n",
        "  %cd \"/content/workspace\"\n",
        "  run_cmd(\"data_src_aligned.zip data_src/aligned\", \"'data=@/content/workspace/data_src_aligned.zip' \"+URL )\n",
        "elif Mode == \"upload data_dst aligned\":\n",
        "  %cd \"/content/workspace\"\n",
        "  run_cmd(\"data_dst_aligned.zip data_dst/aligned/\", \"'data=@/content/workspace/data_dst_aligned.zip' \"+URL)\n",
        "elif Mode == \"upload merged\":\n",
        "  %cd \"/content/workspace/data_dst\"\n",
        "  run_cmd(\"merged.zip merged/\",\"'data=@/content/workspace/data_dst/merged.zip' \"+URL )\n",
        "elif Mode == \"upload model\":\n",
        "  %cd \"/content/workspace\"\n",
        "  run_cmd(\"model.zip model/\", \"'data=@/content/workspace/model.zip' \"+URL)\n",
        "elif Mode == \"upload result video\":\n",
        "  %cd \"/content/workspace\"\n",
        "  run_cmd(\"result.zip result.mp4\", \"'data=@/content/workspace/result.zip' \"+URL)\n",
        "  \n",
        "  \n",
        "!rm *.zip\n",
        "\n",
        "%cd \"/content\"\n",
        "print(\"Done!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ta6ue_UGMkki",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Delete and recreate\n",
        "Mode = \"Delete and recreate workspace\" #@param [\"Delete and recreate workspace\", \"Delete models\", \"Delete data_src\", \"Delete data_src aligned\", \"Delete data_src video\", \"Delete data_dst\", \"Delete data_dst aligned\", \"Delete merged frames\"]\n",
        "\n",
        "%cd \"/content\" \n",
        "\n",
        "if Mode == \"Delete and recreate workspace\":\n",
        "  cmd = \"rm -r /content/workspace ; mkdir /content/workspace; mkdir /content/workspace/data_src; mkdir /content/workspace/data_src/aligned; mkdir /content/workspace/data_dst; mkdir /content/workspace/data_dst/aligned; mkdir /content/workspace/model\"  \n",
        "elif Mode == \"Delete models\":\n",
        "  cmd = \"rm -r /content/workspace/model/*\"\n",
        "elif Mode == \"Delete data_src\":\n",
        "  cmd = \"rm /content/workspace/data_src/*.png || rm -r /content/workspace/data_src/*.jpg\"\n",
        "elif Mode == \"Delete data_src aligned\":\n",
        "  cmd = \"rm -r /content/workspace/data_src/aligned/*\"\n",
        "elif Mode == \"Delete data_src video\":\n",
        "  cmd = \"rm -r /content/workspace/data_src.*\"\n",
        "elif Mode == \"Delete data_dst\":\n",
        "  cmd = \"rm /content/workspace/data_dst/*.png || rm /content/workspace/data_dst/*.jpg\"\n",
        "elif Mode == \"Delete data_dst aligned\":\n",
        "  cmd = \"rm -r /content/workspace/data_dst/aligned/*\"\n",
        "elif Mode == \"Delete merged frames\":\n",
        "  cmd = \"rm -r /content/workspace/data_dst/merged; rm -r /content/workspace/data_dst/merged_mask\"\n",
        "  \n",
        "!$cmd\n",
        "print(\"Done!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tUNVcbujhm00",
        "colab_type": "text"
      },
      "source": [
        "### Extract, sorting and faceset tools\n",
        "* Extract frames for SRC or DST video.\n",
        "* Denoise SRC or DST video. \"Factor\" param set intesity of denoising\n",
        "* Detect and align faces. If you need, you can get frames with debug landmarks.\n",
        "* Export workspace to Google Drive after extract and sort it manually (In \"Manage Workspace\" block)\n",
        "* You can enhance your facesets with DFL FacesetEnhancer.\n",
        "* Apply or remove trained XSeg model to the extracted faces\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qwJEbz5Nhot0",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Extract frames\n",
        "Video = \"data_src\" #@param [\"data_src\", \"data_dst\"]\n",
        "\n",
        "%cd \"/content\"\n",
        "\n",
        "cmd = \"DeepFaceLab/main.py videoed extract-video\"\n",
        "\n",
        "if Video == \"data_dst\":\n",
        "  cmd+= \" --input-file workspace/data_dst.* --output-dir workspace/data_dst/\"\n",
        "else:\n",
        "  cmd+= \" --input-file workspace/data_src.* --output-dir workspace/data_src/\"\n",
        "  \n",
        "!python $cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bFmPo0s2lTil",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Denoise frames\n",
        "Data = \"data_src\" #@param [\"data_src\", \"data_dst\"]\n",
        "Factor = 1 #@param {type:\"slider\", min:1, max:20, step:1}\n",
        "\n",
        "cmd = \"DeepFaceLab/main.py videoed denoise-image-sequence --input-dir workspace/\"+Data+\" --factor \"+str(Factor)\n",
        "\n",
        "%cd \"/content\"\n",
        "!python $cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nmq0Sj2bmq7d",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Detect faces\n",
        "Data = \"data_src\" #@param [\"data_src\", \"data_dst\"]\n",
        "Detector = \"S3FD\" #@param [\"S3FD\", \"S3FD (whole face)\"]\n",
        "Debug = False #@param {type:\"boolean\"}\n",
        "\n",
        "detect_type = \"s3fd\"\n",
        "dbg = \" --output-debug\" if Debug else \" --no-output-debug\"\n",
        "\n",
        "folder = \"workspace/\"+Data\n",
        "folder_aligned = folder+\"/aligned\"\n",
        "\n",
        "cmd = \"DeepFaceLab/main.py extract --input-dir \"+folder+\" --output-dir \"+folder_aligned\n",
        "cmd+=\" --detector \"+detect_type+\" --force-gpu-idxs 0\"+dbg\n",
        "\n",
        "if \"whole face\" in Detector:\n",
        "  cmd+=\" --face-type whole_face\" \n",
        "%cd \"/content\"\n",
        "!python $cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TRNxUFE6p6Eu",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Sort aligned\n",
        "Data = \"data_src\" #@param [\"data_src\", \"data_dst\"]\n",
        "sort_type = \"hist\" #@param [\"blur\", \"face-yaw\", \"face-pitch\", \"face-source-rect-size\", \"hist\", \"hist-dissim\", \"brightness\", \"hue\", \"black\", \"origname\", \"oneface\", \"final\", \"final-faster\", \"absdiff\"]\n",
        "\n",
        "cmd = \"DeepFaceLab/main.py sort --input-dir workspace/\"+Data+\"/aligned --by \"+sort_type\n",
        "\n",
        "%cd \"/content\"\n",
        "!python $cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O5MbnVDyXkP7",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Faceset Enhancer\n",
        "Data = \"data_src\" #@param [\"data_src\", \"data_dst\"]\n",
        "\n",
        "data_path = \"/content/workspace/\"+Data+\"/aligned\"\n",
        "cmd = \"/content/DeepFaceLab/main.py facesettool enhance --input-dir \"+data_path\n",
        "!python $cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-VVvtoBMGnrA",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Apply or remove XSeg mask to the faces\n",
        "Mode = \"Remove mask\" #@param [\"Apply mask\", \"Remove mask\"]\n",
        "Data = \"data_src\" #@param [\"data_src\", \"data_dst\"]\n",
        "\n",
        "main_path = \"/content/DeepFaceLab/main.py \"\n",
        "data_path = \"/content/workspace/\"+Data+\"/aligned \"\n",
        "mode_arg = \"apply \" if Mode == \"Apply mask\" else \"remove \"\n",
        "cmd = main_path+\"xseg \"+mode_arg+\"--input-dir \"+data_path\n",
        "cmd += \"--model-dir /content/workspace/model\" if mode_arg == \"apply \" else \"\"\n",
        "\n",
        "!python $cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WTuyUxgdLA13",
        "colab_type": "text"
      },
      "source": [
        "### Train model\n",
        "\n",
        "* Choose your model type, but SAEHD is recommend for everyone\n",
        "* Set model options on output field\n",
        "* You can see preview manually, if go to model folder in filemanager and double click on preview.jpg file\n",
        "* Your workspace will be archived and upload to mounted Drive after 11 hours from start session\n",
        "* If you select \"Backup_every_hour\" option, your workspace will be backed up every hour.\n",
        "* Also, you can export your workspace manually in \"Manage workspace\" block\n",
        "* \"Silent_Start\" option provides to automatically start with best GPU and last used model. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z0Kya-PJLDhv",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Training\n",
        "Model = \"SAEHD\" #@param [\"SAEHD\", \"Quick96\", \"XSeg\"]\n",
        "Backup_every_hour = True #@param {type:\"boolean\"}\n",
        "Silent_Start = True #@param {type:\"boolean\"}\n",
        "\n",
        "%cd \"/content\"\n",
        "\n",
        "#Mount Google Drive as folder\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "import psutil, os, time\n",
        "\n",
        "p = psutil.Process(os.getpid())\n",
        "uptime = time.time() - p.create_time()\n",
        "\n",
        "if (Backup_every_hour):\n",
        "  if not os.path.exists('workspace.zip'):\n",
        "    print(\"Creating workspace archive ...\")\n",
        "    !zip -r -q workspace.zip workspace\n",
        "    print(\"Archive created!\")\n",
        "  else:\n",
        "    print(\"Archive exist!\")\n",
        "\n",
        "if (Backup_every_hour):\n",
        "  print(\"Time to end session: \"+str(round((43200-uptime)/3600))+\" hours\")\n",
        "  backup_time = str(3600)\n",
        "  backup_cmd = \" --execute-program -\"+backup_time+\" \\\"import os; os.system('zip -r -q workspace.zip workspace/model'); os.system('cp /content/workspace.zip /content/drive/My\\ Drive/'); print('Backed up!') \\\"\" \n",
        "elif (round(39600-uptime) > 0):\n",
        "  print(\"Time to backup: \"+str(round((39600-uptime)/3600))+\" hours\")\n",
        "  backup_time = str(round(39600-uptime))\n",
        "  backup_cmd = \" --execute-program \"+backup_time+\" \\\"import os; os.system('zip -r -q workspace.zip workspace'); os.system('cp /content/workspace.zip /content/drive/My\\ Drive/'); print('Backed up!') \\\"\" \n",
        "else:\n",
        "  print(\"Session expires in less than an hour.\")\n",
        "  backup_cmd = \"\"\n",
        "    \n",
        "cmd = \"DeepFaceLab/main.py train --training-data-src-dir workspace/data_src/aligned --training-data-dst-dir workspace/data_dst/aligned --pretraining-data-dir pretrain --model-dir workspace/model --model \"+Model\n",
        "\n",
        "if Model == \"Quick96\":\n",
        "  cmd+= \" --pretrained-model-dir pretrain_Q96\"\n",
        "\n",
        "if Silent_Start:\n",
        "  cmd+= \" --silent-start\"\n",
        "\n",
        "if (backup_cmd != \"\"):\n",
        "  train_cmd = (cmd+backup_cmd)\n",
        "else:\n",
        "  train_cmd = (cmd)\n",
        "\n",
        "!python $train_cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "avAcSL_uvtq_",
        "colab_type": "text"
      },
      "source": [
        "### Merge frames"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A3Y8K22Sv9Gn",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Merge\n",
        "Model = \"SAEHD\" #@param [\"SAEHD\", \"Quick96\" ]\n",
        "\n",
        "cmd = \"DeepFaceLab/main.py merge --input-dir workspace/data_dst --output-dir workspace/data_dst/merged --output-mask-dir workspace/data_dst/merged_mask --aligned-dir workspace/data_dst/aligned --model-dir workspace/model --model \"+Model\n",
        "\n",
        "%cd \"/content\"\n",
        "!python $cmd"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JNeGfiZpxlnz",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title Get result video \n",
        "Mode = \"result video\" #@param [\"result video\", \"result_mask video\"]\n",
        "Copy_to_Drive = True #@param {type:\"boolean\"}\n",
        "\n",
        "\n",
        "if Mode == \"result video\":\n",
        "  !python DeepFaceLab/main.py videoed video-from-sequence --input-dir workspace/data_dst/merged --output-file workspace/result.mp4 --reference-file workspace/data_dst.mp4 --include-audio\n",
        "  if Copy_to_Drive:\n",
        "    !cp /content/workspace/result.mp4 /content/drive/My\\ Drive/\n",
        "elif Mode == \"result_mask video\":\n",
        "  !python DeepFaceLab/main.py videoed video-from-sequence --input-dir workspace/data_dst/merged_mask --output-file workspace/result_mask.mp4 --reference-file workspace/data_dst.mp4\n",
        "  if Copy_to_Drive:\n",
        "    !cp /content/workspace/result_mask.mp4 /content/drive/My\\ Drive/\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yHR91DXFmxaw",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://raw.githubusercontent.com/idealo/image-super-resolution/master/figures/butterfly.png' height=\"65\" alt=\"filebrowser\" /> ___*Image Super-Resolution (ISR)*___ \n",
        "<h5>(Need to switch to GPU runtime )</h5> "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "KCd2ZuS4V6Z0",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Click Here to Install Image Super-Resolution (ISR)</h3>\n",
        "#@markdown <center><img src='https://raw.githubusercontent.com/idealo/image-super-resolution/master/figures/butterfly.png' height=\"200\" alt=\"filebrowser\" /></center> \n",
        "%cd /content\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...Please Wait....\", ty='twg')\n",
        "os.system('cd /content && pip -q install ISR gdown')\n",
        "\n",
        "## Get the pre-trained weights and data\n",
        "\n",
        "#!wget https://media.githubusercontent.com/media/idealo/image-super-resolution/master/weights/sample_weights/rdn-C6-D20-G64-G064-x2/ArtefactCancelling/rdn-C6-D20-G64-G064-x2_ArtefactCancelling_epoch219.hdf5\n",
        "#!wget https://media.githubusercontent.com/media/idealo/image-super-resolution/master/weights/sample_weights/rdn-C6-D20-G64-G064-x2/PSNR-driven/rdn-C6-D20-G64-G064-x2_PSNR_epoch086.hdf5\n",
        "#!wget https://media.githubusercontent.com/media/idealo/image-super-resolution/master/weights/sample_weights/rdn-C3-D10-G64-G064-x2/PSNR-driven/rdn-C3-D10-G64-G064-x2_PSNR_epoch134.hdf5\n",
        "#!wget https://media.githubusercontent.com/media/idealo/image-super-resolution/master/weights/sample_weights/rrdn-C4-D3-G32-G032-T10-x4/Perceptual/rrdn-C4-D3-G32-G032-T10-x4_epoch299.hdf5\n",
        "\n",
        "import os\n",
        "if not os.path.exists('weights/rrdn-C4-D3-G32-G032-T10-x4_epoch299.hdf'):\n",
        "# download pretrained weights\n",
        " !gdown https://drive.google.com/uc?id=1Sn9FFKXNWOPXdNzy-zmyVYB4eNRnXTKD\n",
        " !gdown https://drive.google.com/uc?id=1_1GGoHF5oq3W_iVVxx1SRDIa_mjwoe26\n",
        " !gdown https://drive.google.com/uc?id=1ro0Rk4xAqo-OEDGgLIYz-F0BHvmUUT2E\n",
        " !gdown https://drive.google.com/uc?id=1o3l_I60xHkdiWZG7UM0nZBblEontHs2W\n",
        " !mkdir weights\n",
        " !mv *.hdf5 weights\n",
        "#=========\n",
        "clear_output()\n",
        "print(\"Sucessfully Installed\")\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KpHgyQC837BE",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Getty Image</h3>\n",
        "from IPython.display import clear_output\n",
        "import os\n",
        "\n",
        "\n",
        "source_image_url = '' #@param {type:\"string\"}\n",
        "!wget -O test.png \"$source_image_url\"\n",
        "\n",
        "\n",
        "\n",
        "os.makedirs(\"data/input/test_images\", exist_ok=True)\n",
        "!mv *.png data/input/test_images\n",
        "\n",
        "\n",
        "clear_output()\n",
        "print(\"Sucessfully Input Image\")\n",
        "\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "\n",
        "img = Image.open('data/input/test_images/test.png')\n",
        "img"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iVeCooijx77y",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Get predictions <i>(Method 1)</i></h3>\n",
        "### Create the model and run prediction\n",
        "\n",
        "select_option = \"Large RDN noise cancelling, detail enchancing model\" #@param [\"RRDN GANS mode\", \"Large RDN model\", \"Small RDN model\", \"Large RDN noise cancelling, detail enchancing model\"]\n",
        "\n",
        "\n",
        "from ISR.models import RDN, RRDN\n",
        "if select_option == 'RRDN GANS model':\n",
        "\n",
        " rrdn = RRDN(arch_params={'C': 4, 'D':3, 'G':32, 'G0':32, 'x':4, 'T': 10})\n",
        " rrdn.model.load_weights('weights/rrdn-C4-D3-G32-G032-T10-x4_epoch299.hdf5')\n",
        "\n",
        "#### Large RDN model\n",
        "elif select_option == 'Large RDN model':\n",
        " rdn = RDN(arch_params={'C': 6, 'D':20, 'G':64, 'G0':64, 'x':2})\n",
        " rdn.model.load_weights('weights/rdn-C6-D20-G64-G064-x2_PSNR_epoch086.hdf5')\n",
        "\n",
        "#### Small RDN model\n",
        "elif select_option == 'Small RDN model':\n",
        " rdn = RDN(arch_params={'C': 3, 'D':10, 'G':64, 'G0':64, 'x':2})\n",
        " rdn.model.load_weights('weights/rdn-C3-D10-G64-G064-x2_PSNR_epoch134.hdf5')\n",
        "\n",
        "#### Large RDN noise cancelling, detail enchancing model\n",
        "else:\n",
        " rdn = RDN(arch_params={'C': 6, 'D':20, 'G':64, 'G0':64, 'x':2})\n",
        " rdn.model.load_weights('weights/rdn-C6-D20-G64-G064-x2_ArtefactCancelling_epoch219.hdf5')\n",
        "\n",
        "#### Run prediction\n",
        "sr_img = rdn.predict(np.array(img))\n",
        "Image.fromarray(sr_img)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "LECussdS47kb",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>← Get predictions <i>(Method 2)</i></h3>\n",
        "#@markdown Usecase: upscaling noisy images\n",
        "\n",
        "#### So let's first  compress the image\n",
        "img.save('data/input/test_images/compressed.jpeg','JPEG', dpi=[300, 300], quality=50)\n",
        "compressed_img = Image.open('data/input/test_images/compressed.jpeg')\n",
        "\n",
        "select_option = \"Large RDN noise cancelling, detail enhancing model\" #@param [\"Large RDN model (PSNR trained)\", \"Small RDN model  (PSNR trained)\", \"Large RDN noise cancelling, detail enhancing model\"]\n",
        "\n",
        "\n",
        "compressed_img\n",
        "# Baseline\n",
        "# Bicubic scaling\n",
        "compressed_img.resize(size=(compressed_img.size[0]*2, compressed_img.size[1]*2), resample=Image.BICUBIC)\n",
        "#### Large RDN model (PSNR trained)\n",
        "if select_option == 'Large RDN model (PSNR trained)':\n",
        " rdn = RDN(arch_params={'C': 6, 'D':20, 'G':64, 'G0':64, 'x':2})\n",
        " rdn.model.load_weights('weights/rdn-C6-D20-G64-G064-x2_PSNR_epoch086.hdf5')\n",
        "#### Small RDN model  (PSNR trained)\n",
        "if select_option == 'Small RDN model  (PSNR trained)':\n",
        " rdn = RDN(arch_params={'C': 3, 'D':10, 'G':64, 'G0':64, 'x':2})\n",
        " rdn.model.load_weights('weights/rdn-C3-D10-G64-G064-x2_PSNR_epoch134.hdf5')\n",
        "#### Large RDN noise cancelling, detail enhancing model\n",
        "else:\n",
        " rdn = RDN(arch_params={'C': 6, 'D':20, 'G':64, 'G0':64, 'x':2})\n",
        " rdn.model.load_weights('weights/rdn-C6-D20-G64-G064-x2_ArtefactCancelling_epoch219.hdf5')\n",
        "\n",
        "\n",
        "sr_img = rdn.predict(np.array(compressed_img))\n",
        "Image.fromarray(sr_img)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SNNyVy6KzowY",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://www.wikihow.com/images/thumb/0/04/Miku1and2.png/728px-Miku1and2.png.webp' height=\"65\" alt=\"filebrowser\" /> ___*Waifu2x*___ <p>(Need to switch to GPU runtime )</p>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1M7PHpNbxCte",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Click Here to Install Waifu2x</h3>\n",
        "#@markdown <center><img src='https://raw.githubusercontent.com/tsurumeso/waifu2x-chainer/master/images/summery.png' height=\"200\" alt=\"filebrowser\" /></center> \n",
        "\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...Please Wait....\", ty='twg')\n",
        "os.system('cd /content && pip install -q cupy-cuda100 && pip install -q futures && pip install -q chainer && git clone -l -s https://github.com/tsurumeso/waifu2x-chainer.git waifu2x-chainer && cd content/waifu2x-chainer')\n",
        "\n",
        "\n",
        "clear_output()\n",
        "print(\"Sucessfully Installed\")\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6SVVOyjCA5QO",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Getty Image</h3>\n",
        "import os, sys, re\n",
        "import google.colab.files\n",
        "%cd /content/waifu2x-chainer\n",
        "os.makedirs(\"Input_images\", exist_ok=True)\n",
        "os.makedirs(\"Output_images\", exist_ok=True)\n",
        "%cd /content/waifu2x-chainer/Input_images\n",
        "clear_all_files_in_input_folder_after_processing = True #@param {type:\"boolean\"}\n",
        "local_upload = False #@param {type:\"boolean\"}\n",
        "source_image_url = '' #@param {type:\"string\"}\n",
        "if local_upload == True:\n",
        " uploaded = google.colab.files.upload()\n",
        "else:\n",
        " !wget \"$source_image_url\"\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown <h5><b>Setting</b></h5>\n",
        "#Rescale_all_files_in_input_folder = False #@param {type:\"boolean\"}\n",
        "#Input_images_file_path = '/content/waifu2x-chainer/Output_images/sad-anime-girl-11579904620pho2n5ujpp.png' #@param {type:\"string\"}\n",
        "#Output_image_folder_url = '' #@param {type:\"string\"}\n",
        "# - Tip : if you untick rescale all files, you will be ask to choose the file\n",
        "\n",
        "from IPython.display import display\n",
        "from ipywidgets import widgets\n",
        "from os import listdir\n",
        "from os.path import isfile, join\n",
        "\n",
        "#@markdown - Tip : arch (VGG7=0,UpConv7=1,ResNet10=2,UpResNet10=3)\n",
        "arch = \"1\" #@param [\"0\",\"1\",\"2\",\"3\"]\n",
        "quality = 100 #@param {type:\"slider\", min:0, max:100, step:1}\n",
        "scale_ratio = 8 #@param {type:\"slider\", min:0, max:20, step:1}\n",
        "#batch_size\n",
        "#block_size\n",
        "extension  = \"png\" #@param [\"png\",\"webp\"]\n",
        "method = \"noise_scale\" #@param [\"noise\",\"scale\",\"noise_scale\"] \n",
        "noise_level = 1 #@param {type:\"slider\", min:0, max:3, step:1}\n",
        "tta_level = \"8\" #@param [\"2\",\"4\",\"8\"]\n",
        "\n",
        "os.environ['q'] = str(quality)\n",
        "os.environ['s'] = str(scale_ratio)\n",
        "os.environ['e'] = extension\n",
        "os.environ['a'] = arch\n",
        "os.environ['m'] = method\n",
        "os.environ['n'] = str(noise_level)\n",
        "os.environ['T'] = tta_level\n",
        "#============================================\n",
        "%cd /content/waifu2x-chainer\n",
        "#if Rescale_all_files_in_input_folder == True:\n",
        "!python waifu2x.py -m \"$m\" -i \"Input_images\" -o \"Output_images\" -g 0 -s \"$s\" -a \"$a\" -n \"$n\" -q \"$ql\" -e \"$e\" -T \"$T\"\n",
        "\n",
        "!zip -r /content/output.zip /content/waifu2x-chainer/Output_images\n",
        "\n",
        "#else:\n",
        "  #!python waifu2x.py -m \"$m\" -i \"$Input_images_file_path\" -o \"Output_images_folder_path\" -g 0 -s \"$s\" -a \"$a\" -n \"$n\" -q \"$ql\" -e \"$e\" -T \"$T\"\n",
        "\n",
        "import glob\n",
        "if clear_all_files_in_input_folder_after_processing  == True:     \n",
        " files = glob.glob('/content/waifu2x-chainer/Input_images/*')\n",
        " for f in files:\n",
        "    os.remove(f)     \n",
        "    \n",
        "  #!python main.py run -i \"/content/waifu2x-chainer/Input_images/$filename_ch.value\" -o \"results/$filename_ch.value\" --ignore-size --hsize \"$Pubic_Hair_Size\" --gpu 0 \n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cdO_RxQZLahB",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://i.kym-cdn.com/photos/images/original/001/297/263/909.jpg_large' height=\"65\" alt=\"filebrowser\" /> ___*Image Animation*___ <p>First Order Motion Model for Image Animation (Need to switch to GPU runtime )</p>\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UCMFMJV7K-ag",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Click Here to Install Face Swap</h3>\n",
        "#@markdown <center><img src='https://i.kym-cdn.com/photos/images/original/001/297/263/909.jpg_large' height=\"200\" alt=\"filebrowser\" /></center> \n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...Please Wait....\", ty='twg')\n",
        "os.system('cd /content && git clone https://github.com/AliaksandrSiarohin/first-order-model && cd /content/first-order-model')\n",
        "\n",
        "\n",
        "\n",
        "!gdown https://drive.google.com/uc?id=1YJ0DDoEy7McI4RDvjPt1JSMsgWJQDUaP\n",
        "!unzip *.zip\n",
        "\n",
        "\n",
        "clear_output()\n",
        "print(\"Sucessfully Installed\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oxi6-riLOgnm",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Load driving video and source image</h3>\n",
        "import os\n",
        "import imageio\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.animation as animation\n",
        "from skimage.transform import resize\n",
        "from IPython.display import HTML\n",
        "import warnings\n",
        "from IPython.display import clear_output\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "#@markdown **Create a model and load checkpoints**\n",
        "#@markdown - checkpoint example file : vox-cpk.pth.tar\n",
        "checkpoint_path = '/content/first-order-model/first-order-motion-model/vox-cpk.pth.tar' #@param {type:\"string\"}\n",
        "#@markdown - config example file : vox-256.yaml\n",
        "config_path = '/content/first-order-model/config/vox-256.yaml' #@param {type:\"string\"}\n",
        "\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown **Input your data**\n",
        "source_image_path = '/content/first-order-model/first-order-motion-model/777.png' #@param {type:\"string\"}\n",
        "driving_video_path = '/content/first-order-model/first-order-motion-model/08.mp4' #@param {type:\"string\"}\n",
        "driving_video_need_to_crop = False #@param {type:\"boolean\"}\n",
        "\n",
        "from demo import load_checkpoints\n",
        "generator, kp_detector = load_checkpoints(config_path, checkpoint_path)\n",
        "\n",
        "\n",
        "\n",
        "if driving_video_need_to_crop == True:\n",
        " !ffmpeg -i \"$driving_video_path\" -ss 00:08:57.50 -t 00:00:08 -filter:v \"crop=600:600:760:50\" -async 1 cropped.mp4\n",
        " clear_output()\n",
        " source_image = imageio.imread(source_image_path)\n",
        " driving_video = imageio.mimread('cropped.mp4')\n",
        "else:\n",
        " source_image = imageio.imread(source_image_path)\n",
        " driving_video = imageio.mimread(driving_video_path)\n",
        "\n",
        "#Resize image and video to 256x256\n",
        "\n",
        "source_image = resize(source_image, (256, 256))[..., :3]\n",
        "driving_video = [resize(frame, (256, 256))[..., :3] for frame in driving_video]\n",
        "\n",
        "\n",
        "#Resize image and video to 256x256\n",
        "\n",
        "def display(source, driving, generated=None):\n",
        "    fig = plt.figure(figsize=(8 + 4 * (generated is not None), 6))\n",
        "\n",
        "    ims = []\n",
        "    for i in range(len(driving)):\n",
        "        cols = [source]\n",
        "        cols.append(driving[i])\n",
        "        if generated is not None:\n",
        "            cols.append(generated[i])\n",
        "        im = plt.imshow(np.concatenate(cols, axis=1), animated=True)\n",
        "        plt.axis('off')\n",
        "        ims.append([im])\n",
        "\n",
        "    ani = animation.ArtistAnimation(fig, ims, interval=50, repeat_delay=1000)\n",
        "    plt.close()\n",
        "    return ani\n",
        "\n",
        "\n",
        "from demo import make_animation\n",
        "from skimage import img_as_ubyte\n",
        "\n",
        "predictions = make_animation(source_image, driving_video, generator, kp_detector, relative=True,\n",
        "                             adapt_movement_scale=True)\n",
        "\n",
        "#save resulting video\n",
        "imageio.mimsave('../generated.mp4', [img_as_ubyte(frame) for frame in predictions])\n",
        "#video can be downloaded from /content folder\n",
        "\n",
        "HTML(display(source_image, driving_video, predictions).to_html5_video())\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EaMj6XDu-C8r",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://ww1.prweb.com/prfiles/2010/04/23/1769214/2D3Dxyz.jpg' height=\"65\" alt=\"filebrowser\" /> ___*2D to 3D photo*___ <p>(Need to switch to GPU runtime )</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IT1PYj3QwJws",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Prepare Environment</h3>\n",
        "#@markdown <center><img src='https://ww1.prweb.com/prfiles/2010/04/23/1769214/2D3Dxyz.jpg' height=\"200\" alt=\"filebrowser\" /></center> \n",
        "\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies... This may take a minute... Please Wait....\", ty='twg')\n",
        "%cd /content\n",
        "os.system('pip3 install torch==1.4.0+cu100 torchvision==0.5.0+cu100 -f https://download.pytorch.org/whl/torch_stable.html')\n",
        "os.system('pip3 install opencv-python==4.2.0.32')\n",
        "os.system('pip3 install vispy==0.6.4')\n",
        "os.system('pip3 install moviepy==1.0.2')\n",
        "os.system('pip3 install transforms3d==0.3.1')\n",
        "os.system('pip3 install networkx==2.3')\n",
        "os.system('sudo apt install sed')\n",
        "\n",
        "os.system('git clone https://github.com/vt-vl-lab/3d-photo-inpainting.git')\n",
        "%cd 3d-photo-inpainting\n",
        "print(\"Downloading trained data.. Please Wait....\")\n",
        "os.system('sh download.sh')\n",
        "\n",
        "#Switch off off-screen rendering\n",
        "!sed -i 's/offscreen_rendering: True/offscreen_rendering: False/g' argument.yml\n",
        "\n",
        "#=========\n",
        "clear_output()\n",
        "print(\"Sucessfully Installed\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V9sf1QCYzSzu",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Getty Image</h3>\n",
        "#@markdown <h5> - Must be <code>.jpg</code></h5>\n",
        "%cd \"/content/3d-photo-inpainting/image\"\n",
        "batch_uploading = False #@param {type:\"boolean\"}\n",
        "local_upload = False #@param {type:\"boolean\"}\n",
        "source_image_url = '' #@param {type:\"string\"}\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os\n",
        "if batch_uploading == False:\n",
        " import glob\n",
        " files = glob.glob('/content/3d-photo-inpainting/image/*')\n",
        " for f in files:\n",
        "   os.remove(f)     \n",
        "\n",
        "if local_upload == True:\n",
        " from google.colab import files\n",
        " uploaded = files.upload()\n",
        " for fn in uploaded.keys():\n",
        "   print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "       name=fn, length=len(uploaded[fn])))\n",
        " \n",
        "\n",
        "else:\n",
        "\n",
        " !wget \"$source_image_url\"\n",
        "\n",
        " \n",
        " \n",
        " \n",
        "\n",
        "%cd ..\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mYw7jlHH2ppm",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Execute the 3D Photo Inpainting</h3>\n",
        "#@markdown - Note: The 3D photo generation process usually takes about 2-3 minutes or more depending on the available computing resources.\n",
        "from IPython.display import clear_output\n",
        "%cd \"/content/3d-photo-inpainting\"\n",
        "!python main.py --config argument.yml\n",
        "%cd \"/content/3d-photo-inpainting/video\"\n",
        "\n",
        "\n",
        "clear_output()\n",
        "print(\"All Done\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y-u1ZRm5_nM7",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Select your 3d photo</h3>\n",
        "path='/content/3d-photo-inpainting/video'\n",
        "os.makedirs(\"./temp\", exist_ok=True)\n",
        "import os\n",
        "if not os.path.exists(path):\n",
        "    os.makedirs(path)\n",
        "\n",
        "from IPython.display import display\n",
        "from ipywidgets import widgets\n",
        "from os import listdir\n",
        "from os.path import isfile, join\n",
        "from IPython.display import HTML\n",
        "from base64 import b64encode\n",
        "\n",
        "mypath = '/content/3d-photo-inpainting/video'\n",
        "onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]\n",
        "\n",
        "if len(onlyfiles)>0:\n",
        "  filename_ch = widgets.Dropdown(\n",
        "      options=onlyfiles,\n",
        "      description='Choose file:',\n",
        "  )\n",
        "  butt = widgets.Button(description='Select')\n",
        "  def on_butt_clicked(b):\n",
        "      print(filename_ch.value)\n",
        "      f = open(\"./temp/selectedvideo.txt\",\"w\") \n",
        "      f.write(filename_ch.value)\n",
        "      f.close() \n",
        "\n",
        "      \n",
        "      \n",
        "  butt.on_click(on_butt_clicked)\n",
        "  # display\n",
        "  display(widgets.VBox([filename_ch,butt]))\n",
        "else:\n",
        "  print('Upload photo at first')\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sxHe66eLJRfL",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  View The Magic</h3>\n",
        "\n",
        "#original_width = False #@param {type:\"boolean\"}\n",
        "#custom_width = 400 #@param {type:\"slider\", min:400, max:1000, step:200}\n",
        "import os\n",
        "\n",
        "f = open('./temp/selectedvideo.txt', 'r')\n",
        "video = f.read()\n",
        "f.close\n",
        "print(video)\n",
        "mp4 = open(video,'rb').read()\n",
        "data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
        "\n",
        "#if original_width == True:\n",
        "HTML(\"\"\"\n",
        "           <video width=\"900\" controls loop>\n",
        "             <source src=\"%s\" type=\"video/mp4\">\n",
        "           </video>\n",
        "                 \"\"\" % data_url)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "4VNIpH9tN45d",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Download final result video</h3>\n",
        "from google.colab import files\n",
        "for filename in os.listdir():\n",
        "  extension = os.path.splitext(filename)[-1].lower()\n",
        "  if extension == \".mp4\":\n",
        "    files.download(filename)\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uCEixJujApc8",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://i1.wp.com/syncedreview.com/wp-content/uploads/2019/09/unnamed-file.gif?fit=640%2C360&ssl=1' height=\"65\" alt=\"filebrowser\" /> ___*3D Ken Burns*___ <p>(Need to switch to GPU runtime )</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZbYRw_GlCL5w",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Click Here to Install Require Modules</h3>\n",
        "#@markdown <center><img src='https://i1.wp.com/syncedreview.com/wp-content/uploads/2019/09/unnamed-file.gif?fit=640%2C360&ssl=1' height=\"200\" alt=\"filebrowser\" /></center> \n",
        "\n",
        "\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...\", ty='twg')\n",
        "%cd /content\n",
        "os.system('git clone https://github.com/sniklaus/3d-ken-burns.git')\n",
        "\n",
        "\n",
        "%cd 3d-ken-burns\n",
        "\n",
        "os.system('pip install moviepy && pip install gevent && bash download.bash && rm images/README.md && mkdir results')\n",
        "os.system('pip3 install torch==1.4.0+cu100 torchvision==0.5.0+cu100 -f https://download.pytorch.org/whl/torch_stable.html')\n",
        "os.system('pip3 install opencv-python==4.2.0.32')\n",
        "os.system('pip3 install vispy==0.6.4')\n",
        "os.system('pip3 install transforms3d==0.3.1')\n",
        "os.system('pip3 install networkx==2.3')\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "import os\n",
        "os.environ['CUDA_HOME'] = \"/usr/local/cuda\"\n",
        "\n",
        "clear_output()\n",
        "print(\"Sucessfully Installed\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rhd37MlBfC5U",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Getty Image</h3>\n",
        "\n",
        "%cd \"/content/3d-ken-burns/images\"\n",
        "batch_uploading = False #@param {type:\"boolean\"}\n",
        "local_upload = False #@param {type:\"boolean\"}\n",
        "source_image_url = '' #@param {type:\"string\"}\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os\n",
        "if batch_uploading == False:\n",
        " import glob\n",
        " files = glob.glob('/content/3d-ken-burns/images/*')\n",
        " for f in files:\n",
        "   os.remove(f)     \n",
        "\n",
        "if local_upload == True:\n",
        " from google.colab import files\n",
        " uploaded = files.upload()\n",
        " for fn in uploaded.keys():\n",
        "   print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "       name=fn, length=len(uploaded[fn])))\n",
        " \n",
        "\n",
        "else:\n",
        "\n",
        " !wget \"$source_image_url\"\n",
        "\n",
        "%cd \"/content/3d-ken-burns\"\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H_6mgeGBDdVD",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Execute the 3D Photo Effect</h3>\n",
        "#@markdown - Note: The 3D photo generation process usually takes about 2-3 minutes or more depending on the available computing resources.\n",
        "%cd /content/3d-ken-burns\n",
        "setting = \"codemaster_custom\" #@param [\"default\", \"codemaster_custom\"]\n",
        "check_path = '/content/3d-ken-burns/autozoom_custom.py'\n",
        "from pathlib import Path\n",
        "if not Path(check_path).exists():\n",
        "  !wget https://raw.githubusercontent.com/totalleecher/Google-Colab-CloudTorrent/master/codemaster/autozoom_custom.py\n",
        "\n",
        "if setting == \"default\":\n",
        "  !for image in ./images/*; do python autozoom.py --in $image --out ./results/$(basename $image | cut -f1 -d '.').mp4; done\n",
        "\n",
        "else:\n",
        "  !for image in ./images/*; do python autozoom_custom.py --in $image --out ./results/$(basename $image | cut -f1 -d '.').mp4; done"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "17sFi2Wu34P0",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Select your 3d photo</h3>\n",
        "%cd /content/3d-ken-burns/results\n",
        "path='/content/3d-ken-burns/results'\n",
        "os.makedirs(\"./temp\", exist_ok=True)\n",
        "import os\n",
        "if not os.path.exists(path):\n",
        "    os.makedirs(path)\n",
        "\n",
        "from IPython.display import display\n",
        "from ipywidgets import widgets\n",
        "from os import listdir\n",
        "from os.path import isfile, join\n",
        "from IPython.display import HTML\n",
        "from base64 import b64encode\n",
        "\n",
        "mypath = '/content/3d-ken-burns/results'\n",
        "onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]\n",
        "\n",
        "if len(onlyfiles)>0:\n",
        "  filename_ch = widgets.Dropdown(\n",
        "      options=onlyfiles,\n",
        "      description='Choose file:',\n",
        "  )\n",
        "  butt = widgets.Button(description='Select')\n",
        "  def on_butt_clicked(b):\n",
        "      print(filename_ch.value)\n",
        "      f = open(\"./temp/selectedvideo.txt\",\"w\") \n",
        "      f.write(filename_ch.value)\n",
        "      f.close() \n",
        "\n",
        "      \n",
        "      \n",
        "  butt.on_click(on_butt_clicked)\n",
        "  # display\n",
        "  display(widgets.VBox([filename_ch,butt]))\n",
        "else:\n",
        "  print('Upload photo at first')\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "cellView": "form",
        "id": "w3dStIA136Fe",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  View The Magic</h3>\n",
        "\n",
        "#original_width = False #@param {type:\"boolean\"}\n",
        "#custom_width = 400 #@param {type:\"slider\", min:400, max:1000, step:200}\n",
        "\n",
        "\n",
        "\n",
        "import os\n",
        "\n",
        "f = open('./temp/selectedvideo.txt', 'r')\n",
        "video = f.read()\n",
        "f.close\n",
        "print(video)\n",
        "mp4 = open(video,'rb').read()\n",
        "data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
        "\n",
        "#if original_width == True:\n",
        "HTML(\"\"\"\n",
        "           <video width=\"900\" controls loop>\n",
        "             <source src=\"%s\" type=\"video/mp4\">\n",
        "           </video>\n",
        "                 \"\"\" % data_url)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7vYU0HNyP2Yu",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>←  Download final result video</h3>\n",
        "from google.colab import files\n",
        "for filename in os.listdir():\n",
        "  extension = os.path.splitext(filename)[-1].lower()\n",
        "  if extension == \".mp4\":\n",
        "    files.download(filename)\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mF1QME7YBwvo"
      },
      "source": [
        "# <center><b>Virtual Machine</b><h5>VPS, Remote Desktop Ubuntu</center></h5>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m5jM8gHbzWUW",
        "colab_type": "text"
      },
      "source": [
        "## <img src='https://pbs.twimg.com/profile_images/552739703141588992/E3oZpVzB_400x400.png' height=\"25\" alt=\"NoMachine\" /> ___NoMachine___"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4TByiWdUD7bu",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <br><center><img src='https://pbs.twimg.com/profile_images/552739703141588992/E3oZpVzB_400x400.png' height=\"200\" alt=\"noMachine\"/></center>\n",
        "#@markdown <center>NoMachine<br><h3>Free Remote Desktop For Everybody</h3></center><br>\n",
        "#@markdown <center>Download NoMachine  <a href=\"https://www.nomachine.com/\">Here</a>  \n",
        "\n",
        "import os\n",
        "import tarfile\n",
        "import urllib.request\n",
        "import shutil\n",
        "import time\n",
        "from IPython.display import HTML, clear_output\n",
        "from subprocess import Popen\n",
        "\n",
        "#####################################\n",
        "USE_FREE_TOKEN = False\n",
        "TOKEN = \"\"  # @param {type:\"string\"}\n",
        "REGION = \"US\" #@param [\"US\", \"EU\", \"AP\", \"AU\", \"SA\", \"JP\", \"IN\"]\n",
        "APT_INSTALL = \"apt install -y \"\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "runW = get_ipython()\n",
        "\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ocr.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/biplobsd/\" \\\n",
        "                \"OneClickRun/master/res/ocr.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/ocr.py\")\n",
        "\n",
        "from ocr import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        "    PortForward_wrapper,\n",
        "    findProcess,\n",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn()\n",
        "\n",
        "os.makedirs(\"tools/nomachine\", exist_ok=True)\n",
        "os.makedirs(\"/root/.icewm\", exist_ok=True)\n",
        "\n",
        "# password ganarate\n",
        "try:\n",
        "  print(f\"Found old password! : {password}\")\n",
        "except:\n",
        "  password = 'nomachine'\n",
        "\n",
        "clear_output()\n",
        "\n",
        "start = time.time()\n",
        "if not os.path.exists(\"tools/nomachine/NX/bin/nxserver\"):\n",
        "  textAn(\"Wait for almost 49 seconds. It's doing for NoMachine ready ...\")\n",
        "\n",
        "  runW.system_raw('apt update --quiet --force-yes')\n",
        "\n",
        "  # Minimal install \n",
        "  runW.system_raw(\n",
        "      'apt install --quiet --force-yes --no-install-recommends \\\n",
        "      icewm x11-xserver-utils firefox xterm pcmanfm')\n",
        "\n",
        "  # icewm theme\n",
        "  with open('/root/.icewm/theme', 'w') as w:\n",
        "    w.write('Theme=\"NanoBlue/default.theme\"')\n",
        "  \n",
        "  # with open('/root/.icewm/toolbar', 'w') as w:\n",
        "  #   w.write('prog \"chromium\" ! chromium-browser --no-sandbox')\n",
        "\n",
        "  # nomachine\n",
        "  staticUrl = \"https://github.com/biplobsd/temp/releases/download/6.9.2_1/nomachine_6.9.2_1_x86_64.tar.gz\"\n",
        "  configUrl = \"https://raw.githubusercontent.com/biplobsd/OneClickRun/master/res/appdata/NoMachine/NXetc.tar.gz\"\n",
        "  \n",
        "  output_file = 'tools/nomachine/nm.tar.gz'\n",
        "  config_file = 'tools/nomachine/etc.tar.gz'\n",
        "  urllib.request.urlretrieve(staticUrl, output_file)\n",
        "  urllib.request.urlretrieve(configUrl, config_file)\n",
        "  \n",
        "  with tarfile.open(output_file, 'r:gz') as t:t.extractall('tools/nomachine')\n",
        "  runSh('./nxserver --install', cd='tools/nomachine/NX', shell=True)\n",
        "  runSh('./nxserver --stop', cd='tools/nomachine/NX/bin', shell=True)\n",
        "  \n",
        "  shutil.rmtree('tools/nomachine/NX/etc')\n",
        "  with tarfile.open(config_file, 'r:gz') as t:t.extractall('tools/nomachine/NX')\n",
        "  os.remove(config_file)\n",
        "  \n",
        "  os.remove(output_file)\n",
        "  runSh('./nxserver --startup', cd='tools/nomachine/NX/bin', shell=True)\n",
        "  runW.system_raw(\"echo root:$password | chpasswd\")\n",
        "\n",
        "end = time.time()\n",
        "# START_SERVER\n",
        "# Ngrok region 'us','eu','ap','au','sa','jp','in'\n",
        "clear_output()\n",
        "PORT_FORWARD = \"ngrok\"\n",
        "Server = PortForward_wrapper(PORT_FORWARD, TOKEN, USE_FREE_TOKEN,\n",
        "                             [['nomachine', 4000, 'tcp']], REGION.lower(), \n",
        "               [f\"{HOME}/.ngrok2/nomachine.yml\", 8459])\n",
        "\n",
        "data = Server.start('nomachine', displayB=False)\n",
        "clear_output()\n",
        "host, port = data['url'][7:].split(':')\n",
        "user = os.popen('whoami').read()\n",
        "\n",
        "# Colors\n",
        "bttxt = 'hsla(10, 50%, 85%, 1)'\n",
        "btcolor = 'hsla(10, 86%, 56%, 1)'\n",
        "btshado = 'hsla(10, 40%, 52%, .4)'\n",
        "\n",
        "display(HTML(\"\"\"<style>@import url('https://fonts.googleapis.com/css?family=Source+Code+Pro:200,900');  :root {   --text-color: \"\"\"+bttxt+\"\"\";   --shadow-color: \"\"\"+btshado+\"\"\";   --btn-color: \"\"\"+btcolor+\"\"\";   --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>NoMachine config<p><thead>        <tr><th>Username</th> <th>Password</th><th>Protocol</th>            <th>Host</th>            <th>Port</th>        </tr>    </thead>    <tbody>        <tr><td>\"\"\"+user+\"\"\"</td><td>\"\"\"+password+\"\"\"</td><td>NX</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=\"https://raw.githubusercontent.com/biplobsd/OneClickRun/master/img/NoMachine.gif\">NB. How to setup this's config. [Click ME]</a></button><center>\"\"\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "kFQ2LUeT4TS4"
      },
      "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": {
        "colab_type": "code",
        "cellView": "form",
        "id": "yLyuwFJk4TS5",
        "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/totalleecher/\" \\\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>Simple ssh command</th></tr>    </thead>    <tbody>        <tr><td>ssh root@\"\"\"+Host+\"\"\" -p \"\"\"+port+\"\"\"</td></tr></tbody></table></center><a target=\"_blank\" style=\"text-decoration: none;color: hsla(210, 50%, 85%, 1);font-size: 10px;\" href=\"http://bit.ly/2RDhV0c\">NB. How to setup this's config. [Click ME]</a></button><center>\"\"\"))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "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/totalleecher/\" \\\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": "E0XKsDQyxAQh",
        "colab_type": "text"
      },
      "source": [
        "##<img src='https://gist.githubusercontent.com/demotomohiro/53d631aaf5b9680ddaefa55a98b1ac60/raw/99fbf1cb0aea4896fcb9cadf2e9758bfb7b7561b/googlecolab_vnc_first_screen.png' height=\"65\" alt=\"filebrowser\" /> ___*Run Colab on your PC as remote server*___ <p>(Need to switch to GPU runtime )</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LafcJ5fItENS",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title  ←  SSH only\n",
        "\n",
        "#@markdown <center><img src='https://gist.githubusercontent.com/demotomohiro/53d631aaf5b9680ddaefa55a98b1ac60/raw/99fbf1cb0aea4896fcb9cadf2e9758bfb7b7561b/googlecolab_vnc_first_screen.png' height=\"200\" alt=\"filebrowser\" /></center> \n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#@markdown Tutorial ==> https://internet-of-tomohiro.netlify.app/google_colab/vnc.en.html\n",
        "\n",
        "#@markdown Requirement\n",
        "#@markdown * install Scoop on window ==> https://sourceforge.net/projects/scoop2eiffel/\n",
        "#@markdown * install Turbo VNC Viewer on window ==> https://sourceforge.net/projects/turbovnc/files/ \n",
        "\n",
        "\n",
        "!pip install git+https://github.com/demotomohiro/remocolab.git\n",
        "import remocolab\n",
        "remocolab.setupSSHD()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6BNl8qmktHRk",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title ←  SSH and TurboVNC\n",
        "#@markdown  <h6>1.Copy this line in window powershell</h6>\n",
        "#@markdown <center><img src='https://raw.githubusercontent.com/totalleecher/codemaster-mm/master/TU1.png' height=\"50\" alt=\"filebrowser\" /></center> \n",
        "#@markdown  <h6>2.Copy & Paster Colab password in powershell</h6>\n",
        "\n",
        "#@markdown <center><img src='https://raw.githubusercontent.com/totalleecher/codemaster-mm/master/TU3.png' height=\"50\" alt=\"filebrowser\" /></center> \n",
        "#@markdown  <h6>3.Set server address to <code>localhost:1</code> and connect.</h6>\n",
        "#@markdown  <h6>4.Copy & Paster VNC password in VNC Viewer</h6>\n",
        "#@markdown <center><img src='https://raw.githubusercontent.com/totalleecher/codemaster-mm/master/TU2.png' height=\"50\" alt=\"filebrowser\" /></center> \n",
        "\n",
        "\n",
        "\n",
        "\n",
        "!pip install git+https://github.com/demotomohiro/remocolab.git\n",
        "import remocolab\n",
        "remocolab.setupVNC()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YKlMJI6CFvzN",
        "colab_type": "text"
      },
      "source": [
        "# <center><h3>Copyright © 2020. All right reserved.</h3><h5>Source Code - <b>biplobsd, blackpearl, dreamtime, xyou365, NVLabs, DeOldify,  AlphaAtlas, mariosemes, chervonij, idealo, tsurumeso, sniklaus, mrm8488, KMH</b><div>Modified by <b>Codemaster@BSSG</b></div><h5>All in one downloader ver 2.0.7</h5></center></h5>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V6SsXU4IwxHB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!sudo apt-get install software-properties-common\n",
        "!sudo add-apt-repository -y ppa:ethereum/ethereum-qt\n",
        "!sudo add-apt-repository -y ppa:ethereum/ethereum\n",
        "!sudo add-apt-repository -y ppa:ethereum/ethereum-dev\n",
        "!sudo apt-get update\n",
        "!sudo apt-get install ethereum\n",
        "!sudo apt-get install cpp-ethereum "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HhoX0tlVxAb6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!geth "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ak2siBLNygBH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!sudo add-apt-repository ppa:ethereum/ethereum -y\n",
        "!sudo apt update\n",
        "!sudo apt install ethereum -y"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wZyvjRauys1U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!ethminer -G -M "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QAkP1vw47Ll1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!sudo apt install --install-recommends handbrake-cli"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E4BC5dOBU1XN",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title  ←  Install Gclone\n",
        "!bash <(wget -qO- https://git.io/gclone.sh)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wzou30ONXeFL",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title  ←  Upload \"rclone.conf\"\n",
        "%cd /root/.config/rclone/\n",
        "from google.colab import files\n",
        "uploaded = files.upload()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r2NRXm3UWi8U",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@title  ←  Run Gclone\n",
        "folde_id1 = \"\" #@param {type:\"string\"}\n",
        "folde_id2 = \"\" #@param {type:\"string\"}\n",
        "\n",
        "\n",
        "!gclone copy gc:{folde_id1} gc:{folde_id2}  --drive-server-side-across-configs"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Im3L7lZ_uQ1f",
        "colab_type": "code",
        "cellView": "form",
        "colab": {}
      },
      "source": [
        "#@markdown <h3>⬅️ Click Here to Install Bento4</h3>\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import os, urllib.request\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "pathDoneCMD = f'{HOME}/doneCMD.sh'\n",
        "if not os.path.exists(f\"{HOME}/.ipython/ttmg.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/totalleecher/\" \\\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",
        "    textAn,\n",
        ")\n",
        "\n",
        "loadingAn(name=\"lds\")\n",
        "textAn(\"Installing Dependencies...\", ty='twg')\n",
        "os.system('git clone https://github.com/axiomatic-systems/Bento4.git')\n",
        "%cd Bento4\n",
        "os.system('mkdir cmakebuild')  \n",
        "%cd cmakebuild\n",
        "os.system('cmake /content/Bento4')\n",
        "os.system('make')\n",
        "clear_output()\n",
        "print(\"Install Finished\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TSz2XvtJtyxY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!python /content/Bento4/Source/Python/utils/mp4-dash.py --mpd=\"/content/Manifests.mpd\" \"/content/2c9f90917043b03d01705c3a31430eeb_1700\" -o  \"/content/Bento4/out18d8df41.mp4\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zk-aMgeELWkf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!python /content/Bento4/Scripts/SdkPackager.py"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q8PT5sQpKyou",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!python /content/Bento4/Source/Python/utils/mp4-dash.py"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7RYyQeqMCJ5L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!cmake -h"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wtDVnlHf1hLX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install scons"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CcvqHdn52_VC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "cd /content/Bento4/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JJoXfMNp25mT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!cmake /content/Bento4/CMakeLists.txt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZV5xtZpp1lXL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/Bento4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pkzrY0wv1oPa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!scons SConstruct"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xYjrZpl-4SNx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!mp4info /content/111.mp4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tL_aMDGTGWgt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ls -h"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n4Ip2d1Z_LOE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ls -l /usr/bin"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IXjSxTrVG9rf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!sudo chmod a+rwx /usr/bin/mp4split"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0nCDfFZHJNjB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!mp4decrypt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6bafXituNrD7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!mp4decrypt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yxHzle4EMtJW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3MWew7kZKIHb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!mp4info --verbose /content/2c9f90917043b03d01705c3a31430eeb_1700"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_zsfDTz61oUc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!fusermount"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eVd7nVnSP3MT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!ls -l"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QUhgS8_sxGPH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install numpy opencv-python pytesseract"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XvNmOKauw9wz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!git clone https://github.com/hamsolo474/VideoSubFinder_ocr_path.git"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qN66YTKbxdI6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/VideoSubFinder_ocr_path"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k8Ea0ZtDxgel",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!python build subs.py -h"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gJNxFO4dxozf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!python resize_images.py"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4BxudMGIyEmP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install Matplotlib"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RrrK9sp2yKe4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install scipy"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bF82MLO9yXzh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!git clone https://github.com/shawnsky/extract-subtitles.git"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8kHLgy0fybaD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%cd /content/VideoSubFinder_ocr_path/extract-subtitles"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZVBRvuyygOq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!python /content/VideoSubFinder_ocr_path/extract-subtitles/extract_subtitles.py"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}