Rclone.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/TheCaduceus/Multi-Cloud-Transfer-Tool/blob/main/Rclone.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Connect Google Account:**"
      ],
      "metadata": {
        "id": "Xw52Y6ujDGcB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**First connect Google Drive, to enable MCT Tool to save/retrive its configuration files.**"
      ],
      "metadata": {
        "id": "xU_gKkKgoLW6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b>Options:</b><br>\n",
        "`FORCE_REMOUNT` :<b> Forcefully remount Google Drive.</b><br>\n",
        "`CUSTOM_MOUNT_POINT` :<b> Choose different path for mounting Google Drive.</b><br>\n",
        "`DEBUG_MODE` :<b> To enable or disable DEBUG Mode.</b>"
      ],
      "metadata": {
        "id": "MGIq_sztgmYu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src=\"https://assets.thecaduceus.eu.org/MCT/img/Google-Drive-Logo.png\" height=\"50\" alt=\"Google-Drive-Logo\"/></center>\n",
        "#@markdown <center><h3>Connect to Google Account</h3></center><br>\n",
        "\n",
        "from pathlib import Path\n",
        "from contextlib import suppress\n",
        "from sys import exit as end\n",
        "from google.colab import output\n",
        "from google.colab.drive import mount, flush_and_unmount as unmount\n",
        "\n",
        "MODE = \"MOUNT\" #@param [\"MOUNT\", \"UNMOUNT\"]\n",
        "FORCE_REMOUNT = True #@param {type:\"boolean\"}\n",
        "CUSTOM_MOUNT_POINT = False #@param {type:\"boolean\"}\n",
        "DEBUG_MODE = False #@param {type:\"boolean\"}\n",
        "\n",
        "if CUSTOM_MOUNT_POINT:\n",
        "  Custom_Mount_Path = input('Please enter Custom Mount Path:\\n')\n",
        "  if not Custom_Mount_Path:\n",
        "    end(\"Path Error: Path can't be blank!\")\n",
        "  elif not Path(Custom_Mount_Path).exists():\n",
        "    end(\"Path Error: Provided Custom path not found! Check if you mounted/connected it or if you having reading/writing permission?\")\n",
        "  elif not Path(Custom_Mount_Path).is_dir():\n",
        "    end(\"Path Error: Given Path is not a valid directory.\")\n",
        "else:\n",
        "  Custom_Mount_Path = '/content/drive'\n",
        "\n",
        "mount._DEBUG = DEBUG_MODE\n",
        "\n",
        "if MODE == \"MOUNT\":\n",
        "  print(\"Please Wait! Mounting...\")\n",
        "  mount(Custom_Mount_Path, force_remount= FORCE_REMOUNT)\n",
        "  if not DEBUG_MODE:\n",
        "    output.clear()\n",
        "  print(f'Mounted at {Custom_Mount_Path}')\n",
        "elif MODE == 'UNMOUNT':\n",
        "  with suppress(ValueError):\n",
        "    print('Please Wait! UNMOUNT in progress...')\n",
        "    unmount()\n",
        "  get_ipython().system_raw('rm -rf /root/.config/Google/DriveFS')"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Yuqm_-xBhOEH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Setup & Configure:**"
      ],
      "metadata": {
        "id": "0Ix50jEQDQvo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Download setup files & configure the environment:**"
      ],
      "metadata": {
        "id": "7vbqfASX1jHx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b>Options:</b><br>\n",
        "`INSTALL_RCLONE_FLAVOR`<b>: Switch Rclone's release branch from stable to beta or vice-versa.</b><br>\n",
        "`FORCE_SETUP`<b>: Forcefully install Rclone by excluding all other dependencies and download them separately. Useful if any dependency (except Rclone) having temporary setup problem.</b><br>\n",
        "`CUSTOM_SH_FILE`:<b> Get custom .sh file from external source (URL or File Path) and execute it to install additional dependecies or requirements with or without normal setup.</b>"
      ],
      "metadata": {
        "id": "l9gOMerpoUYX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src=\"https://assets.thecaduceus.eu.org/MCT/img/Setup_img.png\" height=\"50\" alt=\"Setup-Logo\"/></center>\n",
        "#@markdown <center><h3><b>Setup & Configure Environment</b></h3></center><br>\n",
        "\n",
        "from sys import exit as end\n",
        "from pathlib import Path, PurePath\n",
        "from time import sleep\n",
        "from requests import get as get_url\n",
        "from urllib.parse import urlparse as validate_url\n",
        "from google.colab import output\n",
        "from json import dumps as dump_json\n",
        "\n",
        "current_version = \"v5.1.0\"\n",
        "do_normal_setup = \"1\"\n",
        "\n",
        "# Check for latest version\n",
        "try:\n",
        "\tjson_data = get_url(\"https://assets.thecaduceus.eu.org/MCT/json/mct.json\").json()\n",
        "\tprint(\"Connected with CDN.\")\n",
        "\tif current_version == json_data[\"version\"]:\n",
        "\t\tprint(f'Great Job! you are using latest version: {json_data[\"version\"]}')\n",
        "\telse:\n",
        "\t\tprint(f'Oh-No! you are not using latest version and missing out important fixes & features. Latest version is {json_data[\"version\"]}, use latest notebook available here:\\n{json_data[\"notebookLink\"]}')\n",
        "\t\tsleep(10)\n",
        "except Exception as error_code:\n",
        "\tend(f'Failed to connect with CDN!\\nTraceback:\\n{error_code}')\n",
        "\n",
        "# Save json data locally\n",
        "with open('mct.json', 'w+') as mct_json:\n",
        "\tmct_json.write(dump_json(json_data))\n",
        "\n",
        "# Flavor Flags\n",
        "Stable = \"\"\n",
        "Beta = \"-s beta\"\n",
        "\n",
        "# User Input\n",
        "INSTALL_RCLONE_FLAVOR = Stable #@param [\"Stable\", \"Beta\"] {type:\"raw\"}\n",
        "FORCE_SETUP = False #@param {type:\"boolean\"}\n",
        "CUSTOM_SH_FILE = False #@param {type:\"boolean\"}\n",
        "\n",
        "if CUSTOM_SH_FILE:\n",
        "\n",
        "\tCustom_sh_Source = input(\"Provide the Custom Install.sh file source, it can be URL or File Path:\\n\")\n",
        "\tuse_sudo = input(\"Do you want to execute the .sh file as sudo? 1 = Yes and 0 = No:\\n\")\n",
        "\n",
        "\tif use_sudo not in ['0','1']:\n",
        "\t\tend(\"Unable to check for latest version!\")\n",
        "\telif not Custom_sh_Source:\n",
        "\t\tend(\"Custom sh file source can't be blank!\")\n",
        "\telif all([validate_url(Custom_sh_Source).scheme, validate_url(Custom_sh_Source).netloc]):\n",
        "\t\ttry:\n",
        "\t\t\tget_url(Custom_sh_Source)\n",
        "\t\t\tif use_sudo == '1':\n",
        "\t\t\t\t!curl {Custom_sh_Source} | sudo bash\n",
        "\t\t\t\tprint('Execution completed as sudo!')\n",
        "\t\t\telif use_sudo == '0':\n",
        "\t\t\t\t!curl {Custom_sh_Source} | bash\n",
        "\t\t\t\tprint('Execution completed!')\n",
        "\t\texcept ConnectionError:\n",
        "\t\t\tend(\"Unable to connect with given sh file URL.\")\n",
        "\t\texcept Exception as error_code:\n",
        "\t\t\tend(f\"Failed to complete the execution of .sh file!\\nTraceback:\\n{error_code}\")\n",
        "\telif not Path(Custom_sh_Source).exists():\n",
        "\t\tend(\"Provided Custom sh file path not exist!\")\n",
        "\telif not Path(Custom_sh_Source).is_file():\n",
        "\t\tend(\"Provided Custom sh file path should of a particular file not directory/folder.\")\n",
        "\telif not PurePath(Custom_sh_Source).suffix == '.sh':\n",
        "\t\tend(\"File format should be .sh\")\n",
        "\telse:\n",
        "\t\ttry:\n",
        "\t\t\tif use_sudo == '1':\n",
        "\t\t\t\t!sudo bash \"$Custom_sh_Source\"\n",
        "\t\t\t\tprint(\"Execution completed as sudo.\")\n",
        "\t\t\telse:\n",
        "\t\t\t\t!bash \"$Custom_sh_Source\"\n",
        "\t\t\t\tprint(\"Execution complete.\")\n",
        "\t\texcept Exception as error_code:\n",
        "\t\t\tend(f\"Failed to complete the execution of .sh file!\\nTraceback:\\n{error_code}\")\n",
        "\n",
        "\n",
        "\t# Ask for Normal Setup\n",
        "\tdo_normal_setup = input('Do you want to run Normal Setup also? 1 = Yes and 0 = No:\\n')\n",
        "\n",
        "\tif do_normal_setup not in ['0','1']:\n",
        "\t\tend(\"Input Error: Value should be 1 or 0\")\n",
        "\n",
        "# Force Setup\n",
        "if FORCE_SETUP:\n",
        "\tif Path(\"/content/setup.sh\").exists():\n",
        "\t\t!rm {\"/content/setup.sh\"}\n",
        "\tprint(\"Starting Force Setup...\")\n",
        "\tsleep(4)\n",
        "\t!curl \"https://rclone.org/install.sh\" | sudo bash {INSTALL_RCLONE_FLAVOR}\n",
        "\n",
        "if do_normal_setup == '1' and not Path(\"/content/setup.sh\").exists():\n",
        "\ttry:\n",
        "\t\tget_url(json_data[\"setupFile\"])\n",
        "\t\t!curl {json_data[\"setupFile\"]} | sudo bash {INSTALL_RCLONE_FLAVOR}\n",
        "\t\t!curl {json_data[\"setupFile\"]} > \"/content/setup.sh\"\n",
        "\t\toutput.clear()\n",
        "\t\tprint(\"Setup completed!\")\n",
        "\texcept ConnectionError:\n",
        "\t\tprint('Unable to get setup file!')\n",
        "\texcept Exception as error_code:\n",
        "\t\tprint(f'Setup instructions seems to be having mistake(s)!\\nTraceback:\\n{error_code}')\n",
        "elif do_normal_setup == '1' and Path(\"/content/setup.sh\").exists():\n",
        "\tprint(\"Setup file exist and configured already!\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "VLvNaehXbk59"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Retrive Config Files:**"
      ],
      "metadata": {
        "id": "OFiE8TB7DlSI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b>Options:</b><br>\n",
        "<b>By default, MCT Tool uses MCT-Config folder located in My Drive to restore configurations.</b><br>\n",
        "`CUSTOM_IMPORT_PATH` :<b> Scan a custom path (or directory) give by user for usable MCT Configuration files.</b><br>\n",
        "`CUSTOM_EXPORT_PATH` :<b> Export all your MCT configuration files to a gives path.</b>"
      ],
      "metadata": {
        "id": "sYA6ATyDsrNj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src=\"https://assets.thecaduceus.eu.org/MCT/img/rclone_logo.png\" height=\"50\" alt=\"Rclone-Logo\"/></center>\n",
        "#@markdown <center><h3><b>Fetch Previous MCT Config from My Drive</b></h3></center><br>\n",
        "\n",
        "from sys import exit as end\n",
        "from pathlib import Path, PurePath\n",
        "\n",
        "# Where user mounted Google Drive?\n",
        "try:\n",
        "  CMP = PurePath(Custom_Mount_Path)\n",
        "except NameError:\n",
        "  CMP = '/content/drive'\n",
        "\n",
        "DRIVE_CONFIG_DIR = f\"{CMP}/MyDrive/MCT-Config/\"\n",
        "\n",
        "# Check for Setup & Google Account\n",
        "if not Path(\"/content/setup.sh\").exists():\n",
        "  end('Please download setup first!')\n",
        "elif not Path(CMP).exists():\n",
        "  end('Not Found: Google Drive is not connected!')\n",
        "\n",
        "#@markdown ---\n",
        "CUSTOM_IMPORT_PATH = False #@param {type:\"boolean\"}\n",
        "CUSTOM_EXPORT_PATH = False #@param {type:\"boolean\"}\n",
        "\n",
        "# Import Configuration(s)\n",
        "\n",
        "if CUSTOM_IMPORT_PATH:\n",
        "  Custom_Path = input('Enter the directory path from where configuration file(s) needs to be imported:\\n')\n",
        "  # Check Path\n",
        "  if not Custom_Path:\n",
        "    end(\"Path Error: Path can't be blank!\")\n",
        "  elif not Path(Custom_Path).exists():\n",
        "    end(\"Path Error: Provided Custom path not found! Check if you mounted/connected it or if you having reading/writing permission?\")\n",
        "  elif not Path(Custom_Path).is_dir():\n",
        "    end(\"Path Error: Given Path is not a valid directory.\")\n",
        "  elif not Path(f'{CMP}/MyDrive/MCT-Config/').exists():\n",
        "    !rclone mkdir \"$DRIVE_CONFIG_DIR\"\n",
        "    print('Created: MCT-Config [folder]')\n",
        "\n",
        "  Custom_Path = PurePath(Custom_Path) # Remove any extra '/'\n",
        "\n",
        "  # Paths\n",
        "  IMPORT_TO = DRIVE_CONFIG_DIR\n",
        "  IMPORT_RCLONE_CONF = f\"{Custom_Path}/rclone.conf\"\n",
        "  IMPORT_ACCOUNTS_ZIP = f\"{Custom_Path}/accounts.zip\"\n",
        "  IMPORT_ACCOUNTS_FOLDER = f\"{Custom_Path}/accounts/\"\n",
        "  ZIP_ACCOUNTS_FOLDER = f\"{CMP}/MyDrive/MCT-Config/accounts\" # accounts is name of zip, zip file will be saved in MCT-Config\n",
        "  IMPORT_MEGA_JSON = f\"{Custom_Path}/mega.json\"\n",
        "  IMPORT_GOFILE_JSON = f\"{Custom_Path}/gofile.json\"\n",
        "  IMPORT_TELEGRAM_JSON = f\"{Custom_Path}/telegram.json\"\n",
        "  IMPORT_SESSION_FILES = list(Path(Custom_Path).glob(\"*.session\"))\n",
        "  # Check 'rclone.conf' file\n",
        "\n",
        "  if Path(IMPORT_RCLONE_CONF).exists():\n",
        "\n",
        "    is_import = input('Found: rclone.conf [file] | Do you want to import? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_import not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_import == '1':\n",
        "      !rclone copy \"$IMPORT_RCLONE_CONF\" \"$IMPORT_TO\"\n",
        "      print('Successfully imported \"rclone.conf\" file! (1)')\n",
        "    else:\n",
        "      print('Not Found: rclone.conf [file]')\n",
        "\n",
        "  # Check 'Service Accounts' file/folder\n",
        "\n",
        "  if Path(IMPORT_ACCOUNTS_ZIP).exists() and Path(IMPORT_ACCOUNTS_FOLDER).exists():\n",
        "\n",
        "    choice = input('Found both! \"accounts.zip\" [file] & \"accounts\" [folder]\\n Select one: 0 = accounts.zip [file] or 1 = accounts [folder] or 2 = Ignore\\n')\n",
        "\n",
        "    if choice not in ['0','1','2']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif choice == '1':\n",
        "      !zip \"$ZIP_ACCOUNTS_FOLDER\" \"$IMPORT_ACCOUNTS_FOLDER\"\n",
        "      print('Successfully imported \"accounts.zip\" file! (2)')\n",
        "    elif choice == '0':\n",
        "      !rclone copy \"$IMPORT_ACCOUNTS_ZIP\" \"$IMPORT_TO\"\n",
        "      print('Successfully imported \"accounts.zip\" file! (1)')\n",
        "  elif Path(IMPORT_ACCOUNTS_ZIP).exists():\n",
        "\n",
        "    is_import = input('Found: accounts.zip [file] | Do you want to import? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_import not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_import == '1':\n",
        "      !rclone copy \"$IMPORT_ACCOUNTS_ZIP\" \"$IMPORT_TO\"\n",
        "      print('Successfully imported \"accounts.zip\" file! (1)')\n",
        "  elif Path(IMPORT_ACCOUNTS_FOLDER).exists():\n",
        "\n",
        "    is_import = input('Found: accounts [folder] | Do you want to import ? 0=No & 1=Yes:\\n')\n",
        "\n",
        "    if is_import not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_import == '1':\n",
        "      !zip \"$ZIP_ACCOUNTS_FOLDER\" \"$IMPORT_ACCOUNTS_FOLDER\"\n",
        "      print('Successfully imported \"accounts.zip\" file! (2)')\n",
        "  else:\n",
        "    print('Not Found: accounts.zip [file] or accounts [folder]')\n",
        "\n",
        "  # Check 'mega.json' file\n",
        "\n",
        "  if Path(IMPORT_MEGA_JSON).exists():\n",
        "\n",
        "    is_import = input('Found: mega.json | Do you want to import? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_import not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_import == '1':\n",
        "      !rclone copy \"$IMPORT_MEGA_JSON\" \"$IMPORT_TO\"\n",
        "      print('Successfully imported \"mega.json\" file! (1)')\n",
        "\n",
        "  else:\n",
        "    print('Not Found: mega.json [file]')\n",
        "\n",
        "  # Check 'gofile.json' file\n",
        "\n",
        "  if Path(IMPORT_GOFILE_JSON).exists():\n",
        "\n",
        "    is_import = input('Found: gofile.json | Do you want to import? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_import not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_import == '1':\n",
        "      !rclone copy \"$IMPORT_GOFILE_JSON\" \"$IMPORT_TO\"\n",
        "      print('Successfully imported \"gofile.json\" file! (1)')\n",
        "\n",
        "  else:\n",
        "    print('Not Found: gofile.json [file]')\n",
        "\n",
        "  # Check 'telegram.json' file\n",
        "\n",
        "  if Path(IMPORT_TELEGRAM_JSON).exists():\n",
        "\n",
        "    is_import = input('Found: telegram.json | Do you want to import? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_import not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_import == '1':\n",
        "      !rclone copy \"$IMPORT_TELEGRAM_JSON\" \"$IMPORT_TO\"\n",
        "      print('Successfully imported \"telegram.json\" file! (1)')\n",
        "\n",
        "  else:\n",
        "    print('Not Found: telegram.json [file]')\n",
        "\n",
        "  # Check '*.session' files\n",
        "\n",
        "  if len(IMPORT_SESSION_FILES) != 0:\n",
        "\n",
        "    is_import = input('Found: Telegram session files | Do you want to import? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_import not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_import == '1':\n",
        "      for IMPORT_SESSION_FILE in IMPORT_SESSION_FILES:\n",
        "        !rclone copy \"$IMPORT_SESSION_FILE\" \"$IMPORT_TO\"\n",
        "      print(\"Successfully imported telegram session files! (1)\")\n",
        "\n",
        "  else:\n",
        "    print('Not Found: .session [file]')\n",
        "\n",
        "# Restore Configuration(s) from MCT-Config folder\n",
        "\n",
        "if not Path(DRIVE_CONFIG_DIR).exists():\n",
        "  end('Not Found: MCT-Config [folder]')\n",
        "else:\n",
        "  print('Found: MCT-Config [folder]')\n",
        "\n",
        "# Paths\n",
        "ROOT = \"/content/\"\n",
        "DRIVE_RCLONE_CONF = f\"{CMP}/MyDrive/MCT-Config/rclone.conf\"\n",
        "ROOT_RCLONE_CONF = \"/root/.config/rclone/\"\n",
        "DRIVE_ACCOUNTS_ZIP = f\"{CMP}/MyDrive/MCT-Config/accounts.zip\"\n",
        "DRIVE_MEGA_JSON = f\"{CMP}/MyDrive/MCT-Config/mega.json\"\n",
        "DRIVE_GOFILE_JSON = f\"{CMP}/MyDrive/MCT-Config/gofile.json\"\n",
        "DRIVE_TELEGRAM_JSON = f\"{CMP}/MyDrive/MCT-Config/telegram.json\"\n",
        "DRIVE_SESSION_FILES = list(Path(f\"{CMP}/MyDrive/MCT-Config/\").glob(\"*.session\"))\n",
        "\n",
        "# Check 'rclone.conf' file\n",
        "\n",
        "if Path(DRIVE_RCLONE_CONF).exists():\n",
        "  !rclone copy \"$DRIVE_RCLONE_CONF\" \"$ROOT_RCLONE_CONF\"\n",
        "  print('Restored: rclone.conf [file]')\n",
        "else:\n",
        "  print('Not Found: rclone.conf [file]')\n",
        "\n",
        "# Check 'Service Accounts' file\n",
        "\n",
        "if Path(DRIVE_ACCOUNTS_ZIP).exists():\n",
        "  !rclone copy \"$DRIVE_ACCOUNTS_ZIP\" \"$ROOT\"\n",
        "  print('Restored: accounts.zip [file]')\n",
        "else:\n",
        "  print('Not Found: accounts.zip [file]')\n",
        "\n",
        "# Check 'mega.json' file\n",
        "\n",
        "if Path(DRIVE_MEGA_JSON).exists():\n",
        "  !rclone copy \"$DRIVE_MEGA_JSON\" \"$ROOT\"\n",
        "  print('Restored: mega.json [file]')\n",
        "else:\n",
        "  print('Not Found: mega.json [file]')\n",
        "\n",
        "# Check 'gofile.json' file\n",
        "\n",
        "if Path(DRIVE_GOFILE_JSON).exists():\n",
        "  !rclone copy \"$DRIVE_GOFILE_JSON\" \"$ROOT\"\n",
        "  print('Restored: gofile.json [file]')\n",
        "else:\n",
        "  print('Not Found: gofile.json [file]')\n",
        "\n",
        "# Check 'telegram.json' file\n",
        "\n",
        "if Path(DRIVE_TELEGRAM_JSON).exists():\n",
        "  !rclone copy \"$DRIVE_TELEGRAM_JSON\" \"$ROOT\"\n",
        "  print('Restored: telegram.json [file]')\n",
        "else:\n",
        "  print('Not Found: telegram.json [file]')\n",
        "\n",
        "# Check '*.session' files\n",
        "\n",
        "if len(DRIVE_SESSION_FILES) != 0:\n",
        "  for DRIVE_SESSION_FILE in DRIVE_SESSION_FILES:\n",
        "    !rclone copy \"$DRIVE_SESSION_FILE\" \"$ROOT\"\n",
        "  print('Restored: *.session [files]')\n",
        "else:\n",
        "  print('Not Found: *.session [files]')\n",
        "\n",
        "if CUSTOM_EXPORT_PATH:\n",
        "\n",
        "  #Paths\n",
        "  EXPORT_TO = f\"{Custom_Path}/MCT-Config/\"\n",
        "\n",
        "  Custom_Path = input('Enter the directory path to where configuration file(s) needs to be exported:\\n')\n",
        "\n",
        "  if not Custom_Path:\n",
        "    end(\"Path Error: Path can't be blank!\")\n",
        "  elif not Path(Custom_Path).exists():\n",
        "    end(\"Path Error: Path not found!\")\n",
        "  elif not Path(Custom_Path).is_dir():\n",
        "    end(\"Path Error: Path is not a valid directory.\")\n",
        "  elif not Path(DRIVE_CONFIG_DIR):\n",
        "    !rclone mkdir \"$DRIVE_CONFIG_DIR\"\n",
        "\n",
        "  # Check 'rclone.conf' file\n",
        "\n",
        "  if Path(DRIVE_RCLONE_CONF).exists():\n",
        "\n",
        "    is_export = input('Found: rclone.conf [file] | Do you want to export? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_export not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_export == '1':\n",
        "      !rclone copy \"$DRIVE_RCLONE_CONF\" \"$EXPORT_TO\"\n",
        "      print('Export: rclone.conf [file] (1)')\n",
        "  else:\n",
        "    print('Not Found: rclone.conf [file]')\n",
        "\n",
        "    # Check 'Service Accounts' file\n",
        "\n",
        "  if Path(DRIVE_ACCOUNTS_ZIP).exists():\n",
        "\n",
        "    is_export = input('Found accounts.zip [file] | Do you want to export? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_export not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_export == '1':\n",
        "      !rclone copy \"$DRIVE_ACCOUNTS_ZIP\" \"$EXPORT_TO\"\n",
        "      print('Export: accounts.zip [file] (1)')\n",
        "  else:\n",
        "    print('Not Found: accounts.zip [file]')\n",
        "\n",
        "  # Check 'mega.json' file\n",
        "\n",
        "  if Path(DRIVE_MEGA_JSON).exists():\n",
        "\n",
        "    is_export = input('Found mega.json [file] | Do you want to export? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_export not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_export == '1':\n",
        "      !rclone copy \"$DRIVE_MEGA_JSON\" \"$EXPORT_TO\"\n",
        "      print('Export: mega.json [file] (1)')\n",
        "  else:\n",
        "    print('Not Found: mega.json [file]')\n",
        "\n",
        "  # Check 'gofile.json' file\n",
        "\n",
        "  if Path(DRIVE_GOFILE_JSON).exists():\n",
        "\n",
        "    is_export = input('Found gofile.json [file] | Do you want to export? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_export not in ['0', '1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_export == '1':\n",
        "      !rclone copy \"$DRIVE_GOFILE_JSON\" \"$EXPORT_TO\"\n",
        "      print('Export: gofile.json [file] (1)')\n",
        "  else:\n",
        "    print('Not Found: gofile.json [file]')\n",
        "\n",
        "  # Check 'telegram.json' file\n",
        "\n",
        "  if Path(DRIVE_TELEGRAM_JSON).exists():\n",
        "\n",
        "    is_export = input('Found telegram.json [file] | Do you want to export? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_export not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_export == '1':\n",
        "      !rclone copy \"$DRIVE_TELEGRAM_JSON\" \"$EXPORT_TO\"\n",
        "      print('Export: telegram.json [file] (1)')\n",
        "  else:\n",
        "    print('Not Found: telegram.json [file]')\n",
        "\n",
        "  if len(DRIVE_SESSION_FILES) != 0:\n",
        "\n",
        "    is_export = input('Found Telegram session files | Do you want to export? 0 = No & 1 = Yes:\\n')\n",
        "\n",
        "    if is_export not in ['0','1']:\n",
        "      end('Input Error: Invalid input parameter! Please enter 0 or 1 as input.')\n",
        "    elif is_export == '1':\n",
        "      for DRIVE_SESSION_FILE in DRIVE_SESSION_FILES:\n",
        "        !rclone copy \"$DRIVE_SESSION_FILE\" \"$EXPORT_TO\"\n",
        "      print(\"Export: Telegram session files (1)\")\n",
        "  else:\n",
        "    print(\"Not Found: Telegram session [files]\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "PUyDrhZ5mi2F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Service Accounts:**"
      ],
      "metadata": {
        "id": "Rm_S3nO9D0ok"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Options:**<br>\n",
        "``UPLOAD_SERVICE_ACCOUNTS`` **: Upload new Service Accounts.**<br>\n",
        "``SAVE_TO_MYDRIVE`` **: Save new/existing Service Accounts to Google Drive.**"
      ],
      "metadata": {
        "id": "2GS2DqLNOcQ8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @markdown <br><center><img src=\"https://assets.thecaduceus.eu.org/MCT/img/google-cloud-logo.png\" height=\"150\" alt=\"Google-Cloud-Logo\"/></center>\n",
        "# @markdown <center><h3><b>Using Service Accounts</b></h3></center><br>\n",
        "\n",
        "from sys import exit as end\n",
        "from pathlib import Path, PurePath\n",
        "from google.colab import files\n",
        "\n",
        "# Where user mounted Google Drive?\n",
        "try:\n",
        "\tCMP = PurePath(Custom_Mount_Path)\n",
        "except NameError:\n",
        "\tCMP = '/content/drive'\n",
        "\n",
        "# Paths\n",
        "ROOT = \"/content/\"\n",
        "DRIVE_CONFIG_DIR = f\"{CMP}/MyDrive/MCT-Config/\"\n",
        "ROOT_ACCOUNTS_ZIP = \"/content/accounts.zip\"\n",
        "\n",
        "# Check for Setup & Google Account\n",
        "if not Path(\"/content/setup.sh\").exists():\n",
        "\tend('Please download Setup first!')\n",
        "elif not Path(CMP).exists():\n",
        "\tend('Not Found: Google Drive is not connected!')\n",
        "elif not Path(DRIVE_CONFIG_DIR).exists():\n",
        "\t!rclone mkdir \"$DRIVE_CONFIG_DIR\"\n",
        "\tprint('Created: MCT-Config [folder] -> MyDrive')\n",
        "\n",
        "# Configure Options\n",
        "UPLOAD_SERVICE_ACCOUNTS = True  # @param {type:\"boolean\"}\n",
        "SAVE_TO_MYDRIVE = True  # @param {type:\"boolean\"}\n",
        "\n",
        "if UPLOAD_SERVICE_ACCOUNTS and SAVE_TO_MYDRIVE:\n",
        "\tprint('Upload accounts.zip:\\n')\n",
        "\tfile = files.upload()\n",
        "\tif list(file.keys())[0] == 'accounts.zip':\n",
        "\t\t!rclone copy \"$ROOT_ACCOUNTS_ZIP\" \"$DRIVE_CONFIG_DIR\"\n",
        "\t\t!unzip \"$ROOT_ACCOUNTS_ZIP\" -d \"$ROOT\"\n",
        "\t\tprint('Uploaded & Configured Service Accounts! (2)')\n",
        "\telse:\n",
        "\t\tend('File Error: File is not accounts.zip')\n",
        "\n",
        "elif not UPLOAD_SERVICE_ACCOUNTS and not SAVE_TO_MYDRIVE:\n",
        "\tprint('Task Error: No Task to perform :)')\n",
        "\n",
        "elif UPLOAD_SERVICE_ACCOUNTS:\n",
        "\tprint('Upload accounts.zip:\\n')\n",
        "\tfile = files.upload()\n",
        "\tif list(file.keys())[0] == 'accounts.zip':\n",
        "\t\t!unzip \"$ROOT_ACCOUNTS_ZIP\" -d \"$ROOT\"\n",
        "\t\tprint('Uploaded & Configured Service Accounts! (1)')\n",
        "\telse:\n",
        "\t\tend('File Error: File is not accounts.zip')\n",
        "\n",
        "elif Path(ROOT_ACCOUNTS_ZIP).exists():\n",
        "\tprint('Found: accounts.zip [file]')\n",
        "\t!unzip \"$ROOT_ACCOUNTS_ZIP\" -d \"$ROOT\"\n",
        "\tprint('Configured Service Accounts!')\n",
        "\n",
        "else:\n",
        "\tprint('Not Found: accounts.zip [file]')"
      ],
      "metadata": {
        "id": "C8PeRSS3DwYw",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Rclone Operations:**"
      ],
      "metadata": {
        "id": "XSp43MsDEMIb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Create/Edit/View/Delete your Rclone Config file:<br>``UPLOAD_CONFIG_FILE`` : Upload your existing Rclone config file. It will be placed in its correct location automatically.<br>``SAVE_TO_MYDRIVE`` : Save Rclone config file in Google Drive.<br>``DOWNLOAD_CONFIG`` : Download Rclone config file in your Device.**\n"
      ],
      "metadata": {
        "id": "GE1KvRAg2db5"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UdtGnf8hudAN",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@markdown <br><center><img src=\"https://assets.thecaduceus.eu.org/MCT/img/rclone_logo.png\" height=\"50\" alt=\"Rclone-Logo\"/></center>\n",
        "#@markdown <center><h3><b>Create/Edit/Delete Rclone Config File</b></h3></center><br>\n",
        "\n",
        "from google.colab import files\n",
        "from sys import exit as end\n",
        "from pathlib import Path, PurePath\n",
        "\n",
        "# Where user mounted Google Drive?\n",
        "try:\n",
        "  CMP = PurePath(Custom_Mount_Path)\n",
        "except NameError:\n",
        "  CMP = '/content/drive'\n",
        "\n",
        "# Paths\n",
        "DRIVE_CONFIG_DIR = f\"{CMP}/MyDrive/MCT-Config\"\n",
        "\n",
        "# Check for Setup & Google Account\n",
        "if not Path(\"/content/setup.sh\").exists():\n",
        "  end('Please download Setup first!')\n",
        "elif not Path(f'{CMP}').exists():\n",
        "  end('Not Found: Google Drive is not connected!')\n",
        "elif not Path(DRIVE_CONFIG_DIR).exists():\n",
        "  !rclone mkdir {DRIVE_CONFIG_DIR}\n",
        "  print('Created: MCT-Config [folder] -> MyDrive')\n",
        "\n",
        "#@markdown ****\n",
        "UPLOAD_CONFIG_FILE = False #@param {type:\"boolean\"}\n",
        "SAVE_TO_MYDRIVE = True #@param {type:\"boolean\"}\n",
        "DOWNLOAD_CONFIG = False #@param {type:\"boolean\"}\n",
        "\n",
        "if UPLOAD_CONFIG_FILE and SAVE_TO_MYDRIVE and DOWNLOAD_CONFIG:\n",
        "  # Initiate Upload Request\n",
        "  print('Request: Initiate upload -> rclone.conf [file]')\n",
        "  file = files.upload()\n",
        "  if list(file.keys())[0] != 'rclone.conf':\n",
        "    end('File Error: File is not rclone.conf')\n",
        "  elif not Path(\"/root/.config/rclone/\").exists():\n",
        "    !rclone mkdir \"/root/.config/rclone/\"\n",
        "  !rclone copy \"/content/rclone.conf\" \"/root/.config/rclone/\"\n",
        "  print('Saved: rclone.conf [file] -> Runtime')\n",
        "  # Rclone configuration\n",
        "  !rclone config\n",
        "  # Save to Google Drive\n",
        "  !rclone copy \"/content/rclone.conf\" {DRIVE_CONFIG_DIR}\n",
        "  print('Saved: rclone.conf [file] -> MyDrive')\n",
        "  # Initiate Download Request\n",
        "  files.download(\"/root/.config/rclone/\")\n",
        "  print('Request: Initiated download -> rclone.conf [file]')\n",
        "elif UPLOAD_CONFIG_FILE and SAVE_TO_MYDRIVE:\n",
        "  # Initiate Upload Request\n",
        "  print('Request: Initiate upload -> rclone.conf [file]')\n",
        "  file = files.upload()\n",
        "  if list(file.keys())[0] != 'rclone.conf':\n",
        "    end('File Error: File is not rclone.conf')\n",
        "  elif not Path('/root/.config/rclone/').exists():\n",
        "    !rclone mkdir \"/root/.config/rclone/\"\n",
        "  !rclone copy \"/content/rclone.conf\" \"/root/.config/rclone/\"\n",
        "  print('Saved: rclone.conf [file] -> Runtime')\n",
        "  # Rclone configuration\n",
        "  !rclone config\n",
        "  # Save to Google Drive\n",
        "  !rclone copy \"/content/rclone.conf\" {DRIVE_CONFIG_DIR}\n",
        "  print('Saved: rclone.conf [file] -> MyDrive')\n",
        "elif UPLOAD_CONFIG_FILE:\n",
        "  # Initiate Upload Request\n",
        "  print('Request: Initiate Upload -> rclone.conf [file]')\n",
        "  file = files.upload()\n",
        "  if list(file.keys())[0] != 'rclone.conf':\n",
        "    end('File Error: File is not rclone.conf')\n",
        "  elif not Path('/root/.config/rclone/').exists():\n",
        "    !rclone mkdir \"/root/.config/rclone/\"\n",
        "  print('[WARNING] -> No saving option selected, progress may lose.')\n",
        "  # Rclone configuration\n",
        "  !rclone config\n",
        "elif SAVE_TO_MYDRIVE:\n",
        "  # Rclone configuration\n",
        "  !rclone config\n",
        "  # Save to Google Drive\n",
        "  !rclone copy \"/content/rclone.conf\" {DRIVE_CONFIG_DIR}\n",
        "  print('Saved: rclone.conf [file] -> MyDrive')\n",
        "elif DOWNLOAD_CONFIG:\n",
        "  # Rclone configuration\n",
        "  !rclone config\n",
        "  # Initiate Download Request\n",
        "  files.download(\"/root/.config/rclone/\")\n",
        "  print('Request: Initiated download -> rclone.conf [file]')\n",
        "else:\n",
        "  print('[WARNING] -> No saving option selected, progress may lose.')\n",
        "  !rclone config"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Mount Rclone remotes on this runtime:**"
      ],
      "metadata": {
        "id": "yvyL2d3y56My"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Options:**<br>\n",
        "`CUSTOM_MOUNT_POINT`**: Set custom mount point.**<br>\n",
        "`CUSTOM_CACHE_DIR`**: Set custom cache directory.**"
      ],
      "metadata": {
        "id": "tiN1FZCZchnO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @markdown <br>\n",
        "# @markdown <center><h3><b>Connect To Cloud Accounts</b></h3></center>\n",
        "# @markdown <br><center><img src=\"https://assets.thecaduceus.eu.org/MCT/img/Multiple-Clouds.webp\" height=\"100\" alt=\"Multiple-Clouds\"/></center>\n",
        "# @markdown <center><b>Connect your Cloud Accounts (Rclone remotes) between which you want to transfer Data!</b></center>\n",
        "\n",
        "from sys import exit as end\n",
        "from os import makedirs, system\n",
        "from pathlib import Path, PurePath\n",
        "from re import findall, M\n",
        "\n",
        "if not Path(\"/root/.config/rclone/rclone.conf\").exists():\n",
        "  end('Not Found: rclone.conf [file]')\n",
        "\n",
        "content = open(\"/root/.config/rclone/rclone.conf\").read()\n",
        "avCon = findall(r\"^\\[(.+)\\]$\", content, M)\n",
        "\n",
        "print(\"Available Rclone remotes:\")\n",
        "print(*avCon)\n",
        "remote = input(\"Enter Rclone remote name to continue:\\n\")\n",
        "\n",
        "if remote not in avCon:\n",
        "  end('Not Found: Given remote name not exist in rclone.conf [file]')\n",
        "\n",
        "# User Input\n",
        "CUSTOM_MOUNT_POINT = False  # @param {type:\"boolean\"}\n",
        "CUSTOM_CACHE_DIR = False  # @param {type:\"boolean\"}\n",
        "\n",
        "# Custom Mount Point\n",
        "if CUSTOM_MOUNT_POINT:\n",
        "  Mount_Point = input(\"Enter Custom Mount path:\\n\")\n",
        "  if not Mount_Point:\n",
        "    end(\"Mount Path can't be empty.\")\n",
        "  elif Path(Mount_Point).exists() and Path(Mount_Point).is_dir():\n",
        "      Mount_Point = f\"{PurePath(Mount_Point)}/{remote}\"\n",
        "  elif not Path(Mount_Point).exists():\n",
        "      end('Not Found: Given mount path not found.')\n",
        "  elif not Path(Mount_Point).is_dir():\n",
        "    end('Path Error: Given path is not a valid directory.')\n",
        "else:\n",
        "  Mount_Point = f\"/content/drives/{remote}\"\n",
        "\n",
        "# Custom Cache Directory\n",
        "if CUSTOM_CACHE_DIR:\n",
        "  Cache_dir = input(\"Enter Custom Cache Directory path:\\n\")\n",
        "  if not Cache_dir:\n",
        "    end(\"Cache Directory Path can't be empty.\")\n",
        "  elif Path(Cache_dir).exists() and Path(Cache_dir).is_dir():\n",
        "    Cache_dir = f\"{PurePath(Cache_dir)}/{remote}\"\n",
        "  elif not Path(Cache_dir).exists():\n",
        "    end('Not Found: Given mount path not found.')\n",
        "  elif not Path(Cache_dir).exists():\n",
        "    end('Path Error: Give path is not a valid directory.')\n",
        "else:\n",
        "  Cache_dir = \"/content/temp/Rclone\"\n",
        "\n",
        "Action = input(\"Select Action: 1 = Mount and 0 = Unmount:\\n\")\n",
        "\n",
        "if Action not in ['0','1']:\n",
        "  end(\"Input Error: Value should be 1 or 0.\")\n",
        "elif Action == '1':\n",
        "  makedirs(Mount_Point, exist_ok=True)\n",
        "  !rclone mount {remote}: {Mount_Point} --user-agent 'Mozilla' --buffer-size 256M --transfers 10 --vfs-cache-mode minimal --vfs-read-chunk-size 500M --vfs-cache-max-size 50G --vfs-cache-max-age 0h0m1s --vfs-cache-poll-interval 0m1s --cache-dir {Cache_dir} --allow-other --daemon\n",
        "  print(f'Mounted: {Mount_Point}') if Path(Mount_Point).exists() else print(f\"Mount Error: Unable to mount {Mount_Point}\")\n",
        "elif Action == '0' and system(f\"fusermount -uz {Mount_Point}\") == 0:\n",
        "  !rm -r {Mount_Point}\n",
        "else:\n",
        "  system(f\"fusermount -uz {Mount_Point}\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Rgu4rSMi2NMr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Using various Rclone modes, flags & other options:**\n",
        "\n"
      ],
      "metadata": {
        "id": "hlnd4GxV7Fux"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Options:**<br>\n",
        "`DRY_RUN`**: Check given source & destination.**<br>\n",
        "`EMAIL_NOTIFICATION`**: Receive email notification once task is completed.**<br>\n",
        "`LOGS`**: Send log file with email notification.**"
      ],
      "metadata": {
        "id": "gICeYCbSqdQx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @markdown <br>\n",
        "# @markdown <center><img src=\"https://assets.thecaduceus.eu.org/MCT/img/rclone_logo_text.png\" alt=\"rclone forum\" width=150></center>\n",
        "\n",
        "# @markdown ---\n",
        "import smtplib\n",
        "SOURCE = \"\"  # @param {type:\"string\"}\n",
        "DESTINATION = \"\"  # @param {type:\"string\"}\n",
        "MODE = \"copy\"  # @param [\"copy\", \"copyto\", \"copyurl\", \"move\", \"moveto\", \"check\", \"sync\", \"bisync\", \"cat\", \"mkdir\",\"cleanup\", \"ls\", \"lsd\", \"lsl\", \"test makefile\",\"md5sum\", \"sha1sum\", \"size\", \"genautocomplete\", \"gendocs\", \"tree\",\"obscure\"]\n",
        "DRY_RUN = False  # @param {type:\"boolean\"}\n",
        "ARGUMENTS = \"\"  # @param {type:\"string\"}\n",
        "# @markdown ---\n",
        "EMAIL_NOTIFICATION = False  # @param {type:\"boolean\"}\n",
        "LOGS = False  # @param {type:\"boolean\"}\n",
        "EMAIL_ID = \"\"  # @param {type:\"string\"}\n",
        "PASSWORD = \"\"  # @param {type:\"string\"}\n",
        "RECEIVER_ID = \"\"  # @param {type:\"string\"}\n",
        "# @markdown ---\n",
        "\n",
        "args = \"--transfers 20 --checkers 20 --stats-one-line --stats=5s -v --tpslimit 95 --tpslimit-burst 40 \"\n",
        "if MODE == \"check\":\n",
        "  args += \"--one-way \"\n",
        "if DRY_RUN:\n",
        "    args += \" --dry-run \"\n",
        "if LOGS:\n",
        "  args += \" --log-file Rclone_log.txt \"\n",
        "if ARGUMENTS != \"\":\n",
        "  args += ARGUMENTS\n",
        "\n",
        "def runRclone():\n",
        "  !rclone --user-agent \"Mozilla\" \"$MODE\" \"$SOURCE\" \"$DESTINATION\" $args\n",
        "\n",
        "\n",
        "def checkEmail():\n",
        "  if EMAIL_NOTIFICATION and not LOGS:\n",
        "    print(\"You will receive only a notification after task has finished.\")\n",
        "    runRclone()\n",
        "    s = _extracted_from_checkEmail_7(EMAIL_ID)\n",
        "    message = \"Your rClone task has Completed!\"\n",
        "    s.sendmail(EMAIL_ID, RECEIVER_ID, message)\n",
        "    print(\"Email Alert Sent!\")\n",
        "    s.quit()\n",
        "  elif EMAIL_NOTIFICATION and LOGS == True:\n",
        "    print(\"You will receive a notification with log attached after task has finished.\")\n",
        "    runRclone()\n",
        "    # Sending email notification with logs\n",
        "\n",
        "    from email.mime.multipart import MIMEMultipart\n",
        "    from email.mime.text import MIMEText\n",
        "    from email.mime.base import MIMEBase\n",
        "    from email import encoders\n",
        "\n",
        "    fromaddr = EMAIL_ID\n",
        "    toaddr = RECEIVER_ID\n",
        "    msg = MIMEMultipart()\n",
        "    # storing the senders email address\n",
        "    msg['From'] = fromaddr\n",
        "    # storing the receivers email address\n",
        "    msg['To'] = toaddr\n",
        "    # storing the subject\n",
        "    msg['Subject'] = \"Colab has Finished Running your Cell\"\n",
        "    # string to store the body of the mail\n",
        "    body = \"Your Rclone Task has Completed!\"\n",
        "\n",
        "    msg.attach(MIMEText(body, 'plain'))\n",
        "    filename = \"Rclone_log.txt\"\n",
        "    attachment = open(f\"/content/{filename}\", \"rb\")\n",
        "    p = MIMEBase('application', 'octet-stream')\n",
        "    p.set_payload((attachment).read())\n",
        "    # encode into base64\n",
        "    encoders.encode_base64(p)\n",
        "# p.add_header('Content-Disposition', \"attachment; filename= %s\" % filename)\n",
        "    p.add_header('Content-Disposition', f\"attachment; filename= {filename}\")\n",
        "    msg.attach(p)\n",
        "    s = _extracted_from_checkEmail_7(fromaddr)\n",
        "    text = msg.as_string()\n",
        "    s.sendmail(fromaddr, toaddr, text)\n",
        "    print(\"Email Alert Sent with log!\")\n",
        "    s.quit()\n",
        "  elif not EMAIL_NOTIFICATION and not LOGS:\n",
        "    print(\"You will not receive any notification.\")\n",
        "    runRclone()\n",
        "\n",
        "def _extracted_from_checkEmail_7(arg0):\n",
        "  result = smtplib.SMTP('smtp.gmail.com', 587)\n",
        "  result.starttls()\n",
        "  result.login(arg0, PASSWORD)\n",
        "  return result\n",
        "\n",
        "checkEmail()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "KdX4-pL86jyw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Delete your Files/Folder/Directory from below:<br>``delete`` Delete the content of folder or single file.<br>``purge`` Delete whole directory.<br>``rmdir`` Completely delete the given path.<br>``rmdirs`` Remove any empty directories under the path.**"
      ],
      "metadata": {
        "id": "MszqFrsLw8cD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sys import exit as end\n",
        "from pathlib import Path\n",
        "\n",
        "# User Input\n",
        "ACTION = \"delete\"  # @param [\"delete\", \"purge\", \"rmdir\", \"rmdirs\"]\n",
        "PATH = \"\"  # @param {type:\"string\"}\n",
        "ARGUMENTS = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "if not PATH:\n",
        "    end(\"Path Error: Path can't be empty.\")\n",
        "elif Path(PATH).exists():\n",
        "    !rclone {ACTION} \"$PATH\" $ARGUMENTS\n",
        "    print('Execution Completed!')\n",
        "elif not Path(PATH).exists():\n",
        "    end(\"Path Error: Given path not exist.\")\n",
        "else:\n",
        "    print('[ERROR] - Unhandled Action.')"
      ],
      "metadata": {
        "cellView": "form",
        "id": "ba5oxu8T5fwt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Add-ons:**"
      ],
      "metadata": {
        "id": "hBOFYEu5Dtyl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from libtorrent import session as lt_session, add_magnet_uri, torrent_info\n",
        "from sys import exit as end, stdout\n",
        "from httpx import post as post_url, get as get_url\n",
        "from pathlib import Path, PurePath\n",
        "from google.colab import files as colab_file\n",
        "from os import makedirs, strerror\n",
        "from json import load as json_load, dumps as dump_json\n",
        "from subprocess import Popen, PIPE, STDOUT, run\n",
        "from contextlib import closing\n",
        "from functools import wraps\n",
        "from errno import ETIME\n",
        "from signal import signal, alarm, SIGALRM\n",
        "from getpass import getpass\n",
        "from time import time, sleep\n",
        "import shlex\n",
        "\n",
        "# Where user mounted Google Drive?\n",
        "try:\n",
        "  CMP = PurePath(Custom_Mount_Path)\n",
        "except NameError:\n",
        "  CMP = '/content/drive'\n",
        "\n",
        "# Paths\n",
        "DRIVE_CONFIG_DIR = f\"{CMP}/MyDrive/MCT-Config/\"\n",
        "\n",
        "# Check for Setup & Google Account\n",
        "if not Path(\"/content/setup.sh\").exists():\n",
        "  end('Please download setup first!')\n",
        "elif not Path(CMP).exists():\n",
        "  end('Not Found: Google Drive is not connected!')\n",
        "elif not Path(f'{CMP}/MyDrive/MCT-Config/').exists():\n",
        "\t!rclone mkdir \"$DRIVE_CONFIG_DIR\"\n",
        "\tprint('Created: MCT-Config [folder] -> MyDrive')\n",
        "\n",
        "# Retrive Json Data\n",
        "if Path('mct.json').exists():\n",
        "  with open('mct.json','r') as mct_json:\n",
        "    json_data = json_load(mct_json)\n",
        "else:\n",
        "  print(\"[INFO] - Downloading mct.json [file]\")\n",
        "  json_data = get_url(\"https://assets.thecaduceus.eu.org/MCT/json/mct.json\").json()\n",
        "  with open('mct.json', 'w+') as mct_json:\n",
        "    mct_json.write(dump_json(json_data))\n",
        "\n",
        "# User Input\n",
        "SOURCE = \"\"  # @param {type:\"string\"}\n",
        "MODE = \"YouTube Videos/Playlist & Other Sites\" # @param [\"Direct Download Links\", \"Download Links from txt file\", \"YouTube Videos/Playlist & Other Sites\", \"Torrent DL\", \"Torrent DL (File Selection)\", \"Upload file to Anonymous Platforms\",\"MEGA Link DL\", \"UUP DUMP\"]\n",
        "DESTINATION = \"\"  # @param {type:\"string\"}\n",
        "args = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "\n",
        "def runSh(args, *, output=False, shell=False, cd=None):\n",
        "  if shell:\n",
        "    return ((run(\n",
        "        args,\n",
        "        shell=True,\n",
        "        stdout=PIPE,\n",
        "        stderr=STDOUT,\n",
        "        cwd=cd,\n",
        "    ).stdout.decode(\"utf-8\").strip()) if output else run(\n",
        "        args, shell=True, cwd=cd).returncode)\n",
        "  if output:\n",
        "    proc = Popen(shlex.split(args), stdout=PIPE, stderr=STDOUT, cwd=cd)\n",
        "    while True:\n",
        "      output = proc.stdout.readline()\n",
        "      if output == b\"\" and proc.poll() is not None:\n",
        "        return\n",
        "      if output:\n",
        "        print(output.decode(\"utf-8\").strip())\n",
        "  return run(shlex.split(args), cwd=cd).returncode\n",
        "\n",
        "def mega_dl():\n",
        "  global DESTINATION\n",
        "  if not DESTINATION:\n",
        "    makedirs(\"downloads\", exist_ok=True)\n",
        "    DESTINATION = \"downloads\"\n",
        "  newlines = ['\\n', '\\r\\n', '\\r']\n",
        "  def unbuffered(proc, stream='stdout'):\n",
        "    stream = getattr(proc, stream)\n",
        "    with closing(stream):\n",
        "      while True:\n",
        "        out = []\n",
        "        last = stream.read(1)\n",
        "        if last == '' and proc.poll() is not None:\n",
        "          break\n",
        "        while last not in newlines:\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 transfer():\n",
        "    cmd = [\"mega-get\", SOURCE, f\"{DESTINATION}\"]\n",
        "    proc = Popen(\n",
        "      cmd,\n",
        "      stdout=PIPE,\n",
        "      stderr=STDOUT,\n",
        "      universal_newlines=True,\n",
        "    )\n",
        "    for line in unbuffered(proc):\n",
        "      print(line)\n",
        "  transfer()\n",
        "\n",
        "def config_creds():\n",
        "  class TimeoutError(Exception):\n",
        "    pass\n",
        "\n",
        "  def timeout(seconds=10, error_message=strerror(ETIME)):\n",
        "    def decorator(func):\n",
        "      def _handle_timeout(signum, frame):\n",
        "        raise TimeoutError(error_message)\n",
        "\n",
        "      def wrapper(*args, **kwargs):\n",
        "        signal(SIGALRM, _handle_timeout)\n",
        "        alarm(seconds)\n",
        "        try:\n",
        "          result = func(*args, **kwargs)\n",
        "        finally:\n",
        "          alarm(0)\n",
        "        return result\n",
        "      return wraps(func)(wrapper)\n",
        "    return decorator\n",
        "\n",
        "  @timeout(10)\n",
        "  def runShT(args):\n",
        "    return runSh(args, output=True)\n",
        "  if not Path(\"/usr/bin/mega-cmd\").exists():\n",
        "    print(\"[ERROR] - MEGA not installed.\")\n",
        "  else:\n",
        "    !pkill mega-cmd\n",
        "\n",
        "  with open('mega.json', 'r') as mega_json:\n",
        "    mega_json = json_load(mega_json)\n",
        "    print('[INFO] - Decrypting MEGA credentials.')\n",
        "  try:\n",
        "    decrypted_mega_id = post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/decrypt', json={\"string\": f\"{mega_json['mega_id']}\"}).json()\n",
        "    decrypted_mega_pass = post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/decrypt', json={\"string\": f\"{mega_json['mega_pass']}\"}).json()\n",
        "  except Exception as error_code:\n",
        "    end(f\"Unable to decrypt MEGA Credentials.\\nTraceback:\\n{error_code}\")\n",
        "\n",
        "  try:\n",
        "    runShT(f\"mega-login {decrypted_mega_id['result']} {decrypted_mega_pass['result']}\")\n",
        "  except TimeoutError:\n",
        "    runSh('mega-whoami', output=True)\n",
        "  mega_dl()\n",
        "\n",
        "def save_creds():\n",
        "  mega_id = input('Enter MEGA Email ID or Username:\\n')\n",
        "  mega_pass = getpass('Enter MEGA Account Password: (Input is hidden)\\n')\n",
        "  if not mega_id:\n",
        "    end(\"Input Error: MEGA ID can't be blank!\")\n",
        "  elif not mega_pass:\n",
        "    end(\"Input Error: MEGA Password can't be blank!\")\n",
        "  elif len(mega_pass) < 8:\n",
        "    end(\"Input Error: MEGA Password must be of 8 digit or greater.\")\n",
        "\n",
        "  print('[INFO] - Encrypting MEGA Credentials')\n",
        "  try:\n",
        "    encrypted_mega_id = post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/encrypt', json={\"string\": f\"{mega_id}\"}).json()\n",
        "    encrypted_mega_pass = post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/encrypt', json={\"string\": f\"{mega_pass}\"}).json()\n",
        "  except Exception as error_code:\n",
        "    end(f\"Unable to encrypt MEGA Credentials.\\nTraceback:\\n{error_code}\")\n",
        "  encrypted_mega_json = {\"mega_id\": f\"{encrypted_mega_id['result']}\", \"mega_pass\": f\"{encrypted_mega_pass['result']}\"}\n",
        "  with open('mega.json','w') as save_json:\n",
        "    save_json.write(dump_json(encrypted_mega_json))\n",
        "    print('Created: mega.json [file]')\n",
        "    save_json.close()\n",
        "  !rclone copy \"/content/mega.json\" \"$DRIVE_CONFIG_DIR\"\n",
        "  print('Saved: mega.json -> MyDrive')\n",
        "  config_creds()\n",
        "\n",
        "if MODE ==\"Direct Download Links\":\n",
        "  links = SOURCE.split(',')\n",
        "  for link in links:\n",
        "    %cd \"$DESTINATION\"\n",
        "    !aria2c \"$link\" $args\n",
        "  print('Execution completed!')\n",
        "elif MODE == \"Download Links from txt file\":\n",
        "  %cd \"$DESTINATION\"\n",
        "  !aria2c -i \"$SOURCE\" $args\n",
        "  print('Execution completed!')\n",
        "elif MODE == \"YouTube Videos/Playlist & Other Sites\":\n",
        "  %cd \"$DESTINATION\"\n",
        "  !yt-dlp \"$SOURCE\" $args\n",
        "  print('Execution completed!')\n",
        "elif MODE ==\"Torrent DL\":\n",
        "  ses = lt_session()\n",
        "  ses.listen_on(6881, 6891)\n",
        "  user_input = input(\"Enter magnet link or torrent file path:\\n\") if not SOURCE else SOURCE\n",
        "  if user_input.startswith(\"magnet:\"):\n",
        "    params = {\"save_path\": DESTINATION}\n",
        "    handle = add_magnet_uri(ses, user_input, params)\n",
        "  elif Path(user_input).exists():\n",
        "    info = torrent_info(user_input)\n",
        "    params = {\"ti\": info, \"save_path\": DESTINATION}\n",
        "    handle = ses.add_torrent(params)\n",
        "  else:\n",
        "    end(\"Invalid input or given path not exist.\")\n",
        "\n",
        "  while not handle.status().is_seeding:\n",
        "    s = handle.status()\n",
        "    print(f\"\\r{s.progress * 100:.2f}% | DL: {s.download_rate / 1000000:.2f} MB/s | UP: {s.upload_rate / 1000000:.2f} MB/s | Peers: {s.num_peers} | Seeds: {s.num_seeds}\", end=\" \")\n",
        "    stdout.flush()\n",
        "    sleep(1)\n",
        "\n",
        "elif MODE == \"Torrent DL (File Selection)\":\n",
        "  ses = lt_session()\n",
        "  ses.listen_on(6881, 6891)\n",
        "  user_input = input(\"Enter magnet link or torrent file path:\\n\") if not SOURCE else SOURCE\n",
        "  if user_input.startswith(\"magnet:\"):\n",
        "    params = {\"save_path\": DESTINATION}\n",
        "    handle = add_magnet_uri(ses, user_input, params)\n",
        "  elif Path(user_input).exists():\n",
        "    info = torrent_info(user_input)\n",
        "    params = {\"ti\": info, \"save_path\": DESTINATION}\n",
        "    handle = ses.add_torrent(params)\n",
        "  else:\n",
        "    end(\"Invalid input or given path not exist.\")\n",
        "\n",
        "  print(\"Downloading metadata...\")\n",
        "  start_time = time()\n",
        "  while not handle.has_metadata():\n",
        "    elapsed_time = time() - start_time\n",
        "    if elapsed_time > 30: # Increase timeout time from here, by default its 30 seconds\n",
        "      end(\"Torrent timeout, failed to load metadata.\")\n",
        "\n",
        "  print(\"Metadata downloaded.\")\n",
        "\n",
        "  torinfo = handle.get_torrent_info()\n",
        "  files = torinfo.files()\n",
        "  print(\"Files in torrent:\")\n",
        "  for i, f in enumerate(files):\n",
        "    print(f\"{i+1}: {f.path} ({f.size / 1000000:.2f} MB)\")\n",
        "\n",
        "  file_nums = input(\"Enter file numbers to download [separated by space or dash (for range)]:\").split()\n",
        "\n",
        "  priorities = [0] * len(files)\n",
        "  for n in file_nums:\n",
        "    if \"-\" in n:\n",
        "      start_stop = n.split(\"-\")\n",
        "      start = int(start_stop[0]) - 1\n",
        "      stop = int(start_stop[1])\n",
        "      if start_stop[0] >= start_stop[1]:\n",
        "        end(\"Incorrect range.\")\n",
        "      for i in range(start, stop):\n",
        "        priorities[i] = 1\n",
        "    else:\n",
        "      priorities[int(n) - 1] = 1\n",
        "\n",
        "  handle.prioritize_files(priorities)\n",
        "\n",
        "  print(\"Downloading...\")\n",
        "  while not handle.is_seed():\n",
        "    s = handle.status()\n",
        "    print(f\"\\r{s.progress * 100:.2f}% | DL: {s.download_rate / 1000000:.2f} MB/s | UP: {s.upload_rate / 1000000:.2f} MB/s | Peers: {s.num_peers} | Seeds: {s.num_seeds}\", end=\" \")\n",
        "    stdout.flush()\n",
        "    sleep(1)\n",
        "elif MODE == \"Upload file to Anonymous Platforms\":\n",
        "  if not SOURCE:\n",
        "    end(\"Source path can't be empty!\")\n",
        "  elif not Path(SOURCE).exists():\n",
        "    end(\"Not Found: Given path not exists!\")\n",
        "\n",
        "  API = list(json_data['apis']['anonFileShare'].values())\n",
        "  site_names = \"\"\n",
        "\n",
        "  for num, name in enumerate(list(json_data['apis']['anonFileShare'].keys())):\n",
        "    site_names += f\"{num}.{name}\\n\"\n",
        "\n",
        "  while True:\n",
        "    count = int(input(f\"Choose Platform by its number (0 - {len(API) - 1}):\\n{site_names}>\"))\n",
        "\n",
        "    if count > len(API) - 1:\n",
        "      print('Selection out of list.')\n",
        "    else:\n",
        "      print(f'Selection -> {count}\\nAPI -> {API[count]}\\n')\n",
        "      break\n",
        "\n",
        "  if not Path(SOURCE).exists():\n",
        "    end('Not Found: Given source path not exist.')\n",
        "  elif Path(SOURCE).is_dir():\n",
        "    links = []\n",
        "    is_recursive = input(\"Upload files recursively? 0 = No & 1 = Yes:\\n\")\n",
        "    if is_recursive == '1':\n",
        "      print(\"Scanning path for all possible directories...\")\n",
        "      for file_path in list(Path(SOURCE).rglob('**/*.*')):\n",
        "      # This check is still important, since Google Colab secretly creates '.ipynb_checkpoints' detected as folder by pathlib\n",
        "        if Path(file_path).is_file():\n",
        "          try:\n",
        "            print(f\"Uploading [{PurePath(file_path).name}]\")\n",
        "            api_resp = post_url(API[count], files = {'file': open(file_path,'rb')}).json()\n",
        "            print(f\"{PurePath(file_path).name} -> \" + api_resp[\"data\"][\"file\"][\"url\"][\"full\"])\n",
        "            links.append(f\"{PurePath(file_path).name}:\\n\" + api_resp[\"data\"][\"file\"][\"url\"][\"full\"])\n",
        "          except OverflowError:\n",
        "            print(f\"File [{PurePath(file_path).name}] not allowed.\")\n",
        "          except KeyError as error_code:\n",
        "            print(f\"Key mapping error! printing json as raw:\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "          except Exception as error_code:\n",
        "            print(f\"An error occured!\\nTraceback:\\n{error_code}\")\n",
        "            sleep(4)\n",
        "        else:\n",
        "          print(f\"[Dir] -> {PurePath(file_path).name}\")\n",
        "    else:\n",
        "      for file_path in list(Path(SOURCE).rglob(\"*.*\")):\n",
        "        if Path(file_path).is_file():\n",
        "          try:\n",
        "            print(f\"Uploading [{PurePath(file_path).name}]\")\n",
        "            api_resp = post_url(API[count], files = {'file': open(file_path,'rb')}).json()\n",
        "            print(f\"{PurePath(file_path).name} -> \" + api_resp[\"data\"][\"file\"][\"url\"][\"full\"])\n",
        "            links.append(f\"{PurePath(file_path).name}:\\n\" + api_resp[\"data\"][\"file\"][\"url\"][\"full\"])\n",
        "          except OverflowError:\n",
        "            print(f\"File [{PurePath(file_path).name}] not allowed.\")\n",
        "          except KeyError as error_code:\n",
        "            print(f\"Key mapping error! printing json as raw:\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "          except Exception as error_code:\n",
        "            print(f\"An error occured!\\nTraceback:\\n{error_code}\")\n",
        "            sleep(4)\n",
        "        else:\n",
        "          print(f\"[Dir] -> {PurePath(file_path).name}\")\n",
        "\n",
        "    if len(links) > 1:\n",
        "      print(f\"Total Links -> {len(links)}\")\n",
        "      is_export = input(\"Do you want to export all links in txt file? 0 = No or 1 = Yes:\\n\")\n",
        "      if is_export not in ['0','1'] or is_export == '1':\n",
        "        with open('links.txt','a+') as save_links:\n",
        "          save_links.writelines('%s\\n' % item for item in links)\n",
        "          save_links.close()\n",
        "          colab_file.download('links.txt')\n",
        "          print('Request: Initiated download -> links.txt [file]')\n",
        "      else:\n",
        "        with open('links.txt','w+') as save_links:\n",
        "          save_links.ritelines('%s\\n' % item for item in links)\n",
        "          save_links.close()\n",
        "          print(\"Saved: links.txt [file] -> Runtime\")\n",
        "    else:\n",
        "      print(f'Total Links -> {len(links)}')\n",
        "  elif Path(SOURCE).is_file():\n",
        "    try:\n",
        "      print(f\"Uploading [{PurePath(SOURCE).name}]\")\n",
        "      api_resp = post_url(API[count], files={'file': open(SOURCE, 'rb')}).json()\n",
        "      print(f\"{PurePath(SOURCE).name} -> \" + api_resp[\"data\"][\"file\"][\"url\"][\"full\"])\n",
        "    except OverflowError:\n",
        "      print(\"File not allowed.\")\n",
        "    except Exception as error_code:\n",
        "      print(f\"Unable to upload!\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "\n",
        "elif MODE ==\"MEGA Link DL\":\n",
        "  use_account = input('Do you want to use your MEGA Account? to lift limits imposed on anonymous downloader? 0 = No & 1 = Yes:\\n')\n",
        "  if use_account not in ['0','1']:\n",
        "    end(\"Input Error: Invalid input parameter! Please enter 0 or 1 as input.\")\n",
        "  elif use_account == '1' and Path('/content/mega.json').exists():\n",
        "    use_existing = input('[INFO] - Found existing MEGA Account credentials, do you want to use them? 0 = No & 1 = Yes:\\n')\n",
        "    if use_existing not in ['0','1']:\n",
        "      end(\"Input Error: Invalid input parameter! Please enter 0 or 1 as input.\")\n",
        "    elif use_existing == '1':\n",
        "      config_creds()\n",
        "    elif use_existing == '0':\n",
        "      save_creds()\n",
        "  elif use_account == '1':\n",
        "    save_creds()\n",
        "  else:\n",
        "    mega_dl()\n",
        "\n",
        "elif MODE == \"UUP DUMP\":\n",
        "  if Path(SOURCE).is_file() and PurePath(SOURCE).name == 'uup_download_linux.sh':\n",
        "    !bash \"$SOURCE\"\n",
        "  elif Path(SOURCE).is_dir() and Path(f\"{SOURCE}/uup_download_linux.sh\").exists():\n",
        "    !bash \"$SOURCE/uup_download_linux.sh\"\n",
        "  else:\n",
        "    print(\"Not Found: uup_download_linux.sh [file]\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "FM-cwQR0D3xm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Packaging & Extraction:**"
      ],
      "metadata": {
        "id": "psDoa98YIwLw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sys import exit as end\n",
        "from pathlib import Path, PurePath\n",
        "from getpass import getpass\n",
        "\n",
        "# User Input\n",
        "ACTION = \"Zip\" # @param [\"Zip\", \"Zip with Password\", \"RaR\", \"RaR with Password\", \"7z\", \"7z with Password\", \"Tar\", \"Tar.gz\", \"Tar.bz2\", \"UnZip\", \"UnZip with Password\", \"UnRaR\", \"UnRaR with Password\", \"Extract 7z\", \"Extract 7z with Password\", \"Extract Tar\", \"Extract Tar.gz\", \"Extract Tar.bz2\"]\n",
        "SOURCE_PATH = \"\" #@param {type:\"string\"}\n",
        "OUTPUT_FILENAME = \"\" #@param {type:\"string\"}\n",
        "DESTINATION_PATH = \"\" #@param {type:\"string\"}\n",
        "args = \"\" #@param {type:\"string\"}\n",
        "ENCRYPT_FILENAME = False  # @param {type:\"boolean\"}\n",
        "\n",
        "# Check for Setup & common things\n",
        "if not Path(\"/content/setup.sh\").exists():\n",
        "  end('Please download Setup first!')\n",
        "elif not ACTION:\n",
        "  end(\"Select a supported operation to perform.\")\n",
        "elif not SOURCE_PATH:\n",
        "  end(\"Source field can't be empty.\")\n",
        "elif not DESTINATION_PATH:\n",
        "  end(\"Destination field can't be empty\")\n",
        "elif not Path(SOURCE_PATH).exists():\n",
        "  end(\"Not found: Given source path not exist.\")\n",
        "elif not Path(DESTINATION_PATH).exists():\n",
        "  end(\"Not found: Given destination path not exist.\")\n",
        "else:\n",
        "  SOURCE_PATH = PurePath(SOURCE_PATH)\n",
        "  DESTINATION_PATH = PurePath(DESTINATION_PATH)\n",
        "  OUTPUT_FILENAME = PurePath(SOURCE_PATH).name if not OUTPUT_FILENAME else OUTPUT_FILENAME\n",
        "\n",
        "if ENCRYPT_FILENAME and not ACTION.endswith(\"with Password\") or ACTION == \"Zip with Password\":\n",
        "  print(\"[WARN] - Selected action not support ENCRYPT_FILENAME, continuing without it.\")\n",
        "\n",
        "if ACTION == \"Zip\":\n",
        "  Pack_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.zip\"\n",
        "  !zip -r \"$Pack_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"Zip with Password\":\n",
        "  Pack_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.zip\"\n",
        "  password = getpass(\"Enter password:(Input is hidden)\\n\")\n",
        "  !zip -P \"$password\" -r \"$Pack_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"UnZip\":\n",
        "  !unzip \"$SOURCE_PATH\" -d \"$DESTINATION_PATH\" $args\n",
        "elif ACTION == \"UnZip with Password\":\n",
        "  password = getpass(\"Enter password:(Input is hidden)\\n\")\n",
        "  !unzip -P \"$password\" -d \"$DESTINATION_PATH\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"RaR\":\n",
        "  Rar_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.rar\"\n",
        "  !rar a \"$Rar_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"RaR with Password\":\n",
        "  Rar_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.rar\"\n",
        "  password = getpass(\"Enter password:(Input is hidden)\\n\")\n",
        "  if ENCRYPT_FILENAME:\n",
        "    !rar a -p\"$password\" -hp \"$Rar_Dest\" \"$SOURCE_PATH\" $args\n",
        "  else:\n",
        "    !rar a -p\"$password\" \"$Rar_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"UnRaR\":\n",
        "  !unrar x \"$SOURCE_PATH\" \"$DESTINATION_PATH\" $args\n",
        "elif ACTION == \"UnRaR with Password\":\n",
        "  !unrar x -Y \"$SOURCE_PATH\" \"$DESTINATION_PATH\" $args\n",
        "elif ACTION == \"7z\":\n",
        "  sz_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.7z\"\n",
        "  !7z a \"$sz_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"7z with Password\":\n",
        "  sz_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.7z\"\n",
        "  password = getpass(\"Enter password:(Input is hidden)\\n\")\n",
        "  if ENCRYPT_FILENAME:\n",
        "    !7z a -p\"$password\" -mhe=on \"$sz_Dest\" \"$SOURCE_PATH\" $args\n",
        "  else:\n",
        "    !7z a -p\"$password\" \"$sz_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"Extract 7z\":\n",
        "  !7z x \"$SOURCE_PATH\" -o\"$DESTINATION_PATH\" $args\n",
        "elif ACTION == \"Extract 7z with Password\":\n",
        "  password = getpass(\"Enter password:(Input is hidden)\\n\")\n",
        "  !7z x -p\"$password\" -o\"$DESTINATION_PATH\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"Tar\":\n",
        "  Tar_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.tar\"\n",
        "  !tar -cvf \"$Tar_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"Extract Tar\" :\n",
        "  !tar -xvf \"$SOURCE_PATH\" -C \"$DESTINATION_PATH\" $args\n",
        "elif ACTION == \"Tar.gz\":\n",
        "  Targz_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.tar.gz\"\n",
        "  !tar -czvf \"$Targz_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"Extract Tar.gz\":\n",
        "  !tar -xzvf \"$SOURCE_PATH\" -C \"$DESTINATION_PATH\" $args\n",
        "elif ACTION == \"Tar.bz2\":\n",
        "  !tar -cjvf \"$Tarbz_Dest\" \"$SOURCE_PATH\" $args\n",
        "elif ACTION == \"Extract Tar.bz2\":\n",
        "  Tarbz_Dest = f\"{DESTINATION_PATH}/{OUTPUT_FILENAME}.tar.bz\"\n",
        "  !tar -xjvf \"$SOURCE_PATH\" -C \"$DESTINATION_PATH\" $args\n",
        "else:\n",
        "  print(\"Invalid Operation.\")"
      ],
      "metadata": {
        "id": "qSBmZu-iIv0V",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Telegram Integration:**"
      ],
      "metadata": {
        "id": "YzxPE5OhyfF3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Options:**<br>\n",
        "`RECURSIVE`**: Upload files recursively from folder.**<br>"
      ],
      "metadata": {
        "id": "AUkkF26-ylr0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown <br><center><img src=\"https://pnggrid.com/wp-content/uploads/2021/04/telegram-logo-circle-1536x1536.png\" height=\"60\">\n",
        "#@markdown <center><h3><b><i>Telegram Transfer</i></b></h3>\n",
        "\n",
        "from pathlib import Path, PurePath\n",
        "from sys import exit as end\n",
        "from json import load as json_load, dumps as dump_json\n",
        "from httpx import get as get_url, post as post_url\n",
        "from google.colab import output\n",
        "\n",
        "# Where user mounted Google Drive?\n",
        "try:\n",
        "  CMP = PurePath(Custom_Mount_Path)\n",
        "except NameError:\n",
        "  CMP = '/content/drive'\n",
        "\n",
        "# Paths\n",
        "DRIVE_CONFIG_DIR = f\"{CMP}/MyDrive/MCT-Config/\"\n",
        "\n",
        "# Check for Setup & Google Account\n",
        "if not Path(\"/content/setup.sh\").exists():\n",
        "  end('Please download Setup first!')\n",
        "elif not Path(CMP).exists():\n",
        "  end('Not Found: Google Drive is not connected!')\n",
        "elif not Path(f'{CMP}/MyDrive/MCT-Config/').exists():\n",
        "\t!rclone mkdir \"$DRIVE_CONFIG_DIR\"\n",
        "\tprint('Created: MCT-Config [folder] -> MyDrive')\n",
        "\n",
        "# Retrive Json Data\n",
        "if Path('mct.json').exists():\n",
        "  with open('mct.json', 'r') as mct_json:\n",
        "    json_data = json_load(mct_json)\n",
        "else:\n",
        "  print(\"[INFO] - Downloading mct.json [file]\")\n",
        "  json_data = get_url(\"https://assets.thecaduceus.eu.org/MCT/json/mct.json\").json()\n",
        "  with open('mct.json', 'w+') as mct_json:\n",
        "    mct_json.write(dump_json(json_data))\n",
        "\n",
        "# Load configuration\n",
        "if Path('telegram.json').exists():\n",
        "  with open('telegram.json', 'r') as conf_file:\n",
        "    tg_json = json_load(conf_file)\n",
        "  print(\"[INFO] - Decrypting API ID & API HASH.\")\n",
        "else:\n",
        "  with open('telegram.json', 'w+') as conf_file:\n",
        "    tg_json = {\n",
        "        \"version\": \"1.0\",\n",
        "        \"tokens\": {},\n",
        "    }\n",
        "    conf_file.write(dump_json(tg_json))\n",
        "\n",
        "# Decrypt tokens\n",
        "_API_ID = []\n",
        "_API_HASH = []\n",
        "\n",
        "for API_ID,API_HASH in zip([token.get(\"API_ID\") for token in tg_json[\"tokens\"].values()],[token.get(\"API_HASH\") for token in tg_json[\"tokens\"].values()]):\n",
        "  _API_ID.append(int(post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/decrypt', json={\"string\": API_ID}).json()[\"result\"]))\n",
        "  _API_HASH.append(post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/decrypt', json={\"string\": API_HASH}).json()[\"result\"])\n",
        "\n",
        "# API Profile String\n",
        "api_string = \"\"\n",
        "\n",
        "for num, name in enumerate(list(tg_json[\"tokens\"].keys()), start=1):\n",
        "  api_string += f\"{num}.{name}\\n\"\n",
        "\n",
        "# User Profile String\n",
        "user_string = \"\"\n",
        "\n",
        "for num,name in enumerate(list(Path().glob(\"*.session\")), start=1):\n",
        "  user_string += f\"{num}.{PurePath(name).name.split('.')[0]}\\n\" # name.split('.')[0] will not work\n",
        "\n",
        "METHOD = \"Manage API Profiles\" #@param [\"Manage API Profiles\", \"Manage Telegram Profiles\", \"Upload Files/Folder\"]\n",
        "SOURCE = \"\" #@param {type:\"string\"}\n",
        "DESTINATION = \"\" #@param {type:\"string\"}\n",
        "ARGUMENTS = \"\" #@param {type:\"string\"}\n",
        "RECURSIVE = False #@param {type:\"boolean\"}\n",
        "\n",
        "if METHOD == \"Manage API Profiles\":\n",
        "  print(f\"Availabe API Profiles: {len(_API_ID)}\\n{api_string}\")\n",
        "  while True:\n",
        "    action = input(\"(a)add/(r)remove/(e)exit>\").lower()\n",
        "    if action in ['a', 'add', '+']:\n",
        "      api_profile_name = input(\"Give a name to this API profile:\\n>\")\n",
        "      api_id = int(input(\"Enter your API ID:\\n\"))\n",
        "      api_hash = input(\"Enter your API HASH:\\n\")\n",
        "      print(\"[INFO] - Encrypting API ID & API HASH.\")\n",
        "      api_id = post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/encrypt', json={\"string\": str(api_id)}).json()[\"result\"]\n",
        "      api_hash = post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/encrypt', json={\"string\": api_hash}).json()[\"result\"]\n",
        "      tg_json[\"tokens\"][api_profile_name] = {\"API_ID\": api_id, \"API_HASH\": api_hash}\n",
        "      with open(\"telegram.json\", \"w+\") as conf_file:\n",
        "        conf_file.write(dump_json(tg_json))\n",
        "        print(f\"Saved [{api_profile_name}].\")\n",
        "      !rclone copy \"telegram.json\" \"$DRIVE_CONFIG_DIR\"\n",
        "    elif action in ['r', 'remove', 'rm', '-']:\n",
        "      api_profile_name = input(\"Enter API profile name you want to delete:\\n\")\n",
        "      try:\n",
        "        del tg_json['tokens'][api_profile_name]\n",
        "        with open(\"telegram.json\", \"w+\") as conf_file:\n",
        "          conf_file.write(dump_json(tg_json))\n",
        "          print(f\"Deleted [{api_profile_name}].\")\n",
        "        !rclone copy \"telegram.json\" \"$DRIVE_CONFIG_DIR\"\n",
        "      except KeyError:\n",
        "        print(\"Given API profile not exist.\")\n",
        "    elif action in ['e','exit']:\n",
        "      output.clear()\n",
        "      break\n",
        "elif METHOD == \"Manage Telegram Profiles\":\n",
        "  print(f\"Available User Profiles: {len(list(Path().glob('*.session')))}\\n{user_string}\")\n",
        "  while True:\n",
        "    action = input(\"(a)add/(r)remove/(e)exit>\").lower()\n",
        "    if action in ['a', 'add', '+']:\n",
        "      if len(_API_ID) == 0:\n",
        "        exit(\"Error: No API Profile configured for selection.\")\n",
        "      user_profile_name = input(\"Give a name to new Telegram profile:\\n>\")\n",
        "      count = int(input(f\"\\nSelect API profile (use index number) to create new session with (1 - {len(_API_ID) if len(_API_ID) >= 1 else 1 - 1}):\\n{api_string}\\n>\")) - 1\n",
        "      try:\n",
        "        api_id = _API_ID[count]\n",
        "        api_hash = _API_HASH[count]\n",
        "      except IndexError:\n",
        "        exit(\"Selection out of list.\")\n",
        "      profile_type = input(\"Sign up as user or bot?\\n>\").lower()\n",
        "      if profile_type == \"user\":\n",
        "        phone_number = input(\"Enter your phone number in international format without '+' sign:\\n>\")\n",
        "        print(\"Starting Telegram client as user...\\n\")\n",
        "        !python tg-upload.py --profile \"$user_profile_name\" --api_id \"$api_id\" --api_hash \"$api_hash\" --phone \"$phone_number\" --login_only $ARGUMENTS\n",
        "      else:\n",
        "        bot_token = input(\"Enter your bot token:\\n>\")\n",
        "        print(\"Starting Telegram client as bot...\\n\")\n",
        "        !python tg-upload.py --profile \"$user_profile_name\" --api_id \"$api_id\" --api_hash \"$api_hash\" --bot \"$bot_token\" --login_only $ARGUMENTS\n",
        "\n",
        "      session_path = f\"{user_profile_name}.session\"\n",
        "      if Path(session_path).exists():\n",
        "        !rclone copy \"$session_path\" \"$DRIVE_CONFIG_DIR\"\n",
        "        print(f\"Saved [{user_profile_name}].\")\n",
        "    elif action in ['r','remove','-']:\n",
        "      user_profile_name = input(f\"Enter name of Telegram profile you want to delete:\\n>\")\n",
        "\n",
        "      if not Path(f\"{user_profile_name}.session\").exists() and not Path(f\"{DRIVE_CONFIG_DIR}{user_profile_name}.session\").exists():\n",
        "        exit(\"Given Telegram profile not exist.\")\n",
        "      Path(f\"{user_profile_name}.session\").unlink(missing_ok=True)\n",
        "      Path(f\"{DRIVE_CONFIG_DIR}{user_profile_name}.session\").unlink(missing_ok=True)\n",
        "      print(f\"Deleted [{user_profile_name}].\")\n",
        "    elif action in ['e','exit']:\n",
        "      output.clear()\n",
        "      break\n",
        "elif METHOD == \"Upload Files/Folder\":\n",
        "  if not SOURCE:\n",
        "    exit(\"Source file/folder path can't be empty.\")\n",
        "  elif not DESTINATION:\n",
        "    print(\"[NOTICE] - No destination chat identity passed, file will be uploaded to Saved messages.\")\n",
        "    DESTINATION = \"me\"\n",
        "\n",
        "  if RECURSIVE:\n",
        "    ARGUMENTS += \" -r\"\n",
        "\n",
        "  profile_list = []\n",
        "  for profile in list(Path().glob(\"*.session\")):\n",
        "    profile_list.append(Path(profile).name.split('.')[0])\n",
        "  profile = int(input(f\"Choose Telegram profile (use index number) to upload data using:\\n{user_string}\\n>\")) - 1\n",
        "  profile = profile_list[profile]\n",
        "  !python tg-upload.py --profile \"$profile\" --path \"$SOURCE\" --chat_id \"$DESTINATION\" $ARGUMENTS"
      ],
      "metadata": {
        "cellView": "form",
        "id": "n4wmNGIAoAS0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**GoFile Integration:**"
      ],
      "metadata": {
        "id": "m0FLyGd7jNTU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Options:**<br>\n",
        "`RECURSIVE`**: Upload files recursively from folder.**<br>\n",
        "`RAW`**: Show API Response as raw.**"
      ],
      "metadata": {
        "id": "mYCilPWjjipa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @markdown <br><center><img src=\"https://assets.thecaduceus.eu.org/MCT/img/GoFile_log.png\" height=\"50\" alt=\"GoFile-Logo\"/></center>\n",
        "# @markdown <center><h3><i><b>GoFile Transfer</b></i></h3></center><br>\n",
        "\n",
        "from httpx import get as get_url, post as post_url\n",
        "from sys import exit as end\n",
        "from pathlib import Path, PurePath\n",
        "from json import load as json_load, dumps as dump_json\n",
        "from ping3 import ping\n",
        "from time import sleep\n",
        "from google.colab import output\n",
        "from google.colab.files import download as dl\n",
        "from getpass import getpass\n",
        "from socket import gethostbyname\n",
        "\n",
        "# Where user mounted Google Drive?\n",
        "try:\n",
        "  CMP = PurePath(Custom_Mount_Path)\n",
        "except NameError:\n",
        "  CMP = '/content/drive'\n",
        "\n",
        "# Paths\n",
        "DRIVE_CONFIG_DIR = f\"{CMP}/MyDrive/MCT-Config/\"\n",
        "\n",
        "# Check for Setup & Google Account\n",
        "if not Path(\"/content/setup.sh\").exists():\n",
        "  end('Please download Setup first!')\n",
        "elif not Path(CMP).exists():\n",
        "  end('Not Found: Google Drive is not connected!')\n",
        "elif not Path(f'{CMP}/MyDrive/MCT-Config/').exists():\n",
        "\t!rclone mkdir \"$DRIVE_CONFIG_DIR\"\n",
        "\tprint('Created: MCT-Config [folder] -> MyDrive')\n",
        "\n",
        "# Retrive Json Data\n",
        "if Path('mct.json').exists():\n",
        "  with open('mct.json', 'r') as mct_json:\n",
        "    json_data = json_load(mct_json)\n",
        "else:\n",
        "  print(\"[INFO] - Downloading mct.json [file]\")\n",
        "  json_data = get_url(\"https://assets.thecaduceus.eu.org/MCT/json/mct.json\").json()\n",
        "  with open('mct.json', 'w+') as mct_json:\n",
        "    mct_json.write(dump_json(json_data))\n",
        "\n",
        "METHOD = \"Manage Tokens\" # @param [\"Server Details\", \"Upload Files\", \"Manage Tokens\", \"Account Details\"]\n",
        "SOURCE = \"\"  # @param {type:\"string\"}\n",
        "DESTINATION = \"\"  # @param {type:\"string\"}\n",
        "RECURSIVE = False  # @param {type:\"boolean\"}\n",
        "RAW = False  # @param {type:\"boolean\"}\n",
        "\n",
        "# Get Fastest Server\n",
        "try:\n",
        "  server_id = get_url(json_data[\"apis\"][\"GoFile\"][\"getServer\"]).json()[\"data\"][\"server\"]\n",
        "except Exception as error_code:\n",
        "  end(f\"An error occured!\\nTraceback:\\n{error_code}\")\n",
        "\n",
        "# Load configuration\n",
        "if Path('gofile.json').exists():\n",
        "  with open('gofile.json', 'r') as conf_file:\n",
        "    gofile_json = json_load(conf_file)\n",
        "  print(\"[INFO] - Decrypting tokens.\")\n",
        "else:\n",
        "  with open('gofile.json', 'w+') as conf_file:\n",
        "    gofile_json = {\n",
        "        \"version\": \"2.0\",\n",
        "        \"accounts\": {}\n",
        "    }\n",
        "    conf_file.write(dump_json(gofile_json))\n",
        "\n",
        "if gofile_json[\"version\"] == json_data[\"apis\"][\"GoFile\"][\"configVersion\"]:\n",
        "  print(f\"[INFO] - GoFile config version: [{gofile_json['version']}]\")\n",
        "elif gofile_json[\"version\"] == \"1.0\":\n",
        "  print(f\"[UPGRADE] - GoFile config file version [1.0 -> {json_data['apis']['GoFile']['configVersion']}]\")\n",
        "  # Retrive data\n",
        "  account_names = list(gofile_json[\"tokens\"].keys())\n",
        "  account_tokens = list(gofile_json[\"tokens\"].values())\n",
        "  # Decrypt tokens\n",
        "  tokens = []\n",
        "  for token in account_tokens:\n",
        "    resp = post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/decrypt', json={\"string\": token}).json()[\"result\"]\n",
        "    tokens.append(resp)\n",
        "  # Retrive root folder ids\n",
        "  rootFolder = []\n",
        "  for token in tokens:\n",
        "    resp = get_url(json_data['apis']['GoFile']['getAccountDetails'].format(token=token)).json()[\"data\"][\"rootFolder\"]\n",
        "    rootFolder.append(resp)\n",
        "  # Arrange Json\n",
        "  gofile_json = {\"version\": \"2.0\", \"accounts\": {}}\n",
        "  for name, token, root in zip(account_names, account_tokens, rootFolder):\n",
        "    gofile_json[\"accounts\"][name] = {\"token\": token, \"rootFolder\": root}\n",
        "  # Save Json\n",
        "  with open('gofile.json', 'w+') as conf_file:\n",
        "    conf_file.write(dump_json(gofile_json))\n",
        "else:\n",
        "  end(f\"Unsupported GoFile config file version: {gofile_json['version']}\")\n",
        "output.clear()\n",
        "tokens = []\n",
        "for i in [account.get(\"token\") for account in gofile_json[\"accounts\"].values()]:\n",
        "  tokens.append(post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/decrypt', json={\"string\": i}).json()[\"result\"])\n",
        "\n",
        "profile_string = \"\"\n",
        "for num, name in enumerate(list(gofile_json[\"accounts\"].keys()), start=1):\n",
        "  profile_string += f\"{num}.{name}\\n\"\n",
        "\n",
        "if METHOD == 'Server Details':\n",
        "  print(f\"Server Details:\\nServer ID -> {server_id}\\nServer URL -> {json_data['apis']['GoFile']['serverURL'].format(server_id=server_id)}\\nServer IP -> {gethostbyname(json_data['apis']['GoFile']['serverURL'].format(server_id=server_id))}\\nPing -> {round(ping(json_data['apis']['GoFile']['serverURL'].format(server_id=server_id)) * 1000, 2)} ms\")\n",
        "elif METHOD == 'Upload Files':\n",
        "  while True:\n",
        "    count = int(input(f\"Choose Profile by its number (0 - {len(tokens) if len(tokens) >= 1 else 1 - 1}):\\n0.Anonymous Upload\\n{profile_string}>\")) - 1\n",
        "    if count > len(tokens) - 1:\n",
        "      print(\"Selection out of list.\")\n",
        "    else:\n",
        "      break\n",
        "  output.clear()\n",
        "  links = []\n",
        "  if count == -1:  # For anonymous upload\n",
        "    if not Path(SOURCE).exists():\n",
        "      end(\"Not Found: Given source path not exist!\")\n",
        "    elif Path(SOURCE).is_dir():\n",
        "      if RECURSIVE:\n",
        "        print(\"Scanning path for all possible directories...\")\n",
        "        for file_path in list(Path(SOURCE).rglob('**/*.*')):\n",
        "          # This check is still important, since Google Colab secretly creates '.ipynb_checkpoints' detected as folder by pathlib\n",
        "          if Path(file_path).is_file():\n",
        "            try:\n",
        "              print(f\"Uploading [{PurePath(file_path).name}]\")\n",
        "              api_resp = post_url(json_data['apis']['GoFile']['uploadFile'].format(server_id=server_id), files={'file': open(file_path, 'rb')}).json()\n",
        "              if not RAW:\n",
        "                print(f\"{PurePath(file_path).name} -> \" + api_resp['data']['downloadPage'])\n",
        "              else:\n",
        "                print(f\"{PurePath(file_path).name}:\")\n",
        "                print(api_resp)\n",
        "              links.append(f\"{PurePath(file_path).name}:\\n\" + api_resp['data']['downloadPage'])\n",
        "            except OverflowError:\n",
        "              print(f\"File [{PurePath(file_path).name}] not allowed.\")\n",
        "            except KeyError as error_code:\n",
        "              print(f\"Key mapping error! printing json as raw:\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "            except Exception as error_code:\n",
        "              print(f\"An error occured!\\nTraceback:\\n{error_code}\")\n",
        "              sleep(4)\n",
        "          else:\n",
        "            print(f\"[Dir] -> {PurePath(file_path).name}\")\n",
        "      else:\n",
        "        for file_path in list(Path(SOURCE).rglob(\"*.*\")):\n",
        "          if Path(file_path).is_file():\n",
        "            try:\n",
        "              print(f\"Uploading [{PurePath(file_path).name}]\")\n",
        "              api_resp = post_url(json_data['apis']['GoFile']['uploadFile'].format(server_id=server_id), files={'file': open(file_path, 'rb')}).json()\n",
        "              if not RAW:\n",
        "                print(f\"{PurePath(file_path).name} -> \" + api_resp['data']['downloadPage'])\n",
        "              else:\n",
        "                print(f\"{PurePath(file_path).name}:\")\n",
        "                print(api_resp)\n",
        "              links.append(f\"{PurePath(file_path).name}:\\n\" + api_resp['data']['downloadPage'])\n",
        "            except OverflowError:\n",
        "              print(f\"File [{PurePath(file_path).name}] not allowed.\")\n",
        "            except KeyError as error_code:\n",
        "              print(f\"Key mapping error! printing json as raw:\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "            except Exception as error_code:\n",
        "              print(f\"An error occured!\\nTraceback:\\n{error_code}\")\n",
        "              sleep(4)\n",
        "          else:\n",
        "            print(f\"[Dir] -> {PurePath(file_path).name}\")\n",
        "    elif Path(SOURCE).is_file():\n",
        "      try:\n",
        "        print(f\"Uploading [{PurePath(SOURCE).name}]\")\n",
        "        api_resp = post_url(json_data['apis']['GoFile']['uploadFile'].format(server_id=server_id), files={'file': open(SOURCE, 'rb')}).json()\n",
        "        if not RAW:\n",
        "          print(f\"{PurePath(SOURCE).name} -> \" + api_resp['data']['downloadPage'])\n",
        "        else:\n",
        "          print(f\"{PurePath(SOURCE).name}:\")\n",
        "          print(api_resp)\n",
        "      except OverflowError:\n",
        "        print(\"File is not allowed.\")\n",
        "      except Exception as error_code:\n",
        "        print(f\"Unable to upload!\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "  else:  # For upload with specific token & folder\n",
        "    account_list = list(gofile_json[\"accounts\"].keys())\n",
        "    DESTINATION = gofile_json[\"accounts\"][account_list[count]][\"rootFolder\"] if not DESTINATION else DESTINATION\n",
        "    if not Path(SOURCE).exists():\n",
        "      end(\"Not Found: Given source path not exist.\")\n",
        "    elif Path(SOURCE).is_dir():\n",
        "      if RECURSIVE:\n",
        "        print(\"Scanning path for all possible directories...\")\n",
        "        for file_path in list(Path(SOURCE).rglob('**/*.*')):\n",
        "          # This check is still important, since Google Colab secretly creates '.ipynb_checkpoints' detected as folder by pathlib\n",
        "          if Path(file_path).is_file():\n",
        "            try:\n",
        "              print(f\"Uploading [{PurePath(file_path).name}]\")\n",
        "              api_resp = post_url(json_data['apis']['GoFile']['uploadFile'].format(server_id=server_id), files={'file': open(file_path, 'rb')}, data={'token': tokens[count], 'folderId': DESTINATION}).json()\n",
        "              if not RAW:\n",
        "                print(f\"{PurePath(file_path).name} -> \" + api_resp['data']['downloadPage'])\n",
        "              else:\n",
        "                print(f\"{PurePath(file_path).name}:\")\n",
        "                print(api_resp)\n",
        "              links.append(f\"{PurePath(file_path).name}:\\n\" + api_resp['data']['downloadPage'])\n",
        "            except OverflowError:\n",
        "              print(f\"File [{PurePath(file_path).name}] not allowed.\")\n",
        "            except KeyError as error_code:\n",
        "              print(f\"Key mapping error! printing json as raw:\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "            except Exception as error_code:\n",
        "              print(f\"An error occured!\\nTraceback:\\n{error_code}\")\n",
        "              sleep(4)\n",
        "          else:\n",
        "            print(f\"[Dir] -> {PurePath(file_path).name}\")\n",
        "      else:\n",
        "        for file_path in list(Path(SOURCE).rglob(\"*.*\")):\n",
        "          if Path(file_path).is_file():\n",
        "            try:\n",
        "              print(f\"Uploading [{PurePath(file_path).name}]\")\n",
        "              api_resp = post_url(json_data['apis']['GoFile']['uploadFile'].format(server_id=server_id), files={'file': open(file_path, 'rb')}, data={'token': tokens[count], 'folderId': DESTINATION}).json()\n",
        "              if not RAW:\n",
        "                print(f\"{PurePath(file_path).name} -> \" + api_resp['data']['downloadPage'])\n",
        "              else:\n",
        "                print(f\"{PurePath(file_path).name}:\")\n",
        "                print(api_resp)\n",
        "              links.append(f\"{PurePath(file_path).name}:\\n\" + api_resp['data']['downloadPage'])\n",
        "            except OverflowError:\n",
        "              print(f\"File [{PurePath(file_path).name}] not allowed.\")\n",
        "            except KeyError:\n",
        "              print(f\"Key mapping error! printing json as raw:\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "            except Exception as error_code:\n",
        "              print(f\"An error occured!\\nTraceback:\\n{error_code}\")\n",
        "              sleep(4)\n",
        "          else:\n",
        "            print(f\"[Dir] -> {PurePath(file_path).name}\")\n",
        "    elif Path(SOURCE).is_file():\n",
        "      print(f\"Uploading [{PurePath(SOURCE).name}]\")\n",
        "      try:\n",
        "        api_resp = post_url(json_data['apis']['GoFile']['uploadFile'].format(server_id=server_id), files={'file': open(SOURCE, 'rb')}, data={'token': tokens[count], 'folderId': DESTINATION}).json()\n",
        "        if not RAW:\n",
        "          print(f\"{PurePath(SOURCE).name} -> \" + api_resp['data']['downloadPage'])\n",
        "        else:\n",
        "          print(f\"{PurePath(SOURCE).name}:\")\n",
        "          print(api_resp)\n",
        "      except OverflowError:\n",
        "        print(f\"File [{PurePath(SOURCE).name}] not allowed.\")\n",
        "      except KeyError as error_code:\n",
        "        print(f\"Key mapping error! printing json as raw:\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "      except Exception as error_code:\n",
        "        print(f\"An error occured!\\nTraceback:\\n{error_code}\")\n",
        "\n",
        "  if len(links) > 1:\n",
        "    print(f\"Total Links -> {len(links)}\")\n",
        "    is_export = input(\"Do you want to export all links in txt file? 0 = No or 1 = Yes:\\n\")\n",
        "    if is_export not in ['0', '1'] or is_export == '1':\n",
        "      with open('gofile-links.txt', 'a+') as save_links:\n",
        "        save_links.writelines('%s\\n' % item for item in links)\n",
        "        save_links.close()\n",
        "      dl('gofile-links.txt')\n",
        "      print('Request: Initiated download -> gofile-links.txt [file]')\n",
        "    else:\n",
        "      with open('gofile-links.txt', 'w+') as save_links:\n",
        "        save_links.writelines('%s\\n' % item for item in links)\n",
        "        save_links.close()\n",
        "      print(\"Saved: gofile-links.txt [file] -> Runtime\")\n",
        "\n",
        "elif METHOD == 'Manage Tokens':\n",
        "  print(f\"Availabe tokens: {len(tokens)}\\n{profile_string}\")\n",
        "  while True:\n",
        "    action = input(\"(a)add/(r)remove/(e)exit>\").lower()\n",
        "    if action in ['a', 'add', '+']:\n",
        "      token_name = input(\"Give a name to your token:\\n>\")\n",
        "      token_value = getpass(\"Enter your token value: (input is hidden)\\n\")\n",
        "      print(\"[INFO] - Checking token.\")\n",
        "      try:\n",
        "        resp = get_url(json_data['apis']['GoFile']['getAccountDetails'].format(token=token_value)).json()\n",
        "        rootfolderid = resp[\"data\"][\"rootFolder\"]\n",
        "      except Exception as error_code:\n",
        "        end(f\"Unable to retrive information:\\nAPI Response:\\n{resp}\\nTracback:\\n{error_code}\")\n",
        "      print(\"[INFO] - Encrypting token.\")\n",
        "      token_value = post_url(f'{json_data[\"apis\"][\"encryptAPI\"]}/encrypt', json={\"string\": token_value}).json()[\"result\"]\n",
        "      gofile_json[\"accounts\"][token_name] = {\"token\": token_value, \"rootFolder\": rootfolderid}\n",
        "      with open('gofile.json', 'w+') as conf_file:\n",
        "        conf_file.write(dump_json(gofile_json))\n",
        "        print(f\"Saved [{token_name}].\")\n",
        "      !rclone copy \"gofile.json\" \"$DRIVE_CONFIG_DIR\"\n",
        "    elif action in ['r', 'remove', 'rm', '-']:\n",
        "      token_name = input(\"Enter name of token you want to delete:\\n>\")\n",
        "      try:\n",
        "        del gofile_json['accounts'][token_name]\n",
        "        with open('gofile.json', 'w+') as conf_file:\n",
        "          conf_file.write(dump_json(gofile_json))\n",
        "          print(f\"Deleted [{token_name}].\")\n",
        "          !rclone copy \"gofile.json\" \"$DRIVE_CONFIG_DIR\"\n",
        "      except KeyError:\n",
        "        print(\"Given token name not exist!\")\n",
        "    elif action in ['e','exit']:\n",
        "      output.clear()\n",
        "      break\n",
        "elif METHOD == 'Account Details':\n",
        "  while True:\n",
        "    count = int(input(f\"Choose Profile by its number (1 - {len(tokens) if len(tokens) >= 1 else 1 - 1}):\\n{profile_string}>\")) - 1\n",
        "    if count > len(tokens) - 1:\n",
        "      print(\"Selection out of list.\")\n",
        "    else:\n",
        "      break\n",
        "\n",
        "  output.clear()\n",
        "\n",
        "  try:\n",
        "    api_resp = get_url(json_data['apis']['GoFile']['getAccountDetails'].format(token=tokens[count])).json()\n",
        "    if not RAW:\n",
        "      print(f\"Token:\\n{api_resp['data']['token']}\\nLogin URL:\\n\" + json_data['apis']['GoFile']['loginURL'].format(token=api_resp['data']['token']) + f\"\\nEmail:\\n{api_resp['data']['email']}\\nTier:\\n{api_resp['data']['tier']}\\nCredit:\\n{api_resp['data']['currencySign']}{api_resp['data']['credit']}\\nRoot Folder ID:\\n{api_resp['data']['rootFolder']}\\nTotal Size:\\n{api_resp['data']['totalSize'] / 1000000:.2f} MB\\nTotal Files:\\n{api_resp['data']['filesCount']}\\nTotal Downloads:\\n{api_resp['data']['total30DDLTraffic']}\")\n",
        "    else:\n",
        "      print(api_resp)\n",
        "  except KeyError as error_code:\n",
        "    print(f\"Key mapping error! printing json as raw:\\nAPI Response:\\n{api_resp}\\nTraceback:\\n{error_code}\")\n",
        "  except Exception as error_code:\n",
        "    print(f\"An error occured!\\n{error_code}\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "yEs-ezE3b9Ph"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Run Commands & Code:**"
      ],
      "metadata": {
        "id": "3-GPORzzZXPF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**You can run any supported command below after\n",
        "downloading its setup from above!<br>List of Commands:**\n",
        "```\n",
        "# Putting '!' before any command is mandatory!\n",
        "---\n",
        "!rclone [ACTION] [FLAGS]\n",
        "---\n",
        "!yt-dlp [URL-1 URL-2 URL-3] [OPTIONS]\n",
        "---\n",
        "!aria2c <torrent/magnet/url>\n",
        "```"
      ],
      "metadata": {
        "id": "FlNn7fXbWtHz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Write your Code Below:**"
      ],
      "metadata": {
        "id": "x6Dxey_8bGUJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Code 1**"
      ],
      "metadata": {
        "id": "LF3tVGmLCGxL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "  #<--Write Code before #"
      ],
      "metadata": {
        "id": "k7N-XUplWuwF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Code 2**"
      ],
      "metadata": {
        "id": "1OpnhcI0CKcm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "  #<--Write Code before #"
      ],
      "metadata": {
        "id": "74atFIRKB12M"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}