Multi_tools.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tmatzxzone/multi-tools/blob/main/Multi_tools.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WJ9XTTtVzHfX"
      },
      "source": [
        "##Mount Google Drive\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "tPuLCnbGFmxo",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "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\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "477G4hACPgqM"
      },
      "source": [
        "## <img src=\"https://raw.githubusercontent.com/rclone/rclone/master/graphics/logo/svg/logo_symbol_color.svg\" height=\"45\" align=\"left\"/><font size=6>rclone</font>\n",
        "\n",
        "(collapsible / expandable)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "0VJ4VO1X8YE6",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <font size=5>← Install rclone</font>\n",
        "build_version = \"stable\" #@param [\"stable\", \"beta\" , \"v1.61.1\"]\n",
        "\n",
        "#@markdown ---\n",
        "automatically_clear_cell_output = True  # @param{type: \"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os\n",
        "import IPython\n",
        "from IPython.display import clear_output\n",
        "\n",
        "\n",
        "if build_version == \"stable\":\n",
        "\t!curl https://rclone.org/install.sh | sudo bash\n",
        "if build_version == \"stable\":\n",
        "\t!curl https://rclone.org/install.sh | sudo bash -s beta\n",
        "if build_version == \"v1.61.1\":\n",
        "\t!curl -O https://downloads.rclone.org/v1.61.1/rclone-v1.61.1-linux-amd64.zip\n",
        "\t!unzip rclone-v1.61.1-linux-amd64.zip\n",
        "\t!sudo cp rclone-v1.61.1-linux-amd64/rclone /usr/bin/\n",
        "\t!sudo chown root:root /usr/bin/rclone\n",
        "\t!sudo chmod 755 /usr/bin/rclone\n",
        "\t!sudo mkdir -p /usr/local/share/man/man1\n",
        "\t!sudo rclone-v1.61.1-linux-amd64/cp rclone.1 /usr/local/share/man/man1/\n",
        "\t!sudo mandb\n",
        "\n",
        "!sudo apt-get -y install fuse3\n",
        "\n",
        "try:\n",
        "\tos.makedirs(\"/root/.config/rclone\", exist_ok=True)\n",
        "except OSError as error:\n",
        "\tpass\n",
        "\n",
        "\n",
        "if automatically_clear_cell_output is True:\n",
        "\tclear_output()\n",
        "else:\n",
        "\tpass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wkc0wCvPIUFh"
      },
      "source": [
        "### <font size=6>rclone 2</font>\n",
        "\n",
        "(collapsible / expandable)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "t03ZdwQ-IvPv",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <font size=5>← [Start] rclone</font>\n",
        "Mode = \"Copy\" #@param [\"Copy\", \"Move\", \"Sync\", \"Checker\", \"Deduplicate\", \"Remove Empty Directories\", \"Empty Trash\"]\n",
        "Source = \"\" #@param {type:\"string\"}\n",
        "Destination = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown <center><h3><font color=\"#3399ff\"><b>⚙️ Global Configuration ⚙️</b></font></h3></center>\n",
        "Extra_Arguments = \"--local-no-check-updated\" #@param {type:\"string\"}\n",
        "Compare = \"Size & Mod-Time\" #@param [\"Size & Mod-Time\", \"Size & Checksum\", \"Only Mod-Time\", \"Only Size\", \"Only Checksum\"]\n",
        "Checkers = 10 #@param {type:\"slider\", min:1, max:40, step:1}\n",
        "Transfers = 10 #@param {type:\"slider\", min:1, max:20, step:1}\n",
        "Dry_Run = 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",
        "Google_Drive_optimization = False #@param {type:\"boolean\"}\n",
        "Large_amount_of_files_optimization = False #@param {type:\"boolean\"}\n",
        "Simple_Ouput = True #@param {type:\"boolean\"}\n",
        "Skip_all_files_that_exist = False #@param {type:\"boolean\"}\n",
        "Skip_files_that_are_newer_on_the_destination = False #@param {type:\"boolean\"}\n",
        "Output_Log_File = \"OFF\" #@param [\"OFF\", \"NOTICE\", \"INFO\", \"ERROR\", \"DEBUG\"]\n",
        "\n",
        "#@markdown <br><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 <br><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",
        "#@markdown ---\n",
        "automatically_clear_cell_output = False  # @param{type: \"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "##### Importing the needed modules\n",
        "import os\n",
        "import IPython\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "\n",
        "##### Variable Declaration\n",
        "# Optimized for Google Colaboratory\n",
        "os.environ[\"bufferC\"] = \"--buffer-size 96M\"\n",
        "\n",
        "if Compare == \"Size & Checksum\":\n",
        "    os.environ[\"compareC\"] = \"-c\"\n",
        "elif Compare == \"Only Mod-Time\":\n",
        "    os.environ[\"compareC\"] = \"--ignore-size\"\n",
        "elif Compare == \"Only Size\":\n",
        "    os.environ[\"compareC\"] = \"--size-only\"\n",
        "elif Compare == \"Only Checksum\":\n",
        "    os.environ[\"compareC\"] = \"-c --ignore-size\"\n",
        "else:\n",
        "    os.environ[\"compareC\"] = \"\"\n",
        "\n",
        "os.environ[\"sourceC\"] = Source\n",
        "os.environ[\"destinationC\"] = Destination\n",
        "os.environ[\"transfersC\"] = \"--transfers \"+str(Transfers)\n",
        "os.environ[\"checkersC\"] = \"--checkers \"+str(Checkers)\n",
        "\n",
        "if Skip_files_that_are_newer_on_the_destination == True:\n",
        "    os.environ[\"skipnewC\"] = \"-u\"\n",
        "else:\n",
        "    os.environ[\"skipnewC\"] = \"\"\n",
        "\n",
        "if Skip_all_files_that_exist == True:\n",
        "    os.environ[\"skipexistC\"] = \"--ignore-existing\"\n",
        "else:\n",
        "    os.environ[\"skipexistC\"] = \"\"\n",
        "\n",
        "if Do_not_cross_filesystem_boundaries == True:\n",
        "    os.environ[\"nocrossfilesystemC\"] = \"--one-file-system\"\n",
        "else:\n",
        "    os.environ[\"nocrossfilesystemC\"] = \"\"\n",
        "\n",
        "if Do_not_update_modtime_if_files_are_identical == True:\n",
        "    os.environ[\"noupdatemodtimeC\"] = \"--no-update-modtime\"\n",
        "else:\n",
        "    os.environ[\"noupdatemodtimeC\"] = \"\"\n",
        "\n",
        "if Large_amount_of_files_optimization == True:\n",
        "    os.environ[\"filesoptimizeC\"] = \"--fast-list\"\n",
        "else:\n",
        "    os.environ[\"filesoptimizeC\"] = \"\"\n",
        "\n",
        "if Google_Drive_optimization == True:\n",
        "    os.environ[\"driveoptimizeC\"] = \"--drive-chunk-size 32M --drive-acknowledge-abuse --drive-keep-revision-forever\"\n",
        "else:\n",
        "    os.environ[\"driveoptimizeC\"] = \"\"\n",
        "\n",
        "if Dry_Run == True:\n",
        "    os.environ[\"dryrunC\"] = \"-n\"\n",
        "else:\n",
        "    os.environ[\"dryrunC\"] = \"\"\n",
        "\n",
        "if Output_Log_File != \"OFF\":\n",
        "    os.environ[\"statsC\"] = \"--log-file=/root/.rclone_log/rclone_log.txt\"\n",
        "else:\n",
        "    if Simple_Ouput == True:\n",
        "        os.environ[\"statsC\"] = \"-v --stats-one-line --stats=5s\"\n",
        "    else:\n",
        "        os.environ[\"statsC\"] = \"-v --stats=5s\"\n",
        "\n",
        "if Output_Log_File == \"INFO\":\n",
        "    os.environ[\"loglevelC\"] = \"--log-level INFO\"\n",
        "elif Output_Log_File == \"ERROR\":\n",
        "    os.environ[\"loglevelC\"] = \"--log-level ERROR\"\n",
        "elif Output_Log_File == \"DEBUG\":\n",
        "    os.environ[\"loglevelC\"] = \"--log-level DEBUG\"\n",
        "else:\n",
        "    os.environ[\"loglevelC\"] = \"\"\n",
        "\n",
        "os.environ[\"extraC\"] = Extra_Arguments\n",
        "\n",
        "if Sync_Mode == \"Delete during transfer\":\n",
        "    os.environ[\"syncmodeC\"] = \"--delete-during\"\n",
        "elif Sync_Mode == \"Delete before transfering\":\n",
        "    os.environ[\"syncmodeC\"] = \"--delete-before\"\n",
        "elif Sync_Mode == \"Delete after transfering\":\n",
        "    os.environ[\"syncmodeC\"] = \"--delete-after\"\n",
        "\n",
        "if Track_Renames == True:\n",
        "    os.environ[\"trackrenamesC\"] = \"--track-renames\"\n",
        "else:\n",
        "    os.environ[\"trackrenamesC\"] = \"\"\n",
        "\n",
        "if Deduplicate_Mode == \"Interactive\":\n",
        "    os.environ[\"deduplicateC\"] = \"interactive\"\n",
        "elif Deduplicate_Mode == \"Skip\":\n",
        "    os.environ[\"deduplicateC\"] = \"skip\"\n",
        "elif Deduplicate_Mode == \"First\":\n",
        "    os.environ[\"deduplicateC\"] = \"first\"\n",
        "elif Deduplicate_Mode == \"Newest\":\n",
        "    os.environ[\"deduplicateC\"] = \"newest\"\n",
        "elif Deduplicate_Mode == \"Oldest\":\n",
        "    os.environ[\"deduplicateC\"] = \"oldest\"\n",
        "elif Deduplicate_Mode == \"Largest\":\n",
        "    os.environ[\"deduplicateC\"] = \"largest\"\n",
        "elif Deduplicate_Mode == \"Rename\":\n",
        "    os.environ[\"deduplicateC\"] = \"rename\"\n",
        "\n",
        "if Deduplicate_Use_Trash == True:\n",
        "    os.environ[\"deduplicatetrashC\"] = \"\"\n",
        "else:\n",
        "    os.environ[\"deduplicatetrashC\"] = \"--drive-use-trash=false\"\n",
        "\n",
        "\n",
        "##### rclone Execution\n",
        "if Output_Log_File != \"OFF\" and Mode != \"Config\":\n",
        "    !mkdir -p -m 666 /root/.rclone_log/\n",
        "    display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">Logging enabled, rclone will no longer display any output on the terminal.<br>Please wait until the cell stop by itself.</h2></center><br>\"))\n",
        "\n",
        "if Mode == \"Copy\":\n",
        "    !rclone --config=/root/.config/rclone/rclone.conf copy \"$sourceC\" \"$destinationC\" $transfersC $checkersC $statsC $loglevelC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $dryrunC $extraC\n",
        "elif Mode == \"Move\":\n",
        "    !rclone --config=/root/.config/rclone/rclone.conf move \"$sourceC\" \"$destinationC\" $transfersC $checkersC $statsC $loglevelC --delete-empty-src-dirs $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $dryrunC $extraC\n",
        "elif Mode == \"Sync\":\n",
        "    !rclone --config=/root/.config/rclone/rclone.conf sync \"$sourceC\" \"$destinationC\" $transfersC $checkersC $statsC $loglevelC $syncmodeC $trackrenamesC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $dryrunC $extraC\n",
        "elif Mode == \"Checker\":\n",
        "    !rclone --config=/root/.config/rclone/rclone.conf check \"$sourceC\" \"$destinationC\" $checkersC $statsC $loglevelC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $dryrunC $extraC\n",
        "elif Mode == \"Deduplicate\":\n",
        "    !rclone --config=/root/.config/rclone/rclone.conf dedupe \"$sourceC\" $checkersC $statsC $loglevelC --dedupe-mode $deduplicateC $deduplicatetrashC $compareC $skipnewC $skipexistC $nocrossfilesystemC $noupdatemodtimeC $bufferC $filesoptimizeC $driveoptimizeC $dryrunC $extraC\n",
        "elif Mode == \"Remove Empty Directories\":\n",
        "    !rclone --config=/root/.config/rclone/rclone.conf rmdirs \"$sourceC\" $statsC $loglevelC $dryrunC $extraC\n",
        "elif Mode == \"Empty Trash\":\n",
        "    !rclone --config=/root/.config/rclone/rclone.conf cleanup \"$sourceC\" $statsC $loglevelC $dryrunC $extraC\n",
        "\n",
        "\n",
        "##### Log Output\n",
        "if Output_Log_File != \"OFF\" and Mode != \"Config\":\n",
        "\n",
        "    ##### Rename log file and output settings.\n",
        "    !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",
        "\n",
        "    ##### Compressing log file.\n",
        "    !rm -f /root/rclone_log.zip\n",
        "    !zip -r -q -j -9 /root/rclone_log.zip /root/.rclone_log/\n",
        "    !rm -rf /root/.rclone_log/\n",
        "    !mkdir -p -m 666 /root/.rclone_log/\n",
        "\n",
        "    ##### Send Log\n",
        "    if os.path.isfile(\"/root/rclone_log.zip\") == True:\n",
        "        try:\n",
        "            files.download(\"/root/rclone_log.zip\")\n",
        "            !rm -f /root/rclone_log.zip\n",
        "            display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#446785;\\\">Sending log to your browser...</h2><br></center>\"))\n",
        "        except:\n",
        "            !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:#446785;\\\">You can use file explorer to download the log file.</h2><br><img src=\\\"https://minormole.github.io/RcloneLab/res/rclonelab/01.png\\\"><br></center>\"))\n",
        "    else:\n",
        "        clear_output()\n",
        "        display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">There is no log file.</h2><br></center>\"))\n",
        "\n",
        "\n",
        "### Operation has been successfully completed.\n",
        "if Mode != \"Config\":\n",
        "    display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#00b24c;\\\">✅ Operation has been successfully completed.</h2><br></center>\"))\n",
        "\n",
        "\n",
        "##### Automatically clear terminal output if the checkbox's value on the top is set to True.\n",
        "if automatically_clear_cell_output is True:\n",
        "    clear_output()\n",
        "else:\n",
        "\tpass##### Automatically clear terminal output if the checkbox's value on the top is set to True.\n",
        "if automatically_clear_cell_output is True:\n",
        "    clear_output()\n",
        "else:\n",
        "\tpass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O0NHwsI_-d3W"
      },
      "source": [
        "### <font size=6>rclone Configuration</font>\n",
        "\n",
        "(collapsible / expandable)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "5HURZQEZQ6pT",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <font size=5>← [Start] rclone CLI Configuration</font>\n",
        "# @markdown <p>Run this cell to create and/or edit an rclone configuration.</p>\n",
        "# @markdown > After you have created a configuration, download the configuration file.</br>In the next time you want to mount an rclone drive, simply import the configuration file.\n",
        "USE_FREE_TOKEN = True\n",
        "TOKEN = \"\"  #\n",
        "REGION = \"US\"\n",
        "Tunneling = \"argo_tunnel_(cloudflare)\" #@param [\"argo_tunnel_(cloudflare)\", \"localhost.run\", \"ngrok\"]\n",
        "\n",
        "# @markdown ---\n",
        "automatically_clear_cell_output = True  # @param{type: \"boolean\"}\n",
        "\n",
        "if Tunneling == \"argo_tunnel_(cloudflare)\":\n",
        "    PORT_FORWARD = \"argotunnel\"\n",
        "elif Tunneling == \"localhost.run\":\n",
        "    PORT_FORWARD = \"localhost\"\n",
        "elif Tunneling == \"ngrok\":\n",
        "    PORT_FORWARD = \"ngrok\"\n",
        "# ================================================================ #\n",
        "\n",
        "import os, urllib.request, IPython\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "runW = get_ipython()\n",
        "\n",
        "if not os.path.exists(\"/root/.ipython/mixlab.py\"):\n",
        "  from shlex import split as _spl\n",
        "  from subprocess import run\n",
        "\n",
        "  shellCmd = \"wget -qq https://shirooo39.github.io/MiXLab/resources/mixlab.py \\\n",
        "                  -O /root/.ipython/mixlab.py\"\n",
        "  run(_spl(shellCmd))\n",
        "\n",
        "from mixlab import (\n",
        "    prepareSession,\n",
        "    rcloneConfigurationPath,\n",
        "    runSh,\n",
        "    PortForward_wrapper\n",
        ")\n",
        "\n",
        "import codecs, contextlib, locale, os, pty, select, signal, subprocess, sys, termios, time\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",
        "prepareSession()\n",
        "\n",
        "Server = PortForward_wrapper(PORT_FORWARD, TOKEN, USE_FREE_TOKEN, [['rcloneConfiguration', 53682, 'http']], 'REGION.lower', [f\"{HOME}/.ngrok2/rcloneConfiguration.yml\", 4074]).start('rcloneConfiguration', displayB=False, v=False)\n",
        "\n",
        "printData = \"\"\"\n",
        "Before finishing the configuration, you will be redirected to an address.\n",
        "Replace the address http://127.0.0.0:53682 with {}\"\"\".format(Server['url'])\n",
        "print(printData)\n",
        "display(HTML('</br>(Click <a href=\"https://raw.githubusercontent.com/tofuliang/Google-Colab-CloudTorrent/master/src/rclone_config_create.gif\" target=\"_blank\">here</a> to see how to do it)</br></br>'))\n",
        "print(f\"{Server['url']}\", end=\"\\n\\n\")\n",
        "_run_command(f\"rclone config --config {rcloneConfigurationPath}/rclone.conf\", False)\n",
        "\n",
        "\n",
        "if automatically_clear_cell_output is True:\n",
        "\tclear_output()\n",
        "else:\n",
        "\tpass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "qakuMVVjQlGU",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <font size=5>← Mount/Unmount rclone Drive (Optional)</font>\n",
        "# @markdown Mount a remote drive as a local drive on a mountpoint.\n",
        "# @markdown ---\n",
        "Cache_Directory = \"DISK\" #@param [\"RAM\", \"DISK\"]\n",
        "# ================================================================ #\n",
        "\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/mixlab.py\"):\n",
        "  from shlex import split as _spl\n",
        "  from subprocess import run\n",
        "\n",
        "  shellCmd = \"wget -qq https://shirooo39.github.io/MiXLab/resources/mixlab.py \\\n",
        "                  -O /root/.ipython/mixlab.py\"\n",
        "  run(_spl(shellCmd))\n",
        "\n",
        "from mixlab import (\n",
        "    runSh,\n",
        "    prepareSession,\n",
        "    rcloneConfigurationPath,\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",
        "                  Available drive to mount/unmount:</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\"{rcloneConfigurationPath}/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 {rcloneConfigurationPath}/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\"The drive have been successfully mounted! - \\t{mPoint}\")\n",
        "    else:\n",
        "      print(f\"Failed to mount the drive! - \\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\"The drive have been successfully unmounted! - \\t{mPoint}\")\n",
        "  else:\n",
        "    runSh(f\"fusermount -uz {mPoint}\", output=True)\n",
        "\n",
        "ShowAC()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "G3rr1OuFRApD",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <font size=5>← Upload Configuration File </font>\n",
        "# @markdown <p>If you already have an rclone configuration file, you can upload it by running this cell.</p>\n",
        "\n",
        "# @markdown ---\n",
        "MODE = \"RCONFIG\" # @param ['UTILS', 'RCONFIG', 'RCONFIG_append', \"GENERATELIST\"]\n",
        "REMOTE = \"mnc\" # @param {type:\"string\"}\n",
        "QUERY_PATTERN = \"\" # @param {type:\"string\"}\n",
        "# @markdown > <p><font size=2px>For those who are unable to upload local file: <a href=\"https://stackoverflow.com/a/58661947\">StackOverflow</a></font></p>\n",
        "# ================================================================ #\n",
        "\n",
        "from os import path as _p\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "if not _p.exists(\"/root/.ipython/mixlab.py\"):\n",
        "    from shlex import split as _spl\n",
        "    from subprocess import run  # nosec\n",
        "\n",
        "    shellCmd = \"wget -qq https://shirooo39.github.io/MiXLab/resources/mixlab.py \\\n",
        "                    -O /root/.ipython/mixlab.py\"\n",
        "    run(_spl(shellCmd))  # nosec\n",
        "\n",
        "import importlib, mixlab\n",
        "from google.colab import files  # pylint: disable=import-error #nosec\n",
        "from mixlab import checkAvailable, runSh, rcloneConfigurationPath, 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 {rcloneConfigurationPath}/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/mixlab.py\"\n",
        "    elif MODE in (\"RCONFIG\", \"RCONFIG_append\"):\n",
        "        filePath = f\"{rcloneConfigurationPath}/rclone.conf\"\n",
        "    else:\n",
        "        pass\n",
        "\n",
        "    try:\n",
        "      if checkAvailable(filePath):\n",
        "        runSh(f\"rm -f {filePath}\")\n",
        "      display(HTML(\"<h2 style=\\\"font-family:Trebuchet MS;color:#4f8bd6;\\\">Upload rclone.conf from your local machine.</h2><br>\"))\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(\"\\nOnly upload one configuration 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://shirooo39.github.io/MiXLab/resources/configurations/rclone/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(mixlab)\n",
        "                    !rm /content/upload.txt\n",
        "                    clear_output()\n",
        "                    print(\"rclone.conf has been uploaded to Colab!\")\n",
        "              return\n",
        "      else:\n",
        "          print(\"\\nNo file is chosen!\")\n",
        "          return\n",
        "    except:\n",
        "      return print(\"\\nFailed to upload!\")\n",
        "\n",
        "\n",
        "if MODE == \"GENERATELIST\":\n",
        "    generateUploadList()\n",
        "else:\n",
        "    uploadLocalFiles()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tir2SjUgvFR6"
      },
      "source": [
        "## Mega"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "AelSL7BeTcJA",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <font size=5>← MEGA Login</font>\n",
        "# @markdown <p>Please log in to MEGA first (only needed to use the Uploader).</p>\n",
        "# ================================================================ #\n",
        "\n",
        "from functools import wraps\n",
        "import errno\n",
        "import os\n",
        "import signal\n",
        "import subprocess\n",
        "import shlex\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",
        "if not os.path.exists(\"/root/.ipython/mixlab.py\"):\n",
        "    from subprocess import run\n",
        "    from shlex import split\n",
        "\n",
        "    shellCmd = \"wget -qq https://raw.githubusercontent.com/shirooo39/MiXLab/master/resources/mixlab.py \\\n",
        "                    -O /root/.ipython/mixlab.py\"\n",
        "    run(split(shellCmd))\n",
        "from mixlab import runSh\n",
        "\n",
        "@timeout(10)\n",
        "def runShT(args):\n",
        "    return runSh(args, output=True)\n",
        "\n",
        "# Installing MEGAcmd\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",
        "# Enter MEGA credential\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 enter your MEGA credential.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "p0Wg4seDVseV",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <font size=5>← [Start] MEGA Downloader</font>\n",
        "URL = \"\" #@param {type:\"string\"}\n",
        "OUTPUT_PATH = \"\" #@param {type:\"string\"}\n",
        "# @markdown > URL: is the MEGA link you want to download (ex: mega.nz/file/file_link#decryption_key)</br>OUTPUT_PATH: is where to store the downloaded file(s) (ex: /content/drive/My Drive/)\n",
        "# ================================================================ #\n",
        "\n",
        "import sys, os, urllib.request\n",
        "import time\n",
        "import subprocess\n",
        "import contextlib\n",
        "from IPython.display import clear_output\n",
        "\n",
        "HOME = os.path.expanduser(\"~\")\n",
        "if not os.path.exists(f\"{HOME}/.ipython/mixlab.py\"):\n",
        "    hCode = \"https://raw.githubusercontent.com/shirooo39/\" \\\n",
        "                \"MiXLab/master/resources/mixlab.py\"\n",
        "    urllib.request.urlretrieve(hCode, f\"{HOME}/.ipython/mixlab.py\")\n",
        "\n",
        "from mixlab import (\n",
        "    runSh,\n",
        "    loadingAn,\n",
        ")\n",
        "\n",
        "if not OUTPUT_PATH:\n",
        "  os.makedirs(\"downloads\", exist_ok=True)\n",
        "  OUTPUT_PATH = \"downloads\"\n",
        "# Installing MEGAcmd\n",
        "if not os.path.exists(\"/usr/bin/mega-cmd\"):\n",
        "    loadingAn()\n",
        "    print(\"Installing MEGA ...\")\n",
        "    runSh('sudo apt-get -y update')\n",
        "    runSh('sudo apt-get -y install libmms0 libc-ares2 libc6 libcrypto++6 libgcc1 libmediainfo0v5 libpcre3 libpcrecpp0v5 libssl1.1 libstdc++6 libzen0v5 zlib1g apt-transport-https')\n",
        "    runSh('sudo curl -sL -o /var/cache/apt/archives/MEGAcmd.deb https://mega.nz/linux/repo/xUbuntu_22.04/amd64/megacmd-xUbuntu_22.04_amd64.deb', output=True)\n",
        "    runSh('sudo apt --fix-broken install')\n",
        "    runSh('sudo apt install /var/cache/apt/archives/MEGAcmd.deb', output=True)\n",
        "    print(\"MEGA is installed.\")\n",
        "    clear_output()\n",
        "\n",
        "# Unix, Windows and old Macintosh end-of-line\n",
        "newlines = ['\\n', '\\r\\n', '\\r']\n",
        "\n",
        "def unbuffered(proc, stream='stdout'):\n",
        "    stream = getattr(proc, stream)\n",
        "    with contextlib.closing(stream):\n",
        "        while True:\n",
        "            out = []\n",
        "            last = stream.read(1)\n",
        "            # Don't loop forever\n",
        "            if last == '' and proc.poll() is not None:\n",
        "                break\n",
        "            while last not in newlines:\n",
        "                # Don't loop forever\n",
        "                if last == '' and proc.poll() is not None:\n",
        "                    break\n",
        "                out.append(last)\n",
        "                last = stream.read(1)\n",
        "            out = ''.join(out)\n",
        "            yield out\n",
        "\n",
        "def transfare():\n",
        "    import codecs\n",
        "    decoder = codecs.getincrementaldecoder(\"UTF-8\")()\n",
        "    cmd = [\"mega-get\", URL, OUTPUT_PATH]\n",
        "    proc = subprocess.Popen(\n",
        "        cmd,\n",
        "        stdout=subprocess.PIPE,\n",
        "        stderr=subprocess.STDOUT,\n",
        "        # Make all end-of-lines '\\n'\n",
        "        universal_newlines=True,\n",
        "    )\n",
        "    for line in unbuffered(proc):\n",
        "        print(line)\n",
        "\n",
        "transfare()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "3GKtYuBbUP-c",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <font size=5>← [Start] MEGA Uploader</font>\n",
        "# Simple_torrent = False  # @param{type: \"boolean\"}\n",
        "# Peerflix = False  # @param{type: \"boolean\"}\n",
        "PATH_TO_FILE = \"\" # @param {type:\"string\"}\n",
        "# @markdown > PATH_TO_FILE is the location of the file you want to upload located at. (ex: /content/downloads/file-to-upload.zip)\n",
        "# ================================================================ #\n",
        "\n",
        "import time\n",
        "import subprocess\n",
        "import contextlib\n",
        "from IPython.display import clear_output\n",
        "\n",
        "# Unix, Windows and old Macintosh end-of-line\n",
        "newlines = ['\\n', '\\r\\n', '\\r']\n",
        "\n",
        "def unbuffered(proc, stream='stdout'):\n",
        "    stream = getattr(proc, stream)\n",
        "    with contextlib.closing(stream):\n",
        "        while True:\n",
        "            out = []\n",
        "            last = stream.read(1)\n",
        "            # Don't loop forever\n",
        "            if last == '' and proc.poll() is not None:\n",
        "                break\n",
        "            while last not in newlines:\n",
        "                # Don't loop forever\n",
        "                if last == '' and proc.poll() is not None:\n",
        "                    break\n",
        "                out.append(last)\n",
        "                last = stream.read(1)\n",
        "            out = ''.join(out)\n",
        "            yield out\n",
        "\n",
        "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(\"Please log into your MEGA account first!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R0C-yQp1xZHr"
      },
      "source": [
        "## ZippyShare Downloader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "if-ge8tzJ305",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <h3>← Install the Module and Dependencies</h3>\n",
        "# ================================================================ #\n",
        "\n",
        "import os\n",
        "from IPython.display import clear_output\n",
        "\n",
        "!git clone https://github.com/mcrapet/plowshare.git /content/plowshare\n",
        "clear_output()\n",
        "%cd plowshare\n",
        "clear_output()\n",
        "!make install\n",
        "clear_output()\n",
        "!plowmod --install\n",
        "clear_output()\n",
        "! apt-get install nodejs\n",
        "\n",
        "path1 = '/content/downloads'\n",
        "path2 = '/content/downloads/zippyshare'\n",
        "\n",
        "if os.path.exists(path1) == False:\n",
        "  os.makedirs(path1)\n",
        "  if os.path.exists(path2) == False:\n",
        "    os.makedirs(path2)\n",
        "  elif os.path.exists(path2) == True:\n",
        "    None\n",
        "elif os.path.exists(path1) == True:\n",
        "  if os.path.exists(path2) == False:\n",
        "    os.makedirs(path2)\n",
        "  elif os.path.exists(path2) == True:\n",
        "    None\n",
        "\n",
        "clear_output()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "tO22WPSLKdbH",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <h3>← [Start] zippyshare Downloader</h3></br>\n",
        "mode = 'single' #@param [\"single\", \"batch\"]\n",
        "# @markdown ---\n",
        "direct_url = \"\" #@param {type:\"string\"}\n",
        "store_path = \"\" #@param {type:\"string\"}\n",
        "# @markdown > This downloader isn't working as it can't read from zippyshare's weird url (www(random_number).zippyshare)\n",
        "# ================================================================ #\n",
        "\n",
        "import os\n",
        "from IPython.display import clear_output\n",
        "from google.colab import files\n",
        "\n",
        "if mode == 'single':\n",
        "  if direct_url == '':\n",
        "    print(\"The URL field is empty!\")\n",
        "  else:\n",
        "    if store_path == '':\n",
        "      store_path = '/content/downloads/zippyshare'\n",
        "      !plowdown {direct_url} -o {store_path}\n",
        "    else:\n",
        "      !plowdown {direct_url} -o {store_path}\n",
        "elif mode == 'batch':\n",
        "  print(\"Upload a download.txt file that contains a list of zippyshare links.\\n\")\n",
        "  files.upload()\n",
        "  clear_output()\n",
        "  if store_path == '':\n",
        "    store_path = '/content/downloads/zippyshare'\n",
        "    !plowdown {direct_url} -o {store_path}\n",
        "  else:\n",
        "    !plowdown {direct_url} -o {store_path}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WmJEFkM4x05r"
      },
      "source": [
        "## AnonFiles Uploader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "BIMRKjTrinOM",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <p><font size=5px>← [Start] Upload to anonfiles</font></p>\n",
        "file_path = \"\" # @param {type: \"string\"}\n",
        "\n",
        "url = \"https://api.anonfiles.com/upload\"\n",
        "# ================================================================ #\n",
        "\n",
        "import requests\n",
        "\n",
        "x = requests.post(url, files = {'file': open(file_path,'rb')},)\n",
        "\n",
        "print(\"Download link: \" + x.json()[\"data\"][\"file\"][\"url\"][\"full\"])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rgjf7ZcOygaG"
      },
      "source": [
        "## Create / Extract Archive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "88JkX_J3EXWC",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "# @markdown <p><font size=5px>← Install the Tools</font></p>\n",
        "# ================================================================ #\n",
        "\n",
        "import os\n",
        "import IPython\n",
        "from IPython.display import clear_output\n",
        "\n",
        "os.system(\"sudo apt update\")\n",
        "os.system(\"apt install p7zip-full p7zip-rar unrar rar\")\n",
        "\n",
        "clear_output()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "background_save": true
        },
        "id": "RMy0TxzHzCR9",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <font size=5px>← Create archive</font>\n",
        "source_path = \"\" #@param {type:\"string\"}\n",
        "archive_type = \"zip\" #@param [\"zip\", \"7z\", \"rar\", \"tar\", \"tar.gz\"]\n",
        "archive_name = \"\" #@param {type:\"string\"}\n",
        "#@markdown > If left empty, the default name will be used (archive)\n",
        "archive_password = \"\" #@param {type:\"string\"}\n",
        "#@markdown > Leave this field empty if you do not want to protect the archive with password.\n",
        "compression_level = \"no_compression\" #@param [\"no_compression\", \"fastest\", \"fast\", \"normal\", \"maximum\", \"ultra\"]\n",
        "output_path = \"\" #@param {type:\"string\"}\n",
        "#@markdown > If left empty, the default path will be used (/content)\n",
        "\n",
        "#@markdown ---\n",
        "automatically_clear_cell_output = False  # @param{type: \"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "from IPython.display import HTML, clear_output\n",
        "import os, sys, re\n",
        "\n",
        "\n",
        "if archive_name == \"\":\n",
        "    archive_name = \"archive\"\n",
        "else:\n",
        "    pass\n",
        "\n",
        "if archive_password == \"\":\n",
        "    pass\n",
        "else:\n",
        "    archive_password = \"-p\" + archive_password\n",
        "\n",
        "if compression_level == \"no_compression\":\n",
        "    compression_level = \"-mx=0\"\n",
        "elif compression_level == \"fastest\":\n",
        "    compression_level = \"-mx=1\"\n",
        "elif compression_level == \"fast\":\n",
        "    compression_level = \"-mx=3\"\n",
        "elif compression_level == \"normal\":\n",
        "    compression_level = \"-mx=5\"\n",
        "elif compression_level == \"maximum\":\n",
        "    compression_level = \"-mx=7\"\n",
        "elif compression_level == \"ultra\":\n",
        "    compression_level = \"-mx=9\"\n",
        "\n",
        "if output_path == \"\":\n",
        "    output_path = \"/content\"\n",
        "else:\n",
        "    pass\n",
        "\n",
        "\n",
        "if archive_type == \"zip\":\n",
        "    if source_path == \"\":\n",
        "        display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ The source_path field is empty!</h2><br></center>\"))\n",
        "    else:\n",
        "        #output_file_path = re.search(\"^[\\/].+\\/\", source_path)\n",
        "        #output_file_path_raw = output_file_path.group(0)\n",
        "        #delsplit = re.search(\"\\/(?:.(?!\\/))+$\", source_path)\n",
        "        #folder_name = re.sub(\"^[\\/]\", \"\", delsplit.group(0))\n",
        "\n",
        "        #os.environ['inputDir'] = source_path\n",
        "        #os.environ['outputPath'] = output_file_path_raw\n",
        "        #os.environ['folderName'] = folder_name\n",
        "        #os.environ['archiveLevel'] = compression_level\n",
        "        #os.environ['archivePassword'] = archive_password\n",
        "\n",
        "        #!7z a -tzip \"$archiveLevel\" \"$archivePassword\" \"$outputPath\"/\"$folderName\".zip \"$inputDirectory\"\n",
        "        !7z a -tzip \"$compression_level\" \"$archive_password\" \"$output_path\"/\"$archive_name\".zip \"$source_path\"\n",
        "else:\n",
        "    display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ More archive format will be added in the future.</h2><br></center>\"))\n",
        "\n",
        "\n",
        "if automatically_clear_cell_output is True:\n",
        "\tclear_output()\n",
        "else:\n",
        "\tpass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Mbmf5lk0zF1q",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ============================= FORM ============================= #\n",
        "#@markdown <font size=5px>← Extract archive</font>\n",
        "archive_path = \"\" #@param {type:\"string\"}\n",
        "archive_type = \"zip\" #@param [\"zip\", \"7z\", \"rar\", \"tar\", \"gzip\", \"iso\"]\n",
        "archive_password = \"\" #@param {type:\"string\"}\n",
        "#@markdown > Leave the archive_password field empty if archive is not password protected.\n",
        "output_path = \"\" #@param {type:\"string\"}\n",
        "#@markdown > Leave the output_path field empty to use default extraction path (/content).\n",
        "\n",
        "#@markdown ---\n",
        "automatically_clear_cell_output = False  # @param{type: \"boolean\"}\n",
        "# ================================================================ #\n",
        "\n",
        "import os, sys, re\n",
        "from IPython.display import HTML, clear_output\n",
        "\n",
        "\n",
        "if archive_password == \"\":\n",
        "    pass\n",
        "elif not archive_password == \"\":\n",
        "    archive_password = \"-p\" + archive_password\n",
        "\n",
        "if output_path == \"\":\n",
        "    output_path = \"-o/content\"\n",
        "elif output_path == \"/content\":\n",
        "    output_path = \"-o/content\"\n",
        "else:\n",
        "    output_path = \"-o\" + output_path\n",
        "\n",
        "\n",
        "os.environ['inputFile'] = archive_path\n",
        "os.environ['inputPassword'] = archive_password\n",
        "os.environ['outputFile'] = output_path\n",
        "\n",
        "\n",
        "if archive_path == \"\":\n",
        "    display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ The archive_path field is empty!</h2><br></center>\"))\n",
        "else:\n",
        "    if archive_type == \"zip\":\n",
        "        !7z x \"$inputFile\" \"$inputPassword\" \"$outputFile\"\n",
        "    elif archive_type == \"iso\":\n",
        "        !7z x \"$inputFile\" \"$outputFile\"\n",
        "    elif archive_type == \"rar\":\n",
        "        !7z x \"$inputFile\" \"$inputPassword\" \"$outputFile\"\n",
        "    if archive_type == \"tar\":\n",
        "        !7z x \"$inputFile\" \"$outputFile\"\n",
        "    if archive_type == \"7z\":\n",
        "        !7z x \"$inputFile\" \"$inputPassword\" \"$outputFile\"\n",
        "    else:\n",
        "        display(HTML(\"<center><h2 style=\\\"font-family:Trebuchet MS;color:#ce2121;\\\">❌ More archive format will be added in the future.</h2><br></center>\"))\n",
        "\n",
        "\n",
        "if automatically_clear_cell_output is True:\n",
        "\tclear_output()\n",
        "else:\n",
        "\tpass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TD0jARIQUk0O"
      },
      "source": [
        "# Gallery-DL"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Y9wZd6Qa9dj"
      },
      "source": [
        "<font size=\"4\">Not all features and/or functions are implemented yet!  \n",
        "I cannot yet think of a way to handle sites that require OAuth (for example, Pixiv).  \n",
        "\n",
        "You could, however, use gallery-dl on a separate cell manually.\n",
        "<br> To install in gdrive change this : <br>\n",
        "self.download_path = pathlib.Path('/content/drive/My Drive/')\n",
        "<br> OneDrive: <br>\n",
        "self.download_path = pathlib.Path('/content/drives/Torrent')\n",
        "```\n",
        "!gallery-dl {command goes here}\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "h2grJ90AP9Eh",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ------------------------------#------------------------------ #\n",
        "# @markdown <font size=\"5\">← [Install] gallery-dl</font>\n",
        "# ------------------------------#------------------------------ #\n",
        "\n",
        "import subprocess\n",
        "import pathlib\n",
        "import shutil\n",
        "import sys\n",
        "from IPython.display import clear_output\n",
        "from google.colab import files\n",
        "\n",
        "\n",
        "class gallerydl:\n",
        "    def __init__(self):\n",
        "        clear_output()\n",
        "\n",
        "        self.download_path = pathlib.Path('/content/drives/Torrent')\n",
        "        self.gallery_path = self.download_path.joinpath('gallery-dl')\n",
        "        self.cookies_path = self.gallery_path.joinpath('cookies.txt')\n",
        "\n",
        "        return None\n",
        "\n",
        "\n",
        "    def install(self):\n",
        "        try:\n",
        "            subprocess.run('pip install --upgrade pip setuptools wheel', shell=True)\n",
        "            subprocess.run('pip install --upgrade requests', shell=True)\n",
        "            subprocess.run('pip install -U -I --no-deps --no-cache-dir https://github.com/mikf/gallery-dl/archive/master.tar.gz', shell=True)\n",
        "        except Exception as unknown_error:\n",
        "            print(f'[Error]: {unknown_error}')\n",
        "            return exit\n",
        "        else:\n",
        "            clear_output()\n",
        "\n",
        "        try:\n",
        "            self.gallery_path.mkdir(parents=True, exist_ok=True)\n",
        "        except FileExistsError:\n",
        "            return None\n",
        "        except Exception as unknown_error:\n",
        "            print(f'[Error]: {unknown_error}')\n",
        "            return exit\n",
        "        else:\n",
        "            return None\n",
        "\n",
        "\n",
        "    def check_cookies(self):\n",
        "        if self.cookies_path.exists() and self.cookies_path.is_file() is True:\n",
        "            return True\n",
        "        else:\n",
        "            return False\n",
        "\n",
        "\n",
        "    def upload_cookies(self):\n",
        "        if self.check_cookies() is True:\n",
        "            self.remove_cookies()\n",
        "        else:\n",
        "            pass\n",
        "\n",
        "        uploaded = files.upload()\n",
        "\n",
        "        for filename in uploaded.keys():\n",
        "            shutil.move(filename, self.gallery_path)\n",
        "\n",
        "            print(f'[Notice]: Moved file \"{filename}\" to \"{self.gallery_path}\"')\n",
        "\n",
        "        return None\n",
        "\n",
        "\n",
        "    def remove_cookies(self):\n",
        "        if self.check_cookies() is True:\n",
        "            try:\n",
        "                self.cookies_path.unlink()\n",
        "            except FileNotFoundError:\n",
        "                pass\n",
        "            except Exception as unknown_error:\n",
        "                print(f'[Error]: {unknown_error}')\n",
        "                return exit\n",
        "            else:\n",
        "                pass\n",
        "        else:\n",
        "            pass\n",
        "\n",
        "        return None\n",
        "\n",
        "\n",
        "    def execute(self, command):\n",
        "        #\n",
        "        # Thank you to jfs from stackoverflow for the solution\n",
        "        # to print out subprocess output line-by-line on-the-fly.\n",
        "        # https://stackoverflow.com/a/28319191/14304638\n",
        "        #\n",
        "\n",
        "        try:\n",
        "            with subprocess.Popen(command, shell=True, cwd=self.download_path, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, bufsize=1, universal_newlines=True) as process:\n",
        "                for line in process.stdout:\n",
        "                    print(line, end='')\n",
        "\n",
        "            if process.returncode != 0:\n",
        "                raise subprocess.CalledProcessError(process.returncode, process.args)\n",
        "        except Exception as unknown_error:\n",
        "            print(f'[Error]: {unknown_error}')\n",
        "            return exit\n",
        "        else:\n",
        "            print(\n",
        "                '\\n' + ('-' * 100) + '\\n' +\n",
        "                f'[Notice]: Downloads are stored in \"{self.gallery_path}\"' +\n",
        "                '\\n' + ('-' * 100)\n",
        "            )\n",
        "            return exit\n",
        "\n",
        "\n",
        "    def stop_cell(self):\n",
        "        clear_output()\n",
        "        return exit\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    try:\n",
        "        gallerydl().install()\n",
        "    except KeyboardInterrupt:\n",
        "        stop_cell()\n",
        "    except Exception as unknown_error:\n",
        "        print(f'[Error]: {unknown_error}')\n",
        "        exit\n",
        "    else:\n",
        "        pass\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "-UvCvdHjwR2r",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ------------------------------#------------------------------ #\n",
        "# @markdown <font size=\"5\">← [Start] gallery-dl</font>\n",
        "download_url = \"--filesize-min 30M --retries 1 --http-timeout 10.0 \" #@param {type:\"string\"}\n",
        "\n",
        "# @markdown ---\n",
        "\n",
        "# @markdown <font size=\"5\"><center>Additional Options</center></font>\n",
        "username = \"\" #@param {type:\"string\"}\n",
        "password = \"\" #@param {type:\"string\"}\n",
        "use_login = False #@param {type:\"boolean\"}\n",
        "use_cookies = False #@param {type:\"boolean\"}\n",
        "# ------------------------------#------------------------------ #\n",
        "\n",
        "from IPython.display import clear_output\n",
        "\n",
        "\n",
        "def main():\n",
        "    if download_url == '':\n",
        "        print('[Error]: download_url is empty!')\n",
        "        return exit\n",
        "    else:\n",
        "        pass\n",
        "\n",
        "    if use_login is True:\n",
        "        if username == '':\n",
        "            print('[Error]: username is empty!')\n",
        "            return exit\n",
        "        else:\n",
        "            flag_username = f'--username {username}'\n",
        "\n",
        "        if password == '':\n",
        "            print('[Error]: password is empty!')\n",
        "            return exit\n",
        "        else:\n",
        "            flag_password = f'--password {password}'\n",
        "    else:\n",
        "        flag_username = ''\n",
        "        flag_password = ''\n",
        "\n",
        "    if use_cookies is True:\n",
        "        if gallerydl().check_cookies() is True:\n",
        "            flag_cookies = f'--cookies \"/content/drive/My Drive/gallery-dl/cookies.txt\"'\n",
        "        else:\n",
        "            print('[Notice]: Execution aborted due to missing \"cookies.txt\" file.')\n",
        "            return exit\n",
        "    else:\n",
        "        flag_cookies = ''\n",
        "\n",
        "    try:\n",
        "        command = f'gallery-dl {flag_username} {flag_password} {flag_cookies} {download_url}'\n",
        "        gallerydl().execute(command)\n",
        "    except Exception as unknown_error:\n",
        "        print(f'[Error]: {unknown_error}')\n",
        "        return exit\n",
        "    else:\n",
        "        return None\n",
        "\n",
        "\n",
        "if __name__  == '__main__':\n",
        "    try:\n",
        "        main()\n",
        "    except KeyboardInterrupt:\n",
        "        clear_output()\n",
        "        exit\n",
        "    except Exception as unknown_error:\n",
        "        print(f'[Error]: {unknown_error}')\n",
        "        exit\n",
        "    else:\n",
        "        pass\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6XzR4IVO5xFr"
      },
      "source": [
        "#### <font size=\"5\">Settings -- Cookies</font>\n",
        "\n",
        "<font size=\"3\">(collapsible / expandable)</font>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "ycm43GhQQ5ta",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ==============================#============================== #\n",
        "# @markdown <font size=\"5\">Upload cookies.txt</font>\n",
        "# @markdown > Run this cell if you want to manually upload or re-upload your \"cookies.txt\" file.\n",
        "# ==============================#============================== #\n",
        "\n",
        "from IPython.display import clear_output\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    try:\n",
        "        gallerydl().upload_cookies()\n",
        "    except KeyboardInterrupt:\n",
        "        gallerydl().stop_cell()\n",
        "    except Exception as unknown_error:\n",
        "        print(f'[Error]: {unknown_error}')\n",
        "        exit\n",
        "    else:\n",
        "        clear_output()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "aXwmxO9KUOyB",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# ==============================#============================== #\n",
        "# @markdown <font size=\"5\">Delete cookies.txt</font>\n",
        "# @markdown > Run this cell if you want to delete your \"cookies.txt\" file.\n",
        "# ==============================#============================== #\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    try:\n",
        "        gallerydl().remove_cookies()\n",
        "    except KeyboardInterrupt:\n",
        "        gallerydl().stop_cell()\n",
        "    except Exception as unknown_error:\n",
        "        print(f'[Error]: {unknown_error}')\n",
        "        exit\n",
        "    else:\n",
        "        pass\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "juW1zJHfNdaG"
      },
      "source": [
        "# FFmpeg video tools"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EFOqhHG6hOVH"
      },
      "source": [
        "### ***Required to use Scripts:*** Install FFmpeg, VCSI & Mkvtoolnix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "G3JHGE0Jtzme",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "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\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "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",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "tsY6jhC9SXvF",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "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.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Zam_JHPDalxc",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "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()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "SHBPElqualx6",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "import os, sys, re\n",
        "#@markdown <b>Encoder</b>\n",
        "Encoder = \"GPU\" #@param [\"GPU\", \"CPU\"]\n",
        "codec = \"x265\" #@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",
        "#@markdown <b>Output Path</b>\n",
        "output_file_path = \"\" #@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 = 'same as input' #@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 = 'yuv420p' #@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 = 18000 #@param {type:\"slider\", min:2000, max:50000, step:100}\n",
        "max_bitrate = 21000 #@param {type:\"slider\", min:2000, 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 = 'aac' #@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 = \"-b:a 160k\" #@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\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 -"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bn8deYOrQUMZ"
      },
      "source": [
        "# StreamLink"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "BdxczAg_rqzD",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "#@markdown <center><h2>Streamlink Installer</h2></center><br>\n",
        "#@markdown <center>Install StreamLink</center>\n",
        "from IPython.display import clear_output\n",
        "!pip install streamlink\n",
        "clear_output()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "6Fa5pg0fWctH",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "#@markdown <center><h3><h2>Stream Recorder</h2>Record any stream</h3></center><br>\n",
        "#@markdown 1- Go to your Google Drive and create a directory called \"stream\" (whitout quotes).\n",
        "#@markdown <br />2- Mount Gdrive above.\n",
        "#@markdown <br />3- Install Streamlink above.\n",
        "#@markdown <br />4- Start recording bellow.\n",
        "import os\n",
        "import time\n",
        "import subprocess\n",
        "from IPython.display import clear_output\n",
        "RUN_Dir = \"/content/tools/stream\"\n",
        "\n",
        "if not RUN_Dir:\n",
        "  RUN_Dir = \"tools/stream\"\n",
        "os.makedirs(RUN_Dir, exist_ok=True)\n",
        "\n",
        "#code to use plugin that was removed from streamlink, remove the comment bellow and set the .py name\n",
        "#if not os.path.exists(f\"{RUN_Dir}/.py\"):\n",
        "#  !cd {RUN_Dir} && wget https://raw.githubusercontent.com/limontec/streamlink/master/src/streamlink/plugins/.py\n",
        "\n",
        "#@markdown ---\n",
        "#@markdown ####Type stream url\n",
        "streamURL =  \"\"  # @param {type:\"string\"}\n",
        "#@markdown ---\n",
        "#@markdown ####Type any name for the stream\n",
        "name = \"\"  # @param {type:\"string\"}\n",
        "#@markdown ---\n",
        "#@markdown ####Settings\n",
        "#@markdown start stream record\n",
        "start_record = True #@param {type:\"boolean\"}\n",
        "#@markdown try restart record after stream disconnect\n",
        "loop = False #@param {type:\"boolean\"}\n",
        "#@markdown upload video file to your Drive after finish every record\n",
        "upload_record = True #@param {type:\"boolean\"}\n",
        "#@markdown upload all videos in this session to your Drive\n",
        "upload_all = False #@param {type:\"boolean\"}\n",
        "#@markdown ---\n",
        "#@markdown #####Sites supported: https://streamlink.github.io/plugin_matrix.html\n",
        "#@markdown ---\n",
        "\n",
        "def record():\n",
        "  tempo = time.strftime('_%d-%m-%Y_%H-%M-%S')\n",
        "  if start_record:\n",
        "    !cd {RUN_Dir} && streamlink --plugin-dirs {RUN_Dir} {streamURL} best -o {RUN_Dir}/{name}{tempo}.mp4 --retry-streams 30 --retry-max 300\n",
        "  upload(tempo)\n",
        "\n",
        "def upload(tempo):\n",
        "  if(os.path.exists('/content/drive')):\n",
        "    if (upload_record and os.path.exists(RUN_Dir+'/'+name+tempo+'.mp4')) or loop:\n",
        "      try:\n",
        "        if(os.path.exists(RUN_Dir+'/'+name+tempo+'.mp4')):\n",
        "          print(\"Copying \"+name+tempo+\".mp4 to drive...\")\n",
        "          !cd {RUN_Dir} && cp {name}{tempo}.mp4 /content/drive/My\\ Drive/stream\n",
        "        else:\n",
        "          print(\"No file.\")\n",
        "      except Exception:\n",
        "        print(\"Error!\")\n",
        "    elif upload_all:\n",
        "      try:\n",
        "        print(\"Copying *.mp4 to drive...\")\n",
        "        os.system('cd '+RUN_Dir+' && cp *.mp4 /content/drive/My\\ Drive/stream')\n",
        "      except Exception:\n",
        "        print(\"Error!\")\n",
        "    else:\n",
        "      print(\"Nothing copied.\")\n",
        "  else:\n",
        "    print(\"You need to mount Gdrive to /content/drive to upload\")\n",
        "\n",
        "record()\n",
        "while loop:\n",
        "  tempo = time.strftime('_%d-%m-%Y_%H-%M-%S')\n",
        "  record()\n",
        "  clear_output()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Telegram-Leecher"
      ],
      "metadata": {
        "id": "egF9j-Wnwo2z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title ⚙️ Set-up Modules and Environments [ MUST ]\n",
        "\n",
        "!git clone https://github.com/XronTrix10/Telegram-Leecher &>/dev/null && bash /content/Telegram-Leecher/setup.sh &>/dev/null\n",
        "\n",
        "import shutil, os\n",
        "if os.path.exists(\"/content/sample_data\"):\n",
        "    shutil.rmtree(\"/content/sample_data\")\n",
        "\n",
        "print('Files and modules setup Successfull')"
      ],
      "metadata": {
        "id": "q7HC3z2JwqCz",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title ✒️ Edit the Variables with your data and Run the cell\n",
        "API_ID    = \"\"           # <== YOUR TELEGRAM API ID HERE\n",
        "API_HASH  = \"\"           # <== YOUR TELEGRAM API HASH HERE ( Place Inside Quotes )\n",
        "BOT_TOKEN = \"\"           # <== YOUR TELEGRAM BOT TOKEN HERE ( Place Inside Quotes )\n",
        "CHAT_ID   = \"\"           # <== YOUR CHAT ID WHERE ALL STATUS AND LOGS WILL BE SHOWN\n",
        "DUMP_ID   = \"\"           # <== CHAT ID WHERE ALL FILES WILL BE UPLOADED ( MUST BE A CHANNEL OR SUPERGROUP ) [ ID STARTS WITH -100 ]\n",
        "LEECH_DOCUMENT = False   # Change it to True to leech as Document\n",
        "\n",
        "print('BOT Variables Initialized ! 💖')"
      ],
      "metadata": {
        "id": "NCvkOIsIxggT",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title ⚠️ 👇🏻 Edit The Below Variables Only If you are on Mobile 📱 (Still need to run as well)\n",
        "\n",
        "'''\n",
        "'L' => Leech\n",
        "'Z' => ZipLeech\n",
        "'U' => UnzipLeech\n",
        "'D' => UnDoubleZipLeech\n",
        "'''\n",
        "\n",
        "LEECH_MODE  = \"\"           # <== Leech Mode\n",
        "D_LINK      = \"\"           # <== YOUR Download Link\n",
        "C_NAME      = \"\"           # <== Custom Name [ Leave Empty For Default ]\n",
        "PASSWD      = \"E\"          # <== Password For Unzip [ 'E' For Empty ]\n",
        "\n",
        "# NOTE: Currently only one link is supported for Mobile users"
      ],
      "metadata": {
        "cellView": "form",
        "id": "S4DERrZw0UlJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title 🖊️ Edit This Cell And Run It\n",
        "#@markdown <b>1 = Leech, 2 = Zip Leech, 3 = Unzip Leech</b>\n",
        "LEECH_MODE = \"1\" #@param [\"1\", \"2\", \"3\"]\n",
        "#@markdown <b>Path To Your Colab File/Folder </b>\n",
        "PATH = \"\" #@param {type:\"string\"}\n",
        "C_NAME      = \"\"           # <== Custom Name [ Leave Empty For Default ]\n",
        "PASSWD      = \"E\"          # <== Password For Unzip [ 'E' For Empty ]\n",
        "LEECH_DOCUMENT = False   # Change it to True to leech as Document\n",
        "\n",
        "print('Task Information Acquired ! 💖')"
      ],
      "metadata": {
        "id": "6g6vihS4-beX",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title 🍅 Local Colab Leecher\n",
        "import os, io, re, sys, shutil, time, yt_dlp, math, pytz, psutil, threading, pickle, uvloop, pathlib, datetime, subprocess\n",
        "from PIL import Image\n",
        "from pyrogram import Client\n",
        "from natsort import natsorted\n",
        "from urllib.parse import urlparse\n",
        "from re import search as re_search\n",
        "from os import makedirs, path as ospath\n",
        "from IPython.display import clear_output\n",
        "from urllib.parse import parse_qs, urlparse\n",
        "from googleapiclient.discovery import build\n",
        "from googleapiclient.errors import HttpError\n",
        "from googleapiclient.http import MediaIoBaseDownload\n",
        "from moviepy.video.io.VideoFileClip import VideoFileClip\n",
        "from pyrogram.types import (\n",
        "    ReplyKeyboardMarkup,\n",
        "    InlineKeyboardMarkup,\n",
        "    InlineKeyboardButton,\n",
        ")\n",
        "\n",
        "uvloop.install()\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Local OS Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "def convert_seconds(seconds):\n",
        "    seconds = int(seconds)\n",
        "    days = seconds // (24 * 3600)\n",
        "    seconds = seconds % (24 * 3600)\n",
        "    hours = seconds // 3600\n",
        "    seconds %= 3600\n",
        "    minutes = seconds // 60\n",
        "    seconds %= 60\n",
        "\n",
        "    if days > 0:\n",
        "        return f\"{days}d {hours}h {minutes}m {seconds}s\"\n",
        "    elif hours > 0:\n",
        "        return f\"{hours}h {minutes}m {seconds}s\"\n",
        "    elif minutes > 0:\n",
        "        return f\"{minutes}m {seconds}s\"\n",
        "    else:\n",
        "        return f\"{seconds}s\"\n",
        "\n",
        "\n",
        "def size_measure(size):\n",
        "    if size > 1024 * 1024 * 1024 * 1024 * 1024:\n",
        "        siz = f\"{size/(1024**5):.2f} PiB\"\n",
        "    elif size > 1024 * 1024 * 1024 * 1024:\n",
        "        siz = f\"{size/(1024**4):.2f} TiB\"\n",
        "    elif size > 1024 * 1024 * 1024:\n",
        "        siz = f\"{size/(1024**3):.2f} GiB\"\n",
        "    elif size > 1024 * 1024:\n",
        "        siz = f\"{size/(1024**2):.2f} MiB\"\n",
        "    elif size > 1024:\n",
        "        siz = f\"{size/1024:.2f} KiB\"\n",
        "    else:\n",
        "        siz = f\"{size} B\"\n",
        "    return siz\n",
        "\n",
        "\n",
        "def get_file_type(file_path):\n",
        "    extensions_dict = {\n",
        "        \".mp4\": \"video\",\n",
        "        \".avi\": \"video\",\n",
        "        \".mkv\": \"video\",\n",
        "        \".mov\": \"video\",\n",
        "        \".webm\": \"video\",\n",
        "        \".vob\": \"video\",\n",
        "        \".m4v\": \"video\",\n",
        "        \".mp3\": \"audio\",\n",
        "        \".wav\": \"audio\",\n",
        "        \".flac\": \"audio\",\n",
        "        \".aac\": \"audio\",\n",
        "        \".ogg\": \"audio\",\n",
        "        \".jpg\": \"photo\",\n",
        "        \".jpeg\": \"photo\",\n",
        "        \".png\": \"photo\",\n",
        "        \".bmp\": \"photo\",\n",
        "        \".gif\": \"photo\",\n",
        "    }\n",
        "    _, extension = ospath.splitext(file_path)\n",
        "\n",
        "    if extension.lower() in extensions_dict:\n",
        "        if extensions_dict[extension] == \"video\":\n",
        "            new_path = video_extension_fixer(file_path)\n",
        "        else:\n",
        "            new_path = file_path\n",
        "        return extensions_dict[extension], new_path\n",
        "    else:\n",
        "        return \"document\", file_path\n",
        "\n",
        "\n",
        "def shorterFileName(path):\n",
        "    if ospath.isfile(path):\n",
        "        dir_path, filename = ospath.split(path)\n",
        "        if len(filename) > 60:\n",
        "            basename, ext = ospath.splitext(filename)\n",
        "            basename = basename[: 60 - len(ext)]\n",
        "            filename = basename + ext\n",
        "            path = ospath.join(dir_path, filename)\n",
        "        return path\n",
        "    elif ospath.isdir(path):\n",
        "        dir_path, dirname = ospath.split(path)\n",
        "        if len(dirname) > 60:\n",
        "            dirname = dirname[:60]\n",
        "            path = ospath.join(dir_path, dirname)\n",
        "        return path\n",
        "    else:\n",
        "        if len(path) > 60:\n",
        "            path = path[:60]\n",
        "        return path\n",
        "\n",
        "\n",
        "def get_folder_size(folder_path):\n",
        "    if ospath.isfile(folder_path):\n",
        "        return ospath.getsize(folder_path)\n",
        "    else:\n",
        "        total_size = 0\n",
        "        for dirpath, _, filenames in os.walk(folder_path):\n",
        "            for f in filenames:\n",
        "                fp = ospath.join(dirpath, f)\n",
        "                total_size += ospath.getsize(fp)\n",
        "        return total_size\n",
        "\n",
        "\n",
        "def get_file_count(folder_path):\n",
        "    count = 0\n",
        "    for _, __, filenames in os.walk(folder_path):\n",
        "        for f_ in filenames:\n",
        "            count += 1\n",
        "    return count\n",
        "\n",
        "\n",
        "def video_extension_fixer(file_path):\n",
        "    _, f_name = ospath.split(file_path)\n",
        "    if f_name.endswith(\".mp4\") or f_name.endswith(\".mkv\"):\n",
        "        return file_path\n",
        "    else:\n",
        "        os.rename(file_path, ospath.join(file_path + \".mp4\"))\n",
        "        return ospath.join(file_path + \".mp4\")\n",
        "\n",
        "\n",
        "def Thumbnail_Maintainer(file_path):\n",
        "    thmb = f\"{d_path}/video_frame.jpg\"\n",
        "    if ospath.exists(thmb):\n",
        "        os.remove(thmb)\n",
        "    try:\n",
        "        fname, _ = ospath.splitext(ospath.basename(file_path))\n",
        "        ytdl_thmb = f\"{d_path}/ytdl_thumbnails/{fname}.webp\"\n",
        "        with VideoFileClip(file_path) as video:\n",
        "            if ospath.exists(custom_thumb):\n",
        "                return custom_thumb, video.duration\n",
        "            elif ospath.exists(ytdl_thmb):\n",
        "                return convert_to_jpg(ytdl_thmb), video.duration\n",
        "            else:\n",
        "                video.save_frame(thmb, t=math.floor(video.duration / 2))\n",
        "                return thmb, video.duration\n",
        "    except Exception as e:\n",
        "        print(f\"Thmb Gen ERROR: {e}\")\n",
        "        return thumb_path, 0\n",
        "\n",
        "\n",
        "def Thumbnail_Checker(dir_path):\n",
        "    for filename in os.listdir(dir_path):\n",
        "        _, ext = ospath.splitext(filename)\n",
        "        if ext in [\".png\", \".webp\", \".bmp\"]:\n",
        "            n_path = convert_to_jpg(ospath.join(dir_path, filename))\n",
        "            os.rename(n_path, custom_thumb)\n",
        "            return True\n",
        "        elif ext in [\".jpeg\", \".jpg\"]:\n",
        "            os.rename(ospath.join(dir_path, filename), custom_thumb)\n",
        "            return True\n",
        "    # No jpg file was found\n",
        "    return False\n",
        "\n",
        "\n",
        "def convert_to_jpg(image_path):\n",
        "    image = Image.open(image_path)\n",
        "    if image.mode != \"RGB\":\n",
        "        image = image.convert(\"RGB\")\n",
        "    output_path = ospath.splitext(image_path)[0] + \".jpg\"\n",
        "    image.save(output_path, \"JPEG\")\n",
        "    os.remove(image_path)\n",
        "    return output_path\n",
        "\n",
        "\n",
        "def system_info():\n",
        "    ram_usage = psutil.Process(os.getpid()).memory_info().rss\n",
        "    disk_usage = psutil.disk_usage(\"/\")\n",
        "    cpu_usage_percent = psutil.cpu_percent()\n",
        "\n",
        "    string = \"\\n\\n⍟───── [Colab Usage] ─────⍟\\n\"\n",
        "    string += f\"\\n╭🖥️ **CPU Usage »**  __{cpu_usage_percent}%__\"\n",
        "    string += f\"\\n├💽 **RAM Usage »**  __{size_measure(ram_usage)}__\"\n",
        "    string += f\"\\n╰💾 **DISK Free »**  __{size_measure(disk_usage.free)}__\"\n",
        "    string += f\"\\n\\n<i>💖 When I'm Doin This, Do Something Else ! **Because, Time Is Precious ✨**</i>\"\n",
        "\n",
        "    return string\n",
        "\n",
        "\n",
        "async def zip_folder(path):\n",
        "    dir_p, p_name = ospath.split(path)\n",
        "    r = \"-r\" if ospath.isdir(path) else \"\"\n",
        "    if len(custom_name) != 0:\n",
        "        name = custom_name\n",
        "    elif ospath.isfile(path):\n",
        "        name = ospath.basename(path)\n",
        "    else:\n",
        "        name = d_name\n",
        "    zip_msg = f\"<b>🔐 ZIPPING » </b>\\n\\n<code>{name}</code>\\n\"\n",
        "    starting_time = datetime.datetime.now()\n",
        "    cmd = f'cd \"{dir_p}\" && zip {r} -s 2000m -0 \"{temp_zpath}/{name}.zip\" \"{p_name}\"'\n",
        "    proc = subprocess.Popen(cmd, shell=True)\n",
        "    total = size_measure(get_folder_size(path))\n",
        "    while proc.poll() is None:\n",
        "        speed_string, eta, percentage = speed_eta(\n",
        "            starting_time, get_folder_size(temp_zpath), get_folder_size(path)\n",
        "        )\n",
        "        await status_bar(\n",
        "            zip_msg,\n",
        "            speed_string,\n",
        "            percentage,\n",
        "            convert_seconds(eta),\n",
        "            size_measure(get_folder_size(temp_zpath)),\n",
        "            total,\n",
        "            \"Xr-Zipp 🔒\",\n",
        "        )\n",
        "        time.sleep(1)\n",
        "    if ospath.isfile(path):\n",
        "        os.remove(path)\n",
        "    else:\n",
        "        shutil.rmtree(path)\n",
        "\n",
        "\n",
        "async def extract_zip(zip_filepath):\n",
        "    starting_time = datetime.datetime.now()\n",
        "    dirname, filename = ospath.split(zip_filepath)\n",
        "    unzip_msg = f\"<b>📂 EXTRACTING »</b>\\n\\n<code>{filename}</code>\\n\"\n",
        "    file_pattern = \"\"\n",
        "    p = f\"-p{z_pswd}\" if len(z_pswd) != 0 else \"\"\n",
        "    name, ext = ospath.splitext(filename)\n",
        "    if ext == \".rar\":\n",
        "        if \"part\" in name:\n",
        "            cmd = f\"unrar x -kb -idq {p} '{zip_filepath}' {temp_unzip_path}\"\n",
        "            file_pattern = \"rar\"\n",
        "        else:\n",
        "            cmd = f\"unrar x {p} '{zip_filepath}' {temp_unzip_path}\"\n",
        "\n",
        "    elif ext == \".tar\":\n",
        "        cmd = f\"tar -xvf '{zip_filepath}' -C {temp_unzip_path}\"\n",
        "    elif ext == \".gz\":\n",
        "        cmd = f\"tar -zxvf '{zip_filepath}' -C {temp_unzip_path}\"\n",
        "    else:\n",
        "        cmd = f\"7z x {p} '{zip_filepath}' -o{temp_unzip_path}\"\n",
        "        if ext == \".001\":\n",
        "            file_pattern = \"7z\"\n",
        "        elif ext == \".z01\":\n",
        "            file_pattern = \"zip\"\n",
        "\n",
        "    proc = subprocess.Popen(cmd, shell=True)\n",
        "    total = size_measure(get_folder_size(zip_filepath))\n",
        "    while proc.poll() is None:\n",
        "        speed_string, eta, percentage = speed_eta(\n",
        "            starting_time,\n",
        "            get_folder_size(temp_unzip_path),\n",
        "            get_folder_size(zip_filepath),\n",
        "        )\n",
        "        await status_bar(\n",
        "            unzip_msg,\n",
        "            speed_string,\n",
        "            percentage,\n",
        "            convert_seconds(eta),\n",
        "            size_measure(get_folder_size(temp_unzip_path)),\n",
        "            total,\n",
        "            \"Xr-Unzip 🔓\",\n",
        "        )\n",
        "        time.sleep(1)\n",
        "\n",
        "    # Deletes all remaining Multi Part Volumes\n",
        "    c = 1\n",
        "    if file_pattern == \"rar\":\n",
        "        name_, _ = ospath.splitext(name)\n",
        "        na_p = name_ + \".part\" + str(c) + \".rar\"\n",
        "        p_ap = ospath.join(dirname, na_p)\n",
        "        while ospath.exists(p_ap):\n",
        "            os.remove(p_ap)\n",
        "            c += 1\n",
        "            na_p = name_ + \".part\" + str(c) + \".rar\"\n",
        "            p_ap = ospath.join(dirname, na_p)\n",
        "\n",
        "    elif file_pattern == \"7z\":\n",
        "        na_p = name + \".\" + str(c).zfill(3)\n",
        "        p_ap = ospath.join(dirname, na_p)\n",
        "        while ospath.exists(p_ap):\n",
        "            os.remove(p_ap)\n",
        "            c += 1\n",
        "            na_p = name + \".\" + str(c).zfill(3)\n",
        "            p_ap = ospath.join(dirname, na_p)\n",
        "\n",
        "    elif file_pattern == \"zip\":\n",
        "        na_p = name + \".zip\"\n",
        "        p_ap = ospath.join(dirname, na_p)\n",
        "        if ospath.exists(p_ap):\n",
        "            os.remove(p_ap)\n",
        "        na_p = name + \".z\" + str(c).zfill(2)\n",
        "        p_ap = ospath.join(dirname, na_p)\n",
        "        while ospath.exists(p_ap):\n",
        "            os.remove(p_ap)\n",
        "            c += 1\n",
        "            na_p = name + \".z\" + str(c).zfill(2)\n",
        "            p_ap = ospath.join(dirname, na_p)\n",
        "\n",
        "    if ospath.exists(zip_filepath):\n",
        "        os.remove(zip_filepath)\n",
        "\n",
        "\n",
        "async def size_checker(file_path):\n",
        "    max_size = 2097152000  # 2 GB\n",
        "    file_size = os.stat(file_path).st_size\n",
        "\n",
        "    if file_size > max_size:\n",
        "        if not ospath.exists(temp_lpath):\n",
        "            makedirs(temp_lpath)\n",
        "        _, filename = ospath.split(file_path)\n",
        "        filename = filename.lower()\n",
        "        if (\n",
        "            filename.endswith(\".zip\")\n",
        "            or filename.endswith(\".rar\")\n",
        "            or filename.endswith(\".7z\")\n",
        "            or filename.endswith(\".tar\")\n",
        "            or filename.endswith(\".gz\")\n",
        "        ):\n",
        "            await split_zipFile(file_path, max_size)\n",
        "        else:\n",
        "            await zip_folder(file_path)\n",
        "            time.sleep(2)\n",
        "        return True\n",
        "    else:\n",
        "        return False\n",
        "\n",
        "\n",
        "async def split_zipFile(file_path, max_size):\n",
        "    starting_time = datetime.datetime.now()\n",
        "    _, filename = ospath.split(file_path)\n",
        "    new_path = f\"{temp_lpath}/{filename}\"\n",
        "    down_msg = f\"<b>✂️ SPLITTING » </b>\\n\\n<code>{filename}</code>\\n\"\n",
        "    # Get the total size of the file\n",
        "    total_size = ospath.getsize(file_path)\n",
        "    with open(file_path, \"rb\") as f:\n",
        "        chunk = f.read(max_size)\n",
        "        i = 1\n",
        "        bytes_written = 0\n",
        "        while chunk:\n",
        "            # Generate filename for this chunk\n",
        "            ext = str(i).zfill(3)\n",
        "            output_filename = \"{}.{}\".format(new_path, ext)\n",
        "\n",
        "            # Write chunk to file\n",
        "            with open(output_filename, \"wb\") as out:\n",
        "                out.write(chunk)\n",
        "\n",
        "            bytes_written += len(chunk)\n",
        "            speed_string, eta, percentage = speed_eta(\n",
        "                starting_time, bytes_written, total_size\n",
        "            )\n",
        "            await status_bar(\n",
        "                down_msg,\n",
        "                speed_string,\n",
        "                percentage,\n",
        "                convert_seconds(eta),\n",
        "                size_measure(bytes_written),\n",
        "                size_measure(total_size),\n",
        "                \"Xr-Split ✂️\",\n",
        "            )\n",
        "            # Get next chunk\n",
        "            chunk = f.read(max_size)\n",
        "            i += 1  # Increment chunk counter\n",
        "\n",
        "\n",
        "def is_time_over(current_time):\n",
        "    ten_sec_passed = time.time() - current_time[0] >= 3\n",
        "    if ten_sec_passed:\n",
        "        current_time[0] = time.time()\n",
        "    return ten_sec_passed\n",
        "\n",
        "\n",
        "def speed_eta(start, done, total):\n",
        "    percentage = (done / total) * 100\n",
        "    elapsed_time = (datetime.datetime.now() - start).seconds\n",
        "    if done > 0 and elapsed_time != 0:\n",
        "        raw_speed = done / elapsed_time\n",
        "        speed = f\"{size_measure(raw_speed)}/s\"\n",
        "        eta = (total - done) / raw_speed\n",
        "    else:\n",
        "        speed, eta = \"N/A\", 0\n",
        "    return speed, eta, percentage\n",
        "\n",
        "# =================================================================\n",
        "#    Telegram Upload Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "def keyboard():\n",
        "    return InlineKeyboardMarkup(\n",
        "        [\n",
        "            [  # First row\n",
        "                InlineKeyboardButton(  # Opens a web URL\n",
        "                    \"Git Repo 🪲\",\n",
        "                    url=\"https://github.com/XronTrix10/Telegram-Leecher\",\n",
        "                ),\n",
        "            ],\n",
        "        ]\n",
        "    )\n",
        "\n",
        "\n",
        "async def status_bar(down_msg, speed, percentage, eta, done, left, engine):\n",
        "    bar_length = 12\n",
        "    filled_length = int(percentage / 100 * bar_length)\n",
        "    # bar = \"⬢\" * filled_length + \"⬡\" * (bar_length - filled_length)\n",
        "    bar = \"█\" * filled_length + \"░\" * (bar_length - filled_length)\n",
        "    message = (\n",
        "        f\"\\n╭|{bar}| » __{percentage:.2f}%__\\n├⚡️ **Speed »** __{speed}__\\n├⚙️ **Engine »** __{engine}__\"\n",
        "        + f\"\\n├⏳ **Time Left »** __{eta}__\"\n",
        "        + f\"\\n├🍃 **Time Spent »** __{convert_seconds((datetime.datetime.now() - task_start).seconds)}__\"\n",
        "        + f\"\\n├✅ **Processed »** __{done}__\\n╰📦 **Total Size »** __{left}__\"\n",
        "    )\n",
        "    sys_text = system_info()\n",
        "    try:\n",
        "        print(f\"\\r{engine} ║ {bar} ║ {percentage:.2f}% ║ {speed} ║ ⏳ {eta}\", end=\"\")\n",
        "        # Edit the message with updated progress information.\n",
        "        if is_time_over(current_time):\n",
        "            await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=task_msg + down_msg + message + sys_text,\n",
        "                reply_markup=keyboard(),\n",
        "            )\n",
        "\n",
        "    except Exception as e:\n",
        "        # Catch any exceptions that might occur while editing the message.\n",
        "        print(f\"Error Updating Status bar: {str(e)}\")\n",
        "\n",
        "\n",
        "async def progress_bar(current, total):\n",
        "    upload_speed = 0\n",
        "    if current > 0:\n",
        "        elapsed_time_seconds = (datetime.datetime.now() - start_time).seconds\n",
        "        upload_speed = current / elapsed_time_seconds\n",
        "    eta = (total_down_size - current - sum(up_bytes)) / upload_speed\n",
        "    percentage = (current + sum(up_bytes)) / total_down_size * 100\n",
        "    await status_bar(\n",
        "        down_msg=text_msg,\n",
        "        speed=f\"{size_measure(upload_speed)}/s\",\n",
        "        percentage=percentage,\n",
        "        eta=convert_seconds(eta),\n",
        "        done=size_measure(current + sum(up_bytes)),\n",
        "        left=size_measure(total_down_size),\n",
        "        engine=\"Pyrogram 💥\",\n",
        "    )\n",
        "\n",
        "\n",
        "async def upload_file(file_path, real_name):\n",
        "    global sent\n",
        "\n",
        "    caption = f\"<code>{real_name}</code>\"\n",
        "    type_, file_path = get_file_type(file_path)\n",
        "    f_type = \"document\" if LEECH_DOCUMENT else type_\n",
        "\n",
        "    # Upload the file\n",
        "    try:\n",
        "        if f_type == \"video\":\n",
        "            thmb_path, seconds = Thumbnail_Maintainer(file_path)\n",
        "            with Image.open(thmb_path) as img:\n",
        "                width, height = img.size\n",
        "\n",
        "            sent = await sent.reply_video(\n",
        "                video=file_path,\n",
        "                supports_streaming=True,\n",
        "                width=width,\n",
        "                height=height,\n",
        "                caption=caption,\n",
        "                thumb=thmb_path,\n",
        "                duration=int(seconds),\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "            if thmb_path != custom_thumb:\n",
        "                os.remove(thmb_path)\n",
        "\n",
        "        elif f_type == \"audio\":\n",
        "            thmb_path = None if not ospath.exists(custom_thumb) else custom_thumb\n",
        "            sent = await sent.reply_audio(\n",
        "                audio=file_path,\n",
        "                caption=caption,\n",
        "                thumb=thmb_path,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        elif f_type == \"document\":\n",
        "            if ospath.exists(custom_thumb):\n",
        "                thmb_path = custom_thumb\n",
        "            elif type_ == \"video\":\n",
        "                thmb_path, _ = Thumbnail_Maintainer(file_path)\n",
        "            else:\n",
        "                thmb_path = None\n",
        "\n",
        "            sent = await sent.reply_document(\n",
        "                document=file_path,\n",
        "                caption=caption,\n",
        "                thumb=thmb_path,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        elif f_type == \"photo\":\n",
        "            sent = await sent.reply_photo(\n",
        "                photo=file_path,\n",
        "                caption=caption,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        clear_output()\n",
        "\n",
        "        sent_file.append(sent)\n",
        "        sent_fileName.append(real_name)\n",
        "\n",
        "    except Exception as e:\n",
        "        print(f\"Error When Uploading : {e}\")\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "async def Leecher(file_path):\n",
        "    global text_msg, start_time, msg, sent\n",
        "\n",
        "    leech = await size_checker(file_path)\n",
        "\n",
        "    if leech:  # File was splitted\n",
        "        if ospath.exists(file_path):\n",
        "            os.remove(file_path)  # Delete original Big Zip file\n",
        "\n",
        "        dir_list = natsorted(os.listdir(temp_lpath))\n",
        "\n",
        "        count = 1\n",
        "\n",
        "        for dir_path in dir_list:\n",
        "            short_path = ospath.join(temp_lpath, dir_path)\n",
        "            file_name = ospath.basename(short_path)\n",
        "            new_path = shorterFileName(short_path)\n",
        "            os.rename(short_path, new_path)\n",
        "            start_time = datetime.datetime.now()\n",
        "            current_time[0] = time.time()\n",
        "            text_msg = f\"<b>📤 UPLOADING SPLIT » {count} OF {len(dir_list)} Files</b>\\n\\n<code>{file_name}</code>\\n\"\n",
        "            try:\n",
        "                msg = await bot.edit_message_text(\n",
        "                    chat_id=chat_id,\n",
        "                    message_id=msg.id,\n",
        "                    text=task_msg + text_msg + \"\\n⏳ __Starting.....__\" + system_info(),\n",
        "                    reply_markup=keyboard(),\n",
        "                )\n",
        "            except Exception as d:\n",
        "                print(d)\n",
        "            await upload_file(new_path, file_name)\n",
        "            up_bytes.append(os.stat(new_path).st_size)\n",
        "\n",
        "            count += 1\n",
        "\n",
        "        shutil.rmtree(temp_lpath)\n",
        "\n",
        "    else:\n",
        "        file_name = ospath.basename(file_path)\n",
        "        # Trimming filename upto 50 chars\n",
        "        new_path = shorterFileName(file_path)\n",
        "        os.rename(file_path, new_path)\n",
        "        start_time = datetime.datetime.now()\n",
        "        current_time[0] = time.time()\n",
        "        text_msg = f\"<b>📤 UPLOADING » </b>\\n\\n<code>{file_name}</code>\\n\"\n",
        "        try:\n",
        "            msg = await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=task_msg + text_msg + \"\\n⏳ __Starting.....__\" + system_info(),\n",
        "                reply_markup=keyboard(),\n",
        "            )\n",
        "        except Exception as d:\n",
        "            print(d)\n",
        "        await upload_file(new_path, file_name)\n",
        "        up_bytes.append(os.stat(new_path).st_size)\n",
        "\n",
        "\n",
        "async def Leech(folder_path):\n",
        "    global total_down_size\n",
        "    total_down_size = get_folder_size(folder_path)\n",
        "    files = [str(p) for p in pathlib.Path(folder_path).glob(\"**/*\") if p.is_file()]\n",
        "    for f in natsorted(files):\n",
        "        file_path = ospath.join(folder_path, f)\n",
        "        await Leecher(file_path)\n",
        "\n",
        "    if ospath.exists(f\"{d_path}/ytdl_thumbnails\"):\n",
        "        shutil.rmtree(f\"{d_path}/ytdl_thumbnails\")\n",
        "\n",
        "\n",
        "async def ZipLeech(d_fol_path):\n",
        "    global msg, down_msg, start_time, total_down_size\n",
        "\n",
        "    down_msg = f\"<b>🔐 ZIPPING » </b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    try:\n",
        "        msg = await bot.edit_message_text(\n",
        "            chat_id=chat_id,\n",
        "            message_id=msg.id,\n",
        "            text=task_msg + down_msg + system_info(),\n",
        "        )\n",
        "    except Exception as e2:\n",
        "        print(f\"Problem in ZipLeech !{e2}\")\n",
        "\n",
        "    print(\"\\nNow ZIPPING the folder...\")\n",
        "    current_time[0] = time.time()\n",
        "    start_time = datetime.datetime.now()\n",
        "    if not ospath.exists(temp_zpath):\n",
        "        makedirs(temp_zpath)\n",
        "    await zip_folder(d_fol_path)\n",
        "    clear_output()\n",
        "    time.sleep(2)\n",
        "\n",
        "    total_down_size = get_folder_size(temp_zpath)\n",
        "    await Leech(temp_zpath)\n",
        "\n",
        "\n",
        "async def UnzipLeech(d_fol_path):\n",
        "    global msg\n",
        "\n",
        "    down_msg = f\"\\n<b>📂 EXTRACTING » </b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    msg = await bot.edit_message_text(\n",
        "        chat_id=chat_id,\n",
        "        message_id=msg.id,\n",
        "        text=task_msg + down_msg + \"\\n⏳ __Starting.....__\" + system_info(),\n",
        "    )\n",
        "    cant_files = []\n",
        "    filenames = [str(p) for p in pathlib.Path(d_fol_path).glob(\"**/*\") if p.is_file()]\n",
        "    for f in natsorted(filenames):\n",
        "        short_path = ospath.join(d_fol_path, f)\n",
        "        if not ospath.exists(temp_unzip_path):\n",
        "            makedirs(temp_unzip_path)\n",
        "        filename = ospath.basename(f).lower()\n",
        "        _, ext = ospath.splitext(filename)\n",
        "        try:\n",
        "            if ospath.exists(short_path):\n",
        "                if ext in [\".7z\", \".gz\", \".zip\", \".rar\", \".001\", \".tar\", \".z01\"]:\n",
        "                    await extract_zip(short_path)\n",
        "                    await Leech(temp_unzip_path)\n",
        "                else:\n",
        "                    cant_files.append(short_path)\n",
        "                    print(\n",
        "                        f\"Unable to Extract {ospath.basename(f)} ! Will be Leeching later !\"\n",
        "                    )\n",
        "        except Exception as e5:\n",
        "            print(f\"UZLeech Launcher Exception: {e5}\")\n",
        "\n",
        "    try:\n",
        "        for path in cant_files:\n",
        "            if ospath.exists(path):\n",
        "                await Leecher(path)\n",
        "    except Exception as e5:\n",
        "        print(f\"UZLeech Launcher Exception: {e5}\")\n",
        "\n",
        "\n",
        "async def UnDZipLeech(folder_path):\n",
        "    global msg, down_msg, start_time, total_down_size\n",
        "\n",
        "    down_msg = f\"\\n<b>📂 EXTRACTING » </b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    msg = await bot.edit_message_text(\n",
        "        chat_id=chat_id,\n",
        "        message_id=msg.id,\n",
        "        text=task_msg + down_msg + \"\\n⏳ __Starting.....__\" + system_info(),\n",
        "    )\n",
        "\n",
        "    filenames = [str(p) for p in pathlib.Path(folder_path).glob(\"**/*\") if p.is_file()]\n",
        "    for f in natsorted(filenames):\n",
        "        short_path = ospath.join(folder_path, f)\n",
        "        if not ospath.exists(temp_unzip_path):\n",
        "            makedirs(temp_unzip_path)\n",
        "        filename = ospath.basename(f).lower()\n",
        "        _, ext = ospath.splitext(filename)\n",
        "        try:\n",
        "            if ospath.exists(short_path):\n",
        "                if ext in [\".7z\", \".gz\", \".zip\", \".rar\", \".001\", \".tar\", \".z01\"]:\n",
        "                    await extract_zip(short_path)\n",
        "                else:\n",
        "                    shutil.move(short_path, temp_unzip_path)\n",
        "        except Exception as e5:\n",
        "            print(f\"UnDZLeech Launcher Exception: {e5}\")\n",
        "\n",
        "    await ZipLeech(temp_unzip_path)\n",
        "\n",
        "\n",
        "async def FinalStep(msg):\n",
        "    final_text = (\n",
        "        f\"<b>📂 Total Files:</b>  <code>{len(sent_file)}</code>\\n\\n<b>📜 LOG:</b>\\n\"\n",
        "    )\n",
        "    l_ink = \"⍟───── [Colab Leech] ─────⍟\"\n",
        "    last_text = (\n",
        "        f\"\\n\\n<b>{(task).upper()} COMPLETE 🔥</b>\\n\\n\"\n",
        "        + f\"╭<b>📛 Name » </b>  <code>{d_name}</code>\\n\"\n",
        "        + f\"├<b>📦 Size » </b><code>{size_measure(sum(up_bytes))}</code>\\n\"\n",
        "        + f\"├<b>☘️ File Count » </b><code>{len(sent_file)} Files</code>\\n\"\n",
        "        + f\"╰<b>🍃 Saved Time »</b> <code>{convert_seconds((datetime.datetime.now() - task_start).seconds)}</code>\"\n",
        "    )\n",
        "    src = f\"**SOURCE »** __[Links]({src_link})__\"\n",
        "    await bot.send_message(\n",
        "        chat_id=dump_id,\n",
        "        text=src + last_text,\n",
        "        reply_to_message_id=sent.id,\n",
        "    )\n",
        "\n",
        "    await bot.edit_message_text(\n",
        "        chat_id=chat_id,\n",
        "        message_id=msg.id,\n",
        "        text=task_msg + l_ink + last_text,\n",
        "        reply_markup=keyboard(),\n",
        "    )\n",
        "\n",
        "    try:\n",
        "        final_texts = []\n",
        "\n",
        "        for i in range(len(sent_file)):\n",
        "            file_link = f\"https://t.me/c/{link_p}/{sent_file[i].id}\"\n",
        "            fileName = sent_fileName[i]\n",
        "            fileText = f\"\\n({str(i+1).zfill(2)}) <a href={file_link}>{fileName}</a>\"\n",
        "            if len(final_text + fileText) >= 4096:\n",
        "                final_texts.append(final_text)\n",
        "                final_text = fileText\n",
        "            else:\n",
        "                final_text += fileText\n",
        "        final_texts.append(final_text)\n",
        "\n",
        "        for fn_txt in final_texts:\n",
        "            msg = await bot.send_message(\n",
        "                chat_id=chat_id, reply_to_message_id=msg.id, text=fn_txt\n",
        "            )\n",
        "    except Exception as e:\n",
        "        Err = f\"<b>Error Sending logs » </b><i>{e}</i>\"\n",
        "        await bot.send_message(chat_id=chat_id, reply_to_message_id=msg.id, text=Err)\n",
        "\n",
        "\n",
        "\n",
        "# ****************************************************************\n",
        "#    Main Functions, function calls and variable declarations\n",
        "# ****************************************************************\n",
        "api_id, chat_id, dump_id = int(API_ID), int(CHAT_ID), int(DUMP_ID)\n",
        "link_p = str(dump_id)[4:]\n",
        "custom_thumb = \"/content/thmb.jpg\"\n",
        "d_path = \"/content/bot_Folder\"\n",
        "d_name = \"\"\n",
        "d_fol_path = PATH\n",
        "temp_lpath = f\"{d_path}/Leeched_Files\"\n",
        "temp_unzip_path = f\"{d_path}/Unzipped_Files/\"\n",
        "temp_zpath = temp_lpath\n",
        "sent_file = []\n",
        "sent_fileName = []\n",
        "up_bytes = []\n",
        "up_bytes.append(0)\n",
        "current_time = []\n",
        "current_time.append(time.time())\n",
        "start_time = datetime.datetime.now()\n",
        "text_msg = \"\"\n",
        "choice, z_pswd = \"x\", \"\"\n",
        "\n",
        "if not Thumbnail_Checker(\"/content\"):\n",
        "    thumb_path = \"/content/Telegram-Leecher/custom_thmb.jpg\"\n",
        "    print(\"Didn't find thumbnail, So switching to default thumbnail\")\n",
        "else:\n",
        "    thumb_path = custom_thumb\n",
        "\n",
        "if ospath.exists(d_path):\n",
        "    shutil.rmtree(d_path)\n",
        "    makedirs(d_path)\n",
        "else:\n",
        "    makedirs(d_path)\n",
        "\n",
        "if len(LEECH_MODE) == 0:\n",
        "    while choice not in [\"1\", \"2\", \"3\", \"l\", \"z\", \"u\", \"4\", \"d\"]:\n",
        "        choice = input(\n",
        "            \"Choose the Operation:\\n\\n\\t[1 / L] Leech\\n\\t[2 / Z] Zipleech\\n\\t[3 / U] Unzipleech\\n\\t[4 / D] UnDoubleZipLeech\\n\\nEnter: \"\n",
        "        ).lower()\n",
        "        clear_output()\n",
        "        if choice not in [\"1\", \"2\", \"3\", \"l\", \"z\", \"u\", \"4\", \"d\"]:\n",
        "            print(f\"No Such Leech Mode '{choice}' ! Enter Option Correctly 🦥\\n\")\n",
        "else:\n",
        "    choice = LEECH_MODE.lower()\n",
        "\n",
        "if choice == \"1\" or choice == \"l\":\n",
        "    task = \"Leech\"\n",
        "elif choice == \"2\" or choice == \"z\":\n",
        "    task = \"Zipleech\"\n",
        "elif choice == \"3\" or choice == \"u\":\n",
        "    task = \"Unzipleech\"\n",
        "else:\n",
        "    task = \"UnDoubleZipleech\"\n",
        "leech_type = \"Document\" if LEECH_DOCUMENT else \"Media\"\n",
        "\n",
        "time.sleep(1)\n",
        "clear_output()\n",
        "print(f\"TASK MODE: {task} as {leech_type}\")\n",
        "\n",
        "if len(PASSWD) == 0 and choice in [\"3\", \"u\", \"4\", \"d\"]:\n",
        "    z_pswd = input(f\"Password For Unzip [ Enter 'E' for Empty ]: \")\n",
        "elif len(PASSWD) != 0:\n",
        "    z_pswd = PASSWD\n",
        "\n",
        "if z_pswd.lower() == \"e\":\n",
        "    z_pswd = \"\"\n",
        "\n",
        "custom_name = C_NAME\n",
        "d_name = os.path.basename(PATH)\n",
        "\n",
        "task_start = datetime.datetime.now()\n",
        "down_msg = f\"<b>📤 UPLOADING » </b>\\n\"\n",
        "task_msg = f\"<b>🦞 TASK MODE » </b><i>{task} as {leech_type}</i>\\n\\n\"\n",
        "\n",
        "dump_task = task_msg + \"<b>🖇️ SOURCES » </b>\"\n",
        "dump_task += f\"\\n\\n{PATH}\"\n",
        "cdt = datetime.datetime.now(pytz.timezone(\"Asia/Kolkata\"))\n",
        "dt = cdt.strftime(\" %d/%m/%Y\")\n",
        "dump_task += f\"\\n\\n<b>📆 Task Date » </b><i>{dt}</i>\"\n",
        "\n",
        "if not ospath.exists(d_fol_path):\n",
        "    raise Exception(f\"Provided PATH does not exist ! {d_fol_path}\")\n",
        "\n",
        "async with Client(\n",
        "    \"my_bot\", api_id=api_id, api_hash=API_HASH, bot_token=BOT_TOKEN\n",
        ") as bot:\n",
        "    try:\n",
        "        sent = await bot.send_message(chat_id=dump_id, text=dump_task)\n",
        "\n",
        "        src_link = f\"https://t.me/c/{link_p}/{sent.id}\"\n",
        "        task_msg += \"<b>🖇️ SOURCE » </b>\" + f\"__[Links]({src_link})__\\n\\n\"\n",
        "\n",
        "        msg = await bot.send_message(\n",
        "            chat_id=chat_id,\n",
        "            text=task_msg\n",
        "            + down_msg\n",
        "            + f\"\\n📝 __Preparing To UPLOAD...__\"\n",
        "            + system_info(),\n",
        "            reply_markup=keyboard(),\n",
        "        )\n",
        "        clear_output()\n",
        "        total_down_size = get_folder_size(d_fol_path)\n",
        "\n",
        "        if choice in [\"1\", \"l\"] and len(custom_name) != 0:\n",
        "            files = os.listdir(d_fol_path)\n",
        "            for file_ in files:\n",
        "                current_name = os.path.join(d_fol_path, file_)\n",
        "                new_name = os.path.join(d_fol_path, custom_name)\n",
        "                os.rename(current_name, new_name)\n",
        "\n",
        "        clear_output()\n",
        "\n",
        "        if choice == \"1\" or choice == \"l\":\n",
        "            await Leech(d_fol_path)\n",
        "        elif choice == \"2\" or choice == \"z\":\n",
        "            await ZipLeech(d_fol_path)\n",
        "        elif choice == \"3\" or choice == \"u\":\n",
        "            await UnzipLeech(d_fol_path)\n",
        "        else:\n",
        "            await UnDZipLeech(d_fol_path)\n",
        "\n",
        "        await FinalStep(msg)\n",
        "\n",
        "    except Exception as e:\n",
        "        clear_output()\n",
        "\n",
        "        Error_Text = (\n",
        "            \"⍟───── [Colab Leech] ─────⍟\\n\"\n",
        "            + f\"\\n<b>TASK FAILED TO COMPLETE 💔</b>\\n\\n╭<b>📛 Name » </b> <code>{d_name}</code>\\n├<b>🍃 Wasted Time » </b>\"\n",
        "            + f\"__{convert_seconds((datetime.datetime.now() - task_start).seconds)}__\\n\"\n",
        "            + f\"<b>╰🤔 Reason » </b>__{e}__\"\n",
        "        )\n",
        "        try:\n",
        "            await bot.delete_messages(chat_id=chat_id, message_ids=msg.id)\n",
        "            await bot.send_message(\n",
        "                chat_id=chat_id,\n",
        "                text=task_msg + Error_Text,\n",
        "                reply_markup=InlineKeyboardMarkup(\n",
        "                    [\n",
        "                        [\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"Report Issue 🥺\",\n",
        "                                url=\"https://github.com/XronTrix10/Telegram-Leecher/issues\",\n",
        "                            ),\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"Group Discuss 🤔\",\n",
        "                                url=\"https://t.me/Colab_Leecher_Discuss\",\n",
        "                            ),\n",
        "                        ],\n",
        "                    ]\n",
        "                ),\n",
        "            )\n",
        "        except Exception as d:\n",
        "            print(f\"Another Error Occured: {d}\")\n",
        "        print(f\"Error Occured: {e}\")\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "F5Y5LOUD0noW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# @title 🖥️ Main Colab Leech Code [ Click on RUN for Magic ✨ ]\n",
        "import os, io, re, sys, shutil, time, yt_dlp, math, pytz, psutil, threading, pickle, uvloop, pathlib, datetime, subprocess\n",
        "from PIL import Image\n",
        "from pyrogram import Client\n",
        "from natsort import natsorted\n",
        "from urllib.parse import urlparse\n",
        "from re import search as re_search\n",
        "from os import makedirs, path as ospath\n",
        "from IPython.display import clear_output\n",
        "from urllib.parse import parse_qs, urlparse\n",
        "from googleapiclient.discovery import build\n",
        "from googleapiclient.errors import HttpError\n",
        "from googleapiclient.http import MediaIoBaseDownload\n",
        "from moviepy.video.io.VideoFileClip import VideoFileClip\n",
        "from pyrogram.types import (\n",
        "    ReplyKeyboardMarkup,\n",
        "    InlineKeyboardMarkup,\n",
        "    InlineKeyboardButton,\n",
        ")\n",
        "\n",
        "uvloop.install()\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Local OS Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "def convert_seconds(seconds):\n",
        "    seconds = int(seconds)\n",
        "    days = seconds // (24 * 3600)\n",
        "    seconds = seconds % (24 * 3600)\n",
        "    hours = seconds // 3600\n",
        "    seconds %= 3600\n",
        "    minutes = seconds // 60\n",
        "    seconds %= 60\n",
        "\n",
        "    if days > 0:\n",
        "        return f\"{days}d {hours}h {minutes}m {seconds}s\"\n",
        "    elif hours > 0:\n",
        "        return f\"{hours}h {minutes}m {seconds}s\"\n",
        "    elif minutes > 0:\n",
        "        return f\"{minutes}m {seconds}s\"\n",
        "    else:\n",
        "        return f\"{seconds}s\"\n",
        "\n",
        "\n",
        "def size_measure(size):\n",
        "    if size > 1024 * 1024 * 1024 * 1024 * 1024:\n",
        "        siz = f\"{size/(1024**5):.2f} PiB\"\n",
        "    elif size > 1024 * 1024 * 1024 * 1024:\n",
        "        siz = f\"{size/(1024**4):.2f} TiB\"\n",
        "    elif size > 1024 * 1024 * 1024:\n",
        "        siz = f\"{size/(1024**3):.2f} GiB\"\n",
        "    elif size > 1024 * 1024:\n",
        "        siz = f\"{size/(1024**2):.2f} MiB\"\n",
        "    elif size > 1024:\n",
        "        siz = f\"{size/1024:.2f} KiB\"\n",
        "    else:\n",
        "        siz = f\"{size} B\"\n",
        "    return siz\n",
        "\n",
        "\n",
        "def get_file_type(file_path):\n",
        "    extensions_dict = {\n",
        "        \".mp4\": \"video\",\n",
        "        \".avi\": \"video\",\n",
        "        \".mkv\": \"video\",\n",
        "        \".mov\": \"video\",\n",
        "        \".webm\": \"video\",\n",
        "        \".vob\": \"video\",\n",
        "        \".m4v\": \"video\",\n",
        "        \".mp3\": \"audio\",\n",
        "        \".wav\": \"audio\",\n",
        "        \".flac\": \"audio\",\n",
        "        \".aac\": \"audio\",\n",
        "        \".ogg\": \"audio\",\n",
        "        \".jpg\": \"photo\",\n",
        "        \".jpeg\": \"photo\",\n",
        "        \".png\": \"photo\",\n",
        "        \".bmp\": \"photo\",\n",
        "        \".gif\": \"photo\",\n",
        "    }\n",
        "    _, extension = ospath.splitext(file_path)\n",
        "\n",
        "    if extension.lower() in extensions_dict:\n",
        "        if extensions_dict[extension] == \"video\":\n",
        "            new_path = video_extension_fixer(file_path)\n",
        "        else:\n",
        "            new_path = file_path\n",
        "        return extensions_dict[extension], new_path\n",
        "    else:\n",
        "        return \"document\", file_path\n",
        "\n",
        "\n",
        "def shorterFileName(path):\n",
        "    if ospath.isfile(path):\n",
        "        dir_path, filename = ospath.split(path)\n",
        "        if len(filename) > 60:\n",
        "            basename, ext = ospath.splitext(filename)\n",
        "            basename = basename[: 60 - len(ext)]\n",
        "            filename = basename + ext\n",
        "            path = ospath.join(dir_path, filename)\n",
        "        return path\n",
        "    elif ospath.isdir(path):\n",
        "        dir_path, dirname = ospath.split(path)\n",
        "        if len(dirname) > 60:\n",
        "            dirname = dirname[:60]\n",
        "            path = ospath.join(dir_path, dirname)\n",
        "        return path\n",
        "    else:\n",
        "        if len(path) > 60:\n",
        "            path = path[:60]\n",
        "        return path\n",
        "\n",
        "\n",
        "def get_folder_size(folder_path):\n",
        "    if ospath.isfile(folder_path):\n",
        "        return ospath.getsize(folder_path)\n",
        "    else:\n",
        "        total_size = 0\n",
        "        for dirpath, _, filenames in os.walk(folder_path):\n",
        "            for f in filenames:\n",
        "                fp = ospath.join(dirpath, f)\n",
        "                total_size += ospath.getsize(fp)\n",
        "        return total_size\n",
        "\n",
        "\n",
        "def get_file_count(folder_path):\n",
        "    count = 0\n",
        "    for _, __, filenames in os.walk(folder_path):\n",
        "        for f_ in filenames:\n",
        "            count += 1\n",
        "    return count\n",
        "\n",
        "\n",
        "def video_extension_fixer(file_path):\n",
        "    _, f_name = ospath.split(file_path)\n",
        "    if f_name.endswith(\".mp4\") or f_name.endswith(\".mkv\"):\n",
        "        return file_path\n",
        "    else:\n",
        "        os.rename(file_path, ospath.join(file_path + \".mp4\"))\n",
        "        return ospath.join(file_path + \".mp4\")\n",
        "\n",
        "\n",
        "def Thumbnail_Maintainer(file_path):\n",
        "    thmb = f\"{d_path}/video_frame.jpg\"\n",
        "    if ospath.exists(thmb):\n",
        "        os.remove(thmb)\n",
        "    try:\n",
        "        fname, _ = ospath.splitext(ospath.basename(file_path))\n",
        "        ytdl_thmb = f\"{d_path}/ytdl_thumbnails/{fname}.webp\"\n",
        "        with VideoFileClip(file_path) as video:\n",
        "            if ospath.exists(custom_thumb):\n",
        "                return custom_thumb, video.duration\n",
        "            elif ospath.exists(ytdl_thmb):\n",
        "                return convert_to_jpg(ytdl_thmb), video.duration\n",
        "            else:\n",
        "                video.save_frame(thmb, t=math.floor(video.duration / 2))\n",
        "                return thmb, video.duration\n",
        "    except Exception as e:\n",
        "        print(f\"Thmb Gen ERROR: {e}\")\n",
        "        return thumb_path, 0\n",
        "\n",
        "\n",
        "def Thumbnail_Checker(dir_path):\n",
        "    for filename in os.listdir(dir_path):\n",
        "        _, ext = ospath.splitext(filename)\n",
        "        if ext in [\".png\", \".webp\", \".bmp\"]:\n",
        "            n_path = convert_to_jpg(ospath.join(dir_path, filename))\n",
        "            os.rename(n_path, custom_thumb)\n",
        "            return True\n",
        "        elif ext in [\".jpeg\", \".jpg\"]:\n",
        "            os.rename(ospath.join(dir_path, filename), custom_thumb)\n",
        "            return True\n",
        "    # No jpg file was found\n",
        "    return False\n",
        "\n",
        "\n",
        "def convert_to_jpg(image_path):\n",
        "    image = Image.open(image_path)\n",
        "    if image.mode != \"RGB\":\n",
        "        image = image.convert(\"RGB\")\n",
        "    output_path = ospath.splitext(image_path)[0] + \".jpg\"\n",
        "    image.save(output_path, \"JPEG\")\n",
        "    os.remove(image_path)\n",
        "    return output_path\n",
        "\n",
        "\n",
        "def system_info():\n",
        "    ram_usage = psutil.Process(os.getpid()).memory_info().rss\n",
        "    disk_usage = psutil.disk_usage(\"/\")\n",
        "    cpu_usage_percent = psutil.cpu_percent()\n",
        "\n",
        "    string = \"\\n\\n⍟───── [Colab Usage] ─────⍟\\n\"\n",
        "    string += f\"\\n╭🖥️ **CPU Usage »**  __{cpu_usage_percent}%__\"\n",
        "    string += f\"\\n├💽 **RAM Usage »**  __{size_measure(ram_usage)}__\"\n",
        "    string += f\"\\n╰💾 **DISK Free »**  __{size_measure(disk_usage.free)}__\"\n",
        "    string += f\"\\n\\n<i>💖 When I'm Doin This, Do Something Else ! **Because, Time Is Precious ✨**</i>\"\n",
        "\n",
        "    return string\n",
        "\n",
        "\n",
        "async def zip_folder(path):\n",
        "    dir_p, p_name = ospath.split(path)\n",
        "    r = \"-r\" if ospath.isdir(path) else \"\"\n",
        "    if len(custom_name) != 0:\n",
        "        name = custom_name\n",
        "    elif ospath.isfile(path):\n",
        "        name = ospath.basename(path)\n",
        "    else:\n",
        "        name = d_name\n",
        "    zip_msg = f\"<b>🔐 ZIPPING » </b>\\n\\n<code>{name}</code>\\n\"\n",
        "    starting_time = datetime.datetime.now()\n",
        "    cmd = f'cd \"{dir_p}\" && zip {r} -s 2000m -0 \"{temp_zpath}/{name}.zip\" \"{p_name}\"'\n",
        "    proc = subprocess.Popen(cmd, shell=True)\n",
        "    total = size_measure(get_folder_size(path))\n",
        "    while proc.poll() is None:\n",
        "        speed_string, eta, percentage = speed_eta(\n",
        "            starting_time, get_folder_size(temp_zpath), get_folder_size(path)\n",
        "        )\n",
        "        await status_bar(\n",
        "            zip_msg,\n",
        "            speed_string,\n",
        "            percentage,\n",
        "            convert_seconds(eta),\n",
        "            size_measure(get_folder_size(temp_zpath)),\n",
        "            total,\n",
        "            \"Xr-Zipp 🔒\",\n",
        "        )\n",
        "        time.sleep(1)\n",
        "    if ospath.isfile(path):\n",
        "        os.remove(path)\n",
        "    else:\n",
        "        shutil.rmtree(path)\n",
        "\n",
        "\n",
        "async def extract_zip(zip_filepath):\n",
        "    starting_time = datetime.datetime.now()\n",
        "    dirname, filename = ospath.split(zip_filepath)\n",
        "    unzip_msg = f\"<b>📂 EXTRACTING »</b>\\n\\n<code>{filename}</code>\\n\"\n",
        "    file_pattern = \"\"\n",
        "    p = f\"-p{z_pswd}\" if len(z_pswd) != 0 else \"\"\n",
        "    name, ext = ospath.splitext(filename)\n",
        "    if ext == \".rar\":\n",
        "        if \"part\" in name:\n",
        "            cmd = f\"unrar x -kb -idq {p} '{zip_filepath}' {temp_unzip_path}\"\n",
        "            file_pattern = \"rar\"\n",
        "        else:\n",
        "            cmd = f\"unrar x {p} '{zip_filepath}' {temp_unzip_path}\"\n",
        "\n",
        "    elif ext == \".tar\":\n",
        "        cmd = f\"tar -xvf '{zip_filepath}' -C {temp_unzip_path}\"\n",
        "    elif ext == \".gz\":\n",
        "        cmd = f\"tar -zxvf '{zip_filepath}' -C {temp_unzip_path}\"\n",
        "    else:\n",
        "        cmd = f\"7z x {p} '{zip_filepath}' -o{temp_unzip_path}\"\n",
        "        if ext == \".001\":\n",
        "            file_pattern = \"7z\"\n",
        "        elif ext == \".z01\":\n",
        "            file_pattern = \"zip\"\n",
        "\n",
        "    proc = subprocess.Popen(cmd, shell=True)\n",
        "    total = size_measure(get_folder_size(zip_filepath))\n",
        "    while proc.poll() is None:\n",
        "        speed_string, eta, percentage = speed_eta(\n",
        "            starting_time,\n",
        "            get_folder_size(temp_unzip_path),\n",
        "            get_folder_size(zip_filepath),\n",
        "        )\n",
        "        await status_bar(\n",
        "            unzip_msg,\n",
        "            speed_string,\n",
        "            percentage,\n",
        "            convert_seconds(eta),\n",
        "            size_measure(get_folder_size(temp_unzip_path)),\n",
        "            total,\n",
        "            \"Xr-Unzip 🔓\",\n",
        "        )\n",
        "        time.sleep(1)\n",
        "\n",
        "    # Deletes all remaining Multi Part Volumes\n",
        "    c = 1\n",
        "    if file_pattern == \"rar\":\n",
        "        name_, _ = ospath.splitext(name)\n",
        "        na_p = name_ + \".part\" + str(c) + \".rar\"\n",
        "        p_ap = ospath.join(dirname, na_p)\n",
        "        while ospath.exists(p_ap):\n",
        "            os.remove(p_ap)\n",
        "            c += 1\n",
        "            na_p = name_ + \".part\" + str(c) + \".rar\"\n",
        "            p_ap = ospath.join(dirname, na_p)\n",
        "\n",
        "    elif file_pattern == \"7z\":\n",
        "        na_p = name + \".\" + str(c).zfill(3)\n",
        "        p_ap = ospath.join(dirname, na_p)\n",
        "        while ospath.exists(p_ap):\n",
        "            os.remove(p_ap)\n",
        "            c += 1\n",
        "            na_p = name + \".\" + str(c).zfill(3)\n",
        "            p_ap = ospath.join(dirname, na_p)\n",
        "\n",
        "    elif file_pattern == \"zip\":\n",
        "        na_p = name + \".zip\"\n",
        "        p_ap = ospath.join(dirname, na_p)\n",
        "        if ospath.exists(p_ap):\n",
        "            os.remove(p_ap)\n",
        "        na_p = name + \".z\" + str(c).zfill(2)\n",
        "        p_ap = ospath.join(dirname, na_p)\n",
        "        while ospath.exists(p_ap):\n",
        "            os.remove(p_ap)\n",
        "            c += 1\n",
        "            na_p = name + \".z\" + str(c).zfill(2)\n",
        "            p_ap = ospath.join(dirname, na_p)\n",
        "\n",
        "    if ospath.exists(zip_filepath):\n",
        "        os.remove(zip_filepath)\n",
        "\n",
        "\n",
        "async def size_checker(file_path):\n",
        "    max_size = 2097152000  # 2 GB\n",
        "    file_size = os.stat(file_path).st_size\n",
        "\n",
        "    if file_size > max_size:\n",
        "        if not ospath.exists(temp_lpath):\n",
        "            makedirs(temp_lpath)\n",
        "        _, filename = ospath.split(file_path)\n",
        "        filename = filename.lower()\n",
        "        if (\n",
        "            filename.endswith(\".zip\")\n",
        "            or filename.endswith(\".rar\")\n",
        "            or filename.endswith(\".7z\")\n",
        "            or filename.endswith(\".tar\")\n",
        "            or filename.endswith(\".gz\")\n",
        "        ):\n",
        "            await split_zipFile(file_path, max_size)\n",
        "        else:\n",
        "            await zip_folder(file_path)\n",
        "            time.sleep(2)\n",
        "        return True\n",
        "    else:\n",
        "        return False\n",
        "\n",
        "\n",
        "async def split_zipFile(file_path, max_size):\n",
        "    starting_time = datetime.datetime.now()\n",
        "    _, filename = ospath.split(file_path)\n",
        "    new_path = f\"{temp_lpath}/{filename}\"\n",
        "    down_msg = f\"<b>✂️ SPLITTING » </b>\\n\\n<code>{filename}</code>\\n\"\n",
        "    # Get the total size of the file\n",
        "    total_size = ospath.getsize(file_path)\n",
        "    with open(file_path, \"rb\") as f:\n",
        "        chunk = f.read(max_size)\n",
        "        i = 1\n",
        "        bytes_written = 0\n",
        "        while chunk:\n",
        "            # Generate filename for this chunk\n",
        "            ext = str(i).zfill(3)\n",
        "            output_filename = \"{}.{}\".format(new_path, ext)\n",
        "\n",
        "            # Write chunk to file\n",
        "            with open(output_filename, \"wb\") as out:\n",
        "                out.write(chunk)\n",
        "\n",
        "            bytes_written += len(chunk)\n",
        "            speed_string, eta, percentage = speed_eta(\n",
        "                starting_time, bytes_written, total_size\n",
        "            )\n",
        "            await status_bar(\n",
        "                down_msg,\n",
        "                speed_string,\n",
        "                percentage,\n",
        "                convert_seconds(eta),\n",
        "                size_measure(bytes_written),\n",
        "                size_measure(total_size),\n",
        "                \"Xr-Split ✂️\",\n",
        "            )\n",
        "            # Get next chunk\n",
        "            chunk = f.read(max_size)\n",
        "            i += 1  # Increment chunk counter\n",
        "\n",
        "\n",
        "def is_time_over(current_time):\n",
        "    ten_sec_passed = time.time() - current_time[0] >= 3\n",
        "    if ten_sec_passed:\n",
        "        current_time[0] = time.time()\n",
        "    return ten_sec_passed\n",
        "\n",
        "\n",
        "def speed_eta(start, done, total):\n",
        "    percentage = (done / total) * 100\n",
        "    elapsed_time = (datetime.datetime.now() - start).seconds\n",
        "    if done > 0 and elapsed_time != 0:\n",
        "        raw_speed = done / elapsed_time\n",
        "        speed = f\"{size_measure(raw_speed)}/s\"\n",
        "        eta = (total - done) / raw_speed\n",
        "    else:\n",
        "        speed, eta = \"N/A\", 0\n",
        "    return speed, eta, percentage\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Direct Link Handler Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "async def on_output(output: str):\n",
        "    # print(\"=\" * 60 + f\"\\n\\n{output}\\n\\n\" + \"*\" * 60)\n",
        "    global link_info\n",
        "    total_size = \"0B\"\n",
        "    progress_percentage = \"0B\"\n",
        "    downloaded_bytes = \"0B\"\n",
        "    eta = \"0S\"\n",
        "    try:\n",
        "        if \"ETA:\" in output:\n",
        "            parts = output.split()\n",
        "            total_size = parts[1].split(\"/\")[1]\n",
        "            total_size = total_size.split(\"(\")[0]\n",
        "            progress_percentage = parts[1][parts[1].find(\"(\") + 1 : parts[1].find(\")\")]\n",
        "            downloaded_bytes = parts[1].split(\"/\")[0]\n",
        "            eta = parts[4].split(\":\")[1][:-1]\n",
        "    except Exception as do:\n",
        "        print(f\"Could't Get Info Due to: {do}\")\n",
        "\n",
        "    percentage = re.findall(\"\\d+\\.\\d+|\\d+\", progress_percentage)[0]\n",
        "    down = re.findall(\"\\d+\\.\\d+|\\d+\", downloaded_bytes)[0]\n",
        "    down_unit = re.findall(\"[a-zA-Z]+\", downloaded_bytes)[0]\n",
        "    if \"G\" in down_unit:\n",
        "        spd = 3\n",
        "    elif \"M\" in down_unit:\n",
        "        spd = 2\n",
        "    elif \"K\" in down_unit:\n",
        "        spd = 1\n",
        "    else:\n",
        "        spd = 0\n",
        "\n",
        "    elapsed_time_seconds = (datetime.datetime.now() - start_time).seconds\n",
        "\n",
        "    if elapsed_time_seconds >= 270 and not link_info:\n",
        "        raise Exception(\"Failed to get download information ! Probably dead link 💀\")\n",
        "    # Only Do this if got Information\n",
        "    if total_size != \"0B\":\n",
        "        # Calculate download speed\n",
        "        link_info = True\n",
        "        current_speed = (float(down) * 1024**spd) / elapsed_time_seconds\n",
        "        speed_string = f\"{size_measure(current_speed)}/s\"\n",
        "\n",
        "        await status_bar(\n",
        "            down_msg,\n",
        "            speed_string,\n",
        "            int(percentage),\n",
        "            eta,\n",
        "            downloaded_bytes,\n",
        "            total_size,\n",
        "            \"Aria2c 🧨\",\n",
        "        )\n",
        "\n",
        "\n",
        "async def aria2_Download(link, num):\n",
        "    global start_time, down_msg\n",
        "    name_d = get_Aria2c_Name(link)\n",
        "    start_time = datetime.datetime.now()\n",
        "    down_msg = f\"<b>📥 DOWNLOADING FROM » </b><i>🔗Link {str(num).zfill(2)}</i>\\n\\n<b>🏷️ Name » </b><code>{name_d}</code>\\n\"\n",
        "\n",
        "    # Create a command to run aria2p with the link\n",
        "    command = [\n",
        "        \"aria2c\",\n",
        "        \"-x16\",\n",
        "        \"--seed-time=0\",\n",
        "        \"--summary-interval=1\",\n",
        "        \"--max-tries=3\",\n",
        "        \"--console-log-level=notice\",\n",
        "        \"-d\",\n",
        "        d_fol_path,\n",
        "        link,\n",
        "    ]\n",
        "\n",
        "    # Run the command using subprocess.Popen\n",
        "    proc = subprocess.Popen(\n",
        "        command, bufsize=0, stdout=subprocess.PIPE, stderr=subprocess.PIPE\n",
        "    )\n",
        "\n",
        "    # Read and print output in real-time\n",
        "    while True:\n",
        "        output = proc.stdout.readline()\n",
        "        if output == b\"\" and proc.poll() is not None:\n",
        "            break\n",
        "        if output:\n",
        "            # sys.stdout.write(output.decode(\"utf-8\"))\n",
        "            # sys.stdout.flush()\n",
        "            await on_output(output.decode(\"utf-8\"))\n",
        "\n",
        "    # Retrieve exit code and any error output\n",
        "    exit_code = proc.wait()\n",
        "    error_output = proc.stderr.read()\n",
        "    if exit_code != 0:\n",
        "        if exit_code == 3:\n",
        "            raise Exception(f\"The Resource was Not Found in {link}\")\n",
        "        elif exit_code == 9:\n",
        "            raise Exception(f\"Not enough disk space available\")\n",
        "        elif exit_code == 24:\n",
        "            raise Exception(f\"HTTP authorization failed.\")\n",
        "        else:\n",
        "            raise Exception(\n",
        "                f\"aria2c download failed with return code {exit_code} for {link}.\\nError: {error_output}\"\n",
        "            )\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Telegram Downloader\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "async def media_Identifier(link):\n",
        "    parts = link.split(\"/\")\n",
        "    message_id = parts[-1]\n",
        "    msg_chat_id = \"-100\" + parts[4]\n",
        "    message_id, msg_chat_id = int(message_id), int(msg_chat_id)\n",
        "    message = await bot.get_messages(msg_chat_id, message_id)\n",
        "\n",
        "    media = (\n",
        "        message.document\n",
        "        or message.photo\n",
        "        or message.video\n",
        "        or message.audio\n",
        "        or message.voice\n",
        "        or message.video_note\n",
        "        or message.sticker\n",
        "        or message.animation\n",
        "        or None\n",
        "    )\n",
        "    if media is None:\n",
        "        raise Exception(\"Couldn't Download Telegram Message\")\n",
        "    return media, message\n",
        "\n",
        "\n",
        "async def download_progress(current, total):\n",
        "    speed_string, eta, percentage = speed_eta(start_time, current, total)\n",
        "\n",
        "    await status_bar(\n",
        "        down_msg=down_msg,\n",
        "        speed=speed_string,\n",
        "        percentage=percentage,\n",
        "        eta=convert_seconds(eta),\n",
        "        done=size_measure(sum(down_bytes) + current),\n",
        "        left=size_measure(folder_info[0]),\n",
        "        engine=\"Pyrogram 💥\",\n",
        "    )\n",
        "\n",
        "\n",
        "async def TelegramDownload(link, num):\n",
        "    global start_time, down_msg\n",
        "    media, message = await media_Identifier(link)\n",
        "    if media is not None:\n",
        "        name = media.file_name if hasattr(media, \"file_name\") else \"None\"\n",
        "    else:\n",
        "        raise Exception(\"Couldn't Download Telegram Message\")\n",
        "\n",
        "    down_msg = f\"<b>📥 DOWNLOADING FROM » </b><i>🔗Link {str(num).zfill(2)}</i>\\n\\n<code>{name}</code>\\n\"\n",
        "    start_time = datetime.datetime.now()\n",
        "    file_path = ospath.join(d_fol_path, name)\n",
        "    await message.download(\n",
        "        progress=download_progress, in_memory=False, file_name=file_path\n",
        "    )\n",
        "    down_bytes.append(media.file_size)\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Youtube Link Handler Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "async def YTDL_Status(link, num):\n",
        "    global down_msg\n",
        "    name = get_YT_Name(link)\n",
        "    down_msg = f\"<b>📥 DOWNLOADING FROM » </b><i>🔗Link {str(num).zfill(2)}</i>\\n\\n<code>{name}</code>\\n\"\n",
        "\n",
        "    YTDL_Thread = threading.Thread(target=YouTubeDL, name=\"YouTubeDL\", args=(link,))\n",
        "    YTDL_Thread.start()\n",
        "\n",
        "    while YTDL_Thread.is_alive():  # Until ytdl is downloading\n",
        "        if ytdl_status[0]:\n",
        "            sys_text = system_info()\n",
        "            message = ytdl_status[0]\n",
        "            try:\n",
        "                await bot.edit_message_text(\n",
        "                    chat_id=chat_id,\n",
        "                    message_id=msg.id,\n",
        "                    text=task_msg + down_msg + message + sys_text,\n",
        "                    reply_markup=keyboard(),\n",
        "                )\n",
        "            except Exception as f:\n",
        "                pass\n",
        "        else:\n",
        "            try:\n",
        "                message = ytdl_status[1].split(\"@\")\n",
        "                await status_bar(\n",
        "                    down_msg=down_msg,\n",
        "                    speed=message[0],\n",
        "                    percentage=float(message[1]),\n",
        "                    eta=message[2],\n",
        "                    done=message[3],\n",
        "                    left=message[4],\n",
        "                    engine=\"Xr-YtDL 🏮\",\n",
        "                )\n",
        "            except Exception as f:\n",
        "                pass\n",
        "\n",
        "        time.sleep(2.5)\n",
        "\n",
        "\n",
        "class MyLogger:\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def debug(self, msg):\n",
        "        global ytdl_status\n",
        "        if \"item\" in str(msg):\n",
        "            msgs = msg.split(\" \")\n",
        "            ytdl_status[0] = f\"\\n⏳ __Getting Video Information {msgs[-3]} of {msgs[-1]}__\"\n",
        "\n",
        "    @staticmethod\n",
        "    def warning(msg):\n",
        "        pass\n",
        "\n",
        "    @staticmethod\n",
        "    def error(msg):\n",
        "        # if msg != \"ERROR: Cancelling...\":\n",
        "        # print(msg)\n",
        "        pass\n",
        "\n",
        "\n",
        "def YouTubeDL(url):\n",
        "    global ytdl_status\n",
        "\n",
        "    def my_hook(d):\n",
        "        global ytdl_status\n",
        "\n",
        "        if d[\"status\"] == \"downloading\":\n",
        "            if d.get(\"total_bytes\"):\n",
        "                total_bytes = d[\"total_bytes\"]\n",
        "            elif d.get(\"total_bytes_estimate\"):\n",
        "                total_bytes = d[\"total_bytes_estimate\"]\n",
        "            else:\n",
        "                total_bytes = 0\n",
        "            dl_bytes = d.get(\"downloaded_bytes\", 0)\n",
        "            percent = d.get(\"downloaded_percent\", 0)\n",
        "            speed = d.get(\"speed\", \"N/A\")\n",
        "            eta = d.get(\"eta\", 0)\n",
        "\n",
        "            if percent == 0 and total_bytes != 0:\n",
        "                percent = round((float(dl_bytes) * 100 / float(total_bytes)), 2)\n",
        "\n",
        "            # print(\n",
        "            #     f\"\\rDL: {size_measure(dl_bytes)}/{size_measure(total_bytes)} | {percent}% | Speed: {size_measure(speed)}/s | ETA: {eta}\",\n",
        "            #     end=\"\",\n",
        "            # )\n",
        "            ytdl_status[0] = False\n",
        "            ytdl_status[\n",
        "                1\n",
        "            ] = f\"{size_measure(speed)}/s@{percent}@{convert_seconds(eta)}@{size_measure(dl_bytes)}@{size_measure(total_bytes)}\"\n",
        "\n",
        "        elif d[\"status\"] == \"downloading fragment\":\n",
        "            # log_str = d[\"message\"]\n",
        "            # print(log_str, end=\"\")\n",
        "            pass\n",
        "\n",
        "    ydl_opts = {\n",
        "        \"format\": \"bestvideo[ext=mp4]+bestaudio[ext=m4a]/mp4\",\n",
        "        \"allow_multiple_video_streams\": True,\n",
        "        \"allow_multiple_audio_streams\": True,\n",
        "        \"writethumbnail\": True,\n",
        "        \"allow_playlist_files\": True,\n",
        "        \"overwrites\": True,\n",
        "        \"postprocessors\": [{\"key\": \"FFmpegVideoConvertor\", \"preferedformat\": \"mp4\"}],\n",
        "        \"progress_hooks\": [my_hook],\n",
        "        \"logger\": MyLogger(),\n",
        "    }\n",
        "\n",
        "    with yt_dlp.YoutubeDL(ydl_opts) as ydl:\n",
        "        if not ospath.exists(f\"{d_path}/ytdl_thumbnails\"):\n",
        "            makedirs(f\"{d_path}/ytdl_thumbnails\")\n",
        "        try:\n",
        "            info_dict = ydl.extract_info(url, download=False)\n",
        "            ytdl_status[0] = \"⌛ __Please WAIT a bit...__\"\n",
        "            if \"_type\" in info_dict and info_dict[\"_type\"] == \"playlist\":\n",
        "                playlist_name = info_dict[\"title\"]\n",
        "                if not ospath.exists(ospath.join(d_fol_path, playlist_name)):\n",
        "                    makedirs(ospath.join(d_fol_path, playlist_name))\n",
        "                ydl_opts[\"outtmpl\"] = {\n",
        "                    \"default\": f\"{d_fol_path}/{playlist_name}/%(title)s.%(ext)s\",\n",
        "                    \"thumbnail\": f\"{d_path}/ytdl_thumbnails/%(title)s.%(ext)s\",\n",
        "                }\n",
        "                for entry in info_dict[\"entries\"]:\n",
        "                    video_url = entry[\"webpage_url\"]\n",
        "                    ydl.download([video_url])\n",
        "            else:\n",
        "                ytdl_status[0] = False\n",
        "                ydl_opts[\"outtmpl\"] = {\n",
        "                    \"default\": f\"{d_fol_path}/%(title)s.%(ext)s\",\n",
        "                    \"thumbnail\": f\"{d_path}/ytdl_thumbnails/%(title)s.%(ext)s\",\n",
        "                }\n",
        "                ydl.download([url])\n",
        "        except Exception as e:\n",
        "            print(f\"YTDL ERROR: {e}\")\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Initiator Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "async def calG_DownSize(links):\n",
        "    for link in natsorted(links):\n",
        "        if \"drive.google.com\" in link:\n",
        "            id = getIDFromURL(link)\n",
        "            try:\n",
        "                meta = getFileMetadata(id)\n",
        "            except Exception as e:\n",
        "                if \"File not found\" in str(e):\n",
        "                    raise Exception(\n",
        "                        \"The file link you gave either doesn't exist or You don't have access to it!\"\n",
        "                    )\n",
        "                elif \"Failed to retrieve\" in str(e):\n",
        "                    clear_output()\n",
        "                    raise Exception(\n",
        "                        \"Authorization Error with Google ! Make Sure you uploaded token.pickle !\"\n",
        "                    )\n",
        "                else:\n",
        "                    raise Exception(f\"Error in G-API: {e}\")\n",
        "            if meta.get(\"mimeType\") == \"application/vnd.google-apps.folder\":\n",
        "                folder_info[0] += get_Gfolder_size(id)\n",
        "            else:\n",
        "                folder_info[0] += int(meta[\"size\"])\n",
        "        elif \"t.me\" in link:\n",
        "            media, _ = await media_Identifier(link)\n",
        "            if media is not None:\n",
        "                size = media.file_size\n",
        "                folder_info[0] += size\n",
        "            else:\n",
        "                raise Exception(\"Couldn't Download Telegram Message\")\n",
        "        else:\n",
        "            pass\n",
        "\n",
        "\n",
        "def get_Aria2c_Name(link):\n",
        "    cmd = f'aria2c -x10 --dry-run --file-allocation=none \"{link}\"'\n",
        "    result = subprocess.run(cmd, stdout=subprocess.PIPE, shell=True)\n",
        "    stdout_str = result.stdout.decode(\"utf-8\")\n",
        "    filename = stdout_str.split(\"complete: \")[-1].split(\"\\n\")[0]\n",
        "    name = filename.split(\"/\")[-1]\n",
        "    if len(name) == 0:\n",
        "        name = \"UNKNOWN DOWNLOAD NAME\"\n",
        "    return name\n",
        "\n",
        "\n",
        "def get_YT_Name(link):\n",
        "    with yt_dlp.YoutubeDL({\"logger\": MyLogger()}) as ydl:\n",
        "        info = ydl.extract_info(link, download=False)\n",
        "        if \"title\" in info:\n",
        "            return info[\"title\"]\n",
        "        else:\n",
        "            return \"UNKNOWN DOWNLOAD NAME\"\n",
        "\n",
        "\n",
        "async def get_d_name(link):\n",
        "    global d_name\n",
        "    if custom_name:\n",
        "        d_name = custom_name\n",
        "        return\n",
        "    if \"drive.google.com\" in link:\n",
        "        id = getIDFromURL(link)\n",
        "        meta = getFileMetadata(id)\n",
        "        d_name = meta[\"name\"]\n",
        "    elif \"t.me\" in link:\n",
        "        media, _ = await media_Identifier(link)\n",
        "        d_name = media.file_name if hasattr(media, \"file_name\") else \"None\"\n",
        "    elif \"youtube.com\" in link or \"youtu.be\" in link:\n",
        "        d_name = get_YT_Name(link)\n",
        "    else:\n",
        "        d_name = get_Aria2c_Name(link)\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    G Drive Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "def build_service():\n",
        "    # create credentials object from token.pickle file\n",
        "    creds = None\n",
        "    if ospath.exists(\"/content/token.pickle\"):\n",
        "        with open(\"/content/token.pickle\", \"rb\") as token:\n",
        "            creds = pickle.load(token)\n",
        "    else:\n",
        "        exit(1)\n",
        "\n",
        "    # create drive API client\n",
        "    service = build(\"drive\", \"v3\", credentials=creds)\n",
        "\n",
        "    return service\n",
        "\n",
        "\n",
        "async def g_DownLoad(link, num):\n",
        "    global start_time, down_msg\n",
        "    down_msg = f\"<b>📥 DOWNLOADING FROM » </b><i>🔗Link {str(num).zfill(2)}</i>\\n\\n<b>🏷️ Name » </b><code>{d_name}</code>\\n\"\n",
        "    file_id = getIDFromURL(link)\n",
        "    meta = getFileMetadata(file_id)\n",
        "\n",
        "    if meta.get(\"mimeType\") == \"application/vnd.google-apps.folder\":\n",
        "        await gDownloadFolder(file_id, d_fol_path)\n",
        "    else:\n",
        "        await gDownloadFile(file_id, d_fol_path)\n",
        "        clear_output()\n",
        "\n",
        "\n",
        "def getIDFromURL(link: str):\n",
        "    if \"folders\" in link or \"file\" in link:\n",
        "        regex = r\"https:\\/\\/drive\\.google\\.com\\/(?:drive(.*?)\\/folders\\/|file(.*?)?\\/d\\/)([-\\w]+)\"\n",
        "        res = re_search(regex, link)\n",
        "        if res is None:\n",
        "            raise IndexError(\"G-Drive ID not found.\")\n",
        "        return res.group(3)\n",
        "    parsed = urlparse(link)\n",
        "    return parse_qs(parsed.query)[\"id\"][0]\n",
        "\n",
        "\n",
        "def getFilesByFolderID(folder_id):\n",
        "    page_token = None\n",
        "    files = []\n",
        "    while True:\n",
        "        response = (\n",
        "            service.files()\n",
        "            .list(\n",
        "                supportsAllDrives=True,\n",
        "                includeItemsFromAllDrives=True,\n",
        "                q=f\"'{folder_id}' in parents and trashed = false\",\n",
        "                spaces=\"drive\",\n",
        "                pageSize=200,\n",
        "                fields=\"nextPageToken, files(id, name, mimeType, size, shortcutDetails)\",\n",
        "                orderBy=\"folder, name\",\n",
        "                pageToken=page_token,\n",
        "            )\n",
        "            .execute()\n",
        "        )\n",
        "        files.extend(response.get(\"files\", []))\n",
        "        page_token = response.get(\"nextPageToken\")\n",
        "        if page_token is None:\n",
        "            break\n",
        "    return files\n",
        "\n",
        "\n",
        "def getFileMetadata(file_id):\n",
        "    return (\n",
        "        service.files()\n",
        "        .get(fileId=file_id, supportsAllDrives=True, fields=\"name, id, mimeType, size\")\n",
        "        .execute()\n",
        "    )\n",
        "\n",
        "\n",
        "def get_Gfolder_size(folder_id):\n",
        "    try:\n",
        "        query = \"trashed = false and '{0}' in parents\".format(folder_id)\n",
        "        results = (\n",
        "            service.files()\n",
        "            .list(\n",
        "                supportsAllDrives=True,\n",
        "                includeItemsFromAllDrives=True,\n",
        "                q=query,\n",
        "                fields=\"files(id, mimeType, size)\",\n",
        "            )\n",
        "            .execute()\n",
        "        )\n",
        "\n",
        "        total_size = 0\n",
        "        items = results.get(\"files\", [])\n",
        "\n",
        "        folders_without_size = (\n",
        "            item[\"id\"]\n",
        "            for item in items\n",
        "            if item.get(\"size\") is None\n",
        "            and item[\"mimeType\"] == \"application/vnd.google-apps.folder\"\n",
        "        )\n",
        "\n",
        "        for item in items:\n",
        "            # If the item has a size attribute\n",
        "            if \"size\" in item:\n",
        "                total_size += int(item[\"size\"])\n",
        "\n",
        "        # Recursively call the function for folders whose size is not found\n",
        "        for folder_id in folders_without_size:\n",
        "            total_size += get_Gfolder_size(folder_id)\n",
        "\n",
        "        return total_size\n",
        "\n",
        "    except HttpError as error:\n",
        "        print(f\"Error while checking size: {error}\")\n",
        "        return -1\n",
        "\n",
        "\n",
        "async def gDownloadFile(file_id, path):\n",
        "    # Check if the specified file or folder exists and is downloadable.\n",
        "    try:\n",
        "        file = getFileMetadata(file_id)\n",
        "    except HttpError as error:\n",
        "        print(\"An error occurred: {0}\".format(error))\n",
        "        file = None\n",
        "\n",
        "    if file is None:\n",
        "        print(\n",
        "            \"Sorry, the specified file or folder does not exist or is not accessible.\"\n",
        "        )\n",
        "    else:\n",
        "        if file[\"mimeType\"].startswith(\"application/vnd.google-apps\"):\n",
        "            print(\n",
        "                \"Sorry, the specified ID is for a Google Docs, Sheets, Slides, or Forms document. You can only download these types of files in specific formats.\"\n",
        "            )\n",
        "        else:\n",
        "            try:\n",
        "                file_name = file.get(\"name\", f\"untitleddrivefile_{file_id}\")\n",
        "                file_name = ospath.join(path, file_name)\n",
        "                # Create a BytesIO stream to hold the downloaded file data.\n",
        "                file_contents = io.BytesIO()\n",
        "\n",
        "                # Download the file or folder contents to the BytesIO stream.\n",
        "                request = service.files().get_media(\n",
        "                    fileId=file_id, supportsAllDrives=True\n",
        "                )\n",
        "                file_downloader = MediaIoBaseDownload(\n",
        "                    file_contents, request, chunksize=70 * 1024 * 1024\n",
        "                )\n",
        "                done = False\n",
        "                while done is False:\n",
        "                    status, done = file_downloader.next_chunk()\n",
        "                    # Get current value from file_contents.\n",
        "                    file_contents.seek(0)\n",
        "                    with open(file_name, \"ab\") as f:\n",
        "                        f.write(file_contents.getvalue())\n",
        "                    # Reset the buffer for the next chunk.\n",
        "                    file_contents.seek(0)\n",
        "                    file_contents.truncate()\n",
        "                    # The saved bytes until now\n",
        "                    file_d_size = int(status.progress() * int(file[\"size\"]))\n",
        "                    down_done = sum(down_bytes) + file_d_size\n",
        "                    speed_string, eta, percentage = speed_eta(\n",
        "                        start_time, down_done, folder_info[0]\n",
        "                    )\n",
        "                    await status_bar(\n",
        "                        down_msg=down_msg,\n",
        "                        speed=speed_string,\n",
        "                        percentage=percentage,\n",
        "                        eta=convert_seconds(eta),\n",
        "                        done=size_measure(down_done),\n",
        "                        left=size_measure(folder_info[0]),\n",
        "                        engine=\"G-API ♻️\",\n",
        "                    )\n",
        "                down_bytes.append(int(file[\"size\"]))\n",
        "                down_count[0] += 1\n",
        "\n",
        "            except HttpError as error:\n",
        "                if error.resp.status == 403 and \"User Rate Limit Exceeded\" in str(\n",
        "                    error\n",
        "                ):\n",
        "                    raise HttpError(\"Download quota for the file has been exceeded.\")\n",
        "                else:\n",
        "                    print(\"Error downloading: {0}\".format(error))\n",
        "            except Exception as e:\n",
        "                print(\"Error downloading: {0}\".format(e))\n",
        "\n",
        "\n",
        "async def gDownloadFolder(folder_id, path):\n",
        "    folder_meta = getFileMetadata(folder_id)\n",
        "    folder_name = folder_meta[\"name\"]\n",
        "    if not ospath.exists(f\"{path}/{folder_name}\"):\n",
        "        makedirs(f\"{path}/{folder_name}\")\n",
        "    path += f\"/{folder_name}\"\n",
        "    result = getFilesByFolderID(folder_id)\n",
        "    if len(result) == 0:\n",
        "        return\n",
        "    result = natsorted(result, key=lambda k: k[\"name\"])\n",
        "    for item in result:\n",
        "        file_id = item[\"id\"]\n",
        "        shortcut_details = item.get(\"shortcutDetails\")\n",
        "        if shortcut_details is not None:\n",
        "            file_id = shortcut_details[\"targetId\"]\n",
        "            mime_type = shortcut_details[\"targetMimeType\"]\n",
        "        else:\n",
        "            mime_type = item.get(\"mimeType\")\n",
        "        if mime_type == \"application/vnd.google-apps.folder\":\n",
        "            await gDownloadFolder(file_id, path)\n",
        "        else:\n",
        "            await gDownloadFile(file_id, path)\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Telegram Upload Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "def keyboard():\n",
        "    return InlineKeyboardMarkup(\n",
        "        [\n",
        "            [  # First row\n",
        "                InlineKeyboardButton(  # Opens a web URL\n",
        "                    \"Git Repo 🪲\",\n",
        "                    url=\"https://github.com/XronTrix10/Telegram-Leecher\",\n",
        "                ),\n",
        "            ],\n",
        "        ]\n",
        "    )\n",
        "\n",
        "\n",
        "async def status_bar(down_msg, speed, percentage, eta, done, left, engine):\n",
        "    bar_length = 12\n",
        "    filled_length = int(percentage / 100 * bar_length)\n",
        "    # bar = \"⬢\" * filled_length + \"⬡\" * (bar_length - filled_length)\n",
        "    bar = \"█\" * filled_length + \"░\" * (bar_length - filled_length)\n",
        "    message = (\n",
        "        f\"\\n╭|{bar}| » __{percentage:.2f}%__\\n├⚡️ **Speed »** __{speed}__\\n├⚙️ **Engine »** __{engine}__\"\n",
        "        + f\"\\n├⏳ **Time Left »** __{eta}__\"\n",
        "        + f\"\\n├🍃 **Time Spent »** __{convert_seconds((datetime.datetime.now() - task_start).seconds)}__\"\n",
        "        + f\"\\n├✅ **Processed »** __{done}__\\n╰📦 **Total Size »** __{left}__\"\n",
        "    )\n",
        "    sys_text = system_info()\n",
        "    try:\n",
        "        print(f\"\\r{engine} ║ {bar} ║ {percentage:.2f}% ║ {speed} ║ ⏳ {eta}\", end=\"\")\n",
        "        # Edit the message with updated progress information.\n",
        "        if is_time_over(current_time):\n",
        "            await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=task_msg + down_msg + message + sys_text,\n",
        "                reply_markup=keyboard(),\n",
        "            )\n",
        "\n",
        "    except Exception as e:\n",
        "        # Catch any exceptions that might occur while editing the message.\n",
        "        print(f\"Error Updating Status bar: {str(e)}\")\n",
        "\n",
        "\n",
        "async def progress_bar(current, total):\n",
        "    upload_speed = 4 * 1024 * 1024\n",
        "    elapsed_time_seconds = (datetime.datetime.now() - start_time).seconds\n",
        "    if current > 0 and elapsed_time_seconds > 0:\n",
        "        upload_speed = current / elapsed_time_seconds\n",
        "    eta = (total_down_size - current - sum(up_bytes)) / upload_speed\n",
        "    percentage = (current + sum(up_bytes)) / total_down_size * 100\n",
        "    await status_bar(\n",
        "        down_msg=text_msg,\n",
        "        speed=f\"{size_measure(upload_speed)}/s\",\n",
        "        percentage=percentage,\n",
        "        eta=convert_seconds(eta),\n",
        "        done=size_measure(current + sum(up_bytes)),\n",
        "        left=size_measure(total_down_size),\n",
        "        engine=\"Pyrogram 💥\",\n",
        "    )\n",
        "\n",
        "\n",
        "async def upload_file(file_path, real_name):\n",
        "    global sent\n",
        "\n",
        "    caption = f\"<code>{real_name}</code>\"\n",
        "    type_, file_path = get_file_type(file_path)\n",
        "    f_type = \"document\" if LEECH_DOCUMENT else type_\n",
        "\n",
        "    # Upload the file\n",
        "    try:\n",
        "        if f_type == \"video\":\n",
        "            thmb_path, seconds = Thumbnail_Maintainer(file_path)\n",
        "            with Image.open(thmb_path) as img:\n",
        "                width, height = img.size\n",
        "\n",
        "            sent = await sent.reply_video(\n",
        "                video=file_path,\n",
        "                supports_streaming=True,\n",
        "                width=width,\n",
        "                height=height,\n",
        "                caption=caption,\n",
        "                thumb=thmb_path,\n",
        "                duration=int(seconds),\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "            if thmb_path != custom_thumb:\n",
        "                os.remove(thmb_path)\n",
        "\n",
        "        elif f_type == \"audio\":\n",
        "            thmb_path = None if not ospath.exists(custom_thumb) else custom_thumb\n",
        "            sent = await sent.reply_audio(\n",
        "                audio=file_path,\n",
        "                caption=caption,\n",
        "                thumb=thmb_path,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        elif f_type == \"document\":\n",
        "            if ospath.exists(custom_thumb):\n",
        "                thmb_path = custom_thumb\n",
        "            elif type_ == \"video\":\n",
        "                thmb_path, _ = Thumbnail_Maintainer(file_path)\n",
        "            else:\n",
        "                thmb_path = None\n",
        "\n",
        "            sent = await sent.reply_document(\n",
        "                document=file_path,\n",
        "                caption=caption,\n",
        "                thumb=thmb_path,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        elif f_type == \"photo\":\n",
        "            sent = await sent.reply_photo(\n",
        "                photo=file_path,\n",
        "                caption=caption,\n",
        "                progress=progress_bar,\n",
        "                reply_to_message_id=sent.id,\n",
        "            )\n",
        "\n",
        "        clear_output()\n",
        "\n",
        "        sent_file.append(sent)\n",
        "        sent_fileName.append(real_name)\n",
        "\n",
        "    except Exception as e:\n",
        "        print(f\"Error When Uploading : {e}\")\n",
        "\n",
        "\n",
        "\n",
        "# =================================================================\n",
        "#    Leech Mode Handler Functions\n",
        "# =================================================================\n",
        "\n",
        "\n",
        "\n",
        "async def Leecher(file_path):\n",
        "    global text_msg, start_time, msg, sent\n",
        "\n",
        "    leech = await size_checker(file_path)\n",
        "\n",
        "    if leech:  # File was splitted\n",
        "        if ospath.exists(file_path):\n",
        "            os.remove(file_path)  # Delete original Big Zip file\n",
        "\n",
        "        dir_list = natsorted(os.listdir(temp_lpath))\n",
        "\n",
        "        count = 1\n",
        "\n",
        "        for dir_path in dir_list:\n",
        "            short_path = ospath.join(temp_lpath, dir_path)\n",
        "            file_name = ospath.basename(short_path)\n",
        "            new_path = shorterFileName(short_path)\n",
        "            os.rename(short_path, new_path)\n",
        "            start_time = datetime.datetime.now()\n",
        "            current_time[0] = time.time()\n",
        "            text_msg = f\"<b>📤 UPLOADING SPLIT » {count} OF {len(dir_list)} Files</b>\\n\\n<code>{file_name}</code>\\n\"\n",
        "            try:\n",
        "                msg = await bot.edit_message_text(\n",
        "                    chat_id=chat_id,\n",
        "                    message_id=msg.id,\n",
        "                    text=task_msg + text_msg + \"\\n⏳ __Starting.....__\" + system_info(),\n",
        "                    reply_markup=keyboard(),\n",
        "                )\n",
        "            except Exception as d:\n",
        "                print(d)\n",
        "            await upload_file(new_path, file_name)\n",
        "            up_bytes.append(os.stat(new_path).st_size)\n",
        "\n",
        "            count += 1\n",
        "\n",
        "        shutil.rmtree(temp_lpath)\n",
        "\n",
        "    else:\n",
        "        file_name = ospath.basename(file_path)\n",
        "        # Trimming filename upto 50 chars\n",
        "        new_path = shorterFileName(file_path)\n",
        "        os.rename(file_path, new_path)\n",
        "        start_time = datetime.datetime.now()\n",
        "        current_time[0] = time.time()\n",
        "        text_msg = f\"<b>📤 UPLOADING » </b>\\n\\n<code>{file_name}</code>\\n\"\n",
        "        try:\n",
        "            msg = await bot.edit_message_text(\n",
        "                chat_id=chat_id,\n",
        "                message_id=msg.id,\n",
        "                text=task_msg + text_msg + \"\\n⏳ __Starting.....__\" + system_info(),\n",
        "                reply_markup=keyboard(),\n",
        "            )\n",
        "        except Exception as d:\n",
        "            print(d)\n",
        "        await upload_file(new_path, file_name)\n",
        "        up_bytes.append(os.stat(new_path).st_size)\n",
        "\n",
        "        os.remove(new_path)\n",
        "\n",
        "\n",
        "async def Leech(folder_path):\n",
        "    global total_down_size\n",
        "    total_down_size = get_folder_size(folder_path)\n",
        "    files = [str(p) for p in pathlib.Path(folder_path).glob(\"**/*\") if p.is_file()]\n",
        "    for f in natsorted(files):\n",
        "        file_path = ospath.join(folder_path, f)\n",
        "        await Leecher(file_path)\n",
        "\n",
        "    shutil.rmtree(folder_path)\n",
        "    if ospath.exists(f\"{d_path}/ytdl_thumbnails\"):\n",
        "        shutil.rmtree(f\"{d_path}/ytdl_thumbnails\")\n",
        "\n",
        "\n",
        "async def ZipLeech(d_fol_path):\n",
        "    global msg, down_msg, start_time, total_down_size\n",
        "\n",
        "    down_msg = f\"<b>🔐 ZIPPING » </b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    try:\n",
        "        msg = await bot.edit_message_text(\n",
        "            chat_id=chat_id,\n",
        "            message_id=msg.id,\n",
        "            text=task_msg + down_msg + system_info(),\n",
        "        )\n",
        "    except Exception as e2:\n",
        "        print(f\"Problem in ZipLeech !{e2}\")\n",
        "\n",
        "    print(\"\\nNow ZIPPING the folder...\")\n",
        "    current_time[0] = time.time()\n",
        "    start_time = datetime.datetime.now()\n",
        "    if not ospath.exists(temp_zpath):\n",
        "        makedirs(temp_zpath)\n",
        "    await zip_folder(d_fol_path)\n",
        "    clear_output()\n",
        "    time.sleep(2)\n",
        "\n",
        "    total_down_size = get_folder_size(temp_zpath)\n",
        "\n",
        "    if ospath.exists(d_fol_path):\n",
        "        shutil.rmtree(d_fol_path)\n",
        "    await Leech(temp_zpath)\n",
        "\n",
        "\n",
        "async def UnzipLeech(d_fol_path):\n",
        "    global msg\n",
        "\n",
        "    down_msg = f\"\\n<b>📂 EXTRACTING » </b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    msg = await bot.edit_message_text(\n",
        "        chat_id=chat_id,\n",
        "        message_id=msg.id,\n",
        "        text=task_msg + down_msg + \"\\n⏳ __Starting.....__\" + system_info(),\n",
        "    )\n",
        "    cant_files = []\n",
        "    filenames = [str(p) for p in pathlib.Path(d_fol_path).glob(\"**/*\") if p.is_file()]\n",
        "    for f in natsorted(filenames):\n",
        "        short_path = ospath.join(d_fol_path, f)\n",
        "        if not ospath.exists(temp_unzip_path):\n",
        "            makedirs(temp_unzip_path)\n",
        "        filename = ospath.basename(f).lower()\n",
        "        _, ext = ospath.splitext(filename)\n",
        "        try:\n",
        "            if ospath.exists(short_path):\n",
        "                if ext in [\".7z\", \".gz\", \".zip\", \".rar\", \".001\", \".tar\", \".z01\"]:\n",
        "                    await extract_zip(short_path)\n",
        "                    await Leech(temp_unzip_path)\n",
        "                else:\n",
        "                    cant_files.append(short_path)\n",
        "                    print(\n",
        "                        f\"Unable to Extract {ospath.basename(f)} ! Will be Leeching later !\"\n",
        "                    )\n",
        "        except Exception as e5:\n",
        "            print(f\"UZLeech Launcher Exception: {e5}\")\n",
        "\n",
        "    try:\n",
        "        for path in cant_files:\n",
        "            if ospath.exists(path):\n",
        "                await Leecher(path)\n",
        "    except Exception as e5:\n",
        "        print(f\"UZLeech Launcher Exception: {e5}\")\n",
        "\n",
        "    shutil.rmtree(d_fol_path)\n",
        "\n",
        "\n",
        "async def UnDZipLeech(folder_path):\n",
        "    global msg, down_msg, start_time, total_down_size\n",
        "\n",
        "    down_msg = f\"\\n<b>📂 EXTRACTING » </b>\\n\\n<code>{d_name}</code>\\n\"\n",
        "\n",
        "    msg = await bot.edit_message_text(\n",
        "        chat_id=chat_id,\n",
        "        message_id=msg.id,\n",
        "        text=task_msg + down_msg + \"\\n⏳ __Starting.....__\" + system_info(),\n",
        "    )\n",
        "\n",
        "    filenames = [str(p) for p in pathlib.Path(folder_path).glob(\"**/*\") if p.is_file()]\n",
        "    for f in natsorted(filenames):\n",
        "        short_path = ospath.join(folder_path, f)\n",
        "        if not ospath.exists(temp_unzip_path):\n",
        "            makedirs(temp_unzip_path)\n",
        "        filename = ospath.basename(f).lower()\n",
        "        _, ext = ospath.splitext(filename)\n",
        "        try:\n",
        "            if ospath.exists(short_path):\n",
        "                if ext in [\".7z\", \".gz\", \".zip\", \".rar\", \".001\", \".tar\", \".z01\"]:\n",
        "                    await extract_zip(short_path)\n",
        "                else:\n",
        "                    shutil.move(short_path, temp_unzip_path)\n",
        "        except Exception as e5:\n",
        "            print(f\"UnDZLeech Launcher Exception: {e5}\")\n",
        "\n",
        "    shutil.rmtree(folder_path)\n",
        "    await ZipLeech(temp_unzip_path)\n",
        "\n",
        "\n",
        "async def FinalStep(msg):\n",
        "    final_text = (\n",
        "        f\"<b>📂 Total Files:</b>  <code>{len(sent_file)}</code>\\n\\n<b>📜 LOG:</b>\\n\"\n",
        "    )\n",
        "    l_ink = \"⍟───── [Colab Leech] ─────⍟\"\n",
        "    last_text = (\n",
        "        f\"\\n\\n<b>{(task).upper()} COMPLETE 🔥</b>\\n\\n\"\n",
        "        + f\"╭<b>📛 Name » </b>  <code>{d_name}</code>\\n\"\n",
        "        + f\"├<b>📦 Size » </b><code>{size_measure(sum(up_bytes))}</code>\\n\"\n",
        "        + f\"├<b>☘️ File Count » </b><code>{len(sent_file)} Files</code>\\n\"\n",
        "        + f\"╰<b>🍃 Saved Time »</b> <code>{convert_seconds((datetime.datetime.now() - task_start).seconds)}</code>\"\n",
        "    )\n",
        "    src = f\"**SOURCE »** __[Links]({src_link})__\"\n",
        "    await bot.send_message(\n",
        "        chat_id=dump_id,\n",
        "        text=src + last_text,\n",
        "        reply_to_message_id=sent.id,\n",
        "    )\n",
        "\n",
        "    await bot.edit_message_text(\n",
        "        chat_id=chat_id,\n",
        "        message_id=msg.id,\n",
        "        text=task_msg + l_ink + last_text,\n",
        "        reply_markup=keyboard(),\n",
        "    )\n",
        "\n",
        "    try:\n",
        "        final_texts = []\n",
        "\n",
        "        for i in range(len(sent_file)):\n",
        "            file_link = f\"https://t.me/c/{link_p}/{sent_file[i].id}\"\n",
        "            fileName = sent_fileName[i]\n",
        "            fileText = f\"\\n({str(i+1).zfill(2)}) <a href={file_link}>{fileName}</a>\"\n",
        "            if len(final_text + fileText) >= 4096:\n",
        "                final_texts.append(final_text)\n",
        "                final_text = fileText\n",
        "            else:\n",
        "                final_text += fileText\n",
        "        final_texts.append(final_text)\n",
        "\n",
        "        for fn_txt in final_texts:\n",
        "            msg = await bot.send_message(\n",
        "                chat_id=chat_id, reply_to_message_id=msg.id, text=fn_txt\n",
        "            )\n",
        "    except Exception as e:\n",
        "        Err = f\"<b>Error Sending logs » </b><i>{e}</i>\"\n",
        "        Err += f\"\\n\\n<i>⚠️ If You are Unknown with this **ERROR**, Then Forward This Message in [Colab Leecher Discussion](https://t.me/Colab_Leecher_Discuss) Where [Xron Trix](https://t.me/XronTrix) may fix it</i>\"\n",
        "        await bot.send_message(chat_id=chat_id, reply_to_message_id=msg.id, text=Err)\n",
        "\n",
        "\n",
        "# ****************************************************************\n",
        "#    Main Functions, function calls and variable declarations\n",
        "# ****************************************************************\n",
        "api_id, chat_id, dump_id = int(API_ID), int(CHAT_ID), int(DUMP_ID)\n",
        "link_p = str(dump_id)[4:]\n",
        "custom_thumb = \"/content/Thumbnail.jpg\"\n",
        "d_path = \"/content/bot_Folder\"\n",
        "d_name = \"\"\n",
        "link_info = False\n",
        "d_fol_path = f\"{d_path}/Downloads\"\n",
        "temp_lpath = f\"{d_path}/Leeched_Files\"\n",
        "temp_unzip_path = f\"{d_path}/Unzipped_Files\"\n",
        "temp_zpath = temp_lpath\n",
        "sent_file = []\n",
        "sent_fileName = []\n",
        "down_bytes = []\n",
        "down_bytes.append(0)\n",
        "ytdl_status = []\n",
        "ytdl_status.append(\"\")\n",
        "ytdl_status.append(\"\")\n",
        "up_bytes = []\n",
        "up_bytes.append(0)\n",
        "current_time = []\n",
        "current_time.append(time.time())\n",
        "folder_info = [0, 1]\n",
        "down_count = []\n",
        "down_count.append(1)\n",
        "start_time = datetime.datetime.now()\n",
        "text_msg = \"\"\n",
        "link = \"something\"\n",
        "choice, z_pswd = \"x\", \"\"\n",
        "links = []\n",
        "\n",
        "service = build_service()\n",
        "\n",
        "if not Thumbnail_Checker(\"/content\"):\n",
        "    thumb_path = \"/content/Telegram-Leecher/custom_thmb.jpg\"\n",
        "    print(\"Didn't find thumbnail, So switching to default thumbnail\")\n",
        "else:\n",
        "    thumb_path = custom_thumb\n",
        "\n",
        "if ospath.exists(d_path):\n",
        "    shutil.rmtree(d_path)\n",
        "    makedirs(d_path)\n",
        "else:\n",
        "    makedirs(d_path)\n",
        "\n",
        "if len(LEECH_MODE) == 0:\n",
        "    while choice not in [\"1\", \"2\", \"3\", \"l\", \"z\", \"u\", \"4\", \"d\"]:\n",
        "        choice = input(\n",
        "            \"Choose the Operation:\\n\\n\\t[1 / L] Leech\\n\\t[2 / Z] Zipleech\\n\\t[3 / U] Unzipleech\\n\\t[4 / D] UnDoubleZipLeech\\n\\nEnter: \"\n",
        "        ).lower()\n",
        "        clear_output()\n",
        "        if choice not in [\"1\", \"2\", \"3\", \"l\", \"z\", \"u\", \"4\", \"d\"]:\n",
        "            print(f\"No Such Leech Mode '{choice}' ! Enter Option Correctly 🦥\\n\")\n",
        "else:\n",
        "    choice = LEECH_MODE.lower()\n",
        "\n",
        "if choice == \"1\" or choice == \"l\":\n",
        "    task = \"Leech\"\n",
        "elif choice == \"2\" or choice == \"z\":\n",
        "    task = \"Zipleech\"\n",
        "elif choice == \"3\" or choice == \"u\":\n",
        "    task = \"Unzipleech\"\n",
        "else:\n",
        "    task = \"UnDoubleZipleech\"\n",
        "leech_type = \"Document\" if LEECH_DOCUMENT else \"Media\"\n",
        "\n",
        "time.sleep(1)\n",
        "print(f\"TASK MODE: {task} as {leech_type}\")\n",
        "\n",
        "if len(PASSWD) == 0 and choice in [\"3\", \"u\", \"4\", \"d\"]:\n",
        "    z_pswd = input(f\"Password For Unzip [ Enter 'E' for Empty ]: \")\n",
        "elif len(PASSWD) != 0:\n",
        "    z_pswd = PASSWD\n",
        "\n",
        "if z_pswd.lower() == \"e\":\n",
        "    z_pswd = \"\"\n",
        "\n",
        "if len(D_LINK) == 0:\n",
        "    # Getting Download Links\n",
        "    while link.lower() != \"c\":\n",
        "        link = input(f\"Download link [ Enter 'C' to Terminate]: \")\n",
        "        if link.lower() != \"c\":\n",
        "            links.append(link)\n",
        "else:\n",
        "    links.append(D_LINK)\n",
        "\n",
        "d_name, custom_name = \"\", \"\"\n",
        "\n",
        "if len(LEECH_MODE) + len(D_LINK) + len(C_NAME) == 0:  # Making Sure, he is in Desktop\n",
        "    if choice in [\"2\", \"z\", \"4\", \"d\"] or (len(links) == 1 and choice in [\"1\", \"l\"]):\n",
        "        custom_name = input(\"Enter Custom File name [ 'D' to set Default ]: \")\n",
        "    else:\n",
        "        print(\"Custom Name Not Applicable\")\n",
        "else:\n",
        "    custom_name = C_NAME\n",
        "\n",
        "if custom_name.lower() == \"d\":\n",
        "    custom_name = \"\"\n",
        "\n",
        "\n",
        "task_start = datetime.datetime.now()\n",
        "down_msg = f\"<b>📥 DOWNLOADING » </b>\\n\"\n",
        "task_msg = f\"<b>🦞 TASK MODE » </b><i>{task} as {leech_type}</i>\\n\\n\"\n",
        "\n",
        "dump_task = task_msg + \"<b>🖇️ SOURCES » </b>\"\n",
        "\n",
        "for link in links:\n",
        "    if \"t.me\" in link:\n",
        "        ida = \"💬\"\n",
        "    elif \"drive.google.com\" in link:\n",
        "        ida = \"♻️\"\n",
        "    elif \"magnet\" in link or \"torrent\" in link:\n",
        "        ida = \"🧲\"\n",
        "    elif \"youtube.com\" in link or \"youtu.be\" in link:\n",
        "        ida = \"🏮\"\n",
        "    else:\n",
        "        ida = \"🔗\"\n",
        "    dump_task += f\"\\n\\n{ida} <code>{link}</code>\"\n",
        "\n",
        "# Get the current date and time in the specified time zone\n",
        "cdt = datetime.datetime.now(pytz.timezone(\"Asia/Kolkata\"))\n",
        "# Format the date and time as a string\n",
        "dt = cdt.strftime(\" %d/%m/%Y\")\n",
        "\n",
        "dump_task += f\"\\n\\n<b>📆 Task Date » </b><i>{dt}</i>\"\n",
        "\n",
        "if not ospath.exists(d_fol_path):\n",
        "    makedirs(d_fol_path)\n",
        "\n",
        "async with Client(\n",
        "    \"my_bot\", api_id=api_id, api_hash=API_HASH, bot_token=BOT_TOKEN\n",
        ") as bot:\n",
        "    try:\n",
        "        sent = await bot.send_message(chat_id=dump_id, text=dump_task)\n",
        "\n",
        "        src_link = f\"https://t.me/c/{link_p}/{sent.id}\"\n",
        "        task_msg += \"<b>🖇️ SOURCE » </b>\" + f\"__[Links]({src_link})__\\n\\n\"\n",
        "\n",
        "        msg = await bot.send_message(\n",
        "            chat_id=chat_id,\n",
        "            text=task_msg\n",
        "            + down_msg\n",
        "            + f\"\\n📝 __Starting DOWNLOAD...__\"\n",
        "            + system_info(),\n",
        "            reply_markup=keyboard(),\n",
        "        )\n",
        "        clear_output()\n",
        "        await calG_DownSize(links)\n",
        "        await get_d_name(links[0])\n",
        "\n",
        "        if choice in [\"2\", \"z\"]:\n",
        "            d_fol_path = ospath.join(d_fol_path, d_name)\n",
        "            if ospath.exists(d_fol_path):\n",
        "                makedirs(d_fol_path)\n",
        "\n",
        "        links = natsorted(links)\n",
        "\n",
        "        current_time[0] = time.time()\n",
        "        start_time = datetime.datetime.now()\n",
        "\n",
        "        for c in range(len(links)):\n",
        "            if \"drive.google.com\" in links[c]:\n",
        "                await g_DownLoad(links[c], c + 1)\n",
        "            elif \"t.me\" in links[c]:\n",
        "                await TelegramDownload(links[c], c + 1)\n",
        "            elif \"youtube.com\" in links[c] or \"youtu.be\" in links[c]:\n",
        "                await YTDL_Status(links[c], c + 1)\n",
        "                time.sleep(4)  # Giving Time to Merge The Last Video\n",
        "            else:\n",
        "                aria2_dn = f\"<b>PLEASE WAIT ⌛</b>\\n\\n__Getting Download Info For__\\n\\n<code>{links[c]}</code>\"\n",
        "                try:\n",
        "                    await bot.edit_message_text(\n",
        "                        chat_id=chat_id,\n",
        "                        message_id=msg.id,\n",
        "                        text=aria2_dn + system_info(),\n",
        "                        reply_markup=keyboard(),\n",
        "                    )\n",
        "                except Exception as e1:\n",
        "                    print(f\"Couldn't Update text ! Because: {e1}\")\n",
        "                link_info = False\n",
        "                await aria2_Download(links[c], c + 1)\n",
        "\n",
        "        total_down_size = get_folder_size(d_fol_path)\n",
        "\n",
        "        if choice in [\"1\", \"l\"] and len(custom_name) != 0:\n",
        "            files = os.listdir(d_fol_path)\n",
        "            for file_ in files:\n",
        "                current_name = ospath.join(d_fol_path, file_)\n",
        "                new_name = ospath.join(d_fol_path, custom_name)\n",
        "                os.rename(current_name, new_name)\n",
        "\n",
        "        clear_output()\n",
        "\n",
        "        if choice == \"1\" or choice == \"l\":\n",
        "            await Leech(d_fol_path)\n",
        "        elif choice == \"2\" or choice == \"z\":\n",
        "            await ZipLeech(d_fol_path)\n",
        "        elif choice == \"3\" or choice == \"u\":\n",
        "            await UnzipLeech(d_fol_path)\n",
        "        else:\n",
        "            await UnDZipLeech(d_fol_path)\n",
        "\n",
        "        await FinalStep(msg)\n",
        "\n",
        "    except Exception as e:\n",
        "        clear_output()\n",
        "        if ospath.exists(d_path):\n",
        "            shutil.rmtree(d_path)\n",
        "            print(\"Download Folder was DELETED 💀!\")\n",
        "\n",
        "        Error_Text = (\n",
        "            \"⍟───── [Colab Leech] ─────⍟\\n\"\n",
        "            + f\"\\n<b>TASK FAILED TO COMPLETE 💔</b>\\n\\n╭<b>📛 Name » </b> <code>{d_name}</code>\\n├<b>🍃 Wasted Time » </b>\"\n",
        "            + f\"__{convert_seconds((datetime.datetime.now() - task_start).seconds)}__\\n\"\n",
        "            + f\"<b>╰🤔 Reason » </b>__{e}__\"\n",
        "            + f\"\\n\\n<i>⚠️ If You are Unknown with this **ERROR**, Then Forward This Message in [Colab Leecher Discussion](https://t.me/Colab_Leecher_Discuss) Where [Xron Trix](https://t.me/XronTrix) may fix it</i>\"\n",
        "        )\n",
        "        try:\n",
        "            await bot.delete_messages(chat_id=chat_id, message_ids=msg.id)\n",
        "            await bot.send_message(\n",
        "                chat_id=chat_id,\n",
        "                text=task_msg + Error_Text,\n",
        "                reply_markup=InlineKeyboardMarkup(\n",
        "                    [\n",
        "                        [\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"Report Issue 🥺\",\n",
        "                                url=\"https://github.com/XronTrix10/Telegram-Leecher/issues\",\n",
        "                            ),\n",
        "                            InlineKeyboardButton(  # Opens a web URL\n",
        "                                \"Group Discuss 🤔\",\n",
        "                                url=\"https://t.me/Colab_Leecher_Discuss\",\n",
        "                            ),\n",
        "                        ],\n",
        "                    ]\n",
        "                ),\n",
        "            )\n",
        "        except Exception as d:\n",
        "            print(f\"Another Error Occured: {d}\")\n",
        "        print(f\"Error Occured: {e}\")\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "iGN1UJby1WRA"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "WJ9XTTtVzHfX",
        "477G4hACPgqM",
        "wkc0wCvPIUFh",
        "O0NHwsI_-d3W",
        "tir2SjUgvFR6",
        "R0C-yQp1xZHr",
        "WmJEFkM4x05r",
        "Rgjf7ZcOygaG",
        "TD0jARIQUk0O",
        "6XzR4IVO5xFr",
        "juW1zJHfNdaG",
        "EFOqhHG6hOVH",
        "ey6-UveDalxR",
        "bn8deYOrQUMZ"
      ],
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}